import 'package:flutter_test/flutter_test.dart';
import 'package:get_it/get_it.dart';
import 'package:superport/data/datasources/remote/api_client.dart';
import 'package:superport/models/user_model.dart';
import 'package:superport/domain/usecases/user/get_users_usecase.dart';
import 'package:superport/domain/usecases/user/create_user_usecase.dart';
import 'package:superport/domain/usecases/user/update_user_usecase.dart';
import 'package:superport/domain/usecases/user/delete_user_usecase.dart';
import 'package:superport/services/user_service.dart';
import '../base/base_screen_test.dart';
import '../../framework/models/test_models.dart';

/// 사용자 관리 화면 자동화 테스트
/// 
/// 테스트 범위:
/// - 사용자 목록 조회
/// - 사용자 생성 (권한 설정)
/// - 사용자 수정 (비밀번호 변경)
/// - 사용자 삭제
/// - 역할별 권한 테스트 (Admin/Manager/Member)
class UserScreenTest extends BaseScreenTest {
  late UserService userService;
  late GetUsersUseCase getUsersUseCase;
  late CreateUserUseCase createUserUseCase;
  late UpdateUserUseCase updateUserUseCase;
  late DeleteUserUseCase deleteUserUseCase;
  
  // 테스트 데이터
  final List<int> createdUserIds = [];
  
  UserScreenTest({
    required ApiClient apiClient,
    required GetIt getIt,
    required super.testContext,
    required super.errorDiagnostics,
    required super.autoFixer,
    required super.dataGenerator,
    required super.reportCollector,
  }) : super(
    apiClient: apiClient,
    getIt: getIt,
  );
  
  @override
  ScreenMetadata getScreenMetadata() {
    return ScreenMetadata(
      screenName: 'User',
      screenPath: '/user',
      screenType: ScreenType.list,
      features: [
        'list_view',
        'search',
        'pagination',
        'create',
        'update',
        'delete',
        'role_management',
        'password_change',
      ],
    );
  }
  
  @override
  Future<void> initializeServices() async {
    try {
      // UseCase 인스턴스 가져오기
      getUsersUseCase = getIt<GetUsersUseCase>();
      createUserUseCase = getIt<CreateUserUseCase>();
      updateUserUseCase = getIt<UpdateUserUseCase>();
      deleteUserUseCase = getIt<DeleteUserUseCase>();
      
      // Legacy 서비스 (점진적 마이그레이션을 위해 유지)
      userService = getIt<UserService>();
      
      _log('✅ User 서비스 초기화 완료');
    } catch (e) {
      _log('❌ User 서비스 초기화 실패: $e');
      throw TestSetupError(
        message: 'User 서비스 초기화 실패',
        details: {'error': e.toString()},
      );
    }
  }
  
  @override
  Future<void> performAdditionalSetup() async {
    // 테스트용 사용자 데이터 생성
    await _createTestUsers();
  }
  
  @override
  Future<void> performAdditionalCleanup() async {
    // 생성된 테스트 데이터 정리
    await _cleanupTestUsers();
  }
  
