import { GastosService } from './gastos.service';

/** Listado, KPIs y tipos de gasto (plan 2026-10-19-gastos, Task 7). Prisma falso en memoria. */

const MONEDAS = [
  { id: 'mon-pyg', codigo: 'PYG' },
  { id: 'mon-usd', codigo: 'USD' },
];
const dec = (n: number) => String(n);

function armar(
  opts: {
    montoGrupos?: any[];
    ivaGrupos?: any[];
    ivaNoDeducible?: any[];
    cuenta?: any;
    sinPyg?: boolean;
    monedas?: any[];
  } = {},
) {
  const prisma: any = {
    gasto_cab: {
      findMany: jest.fn().mockResolvedValue([]),
      count: jest.fn().mockResolvedValue(0),
      groupBy: jest
        .fn()
        .mockImplementation(async (args: any) => (args._count ? (opts.montoGrupos ?? []) : (opts.ivaGrupos ?? []))),
    },
    gasto_det: { findMany: jest.fn().mockResolvedValue(opts.ivaNoDeducible ?? []) },
    moneda: {
      findMany: jest
        .fn()
        .mockResolvedValue(opts.sinPyg ? MONEDAS.filter((m) => m.codigo !== 'PYG') : (opts.monedas ?? MONEDAS)),
      findUnique: jest
        .fn()
        .mockImplementation(async ({ where }: any) => MONEDAS.find((m) => m.id === where.id) ?? null),
    },
    cont_documentos: { findMany: jest.fn().mockResolvedValue([]) },
    tes_movimientos: { findMany: jest.fn().mockResolvedValue([]) },
    tes_cheques: { findMany: jest.fn().mockResolvedValue([]) },
    // Medios que la empresa marcó como que no mueven dinero (medio-pago-sin-caja.util): ninguno.
    empresa_medio_pago: { findMany: jest.fn().mockResolvedValue([]) },
    cont_plan_cuentas: { findFirst: jest.fn().mockResolvedValue(opts.cuenta === undefined ? null : opts.cuenta) },
    tipo_gasto: {
      findUnique: jest
        .fn()
        .mockResolvedValue({ id: 'tg1', empresa_id: 'emp', activo: true, aplica_iva: true, porcentaje_iva: 10 }),
      create: jest.fn().mockResolvedValue({ id: 'tg1' }),
      update: jest.fn().mockResolvedValue({ id: 'tg1' }),
    },
  };
  prisma.$transaction = jest
    .fn()
    .mockImplementation(async (arg: any) => (Array.isArray(arg) ? Promise.all(arg) : arg(prisma)));
  const service = new GastosService(prisma, {} as any, {} as any, {} as any, {} as any);
  return { service, prisma };
}

describe('GastosService.findAll — vínculos por fila', () => {
  it('trae rendicion_viatico {id, numero_rendicion} y medio_pago {id, descripcion, codigo} en el include, acotado a la empresa', async () => {
    const { service, prisma } = armar();
    await service.findAll('emp', {});
    const args = prisma.gasto_cab.findMany.mock.calls[0][0];
    expect(args.where.empresa_id).toBe('emp');
    expect(args.include.rendicion_viatico).toEqual({ select: { id: true, numero_rendicion: true } });
    // codigo: para saber si el medio no mueve caja (Pago por anticipo) y no marcar PENDIENTE.
    expect(args.include.medio_pago).toEqual({ select: { id: true, descripcion: true, codigo: true } });
  });
});

