import { isContabilidadEnabledForEmpresa } from '../../common/utils/module-access.util';
import { TesCategoriaService } from './tes-categorias.service';

jest.mock('../../common/utils/module-access.util', () => ({ isContabilidadEnabledForEmpresa: jest.fn() }));
const contabilidad = isContabilidadEnabledForEmpresa as jest.Mock;

const UUID_CC = '11111111-1111-4111-8111-111111111111';

function armar(o: { categoria?: any; planes?: any[]; enUso?: boolean } = {}) {
  const categoria = o.categoria === undefined ? { id: 'cat', empresa_id: 'emp', is_sistema: false } : o.categoria;
  const prisma: any = {
    tes_categorias: {
      findFirst: jest.fn().mockResolvedValue(categoria),
      create: jest.fn().mockImplementation(({ data }) => Promise.resolve({ id: 'nueva', ...data })),
      update: jest.fn().mockImplementation(({ data }) => Promise.resolve(data)),
      delete: jest.fn().mockResolvedValue({}),
    },
    tes_movimiento_det: { findFirst: jest.fn().mockResolvedValue(o.enUso ? { id: 'd' } : null) },
    tes_categoria_cuenta_contable: { deleteMany: jest.fn().mockResolvedValue({ count: 1 }), upsert: jest.fn().mockResolvedValue({ cuenta_contable_id: UUID_CC }) },
    cont_plan_cuentas: {
      findFirst: jest
        .fn()
        .mockImplementation(({ where }) => Promise.resolve((o.planes ?? [{ id: UUID_CC, codigo: '4.1' }]).find((p) => p.id === where.id && !p.codigo.startsWith('OLD-')) ?? null)),
    },
  };
  return { prisma, servicio: new TesCategoriaService(prisma) };
}
const falla = async (p: Promise<unknown>) => {
  try {
    await p;
  } catch (e: any) {
    return { status: e.getStatus(), ...e.getResponse() };
  }
  throw new Error('no lanzó');
};