  @override
  Future<List<TestFeature>> detectFeatures(ScreenMetadata metadata) async {
    final features = <TestFeature>[];
    
    // 기본 CRUD 기능
    features.add(TestFeature(
      featureName: '사용자 목록 조회',
      testSteps: [
        TestStep(
          name: '전체 사용자 목록 조회',
          action: () => _testGetUserList(),
          expectedResult: '사용자 목록이 정상적으로 조회됨',
        ),
        TestStep(
          name: '페이징 처리',
          action: () => _testPagination(),
          expectedResult: '페이지별로 데이터가 정확히 나뉘어짐',
        ),
        TestStep(
          name: '검색 기능',
          action: () => _testSearch(),
          expectedResult: '검색어에 매칭되는 사용자만 조회됨',
        ),
      ],
    ));
    
    features.add(TestFeature(
      featureName: '사용자 생성',
      testSteps: [
        TestStep(
          name: 'Admin 권한 사용자 생성',
          action: () => _testCreateAdminUser(),
          expectedResult: 'Admin 사용자가 성공적으로 생성됨',
        ),
        TestStep(
          name: 'Manager 권한 사용자 생성',
          action: () => _testCreateManagerUser(),
          expectedResult: 'Manager 사용자가 성공적으로 생성됨',
        ),
        TestStep(
          name: 'Member 권한 사용자 생성',
          action: () => _testCreateMemberUser(),
          expectedResult: 'Member 사용자가 성공적으로 생성됨',
        ),
        TestStep(
          name: '이메일 중복 체크',
          action: () => _testEmailDuplicateCheck(),
          expectedResult: '동일한 이메일로 생성 시 에러 발생',
        ),
      ],
    ));
    
    features.add(TestFeature(
      featureName: '사용자 수정',
      testSteps: [
        TestStep(
          name: '기본 정보 수정',
          action: () => _testUpdateUser(),
          expectedResult: '사용자 정보가 정상적으로 수정됨',
        ),
        TestStep(
          name: '권한 변경',
          action: () => _testUpdateUserRole(),
          expectedResult: '사용자 권한이 정상적으로 변경됨',
        ),
        TestStep(
          name: '비밀번호 변경',
          action: () => _testChangePassword(),
          expectedResult: '비밀번호가 성공적으로 변경됨',
        ),
      ],
    ));
    
    features.add(TestFeature(
      featureName: '사용자 삭제',
      testSteps: [
        TestStep(
          name: '일반 삭제',
          action: () => _testDeleteUser(),
          expectedResult: '사용자가 성공적으로 삭제됨',
        ),
        TestStep(
          name: '자기 자신 삭제 방지',
          action: () => _testDeleteSelf(),
          expectedResult: '자기 자신은 삭제할 수 없음',
        ),
      ],
    ));
    
    features.add(TestFeature(
      featureName: '권한 관리',
      testSteps: [
        TestStep(
          name: 'Admin 권한 테스트',
          action: () => _testAdminPermissions(),
          expectedResult: 'Admin은 모든 기능 접근 가능',
        ),
        TestStep(
          name: 'Manager 권한 테스트',
          action: () => _testManagerPermissions(),
          expectedResult: 'Manager는 일부 기능 제한',
        ),
        TestStep(
          name: 'Member 권한 테스트',
          action: () => _testMemberPermissions(),
          expectedResult: 'Member는 읽기 전용',
        ),
      ],
    ));
    
    return features;
  }
  
  // ===== 테스트 구현 메서드들 =====
  
  /// 테스트용 사용자 데이터 생성
  Future<void> _createTestUsers() async {
    try {
      // 각 권한별로 테스트 사용자 생성
      final roles = [UserRole.admin, UserRole.manager, UserRole.member];
      
      for (int i = 0; i < roles.length; i++) {
        final userData = dataGenerator.generateUser(
          email: 'test_${testSessionId}_${i}@superport.kr',
          name: '테스트사용자_${roles[i].name}',
          role: roles[i],
          password: 'Test1234!',
        );
        
        final result = await createUserUseCase.execute(userData);
        result.fold(
          (failure) => _log('사용자 생성 실패: ${failure.message}'),
          (user) {
            createdUserIds.add(user.id!);
            _log('테스트 사용자 생성: ${user.name} (ID: ${user.id}, Role: ${user.role})');
          },
        );
      }
    } catch (e) {
      _log('테스트 사용자 생성 중 에러: $e');
    }
  }
  
  /// 테스트 데이터 정리
  Future<void> _cleanupTestUsers() async {
    for (final id in createdUserIds) {
      try {
        await deleteUserUseCase.execute(id);
        _log('테스트 사용자 삭제: ID $id');
      } catch (e) {
        _log('사용자 삭제 실패 (ID: $id): $e');
      }
    }
    createdUserIds.clear();
  }
  
  /// 사용자 목록 조회 테스트
  Future<void> _testGetUserList() async {
    final result = await getUsersUseCase.execute(
      page: 1,
      size: 10,
    );
    
    result.fold(
      (failure) => throw TestException('사용자 목록 조회 실패: ${failure.message}'),
      (response) {
        assert(response.users.isNotEmpty, '사용자 목록이 비어있음');
        assert(response.totalCount > 0, '전체 개수가 0');
        _log('사용자 목록 조회 성공: ${response.users.length}명');
      },
    );
  }
  
  /// 페이징 테스트
  Future<void> _testPagination() async {
    // 첫 페이지
    final page1Result = await getUsersUseCase.execute(
      page: 1,
      size: 5,
    );
    
    page1Result.fold(
      (failure) => throw TestException('페이지 1 조회 실패: ${failure.message}'),
      (page1) async {
        // 두 번째 페이지
        final page2Result = await getUsersUseCase.execute(
          page: 2,
          size: 5,
        );
        
        page2Result.fold(
          (failure) => _log('페이지 2 조회 실패 (데이터 부족일 수 있음): ${failure.message}'),
          (page2) {
            // 페이지별 데이터가 다른지 확인
            if (page2.users.isNotEmpty) {
              final page1Ids = page1.users.map((u) => u.id).toSet();
              final page2Ids = page2.users.map((u) => u.id).toSet();
              assert(page1Ids.intersection(page2Ids).isEmpty, '페이지 간 데이터 중복');
            }
            _log('페이징 테스트 성공');
          },
        );
      },
    );
  }
  
