import 'package:dartz/dartz.dart';
import 'package:injectable/injectable.dart';
import '../../core/errors/failures.dart';
import '../../domain/repositories/user_repository.dart';
import '../../models/user_model.dart';
import '../datasources/remote/user_remote_datasource.dart';
import '../models/common/paginated_response.dart';
import '../models/user/user_dto.dart';

/// 사용자 관리 Repository 구현체
/// 사용자 계정 CRUD 및 권한 관리 작업을 처리하며 도메인 모델과 API DTO 간 변환을 담당
@Injectable(as: UserRepository)
class UserRepositoryImpl implements UserRepository {
  final UserRemoteDataSource remoteDataSource;

  UserRepositoryImpl({required this.remoteDataSource});

  @override
  Future<Either<Failure, PaginatedResponse<User>>> getUsers({
    int? page,
    int? limit,
    String? search,
    String? role,
    int? companyId,
    bool? isActive,
    String? sortBy,
    String? sortOrder,
  }) async {
    try {
      final result = await remoteDataSource.getUsers(
        page: page ?? 1,
        perPage: limit ?? 20,
        isActive: isActive,
        companyId: companyId,
        role: role,
      );
      
      // DTO를 도메인 모델로 변환
      final users = result.items.map((dto) => _mapDtoToDomain(dto)).toList();
      
      // 검색 필터링 (서버에서 지원하지 않는 경우 클라이언트 측에서 처리)
      if (search != null && search.isNotEmpty) {
        final filteredUsers = users.where((user) {
          final searchLower = search.toLowerCase();
          return (user.username?.toLowerCase().contains(searchLower) ?? false) ||
                 user.name.toLowerCase().contains(searchLower) ||
                 (user.email?.toLowerCase().contains(searchLower) ?? false);
        }).toList();
        
        final paginatedResult = PaginatedResponse<User>(
          items: filteredUsers,
          page: result.page,
          size: result.size,
          totalElements: filteredUsers.length,
          totalPages: (filteredUsers.length / result.size).ceil(),
          first: result.first,
          last: result.last,
        );
        
        return Right(paginatedResult);
      }
      
      final paginatedResult = PaginatedResponse<User>(
        items: users,
        page: result.page,
        size: result.size,
        totalElements: result.totalElements,
        totalPages: result.totalPages,
        first: result.first,
        last: result.last,
      );
      
      return Right(paginatedResult);
    } catch (e) {
      return Left(ServerFailure(
        message: '사용자 목록 조회 중 오류가 발생했습니다: ${e.toString()}',
      ));
    }
  }

  @override
  Future<Either<Failure, User>> getUserById(int id) async {
    try {
      final result = await remoteDataSource.getUser(id);
      final user = _mapDtoToDomain(result);
      return Right(user);
    } catch (e) {
      if (e.toString().contains('404')) {
        return Left(NotFoundFailure(
          message: '해당 사용자를 찾을 수 없습니다.',
          resourceType: 'User',
          resourceId: id.toString(),
        ));
      }
      return Left(ServerFailure(
        message: '사용자 상세 정보 조회 중 오류가 발생했습니다: ${e.toString()}',
      ));
    }
  }

  @override
  Future<Either<Failure, User>> createUser(User user, String password) async {
    try {
      final request = _mapDomainToCreateRequest(user, password);
      final result = await remoteDataSource.createUser(request);
      final createdUser = _mapDtoToDomain(result);
      return Right(createdUser);
    } catch (e) {
      if (e.toString().contains('중복')) {
        return Left(DuplicateFailure(
          message: '이미 사용 중인 이메일입니다.',
          field: 'username',
          value: user.username ?? '',
        ));
      }
      if (e.toString().contains('유효성')) {
        return Left(ValidationFailure(
          message: '입력 데이터가 올바르지 않습니다.',
        ));
      }
      return Left(ServerFailure(
        message: '사용자 생성 중 오류가 발생했습니다: ${e.toString()}',
      ));
    }
  }