describe('TesCategoriaService', () => {
  beforeEach(() => contabilidad.mockReset());

  describe('crear', () => {
    it('sin CONTABILIDAD y con cuenta contable → CONTABILIDAD_NO_CONTRATADA; sin ella crea', async () => {
      contabilidad.mockResolvedValue(false);
      const { prisma, servicio } = armar();
      expect(await falla(servicio.create({ nombre: 'A', tipo: 'INGRESO', cuenta_contable_id: UUID_CC } as never, 'emp'))).toMatchObject({
        codigo: 'CONTABILIDAD_NO_CONTRATADA',
        campo: 'cuenta_contable_id',
      });
      expect(prisma.tes_categorias.create).not.toHaveBeenCalled();
      await servicio.create({ nombre: 'A', tipo: 'INGRESO' } as never, 'emp');
      expect(prisma.tes_categorias.create).toHaveBeenCalledTimes(1);
    });
    it('con CONTABILIDAD y una cuenta OLD- → CUENTA_CONTABLE_INVALIDA', async () => {
      contabilidad.mockResolvedValue(true);
      const { servicio } = armar({ planes: [{ id: UUID_CC, codigo: 'OLD-4.1' }] });
      expect(await falla(servicio.create({ nombre: 'A', tipo: 'INGRESO', cuenta_contable_id: UUID_CC } as never, 'emp'))).toMatchObject({ codigo: 'CUENTA_CONTABLE_INVALIDA' });
    });
  });

  describe('editar', () => {
    it('una del sistema → CATEGORIA_DE_SISTEMA; inexistente → 404 CATEGORIA_NO_ENCONTRADA', async () => {
      expect(await falla(armar({ categoria: { id: 'c', empresa_id: null, is_sistema: true } }).servicio.update('c', { nombre: 'x' } as never, 'emp'))).toMatchObject({
        status: 400,
        codigo: 'CATEGORIA_DE_SISTEMA',
      });
      expect(await falla(armar({ categoria: null }).servicio.update('c', { nombre: 'x' } as never, 'emp'))).toMatchObject({ status: 404, codigo: 'CATEGORIA_NO_ENCONTRADA' });
    });
    it('F6: vaciar la cuenta con CONTABILIDAD guarda null', async () => {
      contabilidad.mockResolvedValue(true);
      const { prisma, servicio } = armar();
      await servicio.update('cat', { cuenta_contable_id: null } as never, 'emp');
      expect(prisma.tes_categorias.update.mock.calls[0][0].data).toHaveProperty('cuenta_contable_id', null);
    });
    it('F6: vaciar la cuenta sin CONTABILIDAD también guarda null (no exige el módulo)', async () => {
      contabilidad.mockResolvedValue(false);
      const { prisma, servicio } = armar();
      await servicio.update('cat', { cuenta_contable_id: null } as never, 'emp');
      expect(prisma.tes_categorias.update.mock.calls[0][0].data).toHaveProperty('cuenta_contable_id', null);
    });
    it('F6: sin tocar la cuenta (undefined) el update no la lleva', async () => {
      const { prisma, servicio } = armar();
      await servicio.update('cat', { nombre: 'Otro' } as never, 'emp');
      expect(prisma.tes_categorias.update.mock.calls[0][0].data).not.toHaveProperty('cuenta_contable_id');
    });
    it('poner una cuenta sin CONTABILIDAD → CONTABILIDAD_NO_CONTRATADA', async () => {
      contabilidad.mockResolvedValue(false);
      expect(await falla(armar().servicio.update('cat', { cuenta_contable_id: UUID_CC } as never, 'emp'))).toMatchObject({ codigo: 'CONTABILIDAD_NO_CONTRATADA' });
    });
  });

  describe('eliminar', () => {
    it('con movimientos → CATEGORIA_EN_USO; una del sistema → CATEGORIA_DE_SISTEMA; inexistente → 404', async () => {
      expect(await falla(armar({ enUso: true }).servicio.remove('cat', 'emp'))).toMatchObject({ codigo: 'CATEGORIA_EN_USO' });
      expect(await falla(armar({ categoria: { id: 'c', empresa_id: null, is_sistema: true } }).servicio.remove('c', 'emp'))).toMatchObject({ codigo: 'CATEGORIA_DE_SISTEMA' });
      expect(await falla(armar({ categoria: null }).servicio.remove('c', 'emp'))).toMatchObject({ status: 404, codigo: 'CATEGORIA_NO_ENCONTRADA' });
    });
    it('sin uso elimina', async () => {
      const { prisma, servicio } = armar();
      await servicio.remove('cat', 'emp');
      expect(prisma.tes_categorias.delete).toHaveBeenCalledTimes(1);
    });
  });

  describe('mapeo de una categoría del sistema', () => {
    const sistema = { id: 'cat', empresa_id: null, is_sistema: true };
    it('sin CONTABILIDAD, con cuenta o con null → CONTABILIDAD_NO_CONTRATADA y no escribe', async () => {
      contabilidad.mockResolvedValue(false);
      const { prisma, servicio } = armar({ categoria: sistema });
      expect(await falla(servicio.upsertMapeoContable('cat', UUID_CC, 'emp'))).toMatchObject({ codigo: 'CONTABILIDAD_NO_CONTRATADA' });
      expect(await falla(servicio.upsertMapeoContable('cat', null, 'emp'))).toMatchObject({ codigo: 'CONTABILIDAD_NO_CONTRATADA' });
      expect(prisma.tes_categoria_cuenta_contable.upsert).not.toHaveBeenCalled();
      expect(prisma.tes_categoria_cuenta_contable.deleteMany).not.toHaveBeenCalled();
    });
    it('con CONTABILIDAD y null borra el mapeo', async () => {
      contabilidad.mockResolvedValue(true);
      const { prisma, servicio } = armar({ categoria: sistema });
      await servicio.upsertMapeoContable('cat', null, 'emp');
      expect(prisma.tes_categoria_cuenta_contable.deleteMany).toHaveBeenCalledWith({ where: { empresa_id: 'emp', categoria_id: 'cat' } });
    });
    it('con una cuenta válida hace upsert; con una inválida → CUENTA_CONTABLE_INVALIDA', async () => {
      contabilidad.mockResolvedValue(true);
      const { prisma, servicio } = armar({ categoria: sistema });
      await servicio.upsertMapeoContable('cat', UUID_CC, 'emp');
      expect(prisma.tes_categoria_cuenta_contable.upsert).toHaveBeenCalledTimes(1);
      const otra = armar({ categoria: sistema, planes: [] });
      expect(await falla(otra.servicio.upsertMapeoContable('cat', UUID_CC, 'emp'))).toMatchObject({ codigo: 'CUENTA_CONTABLE_INVALIDA' });
    });
    it('una categoría que no es del sistema → 404 CATEGORIA_NO_ENCONTRADA', async () => {
      contabilidad.mockResolvedValue(true);
      expect(await falla(armar({ categoria: null }).servicio.upsertMapeoContable('cat', null, 'emp'))).toMatchObject({ status: 404, codigo: 'CATEGORIA_NO_ENCONTRADA' });
    });
  });
});
