import 'package:equatable/equatable.dart';

abstract class Failure extends Equatable {
  const Failure({required this.message, this.code});
  
  final String message;
  final String? code;
  
  @override
  List<Object?> get props => [message, code];
}

class ServerFailure extends Failure {
  const ServerFailure({
    required super.message,
    super.code,
    this.statusCode,
  });
  
  final int? statusCode;
  
  @override
  List<Object?> get props => [message, code, statusCode];
}

class NetworkFailure extends Failure {
  const NetworkFailure({
    required super.message,
    super.code = 'NETWORK_ERROR',
  });
}

class AuthFailure extends Failure {
  const AuthFailure({
    required super.message,
    super.code = 'AUTH_ERROR',
  });
}

class ValidationFailure extends Failure {
  const ValidationFailure({
    required super.message,
    super.code = 'VALIDATION_ERROR',
    this.field,
  });
  
  final String? field;
  
  @override
  List<Object?> get props => [message, code, field];
}

class CacheFailure extends Failure {
  const CacheFailure({
    required super.message,
    super.code = 'CACHE_ERROR',
  });
}

class UnknownFailure extends Failure {
  const UnknownFailure({
    required super.message,
    super.code = 'UNKNOWN_ERROR',
  });
}

// Extension pour convertir les exceptions en failures
extension ExceptionToFailure on Exception {
  Failure toFailure() {
    if (this is NetworkException) {
      final ex = this as NetworkException;
      return NetworkFailure(message: ex.message);
    } else if (this is ServerException) {
      final ex = this as ServerException;
      return ServerFailure(
        message: ex.message,
        statusCode: ex.statusCode,
      );
    } else if (this is AuthException) {
      final ex = this as AuthException;
      return AuthFailure(message: ex.message);
    } else if (this is ValidationException) {
      final ex = this as ValidationException;
      return ValidationFailure(
        message: ex.message,
        field: ex.field,
      );
    } else if (this is CacheException) {
      final ex = this as CacheException;
      return CacheFailure(message: ex.message);
    }
    return UnknownFailure(message: toString());
  }
}

// Exceptions personnalisées
class NetworkException implements Exception {
  const NetworkException(this.message);
  final String message;
}

class ServerException implements Exception {
  const ServerException(this.message, {this.statusCode});
  final String message;
  final int? statusCode;
}

class AuthException implements Exception {
  const AuthException(this.message);
  final String message;
}

class ValidationException implements Exception {
  const ValidationException(this.message, {this.field});
  final String message;
  final String? field;
}

class CacheException implements Exception {
  const CacheException(this.message);
  final String message;
}