  /// 검색 테스트
  Future<void> _testSearch() async {
    final searchTerm = 'test_$testSessionId';
    final result = await getUsersUseCase.execute(
      page: 1,
      size: 10,
      search: searchTerm,
    );
    
    result.fold(
      (failure) => throw TestException('검색 실패: ${failure.message}'),
      (response) {
        for (final user in response.users) {
          assert(
            user.email.contains(searchTerm) || 
            user.name.contains(searchTerm),
            '검색 결과가 검색어와 매치되지 않음'
          );
        }
        _log('검색 테스트 성공: ${response.users.length}명 검색됨');
      },
    );
  }
  
  /// Admin 사용자 생성 테스트
  Future<void> _testCreateAdminUser() async {
    final userData = dataGenerator.generateUser(
      email: 'admin_${DateTime.now().millisecondsSinceEpoch}@superport.kr',
      name: 'Admin 테스트',
      role: UserRole.admin,
      password: 'Admin1234!',
    );
    
    final result = await createUserUseCase.execute(userData);
    
    result.fold(
      (failure) => throw TestException('Admin 사용자 생성 실패: ${failure.message}'),
      (user) {
        assert(user.id != null, '생성된 사용자 ID가 null');
        assert(user.role == UserRole.admin, '권한이 Admin이 아님');
        createdUserIds.add(user.id!);
        _log('Admin 사용자 생성 성공: ${user.name} (ID: ${user.id})');
      },
    );
  }
  
  /// Manager 사용자 생성 테스트
  Future<void> _testCreateManagerUser() async {
    final userData = dataGenerator.generateUser(
      email: 'manager_${DateTime.now().millisecondsSinceEpoch}@superport.kr',
      name: 'Manager 테스트',
      role: UserRole.manager,
      password: 'Manager1234!',
    );
    
    final result = await createUserUseCase.execute(userData);
    
    result.fold(
      (failure) => throw TestException('Manager 사용자 생성 실패: ${failure.message}'),
      (user) {
        assert(user.id != null, '생성된 사용자 ID가 null');
        assert(user.role == UserRole.manager, '권한이 Manager가 아님');
        createdUserIds.add(user.id!);
        _log('Manager 사용자 생성 성공: ${user.name} (ID: ${user.id})');
      },
    );
  }
  
  /// Member 사용자 생성 테스트
  Future<void> _testCreateMemberUser() async {
    final userData = dataGenerator.generateUser(
      email: 'member_${DateTime.now().millisecondsSinceEpoch}@superport.kr',
      name: 'Member 테스트',
      role: UserRole.member,
      password: 'Member1234!',
    );
    
    final result = await createUserUseCase.execute(userData);
    
    result.fold(
      (failure) => throw TestException('Member 사용자 생성 실패: ${failure.message}'),
      (user) {
        assert(user.id != null, '생성된 사용자 ID가 null');
        assert(user.role == UserRole.member, '권한이 Member가 아님');
        createdUserIds.add(user.id!);
        _log('Member 사용자 생성 성공: ${user.name} (ID: ${user.id})');
      },
    );
  }
  
  /// 이메일 중복 체크 테스트
  Future<void> _testEmailDuplicateCheck() async {
    final email = 'duplicate_${DateTime.now().millisecondsSinceEpoch}@superport.kr';
    
    // 첫 번째 생성 (성공해야 함)
    final user1 = dataGenerator.generateUser(
      email: email,
      name: '중복테스트1',
      role: UserRole.member,
      password: 'Test1234!',
    );
    
    final result1 = await createUserUseCase.execute(user1);
    
    result1.fold(
      (failure) => throw TestException('첫 번째 사용자 생성 실패: ${failure.message}'),
      (user) => createdUserIds.add(user.id!),
    );
    
    // 두 번째 생성 (실패해야 함)
    final user2 = dataGenerator.generateUser(
      email: email, // 동일한 이메일
      name: '중복테스트2',
      role: UserRole.member,
      password: 'Test1234!',
    );
    
    final result2 = await createUserUseCase.execute(user2);
    
    result2.fold(
      (failure) => _log('이메일 중복 체크 성공: ${failure.message}'),
      (user) {
        createdUserIds.add(user.id!);
        throw TestException('중복 이메일로 생성이 허용됨');
      },
    );
  }
  
