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

vi.mock('@/lib/prisma', () => ({
  prisma: {
    types_cs: {
      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-cs', () => {
  beforeEach(() => {
    vi.resetAllMocks();
  });

  describe('Unit - services/reference-lookups.types-cs', () => {
    beforeEach(() => {
      vi.resetAllMocks();
    });
  
    it('listTypesCs: should return the types cs list with pagination', async () => {
      const limit = 25;
      const offset = 50;
  
      const expectedList = [{ id: 1 }, { id: 2 }];
  
      vi.mocked(prisma.types_cs.findMany).mockResolvedValue(expectedList as never);
  
      const result = await referenceService.listTypesCs(limit, offset);
  
      expect(prisma.types_cs.findMany).toHaveBeenCalledWith({
        orderBy: [{ id: 'asc' }],
        take: limit,
        skip: offset,
      });
  
      expect(result).toEqual(expectedList);
    });
  
    it('getTypeCsById returns a type cs by id', async () => {
      const expected = {
        id: 1,
        typecs: "typcs",
    report3mois: false,
    typeao: "ao",
        date_creation: new Date('2026-05-28T00:00:00.000Z'),
      };
  
      vi.mocked(prisma.types_cs.findUnique).mockResolvedValue(expected);
  
      const result = await referenceService.getTypeCsById(1);
  
      expect(prisma.types_cs.findUnique).toHaveBeenCalledWith({
        where: { id: 1 },
      });
  
      expect(result).toEqual(expected);
    });
  
    it('createTypesCscreates a type cs', async () => {
      const payload = {
        typecs: "typcs",
    report3mois: false,
    typeao: "ao",
      };
  
      const expected = {
        id: 1,
        ...payload,
        date_creation: new Date('2026-05-28T00:00:00.000Z'),
      };
  
      vi.mocked(prisma.types_cs.create).mockResolvedValue(expected);
  
      const result = await referenceService.createTypesCs(payload);
  
      expect(prisma.types_cs.create).toHaveBeenCalledWith({
        data: payload,
      });
  
      expect(result).toEqual(expected);
    });
  
    it('updateTypesCs updates a type cs', async () => {
      const payload = {
        typeao: 'Mise à jour',
      };
  
      const expected = {
        id: 1,
        typecs: "typcs",
    report3mois: false,
    typeao: "Mise à jour",
        date_creation: new Date('2026-05-28T00:00:00.000Z'),
      };
  
      vi.mocked(prisma.types_cs.update).mockResolvedValue(expected);
  
      const result = await referenceService.updateTypesCs(1, payload);
  
      expect(prisma.types_cs.update).toHaveBeenCalledWith({
        where: { id: 1 },
        data: payload,
      });
  
      expect(result).toEqual(expected);
    });
  
    it('deleteTypesCs deletes a type cs', async () => {
      const expected = {
        id: 1,
        typecs: "typcs",
    report3mois: false,
    typeao: "ao",
        date_creation: new Date('2026-05-28T00:00:00.000Z'),
      };
  
      vi.mocked(prisma.types_cs.delete).mockResolvedValue(expected);
  
      const result = await referenceService.deleteTypesCs(1);
  
      expect(prisma.types_cs.delete).toHaveBeenCalledWith({
        where: { id: 1 },
      });
  
      expect(result).toEqual(expected);
    });
  });
});