import 'package:flutter_test/flutter_test.dart';
import 'package:mocktail/mocktail.dart';
import 'package:rasadyar_chicken/data/data_source/remote/poultry_science/poultry_science_remote.dart';
import 'package:rasadyar_chicken/data/models/poultry_export/poultry_export.dart';
import 'package:rasadyar_chicken/data/models/request/kill_registration/kill_registration.dart';
import 'package:rasadyar_chicken/data/models/response/all_poultry/all_poultry.dart';
import 'package:rasadyar_chicken/data/models/response/approved_price/approved_price.dart';
import 'package:rasadyar_chicken/data/models/response/hatching/hatching_models.dart';
import 'package:rasadyar_chicken/data/models/response/hatching_report/hatching_report.dart';
import 'package:rasadyar_chicken/data/models/response/kill_house_poultry/kill_house_poultry.dart';
import 'package:rasadyar_chicken/data/models/response/kill_request_poultry/kill_request_poultry.dart';
import 'package:rasadyar_chicken/data/models/response/poultry_farm/poultry_farm.dart';
import 'package:rasadyar_chicken/data/models/response/poultry_hatching/poultry_hatching.dart';
import 'package:rasadyar_chicken/data/models/response/poultry_order/poultry_order.dart';
import 'package:rasadyar_chicken/data/models/response/poultry_science/home_poultry_science/home_poultry_science_model.dart';
import 'package:rasadyar_chicken/data/models/response/sell_for_freezing/sell_for_freezing.dart';
import 'package:rasadyar_chicken/data/repositories/poultry_science/poultry_science_repository_imp.dart';
import 'package:rasadyar_core/core.dart';

class MockPoultryScienceRemoteDataSource extends Mock
    implements PoultryScienceRemoteDatasource {}