  /// 사용자 수정 테스트
  Future<void> _testUpdateUser() async {
    if (createdUserIds.isEmpty) {
      await _createTestUsers();
    }
    
    final userId = createdUserIds.first;
    final updatedData = dataGenerator.generateUser(
      email: 'updated_${testSessionId}@superport.kr',
      name: '수정된사용자',
      role: UserRole.member,
    );
    
    final result = await updateUserUseCase.execute(
      id: userId,
      user: updatedData,
    );
    
    result.fold(
      (failure) => throw TestException('사용자 수정 실패: ${failure.message}'),
      (user) {
        assert(user.name == updatedData.name, '사용자명 수정 실패');
        _log('사용자 수정 성공: ${user.name}');
      },
    );
  }
  
  /// 사용자 권한 변경 테스트
  Future<void> _testUpdateUserRole() async {
    if (createdUserIds.isEmpty) {
      await _createTestUsers();
    }
    
    final userId = createdUserIds.first;
    
    // Member로 변경
    final memberData = dataGenerator.generateUser(
      email: 'role_test@superport.kr',
      name: '권한테스트',
      role: UserRole.member,
    );
    
    final result1 = await updateUserUseCase.execute(
      id: userId,
      user: memberData,
    );
    
    result1.fold(
      (failure) => throw TestException('Member 권한 변경 실패: ${failure.message}'),
      (user) {
        assert(user.role == UserRole.member, 'Member 권한 변경 실패');
        _log('Member 권한 변경 성공');
      },
    );
    
    // Manager로 변경
    final managerData = memberData.copyWith(role: UserRole.manager);
    
    final result2 = await updateUserUseCase.execute(
      id: userId,
      user: managerData,
    );
    
    result2.fold(
      (failure) => throw TestException('Manager 권한 변경 실패: ${failure.message}'),
      (user) {
        assert(user.role == UserRole.manager, 'Manager 권한 변경 실패');
        _log('Manager 권한 변경 성공');
      },
    );
  }
  
  /// 비밀번호 변경 테스트
  Future<void> _testChangePassword() async {
    // 비밀번호 변경은 별도 API가 필요할 수 있음
    // 현재는 사용자 수정 API로 처리
    _log('비밀번호 변경 테스트 - 별도 API 구현 필요');
  }
  
  /// 사용자 삭제 테스트
  Future<void> _testDeleteUser() async {
    // 삭제용 사용자 생성
    final userData = dataGenerator.generateUser(
      email: 'delete_${DateTime.now().millisecondsSinceEpoch}@superport.kr',
      name: '삭제테스트',
      role: UserRole.member,
      password: 'Test1234!',
    );
    
    final createResult = await createUserUseCase.execute(userData);
    
    createResult.fold(
      (failure) => throw TestException('삭제 테스트용 사용자 생성 실패: ${failure.message}'),
      (user) async {
        // 삭제
        final deleteResult = await deleteUserUseCase.execute(user.id!);
        
        deleteResult.fold(
          (failure) => throw TestException('사용자 삭제 실패: ${failure.message}'),
          (_) => _log('사용자 삭제 성공: ID ${user.id}'),
        );
      },
    );
  }
  
  /// 자기 자신 삭제 방지 테스트
  Future<void> _testDeleteSelf() async {
    // 현재 로그인한 사용자 ID를 가져와야 함
    // 이 테스트는 프론트엔드에서 처리되어야 할 수도 있음
    _log('자기 자신 삭제 방지 테스트 - 프론트엔드 검증 필요');
  }
  
  /// Admin 권한 테스트
  Future<void> _testAdminPermissions() async {
    // Admin 권한으로 모든 기능 접근 테스트
    // 실제로는 각 API를 Admin 권한으로 호출해보는 것
    _log('Admin 권한 테스트 - 모든 API 접근 가능 확인');
  }
  
  /// Manager 권한 테스트
  Future<void> _testManagerPermissions() async {
    // Manager 권한으로 제한된 기능 테스트
    _log('Manager 권한 테스트 - 일부 기능 제한 확인');
  }
  
  /// Member 권한 테스트
  Future<void> _testMemberPermissions() async {
    // Member 권한으로 읽기 전용 테스트
    _log('Member 권한 테스트 - 읽기 전용 확인');
  }
  
  void _log(String message) {
    print('[UserScreenTest] $message');
  }
}