import { classes } from '@automapper/classes';
import { AutomapperModule } from '@automapper/nestjs';
import { Test, TestingModule } from '@nestjs/testing';
import { LoggingMessager } from '../../adapters/secondaries/logging.messager';
import { TerritoriesRepository } from '../../adapters/secondaries/territories.repository';
import { TerritoryMessager } from '../../adapters/secondaries/territory.messager';
import { CreateTerritoryCommand } from '../../commands/create-territory.command';
import { CreateTerritoryRequest } from '../../domain/dtos/create-territory.request';
import { Territory } from '../../domain/entities/territory';
import { CreateTerritoryUseCase } from '../../domain/usecases/create-territory.usecase';
import { TerritoryProfile } from '../../mappers/territory.profile';

const newTerritoryRequest: CreateTerritoryRequest = {
  name: 'Grand Est',
  shape: 'grand-est-binary-shape',
};
const newTerritoryCommand: CreateTerritoryCommand = new CreateTerritoryCommand(
  newTerritoryRequest,
);

const mockTerritoriesRepository = {
  create: jest
    .fn()
    .mockImplementationOnce(() => {
      return Promise.resolve({
        ...newTerritoryRequest,
        uuid: 'bb281075-1b98-4456-89d6-c643d3044a91',
      });
    })
    .mockImplementation(() => {
      throw new Error('Already exists');
    }),
};

const mockMessager = {
  publish: jest.fn().mockImplementation(),
};

describe('CreateTerritoryUseCase', () => {
  let createTerritoryUseCase: CreateTerritoryUseCase;

  beforeAll(async () => {
    const module: TestingModule = await Test.createTestingModule({
      imports: [AutomapperModule.forRoot({ strategyInitializer: classes() })],
      providers: [
        {
          provide: TerritoriesRepository,
          useValue: mockTerritoriesRepository,
        },
        CreateTerritoryUseCase,
        TerritoryProfile,
        {
          provide: TerritoryMessager,
          useValue: mockMessager,
        },
        {
          provide: LoggingMessager,
          useValue: mockMessager,
        },
      ],
    }).compile();

    createTerritoryUseCase = module.get<CreateTerritoryUseCase>(
      CreateTerritoryUseCase,
    );
  });

  it('should be defined', () => {
    expect(createTerritoryUseCase).toBeDefined();
  });

  describe('execute', () => {
    it('should create and return a new territory', async () => {
      const newTerritory: Territory = await createTerritoryUseCase.execute(
        newTerritoryCommand,
      );

      expect(newTerritory.name).toBe(newTerritoryRequest.name);
      expect(newTerritory.uuid).toBeDefined();
    });

    it('should throw an error if territory already exists', async () => {
      await expect(
        createTerritoryUseCase.execute(newTerritoryCommand),
      ).rejects.toBeInstanceOf(Error);
    });
  });
});