import { VesselDetailsService } from 'app/modules/vesselDetails/root/services/vesselDetails.service';
import {
  createPoolPointsEditRequest,
  createVesselBunkerConsumption,
  createVesselBunkerConsumptionKeyFigures,
  createVesselBunkerConsumptionKeyFiguresDTO,
  createVesselDetailsOffHireDTO,
  createVesselFinancialKeyFigures,
  createVesselFinancialKeyFiguresDTO,
  createVesselGeneralInfo,
  createVesselGeneralInfoDTO,
  createVesselLoadMorePayments,
  createVesselLoadMorePaymentsDTO,
  createVesselPayments,
  createVesselPaymentsDTO,
  createVesselPoolPointsAllocation,
  createVesselPoolPointsAllocationDTO,
  createVesselPoolPointsKeyFigures,
  createVesselPoolPointsKeyFiguresDTO,
} from 'app/testUtils/mocks/VesselDetails.mock';
import { of } from 'rxjs';
import { take } from 'rxjs/operators';

describe('VesselEarnings details service tests', () => {
  const mockApiClient = {
    getVesselGeneralInfo: jest.fn(),
    getPoolPointsAllocation: jest.fn(),
    getPoolPointsKeyFigures: jest.fn(),
    getFinancialKeyFigures: jest.fn(),
    getBunkerConsumptionKeyFigures: jest.fn(),
    getPayments: jest.fn(),
    getMorePayments: jest.fn(),
    getOffHire: jest.fn(),
  };

  const sut = new VesselDetailsService(mockApiClient);

  it('executes fetching general info data', (done) => {

    const poolId = 1;
    const vesselCode = 1;
    const partnerAxCode = 'ABCDE';
    const vesselGeneralInfoDTOMock = createVesselGeneralInfoDTO()[vesselCode];
    const vesselGeneralInfoMock = createVesselGeneralInfo()[vesselCode];

    mockApiClient.getVesselGeneralInfo = jest.fn(() => of(vesselGeneralInfoDTOMock));

    sut.getGeneralInfo(poolId, vesselCode, partnerAxCode).pipe(take(1)).subscribe((data) => {
      expect(data).toEqual(vesselGeneralInfoMock);
      done();
    });
  });

  it('executes fetching pool points allocation data', (done) => {

    const vesselPoolPointsAllocationMock = createVesselPoolPointsAllocation();
    const vesselPoolPointsAllocationDTOMock = createVesselPoolPointsAllocationDTO();
    const poolId = 1;
    const vesselCode = 1;
    const partnerAxCode = 'ABCDE';

    mockApiClient.getPoolPointsAllocation = jest.fn(() => of(vesselPoolPointsAllocationDTOMock));

    sut.getPoolPointsAllocation(poolId, vesselCode, partnerAxCode).pipe(take(1)).subscribe((data) => {
      expect(data).toEqual(vesselPoolPointsAllocationMock);
      done();
    });
  });

  it('executes fetching PoolPoints key figures data', (done) => {

    const poolId = 1;
    const vesselCode = 1;
    const partnerAxCode = 'ABCDE';
    const vesselPoolPointsKeyFiguresMock = createVesselPoolPointsKeyFigures();
    const vesselPoolPointKeyFiguresDTOMock = createVesselPoolPointsKeyFiguresDTO();

    mockApiClient.getPoolPointsKeyFigures= jest.fn(() => of(vesselPoolPointKeyFiguresDTOMock));
    sut.getPoolPointsKeyFigures(poolId, vesselCode, partnerAxCode).pipe(take(1)).subscribe((data) => {
      expect(data).toEqual(vesselPoolPointsKeyFiguresMock);
      done();
    });
  });

  it('executes fetching financial key figures', (done) => {

    const poolId = 1;
    const vesselCode = 1;
    const partnerAxCode = 'ABCDE';
    const vesselFinancialKeyFiguresMock = createVesselFinancialKeyFigures();
    const vesselFinancialKeyFigureDTOsMock = createVesselFinancialKeyFiguresDTO();

    mockApiClient.getFinancialKeyFigures = jest.fn(() => of(vesselFinancialKeyFigureDTOsMock));

    sut.getFinancialKeyFigures(poolId, vesselCode, partnerAxCode).pipe(take(1)).subscribe((data) => {
      expect(data).toEqual(vesselFinancialKeyFiguresMock);
      done();
    });
  });

  it('executes fetching Bunker Adjustment data', (done) => {

    const poolId = 1;
    const vesselCode = 1;
    const partnerAxCode = 'ABCDE';
    const vesselBunkerConsumptionMock = createVesselBunkerConsumption();

    sut.getBunkerConsumption(poolId, vesselCode, partnerAxCode).pipe(take(1)).subscribe((data) => {
      expect(data).toEqual(vesselBunkerConsumptionMock);
      done();
    });
  });

  it('executes fetching Bunker Adjustment key figures data', (done) => {

    const poolId = 1;
    const vesselCode = 1;
    const partnerAxCode = 'ABCDE';
    const vesselBunkerConsumptionKeyFiguresMock = createVesselBunkerConsumptionKeyFigures();
    const vesselBunkerConsumptionKeyFiguresDTOMock = createVesselBunkerConsumptionKeyFiguresDTO();

    mockApiClient.getBunkerConsumptionKeyFigures = jest.fn(() => of(vesselBunkerConsumptionKeyFiguresDTOMock));
    sut.getBunkerConsumptionKeyFigures(poolId, vesselCode, partnerAxCode).pipe(take(1)).subscribe((data) => {
      expect(data).toEqual(vesselBunkerConsumptionKeyFiguresMock);
      done();
    });
  });

  it('executes pool points param edit request', (done) => {

    const paramId = 1;
    const responseMock = createPoolPointsEditRequest();

    sut.sendPoolPointsEditRequest().pipe(take(1)).subscribe((data) => {
      expect(data).toEqual(responseMock[paramId]);
      done();
    });
  });

  it('executes fetching payments', (done) => {
    const poolId = 1;
    const vesselCode = 1;
    const partnerAxCode = 'ABCDE';
    const vesselPaymentsMock = createVesselPayments();
    const vesselPaymentsDTOMock = createVesselPaymentsDTO();

    mockApiClient.getPayments = jest.fn(() => of(vesselPaymentsDTOMock));

    sut.getPayments(poolId, vesselCode, partnerAxCode).pipe(take(1)).subscribe((data) => {
      expect(data).toEqual(vesselPaymentsMock);
      done();
    });
  });

  it('executes loading more payments', (done) => {
    const offset = 5;
    const vesselLoadMoreMock = createVesselLoadMorePayments();
    const vesselLoadMoreDTOMock = createVesselLoadMorePaymentsDTO();

    mockApiClient.getMorePayments = jest.fn(() => of(vesselLoadMoreDTOMock));

    sut.getMorePayments('next', offset).pipe(take(1)).subscribe((data) => {
      expect(data).toEqual(vesselLoadMoreMock);
      done();
    });
  });

  it('executes fetching off hire', (done) => {

    const poolId = 1;
    const vesselCode = 1;
    const partnerAxCode = 'ABCDE';
    const vesselOffHireDTOsMock = createVesselDetailsOffHireDTO();

    mockApiClient.getOffHire = jest.fn(() => of(vesselOffHireDTOsMock));

    sut.getOffHire(poolId, vesselCode, partnerAxCode).pipe(take(1)).subscribe((data) => {
      expect(data).toEqual(vesselOffHireDTOsMock);
      done();
    });
  });
});