import 'package:flutter_test/flutter_test.dart';
import 'package:get_it/get_it.dart';
import 'package:superport/models/user_model.dart';
import 'package:superport/services/user_service.dart';
import 'package:superport/services/company_service.dart';
import 'test_helper.dart';

void main() {
  late UserService userService;
  late CompanyService companyService;
  String? authToken;
  int? createdUserId;
  int? testCompanyId;

  setUpAll(() async {
    await RealApiTestHelper.setupTestEnvironment();
    
    // 로그인하여 인증 토큰 획득
    authToken = await RealApiTestHelper.loginAndGetToken();
    expect(authToken, isNotNull, reason: '로그인에 실패했습니다');
    
    // 서비스 가져오기
    userService = GetIt.instance<UserService>();
    companyService = GetIt.instance<CompanyService>();
    
    // 테스트용 회사 생성 (사용자는 회사에 속해야 함)
    final companies = await companyService.getCompanies(page: 1, perPage: 1);
    if (companies.isNotEmpty) {
      testCompanyId = companies.first.id;
    }
  });

  tearDownAll(() async {
    await RealApiTestHelper.teardownTestEnvironment();
  });

  group('User CRUD API 테스트', skip: 'Real API tests - skipping in CI', () {
    test('사용자 목록 조회', () async {
      if (testCompanyId == null) {
        // 테스트할 회사가 없습니다
        return;
      }

      final users = await userService.getUsers(
        page: 1,
        perPage: 10,
        companyId: testCompanyId,
      );

      expect(users, isNotNull);
      expect(users, isA<List<User>>());
      
      if (users.isNotEmpty) {
        final firstUser = users.first;
        expect(firstUser.id, isNotNull);
        expect(firstUser.name, isNotEmpty);
        expect(firstUser.email, isNotEmpty);
      }
    });

    test('사용자 생성', () async {
      if (testCompanyId == null) {
        // 사용자를 생성할 회사가 없습니다
        return;
      }

      final userName = 'Integration Test User ${DateTime.now().millisecondsSinceEpoch}';
      final userEmail = 'test_${DateTime.now().millisecondsSinceEpoch}@integrationtest.com';
      
      final createdUser = await userService.createUser(
        username: userEmail.split('@')[0], // 이메일에서 username 생성
        email: userEmail,
        password: 'Test1234!',
        name: userName,
        role: 'M', // Member
        companyId: testCompanyId!,
      );
      
      expect(createdUser, isNotNull);
      expect(createdUser.id, isNotNull);
      expect(createdUser.name, equals(userName));
      expect(createdUser.email, equals(userEmail));
      expect(createdUser.companyId, equals(testCompanyId));
      expect(createdUser.role, equals('M'));
      
      createdUserId = createdUser.id;
    });

    test('사용자 상세 조회', () async {
      if (createdUserId == null) {
        // 사용자 목록에서 첫 번째 사용자 ID 사용
        final users = await userService.getUsers(page: 1, perPage: 1);
        if (users.isEmpty) {
          // 조회할 사용자가 없습니다
          return;
        }
        createdUserId = users.first.id;
      }

      final user = await userService.getUser(createdUserId!);
      
      expect(user, isNotNull);
      expect(user.id, equals(createdUserId));
      expect(user.name, isNotEmpty);
      expect(user.email, isNotEmpty);
    });

    test('사용자 정보 수정', () async {
      if (createdUserId == null) {
        // 수정할 사용자가 없습니다
        return;
      }

      // 먼저 현재 사용자 정보 조회
      final currentUser = await userService.getUser(createdUserId!);
      
      // 수정할 정보
      final result = await userService.updateUser(
        createdUserId!,
        name: '${currentUser.name} - Updated',
        // 이메일은 보통 변경 불가
        companyId: currentUser.companyId,
        role: currentUser.role,
      );
      
      expect(result, isNotNull);
      expect(result.id, equals(createdUserId));
      expect(result.name, contains('Updated'));
    });

    test('사용자 비밀번호 변경', () async {
      if (createdUserId == null) {
        // 비밀번호를 변경할 사용자가 없습니다
        return;
      }

      // changePassword 메소드가 현재 서비스에 구현되어 있지 않음
      // updateUser를 통해 비밀번호 변경 시도
      try {
        await userService.updateUser(
          createdUserId!,
          password: 'NewPassword1234!',
        );
        // 비밀번호 변경 성공
      } catch (e) {
        // 비밀번호 변경 실패: $e
      }
    });

    test('사용자 활성/비활성 토글', () async {
      if (createdUserId == null) {
        // 토글할 사용자가 없습니다
        return;
      }

      // 현재 상태 확인
      final currentUser = await userService.getUser(createdUserId!);

      // 상태 토글 (toggleUserActive 메소드가 없으므로 update 사용)
      // isActive 필드를 직접 업데이트할 수 있는 메소드가 필요
      // 현재 서비스에서는 이 기능을 지원하지 않을 수 있음
      try {
        await userService.updateUser(
          createdUserId!,
          name: currentUser.name,
        );
        // 사용자 상태 토글 기능은 향후 구현 예정
      } catch (e) {
        // 상태 토글 실패: $e
      }
      
      // 변경된 상태 확인 (현재는 이름만 확인)
      final updatedUser = await userService.getUser(createdUserId!);
      expect(updatedUser.name, isNotNull);
    });

    test('사용자 역할별 필터링', () async {
      // 관리자 역할 사용자 조회
      final adminUsers = await userService.getUsers(
        page: 1,
        perPage: 10,
        role: 'S', // Super Admin
      );

      expect(adminUsers, isNotNull);
      expect(adminUsers, isA<List<User>>());
      
      if (adminUsers.isNotEmpty) {
        expect(adminUsers.every((user) => user.role == 'S'), isTrue);
      }

      // 일반 멤버 조회
      final memberUsers = await userService.getUsers(
        page: 1,
        perPage: 10,
        role: 'M', // Member
      );

      expect(memberUsers, isNotNull);
      expect(memberUsers, isA<List<User>>());
      
      if (memberUsers.isNotEmpty) {
        expect(memberUsers.every((user) => user.role == 'M'), isTrue);
      }
    });

    test('회사별 사용자 조회', () async {
      if (testCompanyId == null) {
        // 테스트할 회사가 없습니다
        return;
      }

      final companyUsers = await userService.getUsers(
        page: 1,
        perPage: 10,
        companyId: testCompanyId,
      );

      expect(companyUsers, isNotNull);
      expect(companyUsers, isA<List<User>>());
      
      if (companyUsers.isNotEmpty) {
        expect(companyUsers.every((user) => user.companyId == testCompanyId), isTrue);
      }
    });

    test('사용자 삭제', () async {
      if (createdUserId == null) {
        // 삭제할 사용자가 없습니다
        return;
      }

      // 삭제 실행
      await userService.deleteUser(createdUserId!);
      
      // 삭제 확인 (404 에러 예상)
      try {
        await userService.getUser(createdUserId!);
        fail('삭제된 사용자가 여전히 조회됩니다');
      } catch (e) {
        // 삭제 성공 - 404 에러가 발생해야 함
        expect(e.toString(), contains('404'));
      }
    });

    test('잘못된 ID로 사용자 조회 시 에러', () async {
      try {
        await userService.getUser(999999);
        fail('존재하지 않는 사용자가 조회되었습니다');
      } catch (e) {
        // 에러가 발생해야 정상
        expect(e.toString(), isNotEmpty);
      }
    });

    test('중복 이메일로 사용자 생성 시 에러', () async {
      if (testCompanyId == null) {
        // 테스트할 회사가 없습니다
        return;
      }

      // 기존 사용자 이메일 가져오기
      final users = await userService.getUsers(page: 1, perPage: 1);
      if (users.isEmpty) {
        // 중복 테스트할 사용자가 없습니다
        return;
      }

      final existingEmail = users.first.email ?? 'test@example.com';

      try {
        await userService.createUser(
          username: 'duplicateuser',
          name: 'Duplicate User',
          email: existingEmail, // 중복 이메일
          password: 'Test1234!',
          companyId: testCompanyId!,
          role: 'M',
        );
        fail('중복 이메일로 사용자가 생성되었습니다');
      } catch (e) {
        // 에러가 발생해야 정상
        expect(e.toString(), isNotEmpty);
      }
    });

    test('약한 비밀번호로 사용자 생성 시 에러', () async {
      if (testCompanyId == null) {
        // 테스트할 회사가 없습니다
        return;
      }

      try {
        await userService.createUser(
          username: 'weakuser',
          name: 'Weak Password User',
          email: 'weak_${DateTime.now().millisecondsSinceEpoch}@test.com',
          password: '1234', // 약한 비밀번호
          companyId: testCompanyId!,
          role: 'M',
        );
        fail('약한 비밀번호로 사용자가 생성되었습니다');
      } catch (e) {
        // 에러가 발생해야 정상
        expect(e.toString(), isNotEmpty);
      }
    });
  });
}