  @override
  Future<Either<Failure, User>> updateUser(int id, User user) async {
    try {
      final request = _mapDomainToUpdateRequest(user);
      final result = await remoteDataSource.updateUser(id, request);
      final updatedUser = _mapDtoToDomain(result);
      return Right(updatedUser);
    } catch (e) {
      if (e.toString().contains('404')) {
        return Left(NotFoundFailure(
          message: '수정할 사용자를 찾을 수 없습니다.',
          resourceType: 'User',
          resourceId: id.toString(),
        ));
      }
      if (e.toString().contains('중복')) {
        return Left(DuplicateFailure(
          message: '이미 사용 중인 이메일입니다.',
          field: 'username',
          value: user.username ?? '',
        ));
      }
      return Left(ServerFailure(
        message: '사용자 정보 수정 중 오류가 발생했습니다: ${e.toString()}',
      ));
    }
  }

  @override
  Future<Either<Failure, void>> deleteUser(int id) async {
    try {
      await remoteDataSource.deleteUser(id);
      return const Right(null);
    } catch (e) {
      if (e.toString().contains('404')) {
        return Left(NotFoundFailure(
          message: '삭제할 사용자를 찾을 수 없습니다.',
          resourceType: 'User',
          resourceId: id.toString(),
        ));
      }
      if (e.toString().contains('참조')) {
        return Left(BusinessFailure(
          message: '해당 사용자에 연결된 데이터가 있어 삭제할 수 없습니다.',
        ));
      }
      return Left(ServerFailure(
        message: '사용자 삭제 중 오류가 발생했습니다: ${e.toString()}',
      ));
    }
  }

  @override
  Future<Either<Failure, User>> toggleUserStatus(int id) async {
    try {
      // 현재 사용자 정보 조회
      final currentUser = await remoteDataSource.getUser(id);
      final newStatus = !currentUser.isActive;
      
      // 상태 업데이트
      final request = ChangeStatusRequest(isActive: newStatus);
      final updatedUser = await remoteDataSource.changeUserStatus(id, request);
      final user = _mapDtoToDomain(updatedUser);
      
      return Right(user);
    } catch (e) {
      if (e.toString().contains('404')) {
        return Left(NotFoundFailure(
          message: '상태를 변경할 사용자를 찾을 수 없습니다.',
          resourceType: 'User',
          resourceId: id.toString(),
        ));
      }
      return Left(ServerFailure(
        message: '사용자 상태 변경 중 오류가 발생했습니다: ${e.toString()}',
      ));
    }
  }

  @override
  Future<Either<Failure, void>> resetPassword(int id, String newPassword) async {
    try {
      // resetPassword 메서드가 데이터소스에 없으므로 changePassword 사용
      final request = ChangePasswordRequest(currentPassword: '', newPassword: newPassword);
      await remoteDataSource.changePassword(id, request);
      return const Right(null);
    } catch (e) {
      if (e.toString().contains('404')) {
        return Left(NotFoundFailure(
          message: '비밀번호를 재설정할 사용자를 찾을 수 없습니다.',
          resourceType: 'User',
          resourceId: id.toString(),
        ));
      }
      return Left(ServerFailure(
        message: '비밀번호 재설정 중 오류가 발생했습니다: ${e.toString()}',
      ));
    }
  }

  @override
  Future<Either<Failure, User>> changeUserRole(int id, String newRole) async {
    try {
      // changeUserRole 메서드가 데이터소스에 없으므로 updateUser 사용
      final request = UpdateUserRequest(role: newRole);
      final updatedUser = await remoteDataSource.updateUser(id, request);
      final user = _mapDtoToDomain(updatedUser);
      
      return Right(user);
    } catch (e) {
      if (e.toString().contains('404')) {
        return Left(NotFoundFailure(
          message: '역할을 변경할 사용자를 찾을 수 없습니다.',
          resourceType: 'User',
          resourceId: id.toString(),
        ));
      }
      return Left(ServerFailure(
        message: '사용자 역할 변경 중 오류가 발생했습니다: ${e.toString()}',
      ));
    }
  }

