import { describe, it, expect, vi, beforeEach } from 'vitest';

vi.mock('@/lib/prisma', () => ({
    prisma: {
        avenants_contrat: {
            create: vi.fn(),
            findMany: vi.fn(),
        },
    },
}));

import * as avenantService from '@/services/avenants.service';
import { prisma } from '@/lib/prisma';
type CreateAvenantPayload = Parameters<typeof avenantService.createAvenant>[0];

describe('Unit - service/avenant', () => {
    beforeEach(() => {
        vi.resetAllMocks();
    });
    it('listAvenants: Should return the avenants list with pagination', async () => {
        const limit = 25;
        const offset = 0;
        const expectedAvenants = [
            { id: 1, id_avenant: 5524, id_contrat: 5687 },
            { id: 2, id_avenant: 5, id_contrat: 5687 },
        ];

        vi.mocked(prisma.avenants_contrat.findMany).mockResolvedValue(expectedAvenants as never);

        const res = await avenantService.listAvenants(limit, offset);

        expect(prisma.avenants_contrat.findMany).toHaveBeenCalledWith({
            orderBy: [{ id: "asc" }],
            take: limit,
            skip: offset,
        });
        expect(res).toEqual(expectedAvenants);
    });
    it('listAvenants: should return an empty array when no avenants exists', async () => {
        const limit = 10;
        const offset = 0;

        vi.mocked(prisma.avenants_contrat.findMany).mockResolvedValue([] as never);

        const res = await avenantService.listAvenants(limit, offset);

        expect(prisma.avenants_contrat.findMany).toHaveBeenCalledWith({
            orderBy: [{ id: 'asc' }],
            take: limit,
            skip: offset,
        });
        expect(res).toEqual([]);
    });

    it('listAvenantsByContratBusinessId: should return avenants for the given contract business id', async () => {
        const idContrat = 5687;
        const expectedAvenants = [
            { id: 1, id_avenant: 5524, id_contrat: idContrat },
            { id: 2, id_avenant: 5, id_contrat: idContrat },
        ];

        vi.mocked(prisma.avenants_contrat.findMany).mockResolvedValue(expectedAvenants as never);

        const res = await avenantService.listAvenantsByContratBusinessId(idContrat);

        expect(prisma.avenants_contrat.findMany).toHaveBeenCalledWith({
            where: {
                id_contrat: idContrat,
            },
            orderBy: [{ id: 'asc' }],
        });
        expect(res).toEqual(expectedAvenants);
    });

    it('createAvenant: should call prisma.create and return created avenant', async () => {
        const payload: CreateAvenantPayload = {
            id_avenant: 5524,
            id_contrat: 5687,
            commentaire: 'avenant de test',
        };
        const createdAvenant = { id: 1, ...payload };

        vi.mocked(prisma.avenants_contrat.create).mockResolvedValue(createdAvenant as never);

        const res = await avenantService.createAvenant(payload);

        expect(prisma.avenants_contrat.create).toHaveBeenCalledWith({
            data: payload,
        });
        expect(res).toEqual(createdAvenant);
    });
})