void main() {
  late PoultryScienceRepositoryImp poultryScienceRepository;
  late MockPoultryScienceRemoteDataSource mockRemote;

  setUp(() {
    mockRemote = MockPoultryScienceRemoteDataSource();
    poultryScienceRepository = PoultryScienceRepositoryImp(mockRemote);
  });

  group('Poultry Science Integration Tests', () {
    const token = 'test-token';

    group('Complete Poultry Science Home Flow', () {
      test('should complete full poultry science home workflow', () async {
        // Arrange
        const type = 'hatching';

        final expectedHomeModel = HomePoultryScienceModel(
          farmCount: 5,
          hatchingCount: 1000,
          hatchingQuantity: 500,
          hatchingLeftOver: 200,
          hatchingLosses: 50,
          hatchingKilledQuantity: 250,
          hatchingMaxAge: 45,
          hatchingMinAge: 30,
        );

        final expectedHatching = [
          HatchingModel(
            id: 1,
            key: 'hatching-1',
            date: '2024-01-01',
            quantity: 100,
            state: 'active',
          ),
        ];
        final expectedHatchingPagination = PaginationModel<HatchingModel>(
          results: expectedHatching,
          count: 1,
          next: null,
          previous: null,
        );

        // Mock the flow
        when(
          () => mockRemote.getHomePoultryScience(token: token, type: type),
        ).thenAnswer((_) async => expectedHomeModel);

        when(
          () => mockRemote.getHatchingPoultry(
            token: token,
            queryParameters: any(named: 'queryParameters'),
          ),
        ).thenAnswer((_) async => expectedHatchingPagination);

        // Act - Step 1: Get home poultry science data
        final homeModel = await poultryScienceRepository.getHomePoultry(
          token: token,
          type: type,
        );

        // Act - Step 2: Get hatching poultry data
        final hatchingData = await poultryScienceRepository.getHatchingPoultry(
          token: token,
          queryParameters: {'page': '1', 'limit': '10'},
        );

        // Assert
        expect(homeModel, equals(expectedHomeModel));
        expect(hatchingData, equals(expectedHatchingPagination));

        verify(
          () => mockRemote.getHomePoultryScience(token: token, type: type),
        ).called(1);
        verify(
          () => mockRemote.getHatchingPoultry(
            token: token,
            queryParameters: any(named: 'queryParameters'),
          ),
        ).called(1);
      });
    });

    group('Hatching Report Management Flow', () {
      test('should complete hatching report management workflow', () async {
        // Arrange
        final queryParameters = {'page': '1', 'limit': '10'};

        final expectedReports = [
          HatchingReport(
            id: 1,
            key: 'report-1',
            date: DateTime.parse('2024-01-01'),
            state: 'completed',
          ),
        ];
        final expectedPagination = PaginationModel<HatchingReport>(
          results: expectedReports,
          count: 1,
          next: null,
          previous: null,
        );

        final mockFormData = MockFormData();

        // Mock the flow
        when(
          () => mockRemote.getPoultryScienceReport(
            token: token,
            queryParameters: queryParameters,
          ),
        ).thenAnswer((_) async => expectedPagination);

        when(
          () => mockRemote.submitPoultryScienceReport(
            token: token,
            data: mockFormData,
            onSendProgress: any(named: 'onSendProgress'),
          ),
        ).thenAnswer((_) async {});

        // Act - Step 1: Get hatching reports
        final reports = await poultryScienceRepository.getHatchingPoultryReport(
          token: token,
          queryParameters: queryParameters,
        );

        // Act - Step 2: Submit new report
        await poultryScienceRepository.submitPoultryScienceReport(
          token: token,
          data: mockFormData,
        );

        // Assert
        expect(reports, equals(expectedPagination));

        verify(
          () => mockRemote.getPoultryScienceReport(
            token: token,
            queryParameters: queryParameters,
          ),
        ).called(1);
        verify(
          () => mockRemote.submitPoultryScienceReport(
            token: token,
            data: mockFormData,
            onSendProgress: any(named: 'onSendProgress'),
          ),
        ).called(1);
      });
    });

    group('Poultry Farm Management Flow', () {
      test('should complete poultry farm management workflow', () async {
        // Arrange
        final queryParameters = {'page': '1', 'limit': '10'};

        final expectedFarms = [
          PoultryFarm(
            id: 1,
            key: 'farm-1',
            unitName: 'Farm 1',
            totalCapacity: 1000,
            cityName: 'Tehran',
          ),
        ];
        final expectedPagination = PaginationModel<PoultryFarm>(
          results: expectedFarms,
          count: 1,
          next: null,
          previous: null,
        );

        // Mock the flow
        when(
          () => mockRemote.getPoultryScienceFarmList(
            token: token,
            queryParameters: queryParameters,
          ),
        ).thenAnswer((_) async => expectedPagination);

        // Act
        final farms = await poultryScienceRepository.getPoultryScienceFarmList(
          token: token,
          queryParameters: queryParameters,
        );

        // Assert
        expect(farms, equals(expectedPagination));

        verify(
          () => mockRemote.getPoultryScienceFarmList(
            token: token,
            queryParameters: queryParameters,
          ),
        ).called(1);
      });
    });

    group('Pricing and Market Data Flow', () {
      test('should complete pricing and market data workflow', () async {
        // Arrange
        final queryParameters = {'date': '2024-01-01'};

        final expectedApprovedPrice = ApprovedPrice(
          approved: true,
          lowestPrice: 45000.0,
          highestPrice: 55000.0,
          lowestWeight: 1.5,
          highestWeight: 2.5,
        );

        final expectedSellForFreezing = SellForFreezing(permission: true);

        final expectedPoultryExport = PoultryExport(
          key: 'export-key',
          allow: true,
          limitationStatus: false,
          limitation: 100.0,
        );

        // Mock the flow
        when(
          () => mockRemote.getApprovedPrice(
            token: token,
            queryParameters: queryParameters,
          ),
        ).thenAnswer((_) async => expectedApprovedPrice);

        when(
          () => mockRemote.getSellForFreezing(
            token: token,
            queryParameters: queryParameters,
          ),
        ).thenAnswer((_) async => expectedSellForFreezing);

        when(
          () => mockRemote.getPoultryExport(
            token: token,
            queryParameters: queryParameters,
          ),
        ).thenAnswer((_) async => expectedPoultryExport);

        // Act - Step 1: Get approved price
        final approvedPrice = await poultryScienceRepository.getApprovedPrice(
          token: token,
          queryParameters: queryParameters,
        );

        // Act - Step 2: Get sell for freezing data
        final sellForFreezing = await poultryScienceRepository
            .getSellForFreezing(token: token, queryParameters: queryParameters);

        // Act - Step 3: Get poultry export data
        final poultryExport = await poultryScienceRepository.getPoultryExport(
          token: token,
          queryParameters: queryParameters,
        );

        // Assert
        expect(approvedPrice, equals(expectedApprovedPrice));
        expect(sellForFreezing, equals(expectedSellForFreezing));
        expect(poultryExport, equals(expectedPoultryExport));

        verify(
          () => mockRemote.getApprovedPrice(
            token: token,
            queryParameters: queryParameters,
          ),
        ).called(1);
        verify(
          () => mockRemote.getSellForFreezing(
            token: token,
            queryParameters: queryParameters,
          ),
        ).called(1);
        verify(
          () => mockRemote.getPoultryExport(
            token: token,
            queryParameters: queryParameters,
          ),
        ).called(1);
      });
    });

    group('Kill Registration Flow', () {
      test('should complete kill registration workflow', () async {
        // Arrange
        final queryParameters = {'page': '1', 'limit': '10'};

        final expectedKillRequests = [
          KillRequestPoultry(
            key: 'kill-request-1',
            unitName: 'Farm 1',
            totalCapacity: 1000,
            cityName: 'Tehran',
            provinceName: 'Tehran',
          ),
        ];

        final expectedKillHouses = [
          KillHousePoultry(
            name: 'Kill House 1',
            killer: true,
            fullname: 'Kill House Manager',
            quantitySum: 500,
            firstQuantity: 100,
            poultryQuantitySum: 400,
            killReqKey: 'killhouse-1',
          ),
        ];

        final expectedPoultryHatching = [
          PoultryHatching(
            key: 'hatching-1',
            quantity: 100,
            losses: 5,
            leftOver: 95,
            killedQuantity: 50,
            state: 'active',
            date: '2024-01-01',
            age: 30,
          ),
        ];

        final killRegistrationRequest = KillRegistrationRequest(
          killReqKey: 'registration-key',
          operatorKey: 'operator-1',
          poultryHatchingKey: 'hatching-1',
          quantity: 100,
          sendDate: '2024-01-01',
          chickenBreed: 'Broiler',
          indexWeight: 2.0,
          losses: '5',
          freezing: false,
          export: false,
          cash: true,
          credit: false,
          role: 'farmer',
          poultryKey: 'poultry-1',
          amount: 100000,
          financialOperation: 'cash',
          freeSaleInProvince: true,
          confirmPoultryMobile: '09123456789',
        );

        // Mock the flow
        when(
          () => mockRemote.getUserPoultry(
            token: token,
            queryParameters: queryParameters,
          ),
        ).thenAnswer(
          (_) async => expectedKillRequests.cast<KillRequestPoultry>(),
        );

        when(
          () => mockRemote.getKillHouseList(
            token: token,
            queryParameters: queryParameters,
          ),
        ).thenAnswer((_) async => expectedKillHouses.cast<KillHousePoultry>());

        when(
          () => mockRemote.getPoultryHatching(
            token: token,
            queryParameters: queryParameters,
          ),
        ).thenAnswer(
          (_) async => expectedPoultryHatching.cast<PoultryHatching>(),
        );

        when(
          () => mockRemote.submitKillRegistration(
            token: token,
            request: killRegistrationRequest,
          ),
        ).thenAnswer((_) async {});

        // Act - Step 1: Get user poultry
        final killRequests = await poultryScienceRepository.getUserPoultry(
          token: token,
          queryParameters: queryParameters,
        );

        // Act - Step 2: Get kill house list
        final killHouses = await poultryScienceRepository.getKillHouseList(
          token: token,
          queryParameters: queryParameters,
        );

        // Act - Step 3: Get poultry hatching
        final poultryHatching = await poultryScienceRepository
            .getPoultryHatching(token: token, queryParameters: queryParameters);

        // Act - Step 4: Submit kill registration
        await poultryScienceRepository.submitKillRegistration(
          token: token,
          request: killRegistrationRequest,
        );

        // Assert
        expect(killRequests, equals(expectedKillRequests));
        expect(killHouses, equals(expectedKillHouses));
        expect(poultryHatching, equals(expectedPoultryHatching));

        verify(
          () => mockRemote.getUserPoultry(
            token: token,
            queryParameters: queryParameters,
          ),
        ).called(1);
        verify(
          () => mockRemote.getKillHouseList(
            token: token,
            queryParameters: queryParameters,
          ),
        ).called(1);
        verify(
          () => mockRemote.getPoultryHatching(
            token: token,
            queryParameters: queryParameters,
          ),
        ).called(1);
        verify(
          () => mockRemote.submitKillRegistration(
            token: token,
            request: killRegistrationRequest,
          ),
        ).called(1);
      });
    });

    group('Poultry Order Management Flow', () {
      test('should complete poultry order management workflow', () async {
        // Arrange
        final queryParameters = {'page': '1', 'limit': '10'};
        const orderId = 'order-1';

        final expectedOrders = [
          PoultryOrder(
            key: 'order-1',
            id: 1,
            orderCode: 1001,
            createDate: '2024-01-01',
            sendDate: '2024-01-02',
            quantity: 100,
            firstQuantity: 100,
            amount: 5000000.0,
            finalState: 'pending',
            provinceState: 'pending',
            stateProcess: 'processing',
            freeSaleInProvince: true,
            freezing: false,
            export: false,
            market: true,
          ),
        ];
        final expectedPagination = PaginationModel<PoultryOrder>(
          count: 1,
          next: null,
          previous: null,
          results: expectedOrders,
        );

        // Mock the flow
        when(
          () => mockRemote.getPoultryOderList(
            token: token,
            queryParameters: queryParameters,
          ),
        ).thenAnswer((_) async => expectedPagination);

        when(
          () => mockRemote.deletePoultryOder(token: token, orderId: orderId),
        ).thenAnswer((_) async {});

        // Act - Step 1: Get poultry orders
        final orders = await poultryScienceRepository.getPoultryOderList(
          token: token,
          queryParameters: queryParameters,
        );

        // Act - Step 2: Delete poultry order
        await poultryScienceRepository.deletePoultryOder(
          token: token,
          orderId: orderId,
        );

        // Assert
        expect(orders, equals(expectedPagination));

        verify(
          () => mockRemote.getPoultryOderList(
            token: token,
            queryParameters: queryParameters,
          ),
        ).called(1);
        verify(
          () => mockRemote.deletePoultryOder(token: token, orderId: orderId),
        ).called(1);
      });
    });

    group('All Poultry Data Flow', () {
      test('should complete all poultry data retrieval workflow', () async {
        // Arrange
        final queryParameters = {'type': 'all'};

        final expectedAllPoultry = [
          AllPoultry(
            key: 'poultry-1',
            unitName: 'Poultry Farm 1',
            lastHatchingRemainQuantity: 100,
            provinceAllowSellFree: true,
          ),
        ];

        // Mock the flow
        when(
          () => mockRemote.getAllPoultry(
            token: token,
            queryParameters: queryParameters,
          ),
        ).thenAnswer((_) async => expectedAllPoultry.cast<AllPoultry>());

        // Act
        final allPoultry = await poultryScienceRepository.getAllPoultry(
          token: token,
          queryParameters: queryParameters,
        );

        // Assert
        expect(allPoultry, equals(expectedAllPoultry));

        verify(
          () => mockRemote.getAllPoultry(
            token: token,
            queryParameters: queryParameters,
          ),
        ).called(1);
      });
    });

    group('Error Handling in Poultry Science Workflow', () {
      test('should handle home poultry data retrieval failure', () async {
        // Arrange
        const type = 'hatching';

        when(
          () => mockRemote.getHomePoultryScience(token: token, type: type),
        ).thenAnswer((_) async => null);

        // Act
        final homeModel = await poultryScienceRepository.getHomePoultry(
          token: token,
          type: type,
        );

        // Assert
        expect(homeModel, isNull);
        verify(
          () => mockRemote.getHomePoultryScience(token: token, type: type),
        ).called(1);
      });

      test('should handle kill registration submission failure', () async {
        // Arrange
        final killRegistrationRequest = KillRegistrationRequest(
          killReqKey: 'registration-key',
          operatorKey: 'operator-1',
          poultryHatchingKey: 'hatching-1',
          quantity: 100,
          sendDate: '2024-01-01',
          chickenBreed: 'Broiler',
          indexWeight: 2.0,
          losses: '5',
          freezing: false,
          export: false,
          cash: true,
          credit: false,
          role: 'farmer',
          poultryKey: 'poultry-1',
          amount: 100000,
          financialOperation: 'cash',
          freeSaleInProvince: true,
          confirmPoultryMobile: '09123456789',
        );

        when(
          () => mockRemote.submitKillRegistration(
            token: token,
            request: killRegistrationRequest,
          ),
        ).thenThrow(Exception('Kill registration submission failed'));

        // Act & Assert
        expect(
          () => poultryScienceRepository.submitKillRegistration(
            token: token,
            request: killRegistrationRequest,
          ),
          throwsA(isA<Exception>()),
        );

        verify(
          () => mockRemote.submitKillRegistration(
            token: token,
            request: killRegistrationRequest,
          ),
        ).called(1);
      });
    });
  });
}

// Mock FormData class
class MockFormData extends Mock implements FormData {}