import { BadRequestException } from '@nestjs/common';
import { Test, TestingModule } from '@nestjs/testing';
import { PiecesService } from './pieces.service';
import { PrismaService } from '../prisma/prisma.service';
import { CreatePieceDto } from '../shared/dto/piece.dto';

describe('PiecesService', () => {
  let service: PiecesService;
  let prisma: any;

  beforeEach(async () => {
    prisma = {
      piece: {
        create: jest.fn(),
      },
      machine: {
        findUnique: jest.fn(),
      },
      composant: {
        findUnique: jest.fn(),
      },
    };

    const module: TestingModule = await Test.createTestingModule({
      providers: [PiecesService, { provide: PrismaService, useValue: prisma }],
    }).compile();

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

  afterEach(() => {
    jest.clearAllMocks();
  });

  it('should create a piece when requirement matches the machine skeleton', async () => {
    const dto: CreatePieceDto = {
      name: 'Piece A',
      machineId: 'machine-1',
      typePieceId: 'type-piece-1',
      typeMachinePieceRequirementId: 'req-1',
    };

    prisma.machine.findUnique.mockResolvedValue({
      id: 'machine-1',
      typeMachine: {
        pieceRequirements: [
          { id: 'req-1', typePieceId: 'type-piece-1' },
        ],
      },
    });

    const created = { id: 'piece-1' };
    prisma.piece.create.mockResolvedValue(created);

    await expect(service.create(dto)).resolves.toEqual(created);
    expect(prisma.piece.create).toHaveBeenCalled();
    expect(prisma.piece.create.mock.calls[0][0].data.machineId).toBe(
      'machine-1',
    );
  });

  it('should refuse creation when requirement does not belong to machine skeleton', async () => {
    const dto: CreatePieceDto = {
      name: 'Piece A',
      machineId: 'machine-1',
      typePieceId: 'type-piece-1',
      typeMachinePieceRequirementId: 'req-2',
    };

    prisma.machine.findUnique.mockResolvedValue({
      id: 'machine-1',
      typeMachine: {
        pieceRequirements: [
          { id: 'req-1', typePieceId: 'type-piece-1' },
        ],
      },
    });

    await expect(service.create(dto)).rejects.toBeInstanceOf(
      BadRequestException,
    );

    expect(prisma.piece.create).not.toHaveBeenCalled();
  });
});