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

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

import * as referenceService from '@/services/reference-lookups.service';
import { prisma } from '@/lib/prisma';

describe('Unit - services/reference-lookups.types-absence', () => {
  beforeEach(() => {
    vi.resetAllMocks();
  });
  it('listTypesAbsence: should return the types absence list with pagination', async () => {
          const limit = 25;
          const offset = 50;
          
          const expectedList = [{ id: 1 }, { id: 2 }];
  
          vi.mocked(prisma.types_absence.findMany).mockResolvedValue(expectedList as never);
  
          const res = await referenceService.listTypesAbsence(limit, offset);
  
          expect(prisma.types_absence.findMany).toHaveBeenCalledWith({
              orderBy: [{ id: 'asc' }],
              take: limit,
              skip: offset,
          });
          expect(res).toEqual(expectedList);
      });
  it('getTypeAbsenceById returns a type absence by id', async () => {
    const expected = {
      id: 1,
      typeabsence: 'Maladie',
      libabsence: 'Maladie',
      date_creation: new Date('2026-05-28T00:00:00.000Z'),
    };

    vi.mocked(prisma.types_absence.findUnique).mockResolvedValue(expected);

    const result = await referenceService.getTypeAbsenceById(1);

    expect(prisma.types_absence.findUnique).toHaveBeenCalledWith({ where: { id: 1 } });
    expect(result).toEqual(expected);
  });

  it('createTypesAbsenceFeed creates a type absence', async () => {
    const payload = { typeabsence: 'Maladie', libabsence: 'Maladie' };
    const expected = {
      id: 1,
      ...payload,
      date_creation: new Date('2026-05-28T00:00:00.000Z'),
    };

    vi.mocked(prisma.types_absence.create).mockResolvedValue(expected);

    const result = await referenceService.createTypesAbsenceFeed(payload);

    expect(prisma.types_absence.create).toHaveBeenCalledWith({ data: payload });
    expect(result).toEqual(expected);
  });

  it('updateTypesAbsenceFeed updates a type absence', async () => {
    const payload = { libabsence: 'Accident' };
    const expected = {
      id: 1,
      typeabsence: 'Maladie',
      libabsence: 'Accident',
      date_creation: new Date('2026-05-28T00:00:00.000Z'),
    };

    vi.mocked(prisma.types_absence.update).mockResolvedValue(expected);

    const result = await referenceService.updateTypesAbsenceFeed(1, payload);

    expect(prisma.types_absence.update).toHaveBeenCalledWith({ where: { id: 1 }, data: payload });
    expect(result).toEqual(expected);
  });

  it('deleteTypesAbsenceFeed deletes a type absence', async () => {
    const expected = {
      id: 1,
      typeabsence: 'Maladie',
      libabsence: 'Maladie',
      date_creation: new Date('2026-05-28T00:00:00.000Z'),
    };

    vi.mocked(prisma.types_absence.delete).mockResolvedValue(expected);

    const result = await referenceService.deleteTypesAbsenceFeed(1);

    expect(prisma.types_absence.delete).toHaveBeenCalledWith({ where: { id: 1 } });
    expect(result).toEqual(expected);
  });
});