describe('GastosService.findAll — filtros y KPIs', () => {
  it('moneda_id y estado=parcial filtran (y excluyen anulados)', async () => {
    const { service, prisma } = armar();
    await service.findAll('emp', { moneda_id: 'mon-usd', estado: 'parcial' });
    expect(prisma.gasto_cab.findMany.mock.calls[0][0].where).toMatchObject({
      moneda_id: 'mon-usd',
      estado: 'parcial',
      anulado: false,
    });
  });

  it('moneda_id de PYG trae también los gastos sin moneda, combinado por AND con la búsqueda', async () => {
    const { service, prisma } = armar();
    await service.findAll('emp', { moneda_id: 'mon-pyg', search: 'luz' });
    const where = prisma.gasto_cab.findMany.mock.calls[0][0].where;
    expect(where).not.toHaveProperty('moneda_id');
    expect(where.AND).toEqual([{ OR: [{ moneda_id: 'mon-pyg' }, { moneda_id: null }] }]);
    expect(where.OR).toHaveLength(4);
    // los KPIs usan el mismo where
    expect(JSON.stringify(prisma.gasto_cab.groupBy.mock.calls[0][0].where)).toContain('"moneda_id":null');
  });

  it('por_moneda: PYG primero y el resto por código', async () => {
    const { service } = armar({
      montoGrupos: [
        { moneda_id: 'mon-usd', cotizacion: dec(7300), _count: { _all: 1 }, _sum: { total: dec(10) } },
        { moneda_id: 'mon-eur', cotizacion: dec(8000), _count: { _all: 1 }, _sum: { total: dec(5) } },
        { moneda_id: 'mon-pyg', cotizacion: dec(1), _count: { _all: 1 }, _sum: { total: dec(1000) } },
      ],
      monedas: [...MONEDAS, { id: 'mon-eur', codigo: 'EUR' }],
    });
    const { stats } = await service.findAll('emp', {});
    expect(stats.por_moneda.map((f: any) => f.moneda.codigo)).toEqual(['PYG', 'EUR', 'USD']);
  });

  it('sin fila PYG, los gastos sin moneda salen con id vacío y código PYG', async () => {
    const { service } = armar({
      sinPyg: true,
      montoGrupos: [{ moneda_id: null, cotizacion: null, _count: { _all: 1 }, _sum: { total: dec(900) } }],
    });
    const { stats } = await service.findAll('emp', {});
    expect(stats.por_moneda).toEqual([{ moneda: { id: '', codigo: 'PYG' }, cantidad: 1, monto: 900, iva_credito: 0 }]);
  });

  it('estado=anulado filtra anulado: true, sin tocar estado', async () => {
    const { service, prisma } = armar();
    await service.findAll('emp', { estado: 'anulado' });
    const where = prisma.gasto_cab.findMany.mock.calls[0][0].where;
    expect(where.anulado).toBe(true);
    expect(where).not.toHaveProperty('estado');
  });

  it('los groupBy de monto e IVA y por_moneda filtran anulado: false', async () => {
    const { service, prisma } = armar();
    await service.findAll('emp', {});
    const llamadas = prisma.gasto_cab.groupBy.mock.calls.map((c: any[]) => JSON.stringify(c[0].where));
    expect(llamadas).toHaveLength(2);
    for (const w of llamadas) expect(w).toContain('"anulado":false');
    expect(JSON.stringify(prisma.gasto_det.findMany.mock.calls[0][0].where)).toContain('"anulado":false');
  });

  it('deducibles y no_deducibles no cuentan los anulados; anulados sí', async () => {
    const { service, prisma } = armar();
    await service.findAll('emp', {});
    const conteos = prisma.gasto_cab.count.mock.calls.map((c: any[]) => JSON.stringify(c[0].where));
    const deducibles = conteos.filter((w: string) => w.includes('"deducible":'));
    expect(deducibles).toHaveLength(2);
    for (const w of deducibles) expect(w).toContain('"anulado":false');
    expect(conteos.some((w: string) => w.includes('"anulado":true'))).toBe(true);
  });

  it('iva_credito resta el IVA de ítems no deducibles: 1000 de IVA con un ítem no deducible de 300 → 700', async () => {
    const { service } = armar({
      montoGrupos: [{ moneda_id: 'mon-pyg', cotizacion: dec(1), _count: { _all: 1 }, _sum: { total: dec(11000) } }],
      ivaGrupos: [{ moneda_id: 'mon-pyg', cotizacion: dec(1), _sum: { iva_total: dec(1000) } }],
      ivaNoDeducible: [{ monto_iva: dec(300), gasto_cab: { moneda_id: 'mon-pyg', cotizacion: dec(1) } }],
    });
    const { stats } = await service.findAll('emp', {});
    expect(stats.iva_credito).toBe(700);
    expect(stats.por_moneda).toEqual([
      { moneda: { id: 'mon-pyg', codigo: 'PYG' }, cantidad: 1, monto: 11000, iva_credito: 700 },
    ]);
  });

  it('monto e IVA en guaraníes y por_moneda en la moneda propia; la moneda NULL cuenta en PYG', async () => {
    const { service } = armar({
      montoGrupos: [
        { moneda_id: null, cotizacion: null, _count: { _all: 2 }, _sum: { total: dec(50000) } },
        { moneda_id: 'mon-pyg', cotizacion: dec(1), _count: { _all: 1 }, _sum: { total: dec(10000) } },
        { moneda_id: 'mon-usd', cotizacion: dec(7300), _count: { _all: 1 }, _sum: { total: dec(100) } },
        { moneda_id: 'mon-usd', cotizacion: dec(7400), _count: { _all: 1 }, _sum: { total: dec(100) } },
      ],
      ivaGrupos: [
        { moneda_id: null, cotizacion: null, _sum: { iva_total: dec(4545) } },
        { moneda_id: 'mon-usd', cotizacion: dec(7300), _sum: { iva_total: dec(9) } },
      ],
    });
    const { stats } = await service.findAll('emp', {});
    expect(stats.monto).toBe(60000 + 730000 + 740000);
    expect(stats.iva_credito).toBe(4545 + 9 * 7300);
    expect(stats.por_moneda).toEqual([
      { moneda: { id: 'mon-pyg', codigo: 'PYG' }, cantidad: 3, monto: 60000, iva_credito: 4545 },
      { moneda: { id: 'mon-usd', codigo: 'USD' }, cantidad: 2, monto: 200, iva_credito: 9 },
    ]);
  });
});

