import { TesoreriaService } from './tesoreria.service';

/**
 * Movimientos de caja (Reportes · carril C, T1). `movimiento_cajas.monto` ya está en la moneda base de la empresa
 * (la venta en otra moneda graba `montoBase`; ningún escritor llena `moneda_id`/`cotizacion`): los totales no se
 * convierten y se rotulan con la moneda base de la empresa.
 */
const FACTURA = '11111111-1111-4111-8111-111111111111';
const BASE = { id: 'mon-pyg', codigo: 'PYG' };

type Mov = { id: string; tipo: string | null; monto: number; referencia: string | null; moneda_id?: string | null };

const MOVS: Mov[] = [
  { id: 'm1', tipo: 'Entrada', monto: 100000, referencia: null },
  { id: 'm2', tipo: 'Venta', monto: 50000, referencia: FACTURA },
  { id: 'm3', tipo: 'Salida', monto: 30000, referencia: null },
];

const crear = (movs: Mov[] = MOVS, opts: { count?: number; base?: typeof BASE | null } = {}) => {
  const service: any = Object.create(TesoreriaService.prototype);
  service.logger = { log: jest.fn(), warn: jest.fn(), error: jest.fn() };
  const tipoId = (t: string | null) => (t ? `tipo-${t}` : null);
  const fila = (m: Mov) => ({
    id: m.id,
    monto: m.monto,
    referencia: m.referencia,
    fecha_mov: new Date('2026-11-05T12:00:00-03:00'),
    tipo_movimiento_caja_id: tipoId(m.tipo),
    tipo_movimiento_cajas: m.tipo ? { id: tipoId(m.tipo), descripcion: m.tipo } : null,
    moneda: null,
  });
  const base = opts.base === undefined ? BASE : opts.base;
  service.prisma = {
    movimiento_cajas: {
      findMany: jest.fn(() => movs.map(fila)),
      count: jest.fn(() => opts.count ?? movs.length),
      groupBy: jest.fn(() => {
        const g = new Map<string | null, { tipo_movimiento_caja_id: string | null; _sum: { monto: number }; _count: { _all: number } }>();
        for (const m of movs) {
          const k = tipoId(m.tipo);
          const x = g.get(k) ?? { tipo_movimiento_caja_id: k, _sum: { monto: 0 }, _count: { _all: 0 } };
          x._sum.monto += m.monto;
          x._count._all += 1;
          g.set(k, x);
        }
        return [...g.values()];
      }),
    },
    tipo_movimiento_cajas: {
      findMany: jest.fn(({ where }: any) =>
        movs.filter((m) => m.tipo && where.id.in.includes(tipoId(m.tipo))).map((m) => ({ id: tipoId(m.tipo), descripcion: m.tipo })),
      ),
    },
    factura_cab: {
      findMany: jest.fn(() => [
        {
          id: FACTURA,
          dest: '001',
          dpunexp: '001',
          dnumdoc: '0000123',
          moneda: { codigo: 'PYG' },
          factura_forma_pagos: [{ medio_pago_id: 'mp-ef', dmontipag: 50000, medio_pago: { id: 'mp-ef', descripcion: 'Efectivo' } }],
        },
      ]),
    },
    recibos_cobro: { findMany: jest.fn(() => []) },
    empresa_monedas: { findFirst: jest.fn(() => (base ? { moneda_id: base.id } : null)) },
    moneda: {
      findFirst: jest.fn(() => null),
      findUnique: jest.fn(({ where }: any) => (base && where.id === base.id ? base : null)),
    },
  };
  return service;
};

