import { ConfigModule } from '@nestjs/config';
import { Test, TestingModule } from '@nestjs/testing';

import { nestConfig } from '@/app/config/nest.config';
import { PrismaService } from '@/app/prisma/prisma.service';
import { mockedPrismaService } from '@/app/__mocks__';
import { ProductsService } from '../../services/products.service';
import { mockedCreateProductDto, mockedProduct } from '../../__mocks__';
import { ConflictProductExistsError } from '../../exceptions';

describe(ProductsService.name, () => {
  let service: ProductsService;

  beforeEach(async () => {
    const module: TestingModule = await Test.createTestingModule({
      imports: [ConfigModule.forFeature(nestConfig)],
      providers: [
        ProductsService,
        {
          provide: PrismaService,
          useValue: mockedPrismaService,
        },
      ],
    }).compile();

    service = module.get<ProductsService>(ProductsService);
  });

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

  describe(ProductsService.prototype.newProduct.name, () => {
    it('should create a product when provide valid product data', async () => {
      jest
        .spyOn(mockedPrismaService.product, 'findFirst')
        .mockImplementationOnce(() => null);

      const product = service.newProduct(mockedCreateProductDto);

      await expect(product).resolves.toBe(mockedProduct);
    });

    it('should return an error when product exists', async () => {
      jest
        .spyOn(mockedPrismaService.product, 'findFirst')
        .mockImplementationOnce(() => mockedProduct);

      const product = service.newProduct(mockedCreateProductDto);

      await expect(product).rejects.toThrow(ConflictProductExistsError);
    });
  });

  describe(ProductsService.prototype.getTotalProducts.name, () => {
    it('should get total quantity of products', async () => {
      jest
        .spyOn(mockedPrismaService.product, 'findFirst')
        .mockImplementationOnce(() => null);

      const totalProducts = await service.getTotalProducts();

      expect(typeof totalProducts).toBe('number');
    });
  });

  describe(ProductsService.prototype.getProductById.name, () => {
    it('should return a product', async () => {
      const product = await service.getProductById(mockedProduct.id);

      expect(product).toStrictEqual(mockedProduct);
    });

    it('should return an error if provide a invalid product id', async () => {
      jest
        .spyOn(mockedPrismaService.product, 'findFirst')
        .mockImplementation(() => null);

      const product = service.getProductById('invalid id');

      await expect(product).rejects.toThrowError();
    });
  });
  describe(ProductsService.prototype.findProduct.name, () => {
    it('should return a product when use search', async () => {
      jest
        .spyOn(mockedPrismaService.product, 'findFirst')
        .mockImplementation(() => mockedProduct);

      const product = await service.findProduct(mockedProduct.id);

      expect(product).toBe(mockedProduct);
    });
  });
  describe(ProductsService.prototype.findProductsBySearchQuery.name, () => {
    it('should find a product by id when provide a search query', async () => {
      const product = await service.findProductsBySearchQuery(mockedProduct.id);

      expect(product).toStrictEqual([mockedProduct]);
    });
  });
  describe(ProductsService.prototype.getProducts.name, () => {
    it('should return the list of all products', async () => {
      const products = await service.getProducts();

      expect(products).toStrictEqual([mockedProduct]);
    });
  });
});