  @override
  Future<Either<Failure, bool>> isDuplicateUsername(String username, {int? excludeId}) async {
    try {
      final isDuplicate = await remoteDataSource.checkDuplicateUsername(username);
      // excludeId가 있는 경우 해당 ID 제외 로직 추가 필요
      return Right(isDuplicate);
    } catch (e) {
      return Left(ServerFailure(
        message: '중복 사용자명 확인 중 오류가 발생했습니다: ${e.toString()}',
      ));
    }
  }

  @override
  Future<Either<Failure, List<User>>> getUsersByCompany(int companyId, {bool includeInactive = false}) async {
    try {
      // getUsersByCompany 메서드가 없으므로 getUsers로 대체
      final result = await remoteDataSource.getUsers(
        companyId: companyId,
        isActive: includeInactive ? null : true,
      );
      final users = result.users.map((dto) => _mapDtoToDomain(dto)).toList();
      return Right(users);
    } catch (e) {
      return Left(ServerFailure(
        message: '회사별 사용자 조회 중 오류가 발생했습니다: ${e.toString()}',
      ));
    }
  }

  @override
  Future<Either<Failure, Map<String, int>>> getUserCountByRole() async {
    // TODO: API에서 역할별 사용자 수 통계 기능이 구현되면 추가
    return const Left(ServerFailure(
      message: '역할별 사용자 수 통계 기능이 아직 구현되지 않았습니다.',
    ));
  }

  @override
  Future<Either<Failure, List<User>>> searchUsers(String query, {int? companyId, int? limit}) async {
    try {
      final result = await remoteDataSource.searchUsers(
        query: query,
        companyId: companyId,
        perPage: limit ?? 10,
      );
      final users = result.users.map((dto) => _mapDtoToDomain(dto)).toList();
      return Right(users);
    } catch (e) {
      return Left(ServerFailure(
        message: '사용자 검색 중 오류가 발생했습니다: ${e.toString()}',
      ));
    }
  }

  @override
  Future<Either<Failure, void>> updateLastLoginTime(int id) async {
    try {
      // updateLastLoginTime 메서드가 데이터소스에 없으므로 비어있는 구현
      // TODO: API에서 지원되면 구현
      throw UnimplementedError('마지막 로그인 시간 업데이트 기능이 아직 구현되지 않았습니다.');
      return const Right(null);
    } catch (e) {
      return Left(ServerFailure(
        message: '마지막 로그인 시간 업데이트 중 오류가 발생했습니다: ${e.toString()}',
      ));
    }
  }

  // Private 매퍼 메서드들
  
  User _mapDtoToDomain(UserDto dto) {
    return User(
      id: dto.id,
      companyId: dto.companyId ?? 0,
      branchId: dto.branchId,
      name: dto.name,
      role: dto.role,
      email: dto.email,
      phoneNumbers: dto.phone != null ? [{'type': 'primary', 'number': dto.phone!}] : [],
      username: dto.username,
      isActive: dto.isActive,
      createdAt: dto.createdAt,
      updatedAt: dto.updatedAt,
    );
  }
  
  // _mapDetailDtoToDomain 함수는 더 이상 사용하지 않음 - _mapDtoToDomain 사용
  
  // _mapResponseToDomain 함수는 더 이상 사용하지 않음 - _mapDtoToDomain 사용
  
  // UserRole enum은 더 이상 필요하지 않음 - String role을 직접 사용
  
  CreateUserRequest _mapDomainToCreateRequest(User user, String password) {
    return CreateUserRequest(
      username: user.username ?? user.email ?? '',
      password: password,
      name: user.name,
      email: user.email,
      phone: user.phoneNumbers.isNotEmpty ? user.phoneNumbers.first['number'] : null,
      role: user.role,
      companyId: user.companyId,
      branchId: user.branchId,
    );
  }
  
  UpdateUserRequest _mapDomainToUpdateRequest(User user) {
    return UpdateUserRequest(
      name: user.name,
      email: user.email,
      phone: user.phoneNumbers.isNotEmpty ? user.phoneNumbers.first['number'] : null,
      role: user.role,
      companyId: user.companyId,
      branchId: user.branchId,
      isActive: user.isActive,
    );
  }
  
  // _mapRoleToString 함수는 더 이상 필요하지 않음 - role을 직접 String으로 사용
}