describe('GET /tesoreria/movimientos — totales y por medio (caracterización)', () => {
  it('entrada 100.000 + venta 50.000 + salida 30.000 → totales de todo el filtro', async () => {
    const r = await crear().getMovimientos('emp-1', {});

    expect(r.totales).toEqual({ entradas: 150000, salidas: 30000, neto: 120000, cantidad: 3 });
    expect(r.total).toBe(3);
    expect(r.totalPages).toBe(1);
  });

  it('por medio: la venta con su forma de pago y los manuales juntos', async () => {
    const r = await crear().getMovimientos('emp-1', {});

    expect(r.por_medio).toEqual([
      { medio_pago: 'Sin medio (movimiento manual)', medio_pago_id: null, entradas: 100000, salidas: 30000, cantidad: 2, neto: 70000 },
      { medio_pago: 'Efectivo', medio_pago_id: 'mp-ef', entradas: 50000, salidas: 0, cantidad: 1, neto: 50000 },
    ]);
  });

  it('cada fila sin moneda sale rotulada con la base', async () => {
    const r = await crear().getMovimientos('emp-1', {});

    expect(r.items.map((i: any) => i.moneda)).toEqual([{ codigo: 'PYG' }, { codigo: 'PYG' }, { codigo: 'PYG' }]);
    expect(r.items[1].referencia_legible).toBe('Factura 001-001-0000123');
  });
});

describe('GET /tesoreria/movimientos — moneda base, sentido y aviso de corte (T1)', () => {
  it('los totales vienen rotulados con la moneda base de la empresa, sin convertir', async () => {
    const r = await crear().getMovimientos('emp-1', {});

    expect(r.moneda).toEqual({ id: 'mon-pyg', codigo: 'PYG' });
    expect(r.totales).toEqual({ entradas: 150000, salidas: 30000, neto: 120000, cantidad: 3 });
  });

  it('la moneda base es la principal de la empresa, nunca «PYG» fijo', async () => {
    const r = await crear(MOVS, { base: { id: 'mon-usd', codigo: 'USD' } }).getMovimientos('emp-1', {});

    expect(r.moneda).toEqual({ id: 'mon-usd', codigo: 'USD' });
    expect(r.items[0].moneda).toEqual({ codigo: 'USD' });
  });

  it('sin moneda base cargada no se inventa el código', async () => {
    const r = await crear(MOVS, { base: null }).getMovimientos('emp-1', {});

    expect(r.moneda).toBeNull();
    expect(r.totales.entradas).toBe(150000);
  });

  it('es_entrada por fila sale de la misma regla que los totales', async () => {
    const movs: Mov[] = [
      { id: 'a', tipo: 'Entrada', monto: 1, referencia: null },
      { id: 'b', tipo: 'Venta', monto: 1, referencia: null },
      { id: 'c', tipo: 'Apertura', monto: 1, referencia: null },
      { id: 'd', tipo: 'Salida', monto: 1, referencia: null },
      { id: 'e', tipo: 'Retiro', monto: 1, referencia: null },
      { id: 'f', tipo: null, monto: 1, referencia: null },
    ];
    const r = await crear(movs).getMovimientos('emp-1', {});

    expect(r.items.map((i: any) => [i.id, i.es_entrada])).toEqual([
      ['a', true],
      ['b', true],
      ['c', true],
      ['d', false],
      ['e', false],
      ['f', false],
    ]);
    expect(r.totales).toEqual({ entradas: 3, salidas: 3, neto: 0, cantidad: 6 });
  });

  it('por_medio_incompleto avisa cuando el filtro pasa los 20.000 movimientos', async () => {
    expect((await crear(MOVS, { count: 20001 }).getMovimientos('emp-1', {})).por_medio_incompleto).toBe(true);
    expect((await crear(MOVS, { count: 20000 }).getMovimientos('emp-1', {})).por_medio_incompleto).toBe(false);
    expect((await crear().getMovimientos('emp-1', {})).por_medio_incompleto).toBe(false);
  });

  it('por medio sigue con el mismo tope de 20.000 filas', async () => {
    const service = crear();
    await service.getMovimientos('emp-1', {});

    const llamadaPorMedio = service.prisma.movimiento_cajas.findMany.mock.calls.find((c: any[]) => c[0].select);
    expect(llamadaPorMedio[0].take).toBe(20000);
  });
});