describe('Tipos de gasto — cuenta contable (S13)', () => {
  const MSJ = 'La cuenta contable elegida no está activa o no acepta movimientos.';
  const casos: Array<[string, any, string]> = [
    ['de otra empresa o inexistente', null, 'La cuenta contable seleccionada no existe o no pertenece a la empresa'],
    ['inactiva', { id: 'c1', active: false, acepta_movimientos: true }, MSJ],
    ['que no acepta movimientos', { id: 'c1', active: true, acepta_movimientos: false }, MSJ],
  ];

  it.each(casos)('POST con cuenta %s → 400', async (_n, cuenta, mensaje) => {
    const { service, prisma } = armar({ cuenta });
    await expect(
      service.crearTipoGasto({ descripcion: 'Viáticos', cuenta_contable_id: 'c1' } as any, 'emp'),
    ).rejects.toThrow(mensaje);
    expect(prisma.tipo_gasto.create).not.toHaveBeenCalled();
    expect(prisma.cont_plan_cuentas.findFirst.mock.calls[0][0].where).toEqual({ id: 'c1', empresa_id: 'emp' });
  });

  it.each(casos)('el 400 con cuenta %s dice el campo: cuenta_contable_id', async (_n, cuenta, mensaje) => {
    const { service } = armar({ cuenta });
    const error: any = await service
      .crearTipoGasto({ descripcion: 'Viáticos', cuenta_contable_id: 'c1' } as any, 'emp')
      .catch((e: unknown) => e);
    expect(error.getStatus()).toBe(400);
    expect(error.getResponse()).toEqual({ message: mensaje, campo: 'cuenta_contable_id' });
  });

  it.each(casos)('PATCH con cuenta %s → 400', async (_n, cuenta, mensaje) => {
    const { service, prisma } = armar({ cuenta });
    await expect(service.actualizarTipoGasto('tg1', { cuenta_contable_id: 'c1' } as any, 'emp')).rejects.toThrow(
      mensaje,
    );
    expect(prisma.tipo_gasto.update).not.toHaveBeenCalled();
  });

  it('una cuenta activa que acepta movimientos pasa', async () => {
    const { service, prisma } = armar({ cuenta: { id: 'c1', active: true, acepta_movimientos: true } });
    await service.crearTipoGasto({ descripcion: 'Viáticos', cuenta_contable_id: 'c1' } as any, 'emp');
    await service.actualizarTipoGasto('tg1', { cuenta_contable_id: 'c1' } as any, 'emp');
    expect(prisma.tipo_gasto.create).toHaveBeenCalled();
    expect(prisma.tipo_gasto.update).toHaveBeenCalled();
  });
});

describe('GastosService.findAll — Tesorería que no se pudo leer (I12)', () => {
  it('ninguna fila dice PENDIENTE: estado null y el aviso con el motivo', async () => {
    const { service, prisma } = armar();
    prisma.gasto_cab.findMany.mockResolvedValue([
      { id: 'g1', estado: 'pagada', forma_pago: 'CONTADO', pago_historico: false, anulado: false },
    ]);
    prisma.tes_movimientos.findMany.mockRejectedValue(new Error('connection reset'));
    const r: any = await service.findAll('emp', {});
    expect(r.data[0]).toMatchObject({
      tesoreria_estado: null,
      tesoreria_aviso: 'No se pudo verificar Tesorería. Motivo: connection reset',
    });
  });
});
