import 'package:flutter_test/flutter_test.dart';
import 'test_data_generator.dart';

void main() {
  setUpAll(() async {
    // 실제 API 테스트 환경 초기화
    // RealApiTestHelper가 없으므로 주석 처리
    // await RealApiTestHelper.setupTestEnvironment();
    // await RealApiTestHelper.loginAndGetToken();
  });

  tearDownAll(() async {
    // 모든 테스트 데이터 정리
    await TestDataGenerator.cleanupAllTestData();
    // await RealApiTestHelper.teardownTestEnvironment();
  });

  group('TestDataGenerator 단위 메서드 테스트', () {
    test('고유 ID 생성 테스트', () {
      final id1 = TestDataGenerator.generateUniqueId();
      final id2 = TestDataGenerator.generateUniqueId();
      
      expect(id1, isNotNull);
      expect(id2, isNotNull);
      expect(id1, isNot(equals(id2)));
    });

    test('고유 이메일 생성 테스트', () {
      final email1 = TestDataGenerator.generateUniqueEmail();
      final email2 = TestDataGenerator.generateUniqueEmail(domain: 'company.kr');
      
      expect(email1, contains('@test.com'));
      expect(email2, contains('@company.kr'));
      expect(email1, isNot(equals(email2)));
    });

    test('전화번호 생성 테스트', () {
      final phone = TestDataGenerator.generatePhoneNumber();
      
      expect(phone, matches(RegExp(r'^\d{3}-\d{4}-\d{4}$')));
    });

    test('사업자등록번호 생성 테스트', () {
      final businessNumber = TestDataGenerator.generateBusinessNumber();
      
      expect(businessNumber, matches(RegExp(r'^\d{3}-\d{2}-\d{5}$')));
    });
  });

  group('스마트 데이터 생성 테스트', () {
    test('회사 데이터 생성 테스트', () {
      final companyData = TestDataGenerator.createSmartCompanyData();
      
      expect(companyData.name, isNotEmpty);
      expect(companyData.address, contains('서울시 강남구'));
      expect(companyData.contactPhone, matches(RegExp(r'^\d{3}-\d{4}-\d{4}$')));
      expect(companyData.contactEmail, contains('@company.com'));
    });

    test('사용자 데이터 생성 테스트', () {
      final userData = TestDataGenerator.createSmartUserData(
        companyId: 1,
        role: 'manager',
      );
      
      expect(userData.name, matches(RegExp(r'^[가-힣]{2,4}$')));
      expect(userData.email, contains('@company.com'));
      expect(userData.password, equals('Test1234!@'));
      expect(userData.role, equals('manager'));
      expect(userData.companyId, equals(1));
    });

    test('장비 데이터 생성 테스트', () {
      final equipmentData = TestDataGenerator.createSmartEquipmentData(
        companyId: 1,
        warehouseLocationId: 1,
      );
      
      expect(equipmentData.equipmentNumber, startsWith('EQ-'));
      expect(equipmentData.manufacturer, isIn([
        '삼성전자', 'LG전자', 'Apple', 'Dell', 'HP', 'Lenovo', 'Microsoft', 'ASUS'
      ]));
      expect(equipmentData.serialNumber, matches(RegExp(r'^[A-Z]{2}\d{10}$')));
      expect(equipmentData.purchasePrice, greaterThan(0));
    });

    test('라이선스 데이터 생성 테스트', () {
      final licenseData = TestDataGenerator.createSmartLicenseData(
        companyId: 1,
      );
      
      expect(licenseData.licenseKey, startsWith('LIC-'));
      expect(licenseData.productName, isIn([
        'Microsoft Office 365',
        'Adobe Creative Cloud',
        'AutoCAD 2024',
        'Windows 11 Pro',
        'Visual Studio Enterprise',
        'JetBrains All Products',
        'Slack Business+',
        'Zoom Business',
      ]));
      expect(licenseData.vendor, isNotEmpty);
      expect(licenseData.expiryDate!.isAfter(DateTime.now()), isTrue);
    });

    test('창고 데이터 생성 테스트', () {
      final warehouseData = TestDataGenerator.createSmartWarehouseData();
      
      expect(warehouseData.name, isNotEmpty);
      expect(warehouseData.address, contains('서울시 강남구'));
      expect(warehouseData.city, equals('서울'));
      expect(warehouseData.country, equals('대한민국'));
      expect(warehouseData.capacity, isIn([100, 200, 500, 1000, 2000]));
    });
  });

  group('시나리오 데이터 생성 테스트', () {
    test('장비 입고 시나리오 테스트', () async {
      final scenario = await TestDataGenerator.createEquipmentScenario(
        equipmentCount: 3,
      );
      
      expect(scenario.company.name, equals('테크장비관리 주식회사'));
      expect(scenario.warehouse.name, equals('중앙 물류센터'));
      expect(scenario.equipments.length, equals(3));
      
      // Equipment 모델에 currentCompanyId와 warehouseLocationId 필드가 없음
      // 대신 장비 수만 확인
      for (final equipment in scenario.equipments) {
        expect(equipment, isNotNull);
        expect(equipment.name, isNotEmpty);
      }
    });

    test('사용자 관리 시나리오 테스트', () async {
      final scenario = await TestDataGenerator.createUserScenario(
        userCount: 8,
      );
      
      expect(scenario.company.name, equals('스마트HR 솔루션'));
      expect(scenario.users.length, equals(8));
      
      // 모든 사용자가 같은 회사에 속하는지 확인
      for (final user in scenario.users) {
        expect(user.companyId, equals(scenario.company.id));
      }
      
      // 매니저가 있는지 확인
      final managers = scenario.users.where((u) => u.role == 'manager');
      expect(managers.isNotEmpty, isTrue);
    });

    test('라이선스 관리 시나리오 테스트', () async {
      final scenario = await TestDataGenerator.createLicenseScenario(
        licenseCount: 6,
      );
      
      expect(scenario.company.name, equals('소프트웨어 라이선스 매니지먼트'));
      expect(scenario.users.length, equals(5));
      expect(scenario.licenses.length, equals(6));
      
      // 할당된 라이선스와 미할당 라이선스 확인
      expect(scenario.assignedLicenses.length, greaterThan(0));
      expect(scenario.unassignedLicenses.length, greaterThan(0));
      expect(
        scenario.assignedLicenses.length + scenario.unassignedLicenses.length,
        equals(scenario.licenses.length),
      );
    });
  });

  group('데이터 정리 테스트', () {
    test('특정 타입 데이터 정리 테스트', () async {
      // 테스트 데이터 생성
      // 실제 생성은 시나리오 테스트에서 이미 수행됨
      
      // 특정 타입만 정리
      await TestDataGenerator.cleanupTestDataByType(TestDataType.equipment);
      
      // 정리 후 확인 (실제 테스트에서는 API 호출로 확인 필요)
      expect(true, isTrue); // 단순 성공 확인
    });
  });

  group('실제 데이터 풀 검증', () {
    test('제조사별 모델 매핑 검증', () {
      final samsung = TestDataGenerator.createSmartEquipmentData(
        companyId: 1,
        warehouseLocationId: 1,
        manufacturer: '삼성전자',
      );
      
      expect(samsung.modelName, isIn([
        'Galaxy Book Pro',
        'Galaxy Book Pro 360',
        'Odyssey G9',
        'ViewFinity S9',
      ]));
    });

    test('카테고리별 가격 범위 검증', () {
      final laptop = TestDataGenerator.createSmartEquipmentData(
        companyId: 1,
        warehouseLocationId: 1,
        category: '노트북',
      );
      
      // 노트북 기본 가격 1,500,000원의 ±30% 범위
      expect(laptop.purchasePrice, greaterThanOrEqualTo(1050000));
      expect(laptop.purchasePrice, lessThanOrEqualTo(1950000));
    });

    test('라이선스 제품별 벤더 매핑 검증', () {
      final office = TestDataGenerator.createSmartLicenseData(
        companyId: 1,
        productName: 'Microsoft Office 365',
      );
      
      expect(office.vendor, equals('Microsoft'));
      expect(office.purchasePrice, equals(120000.0));
    });
  });
}