describe('GET /tesoreria/movimientos — moneda_id (ronda 2: solo la base)', () => {
  const PYG_ID = '33333333-3333-4333-8333-333333333333';
  const USD_ID = '22222222-2222-4222-8222-222222222222';
  const conMonedas = () => {
    const service = crear(MOVS, { base: { id: PYG_ID, codigo: 'PYG' } });
    service.prisma.moneda.findUnique = jest.fn(({ where }: any) =>
      where.id === PYG_ID ? { id: PYG_ID, codigo: 'PYG' } : where.id === USD_ID ? { id: USD_ID, codigo: 'USD' } : null,
    );
    return service;
  };

  it('otra moneda que la base → 400 MONEDA_INVALIDA (los montos están en la base; rotularlos con otra sería falso)', async () => {
    const service = conMonedas();

    await expect(service.getMovimientos('emp-1', { moneda_id: USD_ID })).rejects.toMatchObject({
      status: 400,
      response: { codigo: 'MONEDA_INVALIDA', campo: 'moneda_id' },
    });
    expect(service.prisma.movimiento_cajas.findMany).not.toHaveBeenCalled();
  });

  it('una moneda que no existe → 400 MONEDA_INVALIDA', async () => {
    await expect(conMonedas().getMovimientos('emp-1', { moneda_id: '44444444-4444-4444-8444-444444444444' })).rejects.toMatchObject({
      status: 400,
      response: { codigo: 'MONEDA_INVALIDA' },
    });
  });

  it('la base se acepta: incluye los movimientos sin moneda y rotula con la base', async () => {
    const service = conMonedas();
    const r = await service.getMovimientos('emp-1', { moneda_id: PYG_ID });

    expect(r.moneda).toEqual({ id: PYG_ID, codigo: 'PYG' });
    expect(r.totales).toEqual({ entradas: 150000, salidas: 30000, neto: 120000, cantidad: 3 });
    expect(service.prisma.movimiento_cajas.count.mock.calls[0][0].where.AND).toEqual([{ OR: [{ moneda_id: PYG_ID }, { moneda_id: null }] }]);
  });
});

describe('GET /tesoreria/movimientos — exportación por páginas (ronda 1)', () => {
  it('sin_totales no recalcula totales ni por medio; la página y el total siguen', async () => {
    const service = crear();
    const r = await service.getMovimientos('emp-1', { page: 2, limit: 1, sin_totales: true });

    expect(r.totales).toBeNull();
    expect(r.por_medio).toBeNull();
    expect(r.total).toBe(3);
    expect(r.totalPages).toBe(3);
    expect(r.por_medio_incompleto).toBe(false);
    expect(service.prisma.movimiento_cajas.groupBy).not.toHaveBeenCalled();
    expect(service.prisma.movimiento_cajas.findMany).toHaveBeenCalledTimes(1);
    expect(service.prisma.movimiento_cajas.findMany.mock.calls[0][0]).toMatchObject({ skip: 1, take: 1 });
  });

  it('por defecto calcula los totales como siempre', async () => {
    const service = crear();
    const r = await service.getMovimientos('emp-1', {});

    expect(r.totales).toEqual({ entradas: 150000, salidas: 30000, neto: 120000, cantidad: 3 });
    expect(service.prisma.movimiento_cajas.groupBy).toHaveBeenCalledTimes(1);
  });

  it.each([
    [50000, 10000],
    [10000, 10000],
    [500, 500],
    [0, 20],
    [-5, 1],
    [Number.NaN, 20],
    [undefined, 20],
  ])('limit %p se recorta a %p (sin rechazar)', async (pedido, usado) => {
    const service = crear();
    const r = await service.getMovimientos('emp-1', { limit: pedido as number });

    expect(r.limit).toBe(usado);
    expect(service.prisma.movimiento_cajas.findMany.mock.calls[0][0].take).toBe(usado);
  });
});
