import { BadRequestException, ConflictException } from '@nestjs/common';
import { Prisma } from '@prisma/client';
import { desgloseRecibo, rangoFechaDb, RendicionesService, totalVerificado } from './rendiciones.service';

// Rendiciones de cobranza (spec 2026-10-18-rendiciones, Contrato del backend):
// diferencia = declarado − cobrado, una activa por cobrador y moneda, resumen por rango
// y resumen diario que cuenta solo su día.

const PYG = { id: '11111111-1111-4111-8111-111111111111', codigo: 'PYG', simbolo: '₲', decimales: 0 };
const USD = { id: '22222222-2222-4222-8222-222222222222', codigo: 'USD', simbolo: 'US$', decimales: 2 };
const COBRADOR = { id: 'cob-1', empresa_id: 'emp-1', active: true };

const rendicion = (over: Record<string, any> = {}) => ({
  estado: 'APROBADO',
  monto_cobrado: '0',
  total_declarado: '0',
  monto_esperado: '0',
  monto_efectivo: '0',
  monto_cheque: '0',
  monto_transferencia: '0',
  monto_tarjeta: '0',
  diferencia: '0',
  cantidad_recibos: 1,
  moneda_id: PYG.id,
  moneda: PYG,
  ...over,
});

/** Recibo LEGACY en efectivo (código 1) por `monto`. */
const reciboEfectivo = (id: string, monto: string, monedaId = PYG.id) => ({
  id,
  modo: 'LEGACY',
  moneda_id: monedaId,
  recibo_cobro_detalle: [{ monto_pagado: monto, medio_pago: { id: 'mp-1', codigo: 1, descripcion: 'Efectivo' } }],
  medios_pago_multi: [],
});

/**
 * Prisma falso. `activas` son las rendiciones BORRADOR/PENDIENTE/OBSERVADO de la base:
 * el findFirst de unicidad responde la que coincide en empresa, cobrador y moneda.
 * `existentes` son filas (con sus `recibos_cobro` crudos) que lee `findOne` y que el
 * `updateMany` condicionado del `tx` modifica; `carrera` es el estado al que otro usuario
 * la movió entre la lectura y el UPDATE. `medios` responde `recibo_cobro_medios_pago.findMany`.
 */
const crearService = (
  opts: {
    rendiciones?: any[];
    recibos?: any[];
    activas?: any[];
    fallarCreate?: unknown;
    existentes?: any[];
    carrera?: string;
    medios?: any[];
  } = {},
) => {
  const activas = opts.activas ?? [];
  const creadas: any[] = [...(opts.existentes ?? [])];
  const prisma: any = {
    empresas: {
      findUnique: jest.fn().mockResolvedValue({ type: 'empresa' }),
      findMany: jest.fn().mockResolvedValue([]),
    },
    vendedores_cobradores: {
      findFirst: jest.fn().mockResolvedValue(COBRADOR),
      findUnique: jest.fn().mockResolvedValue({ usuario_id: null }),
      findMany: jest.fn().mockResolvedValue([]),
    },
    medio_pago: { findMany: jest.fn().mockResolvedValue([]) },
    moneda: {
      findUnique: jest
        .fn()
        .mockImplementation(({ where }: any) => Promise.resolve([PYG, USD].find((m) => m.id === where.id) ?? null)),
      // D-T4: códigos para `por_moneda` de los reportes.
      findMany: jest.fn().mockImplementation(({ where }: any) => Promise.resolve([PYG, USD].filter((m) => where.id.in.includes(m.id)))),
      findFirst: jest.fn().mockResolvedValue(PYG),
    },
    empresa_monedas: { findFirst: jest.fn().mockResolvedValue({ moneda_id: PYG.id }) },
    recibos_cobro: {
      findMany: jest.fn().mockResolvedValue(opts.recibos ?? []),
      updateMany: jest.fn().mockResolvedValue({ count: (opts.recibos ?? []).length }),
    },
    rendiciones_cobranza: {
      findMany: jest.fn().mockResolvedValue(opts.rendiciones ?? []),
      findFirst: jest.fn().mockImplementation(({ where }: any) => {
        if (where.id) {
          const fila = creadas.find((c) => c.id === where.id);
          return Promise.resolve(fila ? { ...fila } : null);
        }
        const a = activas.find(
          (r) =>
            r.empresa_id === where.empresa_id && r.cobrador_id === where.cobrador_id && r.moneda_id === where.moneda_id,
        );
        return Promise.resolve(a ?? null);
      }),
    },
    rendicion_historial: { create: jest.fn().mockResolvedValue({}) },
    recibo_cobro_medios_pago: { findMany: jest.fn().mockResolvedValue(opts.medios ?? []) },
  };
  const filaDe = (id: string) => creadas.find((c) => c.id === id);
  const tx: any = {
    rendiciones_cobranza: {
      create: jest.fn().mockImplementation(({ data }: any) => {
        if (opts.fallarCreate) return Promise.reject(opts.fallarCreate);
        const fila = { id: `ren-${creadas.length + 1}`, ...data, recibos_cobro: [] };
        creadas.push(fila);
        return Promise.resolve(fila);
      }),
      updateMany: jest.fn().mockImplementation(({ where, data }: any) => {
        const fila = filaDe(where.id);
        if (fila && opts.carrera) fila.estado = opts.carrera;
        if (!fila || !where.estado.in.includes(fila.estado)) return Promise.resolve({ count: 0 });
        Object.assign(fila, data);
        return Promise.resolve({ count: 1 });
      }),
      findUnique: jest.fn().mockImplementation(({ where, select }: any) => {
        const fila = filaDe(where.id);
        if (!fila) return Promise.resolve(null);
        return Promise.resolve(select?.estado ? { estado: fila.estado } : { ...fila });
      }),
    },
    recibos_cobro: {
      updateMany: prisma.recibos_cobro.updateMany,
      findMany: jest
        .fn()
        .mockImplementation(({ where }: any) =>
          Promise.resolve(
            (filaDe(where.rendicion_id)?.recibos_cobro ?? []).map((rc: any) => ({
              id: rc.id,
              numero_recibo: rc.numero_recibo,
            })),
          ),
        ),
    },
    rendicion_historial: prisma.rendicion_historial,
    comisiones: { updateMany: jest.fn().mockResolvedValue({ count: 0 }) },
    recibo_cobro_medios_pago: {
      findMany: jest.fn().mockImplementation(() => Promise.resolve(opts.medios ?? [])),
      updateMany: jest.fn().mockResolvedValue({ count: 1 }),
      findUnique: jest.fn().mockImplementation(({ where }: any) => Promise.resolve({ id: where.id })),
    },
  };
  tx.rendiciones_cobranza.update = jest.fn().mockImplementation(({ where, data }: any) => {
    const fila = filaDe(where.id);
    Object.assign(fila, data);
    return Promise.resolve({ ...fila });
  });
  // Rollback: si el callback falla, las filas creadas dentro de la transacción no quedan.
  prisma.$transaction = jest.fn().mockImplementation(async (cb: any) => {
    const antes = creadas.length;
    try {
      return await cb(tx);
    } catch (e) {
      creadas.splice(antes);
      throw e;
    }
  });
  return { service: new RendicionesService(prisma), prisma, tx, creadas };
};

const dtoCrear = (over: Record<string, any> = {}) => ({
  cobrador_id: COBRADOR.id,
  moneda_id: PYG.id,
  fecha_cobranza: '2026-10-06',
  recibo_ids: ['r-1'],
  ...over,
});

describe('rangoFechaDb', () => {
  it('devuelve fechas puras (00:00 UTC), sin límites de hora', () => {
    expect(rangoFechaDb('2026-10-01', '2026-10-31')).toEqual({
      gte: new Date('2026-10-01T00:00:00.000Z'),
      lte: new Date('2026-10-31T00:00:00.000Z'),
    });
  });

  it.each([
    ['2026-10-1', '2026-10-31'],
    ['2026-10-01', '31/10/2026'],
    ['2026-02-30', '2026-03-01'],
    ['2026-10-31', '2026-10-01'],
    ['', ''],
  ])('400 con %s .. %s', (desde, hasta) => {
    expect(() => rangoFechaDb(desde, hasta)).toThrow(new BadRequestException('Rango de fechas inválido'));
  });
});

describe('RendicionesService.getResumen', () => {
  it('resumen: pide fecha_cobranza { gte: 2026-10-01, lte: 2026-10-31 } en fechas puras y la moneda', async () => {
    const { service, prisma } = crearService();
    await service.getResumen('emp-1', { fecha_desde: '2026-10-01', fecha_hasta: '2026-10-31', moneda_id: PYG.id });
    const { where } = prisma.rendiciones_cobranza.findMany.mock.calls[0][0];
    expect(where).toEqual({
      empresa_id: 'emp-1',
      deleted_at: null,
      moneda_id: PYG.id,
      fecha_cobranza: { gte: new Date('2026-10-01T00:00:00.000Z'), lte: new Date('2026-10-31T00:00:00.000Z') },
    });
  });

  it('resumen: conteos de todos los estados; cobrado y declarado sin ANULADO ni RECHAZADO; diferencia = declarado − cobrado', async () => {
    const { service } = crearService({
      rendiciones: [
        rendicion({ estado: 'BORRADOR', monto_cobrado: '10000', total_declarado: '10000' }),
        rendicion({ estado: 'PENDIENTE', monto_cobrado: '20000', total_declarado: '15000' }),
        rendicion({ estado: 'OBSERVADO', monto_cobrado: '30000', total_declarado: '25000' }),
        rendicion({ estado: 'APROBADO', monto_cobrado: '40000', total_declarado: '40000' }),
        rendicion({ estado: 'RECHAZADO', monto_cobrado: '500000', total_declarado: '1' }),
        rendicion({ estado: 'ANULADO', monto_cobrado: '700000', total_declarado: '2' }),
      ],
    });
    const r = await service.getResumen('emp-1', {
      fecha_desde: '2026-10-01',
      fecha_hasta: '2026-10-31',
      moneda_id: PYG.id,
    });
    expect(r).toEqual({
      moneda: PYG,
      total_rendiciones: 6,
      por_estado: { borrador: 1, pendientes: 1, observadas: 1, aprobadas: 1, rechazadas: 1, anuladas: 1 },
      cobrado: 100000,
      declarado: 90000,
      diferencia: -10000,
    });
  });

  it('resumen: sin rendiciones responde ceros con la moneda', async () => {
    const { service } = crearService();
    const r = await service.getResumen('emp-1', {
      fecha_desde: '2026-10-18',
      fecha_hasta: '2026-10-18',
      moneda_id: USD.id,
    });
    expect(r).toEqual({
      moneda: USD,
      total_rendiciones: 0,
      por_estado: { borrador: 0, pendientes: 0, observadas: 0, aprobadas: 0, rechazadas: 0, anuladas: 0 },
      cobrado: 0,
      declarado: 0,
      diferencia: 0,
    });
  });

  it.each([
    [{ fecha_desde: '2026-10', fecha_hasta: '2026-10-31', moneda_id: PYG.id }, 'Rango de fechas inválido'],
    [{ fecha_desde: '2026-10-31', fecha_hasta: '2026-10-01', moneda_id: PYG.id }, 'Rango de fechas inválido'],
    [{ fecha_hasta: '2026-10-31', moneda_id: PYG.id }, 'Rango de fechas inválido'],
    [{ fecha_desde: '2026-10-01', fecha_hasta: '2026-10-31' }, 'Falta la moneda'],
    [{ fecha_desde: '2026-10-01', fecha_hasta: '2026-10-31', moneda_id: '' }, 'Falta la moneda'],
    [{ fecha_desde: '2026-10-01', fecha_hasta: '2026-10-31', moneda_id: 'no-es-uuid' }, 'Moneda inválida'],
  ])('resumen: 400 con fecha mal formada, desde > hasta, sin moneda o moneda no uuid (%o)', async (q, mensaje) => {
    const { service, prisma } = crearService();
    await expect(service.getResumen('emp-1', q as any)).rejects.toThrow(new BadRequestException(mensaje));
    expect(prisma.rendiciones_cobranza.findMany).not.toHaveBeenCalled();
  });
});

describe('RendicionesService.getResumenDiario', () => {
  it('resumen-diario 2026-10-06 pide gte = lte = 2026-10-06 (no cuenta el 07)', async () => {
    const { service, prisma } = crearService();
    await service.getResumenDiario('emp-1', '2026-10-06');
    const { where } = prisma.rendiciones_cobranza.findMany.mock.calls[0][0];
    expect(where.fecha_cobranza).toEqual({
      gte: new Date('2026-10-06T00:00:00.000Z'),
      lte: new Date('2026-10-06T00:00:00.000Z'),
    });
  });
});

describe('RendicionesService.create', () => {
  it('crear: diferencia = total_declarado − monto_cobrado', async () => {
    const { service, tx } = crearService({ recibos: [reciboEfectivo('r-1', '100000')] });
    await service.create('emp-1', 'u-1', dtoCrear({ total_declarado: 90000 }) as any);
    const { data } = tx.rendiciones_cobranza.create.mock.calls[0][0];
    expect(data.monto_cobrado).toBe(100000);
    expect(data.total_declarado).toBe(90000);
    expect(data.diferencia).toBe(-10000);
  });

  it('crear sin declarado: diferencia 0', async () => {
    const { service, tx } = crearService({ recibos: [reciboEfectivo('r-1', '100000')] });
    await service.create('emp-1', 'u-1', dtoCrear() as any);
    const { data } = tx.rendiciones_cobranza.create.mock.calls[0][0];
    expect(data.total_declarado).toBe(100000);
    expect(data.diferencia).toBe(0);
  });

  const borrador = (moneda: typeof PYG) => ({
    id: 'ren-10',
    codigo: 'REN-000010',
    estado: 'BORRADOR',
    empresa_id: 'emp-1',
    cobrador_id: COBRADOR.id,
    moneda_id: moneda.id,
    moneda: { codigo: moneda.codigo },
  });

  it('unicidad: con un BORRADOR en USD del cobrador, crear en PYG pasa; con uno en PYG → 400', async () => {
    const enUsd = crearService({ recibos: [reciboEfectivo('r-1', '100000')], activas: [borrador(USD)] });
    await expect(enUsd.service.create('emp-1', 'u-1', dtoCrear() as any)).resolves.toBeDefined();
    expect(enUsd.tx.rendiciones_cobranza.create).toHaveBeenCalledTimes(1);

    const enPyg = crearService({ recibos: [reciboEfectivo('r-1', '100000')], activas: [borrador(PYG)] });
    await expect(enPyg.service.create('emp-1', 'u-1', dtoCrear() as any)).rejects.toThrow(
      new BadRequestException('El cobrador ya tiene una rendición borrador en PYG (REN-000010)'),
    );
    expect(enPyg.tx.rendiciones_cobranza.create).not.toHaveBeenCalled();
  });

  it('unicidad: el findFirst lleva empresa_id y moneda_id y trae el código de la moneda', async () => {
    const { service, prisma } = crearService({ recibos: [reciboEfectivo('r-1', '100000')] });
    await service.create('emp-1', 'u-1', dtoCrear() as any);
    const llamada = prisma.rendiciones_cobranza.findFirst.mock.calls[0][0];
    expect(llamada.where).toEqual({
      empresa_id: 'emp-1',
      cobrador_id: COBRADOR.id,
      moneda_id: PYG.id,
      estado: { in: ['BORRADOR', 'PENDIENTE', 'OBSERVADO'] },
      deleted_at: null,
    });
    expect(llamada.select.moneda).toEqual({ select: { codigo: true } });
  });

  it('unicidad: un P2002 del índice da el mismo 400', async () => {
    const p2002 = new Prisma.PrismaClientKnownRequestError('Unique constraint failed', {
      code: 'P2002',
      clientVersion: 'test',
      meta: { target: 'ux_rendiciones_activa_cobrador_moneda' },
    });
    const activas: any[] = [];
    const ctx = crearService({ recibos: [reciboEfectivo('r-1', '100000')], activas, fallarCreate: p2002 });
    // Otra pestaña creó la rendición entre el chequeo y el INSERT.
    ctx.tx.rendiciones_cobranza.create.mockImplementationOnce(() => {
      activas.push(borrador(PYG));
      return Promise.reject(p2002);
    });
    await expect(ctx.service.create('emp-1', 'u-1', dtoCrear() as any)).rejects.toThrow(
      new BadRequestException('El cobrador ya tiene una rendición borrador en PYG (REN-000010)'),
    );
  });
});

// ── Transiciones (Task 4) ──────────────────────────────────────────────

const reciboLegacy = (id: string, numero: string, monto: string) => ({
  id,
  numero_recibo: numero,
  modo: 'LEGACY',
  facturas_multi: [],
  medios_pago_multi: [],
  recibo_cobro_detalle: [
    { id: `d-${id}`, monto_pagado: monto, medio_pago: { id: 'mp-1', codigo: 1, descripcion: 'Efectivo' } },
  ],
});

const reciboMulti = (id: string, numero: string, medios: any[]) => ({
  id,
  numero_recibo: numero,
  modo: 'MULTI',
  facturas_multi: [],
  recibo_cobro_detalle: [],
  medios_pago_multi: medios,
});

const existente = (over: Record<string, any> = {}) => ({
  id: 'ren-7',
  codigo: 'REN-000007',
  estado: 'BORRADOR',
  monto_cobrado: '150000',
  total_declarado: '150000',
  diferencia: '0',
  cantidad_recibos: 2,
  observaciones_cobrador: null,
  observaciones_supervisor: null,
  recibos_cobro: [reciboLegacy('r-1', 'R-1', '100000'), reciboLegacy('r-2', 'R-2', '50000')],
  ...over,
});

const historial = (prisma: any) => prisma.rendicion_historial.create.mock.calls.map((c: any[]) => c[0].data);
const conflicto = (estado: string) =>
  new ConflictException(`La rendición cambió de estado mientras tanto (ahora: ${estado}). Recargá la pantalla.`);

describe('RendicionesService.enviarATesoreria', () => {
  it('enviar con nota: el historial guarda la nota', async () => {
    const { service, prisma } = crearService({ existentes: [existente()] });
    await service.enviarATesoreria('emp-1', 'ren-7', 'u-1', { nota: 'Faltan 2 cheques' } as any);
    expect(historial(prisma)).toEqual([
      expect.objectContaining({ estado_anterior: 'BORRADOR', estado_nuevo: 'PENDIENTE', motivo: 'Faltan 2 cheques' }),
    ]);
  });

  it('enviar con total_declarado recalcula diferencia', async () => {
    const { service, tx } = crearService({ existentes: [existente()] });
    const fila = await service.enviarATesoreria('emp-1', 'ren-7', 'u-1', { total_declarado: 140000 } as any);
    const { where, data } = tx.rendiciones_cobranza.updateMany.mock.calls[0][0];
    expect(where).toEqual({ id: 'ren-7', estado: { in: ['BORRADOR', 'OBSERVADO'] } });
    expect(data).toMatchObject({ estado: 'PENDIENTE', total_declarado: 140000, diferencia: -10000 });
    expect(fila).toMatchObject({ id: 'ren-7', estado: 'PENDIENTE', diferencia: -10000 });
  });
});

describe('Transiciones condicionadas: otro usuario la movió → 409', () => {
  it('enviar con updateMany count 0 → 409 con el estado actual', async () => {
    const { service, prisma } = crearService({ existentes: [existente()], carrera: 'PENDIENTE' });
    await expect(service.enviarATesoreria('emp-1', 'ren-7', 'u-1', {} as any)).rejects.toThrow(conflicto('PENDIENTE'));
    expect(prisma.rendicion_historial.create).not.toHaveBeenCalled();
  });

  it('aprobar con updateMany count 0 → 409 con el estado actual', async () => {
    const { service, tx } = crearService({ existentes: [existente({ estado: 'PENDIENTE' })], carrera: 'OBSERVADO' });
    await expect(service.aprobar('emp-1', 'ren-7', 'u-1', {})).rejects.toThrow(conflicto('OBSERVADO'));
    expect(tx.comisiones.updateMany).not.toHaveBeenCalled();
  });

  it('rechazar con updateMany count 0 → 409 con el estado actual', async () => {
    const { service, prisma } = crearService({ existentes: [existente({ estado: 'PENDIENTE' })], carrera: 'APROBADO' });
    await expect(service.rechazar('emp-1', 'ren-7', 'u-1', { accion: 'RECHAZADO', motivo: 'x' })).rejects.toThrow(
      conflicto('APROBADO'),
    );
    expect(prisma.recibos_cobro.updateMany).not.toHaveBeenCalled();
  });

  it('anular con updateMany count 0 → 409 con el estado actual', async () => {
    const { service, prisma } = crearService({ existentes: [existente()], carrera: 'PENDIENTE' });
    await expect(service.anular('emp-1', 'ren-7', 'u-1', { motivo: 'x' })).rejects.toThrow(conflicto('PENDIENTE'));
    expect(prisma.recibos_cobro.updateMany).not.toHaveBeenCalled();
  });
});

describe('RendicionesService.rechazar', () => {
  it("rechazar RECHAZADO libera los recibos en la misma transacción y el historial dice 'Recibos liberados: R-1, R-2'", async () => {
    const { service, prisma, tx } = crearService({ existentes: [existente({ estado: 'PENDIENTE' })] });
    const fila = await service.rechazar('emp-1', 'ren-7', 'u-1', { accion: 'RECHAZADO', motivo: 'Faltante' });
    expect(prisma.$transaction).toHaveBeenCalledTimes(1);
    expect(tx.recibos_cobro.updateMany).toHaveBeenCalledWith({
      where: { rendicion_id: 'ren-7', empresa_id: 'emp-1' },
      data: { rendicion_id: null },
    });
    expect(historial(prisma)).toEqual([
      expect.objectContaining({
        estado_anterior: 'PENDIENTE',
        estado_nuevo: 'RECHAZADO',
        motivo: 'Faltante · Recibos liberados: R-1, R-2',
      }),
    ]);
    expect(fila).toMatchObject({ estado: 'RECHAZADO', motivo_rechazo: 'Faltante' });
  });

  it('rechazar OBSERVADO no libera', async () => {
    const { service, prisma } = crearService({ existentes: [existente({ estado: 'PENDIENTE' })] });
    await service.rechazar('emp-1', 'ren-7', 'u-1', { accion: 'OBSERVADO', motivo: 'Revisar cheque' });
    expect(prisma.recibos_cobro.updateMany).not.toHaveBeenCalled();
    expect(historial(prisma)).toEqual([
      expect.objectContaining({ estado_nuevo: 'OBSERVADO', motivo: 'Revisar cheque' }),
    ]);
  });
});

describe('RendicionesService.anular', () => {
  it('anular desde BORRADOR: ANULADO, motivo_rechazo = motivo, libera, historial', async () => {
    const { service, prisma, tx } = crearService({ existentes: [existente()] });
    const fila = await service.anular('emp-1', 'ren-7', 'u-1', { motivo: 'Cargada por error' });
    const { where, data } = tx.rendiciones_cobranza.updateMany.mock.calls[0][0];
    expect(where).toEqual({ id: 'ren-7', estado: { in: ['BORRADOR', 'OBSERVADO'] } });
    expect(data).toEqual({ estado: 'ANULADO', motivo_rechazo: 'Cargada por error' });
    expect(tx.recibos_cobro.updateMany).toHaveBeenCalledWith({
      where: { rendicion_id: 'ren-7', empresa_id: 'emp-1' },
      data: { rendicion_id: null },
    });
    expect(historial(prisma)).toEqual([
      expect.objectContaining({
        estado_anterior: 'BORRADOR',
        estado_nuevo: 'ANULADO',
        usuario_id: 'u-1',
        motivo: 'Cargada por error · Recibos liberados: R-1, R-2',
      }),
    ]);
    expect(fila).toMatchObject({ id: 'ren-7', estado: 'ANULADO', motivo_rechazo: 'Cargada por error' });
  });

  it('anular desde OBSERVADO ok', async () => {
    const { service, prisma } = crearService({ existentes: [existente({ estado: 'OBSERVADO' })] });
    await expect(service.anular('emp-1', 'ren-7', 'u-1', { motivo: 'No se reenvía' })).resolves.toMatchObject({
      estado: 'ANULADO',
    });
    expect(historial(prisma)).toEqual([
      expect.objectContaining({ estado_anterior: 'OBSERVADO', estado_nuevo: 'ANULADO' }),
    ]);
  });

  it("anular desde PENDIENTE → 409 'Solo se anula…' con codigo ESTADO_CAMBIADO y el estado actual (I7.1)", async () => {
    const { service, tx } = crearService({ existentes: [existente({ estado: 'PENDIENTE' })] });
    const p = service.anular('emp-1', 'ren-7', 'u-1', { motivo: 'x' });
    await expect(p).rejects.toThrow(
      new ConflictException('Solo se anula una rendición en BORRADOR u OBSERVADO (estado actual: PENDIENTE)'),
    );
    await p.catch((e: ConflictException) =>
      expect(e.getResponse()).toEqual({
        message: 'Solo se anula una rendición en BORRADOR u OBSERVADO (estado actual: PENDIENTE)',
        codigo: 'ESTADO_CAMBIADO',
        estado_actual: 'PENDIENTE',
      }),
    );
    expect(tx.rendiciones_cobranza.updateMany).not.toHaveBeenCalled();
  });
});

describe('RendicionesService.aprobar', () => {
  it('aprobar mixta: MULTI 100 verificado en 95 + LEGACY 50 → total_verificado 145', async () => {
    const multi = {
      id: 'mpm-1',
      medio: 'EFECTIVO',
      monto: '100',
      importe_verificado: '95',
      verificacion_estado: 'DIFERENCIA',
    };
    const { service, tx } = crearService({
      existentes: [
        existente({
          estado: 'PENDIENTE',
          monto_cobrado: '150',
          total_declarado: '150',
          recibos_cobro: [reciboMulti('r-1', 'R-1', [multi]), reciboLegacy('r-2', 'R-2', '50')],
        }),
      ],
      medios: [{ id: 'mpm-1', monto: '100', importe_verificado: '95', verificacion_estado: 'DIFERENCIA' }],
    });
    const fila = await service.aprobar('emp-1', 'ren-7', 'u-1', {});
    const { where, data } = tx.rendiciones_cobranza.updateMany.mock.calls[0][0];
    expect(where).toEqual({ id: 'ren-7', estado: { in: ['PENDIENTE'] } });
    expect(data.estado).toBe('APROBADO');
    expect(tx.rendiciones_cobranza.update.mock.calls[0][0]).toEqual({
      where: { id: 'ren-7' },
      data: { total_verificado: 145 },
    });
    expect(fila).toMatchObject({ estado: 'APROBADO', total_verificado: 145 });
  });

  it('aprobar sin medios usa total_declarado', async () => {
    const { service, tx } = crearService({
      existentes: [
        existente({ estado: 'PENDIENTE', monto_cobrado: '150000', total_declarado: '140000', recibos_cobro: [] }),
      ],
    });
    await service.aprobar('emp-1', 'ren-7', 'u-1', {});
    expect(tx.rendiciones_cobranza.update.mock.calls[0][0].data.total_verificado).toBe(140000);
  });

  it('totalVerificado: MULTI sin importe_verificado cuenta el monto', () => {
    const r = {
      recibos_cobro: [{ medios_pago_unificado: [{ monto: '80', verificacion: { importe_verificado: null } }] }],
    };
    expect(totalVerificado(r)).toBe(80);
  });
});

// ── Recibos disponibles y crear-y-enviar (Task 5) ──────────────────────

describe('desgloseRecibo', () => {
  it('desglose: código 4 → transferencia, código 7 (QR) → efectivo, MULTI CHEQUE → cheque; total = suma', () => {
    const legacy = {
      modo: 'LEGACY',
      recibo_cobro_detalle: [
        { monto_pagado: '30000', medio_pago: { codigo: 4, descripcion: 'Transferencia' } },
        { monto_pagado: '20000', medio_pago: { codigo: 7, descripcion: 'QR' } },
        { monto_pagado: '5000', medio_pago: { codigo: 3, descripcion: 'Tarjeta' } },
      ],
      medios_pago_multi: [],
    };
    expect(desgloseRecibo(legacy)).toEqual({
      efectivo: 20000,
      cheque: 0,
      transferencia: 30000,
      tarjeta: 5000,
      total: 55000,
    });

    const multi = {
      modo: 'MULTI',
      recibo_cobro_detalle: [],
      medios_pago_multi: [
        { medio: 'CHEQUE', monto: '70000' },
        { medio: 'efectivo', monto: '10000' },
        { medio: 'OTRO', monto: '1000' },
      ],
    };
    expect(desgloseRecibo(multi)).toEqual({
      efectivo: 11000,
      cheque: 70000,
      transferencia: 0,
      tarjeta: 0,
      total: 81000,
    });
  });

  it('crear guarda los mismos montos que desgloseRecibo', async () => {
    const recibo = {
      id: 'r-1',
      modo: 'LEGACY',
      moneda_id: PYG.id,
      recibo_cobro_detalle: [
        { monto_pagado: '30000', medio_pago: { codigo: 4, descripcion: 'Transferencia' } },
        { monto_pagado: '20000', medio_pago: { codigo: 7, descripcion: 'QR' } },
      ],
      medios_pago_multi: [],
    };
    const { service, tx } = crearService({ recibos: [recibo] });
    await service.create('emp-1', 'u-1', dtoCrear() as any);
    expect(tx.rendiciones_cobranza.create.mock.calls[0][0].data).toMatchObject({
      monto_efectivo: 20000,
      monto_cheque: 0,
      monto_transferencia: 30000,
      monto_tarjeta: 0,
      monto_cobrado: 50000,
    });
  });
});

describe('RendicionesService.getRecibosDisponiblesConMeta', () => {
  const filas = (n: number) => Array.from({ length: n }, (_, i) => reciboEfectivo(`r-${i}`, '1000'));

  it('recibos disponibles: 101 filas → 100 y truncado true; 3 → truncado false', async () => {
    const muchas = crearService({ recibos: filas(101) });
    const r = await muchas.service.getRecibosDisponiblesConMeta('emp-1');
    expect(muchas.prisma.recibos_cobro.findMany.mock.calls[0][0].take).toBe(101);
    expect(r.recibos).toHaveLength(100);
    expect(r).toMatchObject({ truncado: true, limite: 100, rendicion_activa: null });

    const pocas = crearService({ recibos: filas(3) });
    const r3 = await pocas.service.getRecibosDisponiblesConMeta('emp-1');
    expect(r3.recibos).toHaveLength(3);
    expect(r3.truncado).toBe(false);
    expect(r3.recibos[0].desglose).toEqual({ efectivo: 1000, cheque: 0, transferencia: 0, tarjeta: 0, total: 1000 });
  });

  it('rendicion_activa con cobrador y moneda; null sin moneda', async () => {
    const activa = {
      id: 'ren-10',
      codigo: 'REN-000010',
      estado: 'OBSERVADO',
      empresa_id: 'emp-1',
      cobrador_id: COBRADOR.id,
      moneda_id: PYG.id,
    };
    const ctx = crearService({ recibos: filas(1), activas: [activa] });
    const r = await ctx.service.getRecibosDisponiblesConMeta('emp-1', COBRADOR.id, undefined, PYG.id);
    expect(r.rendicion_activa).toMatchObject({ id: 'ren-10', codigo: 'REN-000010', estado: 'OBSERVADO' });
    const llamada = ctx.prisma.rendiciones_cobranza.findFirst.mock.calls[0][0];
    expect(llamada.where).toEqual({
      empresa_id: 'emp-1',
      cobrador_id: COBRADOR.id,
      moneda_id: PYG.id,
      estado: { in: ['BORRADOR', 'PENDIENTE', 'OBSERVADO'] },
      deleted_at: null,
    });
    expect(llamada.select).toEqual({ id: true, codigo: true, estado: true });

    const sinMoneda = crearService({ recibos: filas(1), activas: [activa] });
    const r2 = await sinMoneda.service.getRecibosDisponiblesConMeta('emp-1', COBRADOR.id);
    expect(r2.rendicion_activa).toBeNull();
    expect(sinMoneda.prisma.rendiciones_cobranza.findFirst).not.toHaveBeenCalled();

    const sinCobrador = crearService({ recibos: filas(1), activas: [activa] });
    expect(
      (await sinCobrador.service.getRecibosDisponiblesConMeta('emp-1', undefined, undefined, PYG.id)).rendicion_activa,
    ).toBeNull();
  });

  it('getRecibosDisponibles sigue devolviendo solo el array', async () => {
    const { service } = crearService({ recibos: filas(2) });
    const r = await service.getRecibosDisponibles('emp-1');
    expect(Array.isArray(r)).toBe(true);
    expect(r).toHaveLength(2);
  });
});

describe('RendicionesService.create con enviar', () => {
  it('crea y envía en un solo $transaction: BORRADOR → PENDIENTE con dos entradas de historial', async () => {
    const { service, prisma, tx } = crearService({ recibos: [reciboEfectivo('r-1', '100000')] });
    const fila = await service.create('emp-1', 'u-1', dtoCrear({ total_declarado: 90000 }) as any, { enviar: true });
    expect(prisma.$transaction).toHaveBeenCalledTimes(1);
    const { where, data } = tx.rendiciones_cobranza.updateMany.mock.calls[0][0];
    expect(where).toEqual({ id: 'ren-1', estado: { in: ['BORRADOR'] } });
    expect(data).toMatchObject({ estado: 'PENDIENTE', total_declarado: 90000, diferencia: -10000 });
    expect(data.fecha_envio_tesoreria).toBeInstanceOf(Date);
    expect(historial(prisma)).toEqual([
      expect.objectContaining({ estado_anterior: null, estado_nuevo: 'BORRADOR', motivo: 'Creación' }),
      expect.objectContaining({ estado_anterior: 'BORRADOR', estado_nuevo: 'PENDIENTE', motivo: null }),
    ]);
    expect(fila).toMatchObject({ id: 'ren-1', estado: 'PENDIENTE' });
  });

  it('si falla el envío no queda nada (la transacción entera se revierte)', async () => {
    const ctx = crearService({ recibos: [reciboEfectivo('r-1', '100000')], carrera: 'ANULADO' });
    await expect(ctx.service.create('emp-1', 'u-1', dtoCrear() as any, { enviar: true })).rejects.toThrow(
      conflicto('ANULADO'),
    );
    expect(ctx.prisma.$transaction).toHaveBeenCalledTimes(1);
    expect(ctx.creadas).toHaveLength(0);
  });

  it('con enviar y sin recibos → 400 antes de abrir la transacción', async () => {
    const { service, prisma } = crearService({ recibos: [] });
    await expect(
      service.create('emp-1', 'u-1', dtoCrear({ recibo_ids: undefined }) as any, { enviar: true }),
    ).rejects.toThrow(new BadRequestException('La rendición no tiene recibos vinculados'));
    expect(prisma.$transaction).not.toHaveBeenCalled();
  });

  it('con enviar respeta la unicidad por moneda', async () => {
    const activa = {
      id: 'ren-10',
      codigo: 'REN-000010',
      estado: 'PENDIENTE',
      empresa_id: 'emp-1',
      cobrador_id: COBRADOR.id,
      moneda_id: PYG.id,
      moneda: { codigo: 'PYG' },
    };
    const { service, prisma } = crearService({ recibos: [reciboEfectivo('r-1', '100000')], activas: [activa] });
    await expect(service.create('emp-1', 'u-1', dtoCrear() as any, { enviar: true })).rejects.toThrow(
      new BadRequestException('El cobrador ya tiene una rendición pendiente en PYG (REN-000010)'),
    );
    expect(prisma.$transaction).not.toHaveBeenCalled();
  });
});

// ── Ola final de correcciones (revisión final) ─────────────────────────

describe('Ola final: alta (C1, M7)', () => {
  const p2002 = () =>
    new Prisma.PrismaClientKnownRequestError('Unique constraint failed', {
      code: 'P2002',
      clientVersion: 'test',
      meta: { target: 'idx_rendicion_activa_cobrador' },
    });

  it('C1: un P2002 de otro índice (sin activa en esa moneda) da 409 claro, no el error crudo', async () => {
    const { service } = crearService({ recibos: [reciboEfectivo('r-1', '100000')], fallarCreate: p2002() });
    await expect(service.create('emp-1', 'u-1', dtoCrear() as any)).rejects.toThrow(
      new ConflictException('El cobrador ya tiene una rendición activa. Recargá la pantalla.'),
    );
  });

  it('C1: un error que no es P2002 se relanza tal cual', async () => {
    const otro = new Error('se cayó la base');
    const { service } = crearService({ recibos: [reciboEfectivo('r-1', '100000')], fallarCreate: otro });
    await expect(service.create('emp-1', 'u-1', dtoCrear() as any)).rejects.toBe(otro);
  });

  it('M7: vincula solo recibos libres; si otra alta se quedó con alguno → 409 y rollback', async () => {
    const ctx = crearService({ recibos: [reciboEfectivo('r-1', '100000'), reciboEfectivo('r-2', '5000')] });
    ctx.tx.recibos_cobro.updateMany.mockResolvedValueOnce({ count: 1 });
    await expect(ctx.service.create('emp-1', 'u-1', dtoCrear({ recibo_ids: ['r-1', 'r-2'] }) as any)).rejects.toThrow(
      new ConflictException('Algún recibo ya se rindió en otra rendición. Recargá la lista.'),
    );
    expect(ctx.tx.recibos_cobro.updateMany.mock.calls[0][0].where).toEqual({
      id: { in: ['r-1', 'r-2'] },
      rendicion_id: null,
    });
    expect(ctx.creadas).toHaveLength(0);
  });
});

describe('Ola final: liberar limpia la verificación (I2)', () => {
  const limpia = {
    importe_verificado: null,
    verificacion_estado: null,
    verificacion_observacion: null,
    verificado_por: null,
    verificado_at: null,
  };

  it('rechazar RECHAZADO borra la verificación de los medios de los recibos liberados', async () => {
    const { service, tx } = crearService({ existentes: [existente({ estado: 'PENDIENTE' })] });
    await service.rechazar('emp-1', 'ren-7', 'u-1', { accion: 'RECHAZADO', motivo: 'Cheque sin fondos' });
    expect(tx.recibo_cobro_medios_pago.updateMany).toHaveBeenCalledWith({
      where: { recibo_cobro_id: { in: ['r-1', 'r-2'] } },
      data: limpia,
    });
  });

  it('anular también la borra; observar no toca los medios', async () => {
    const anulada = crearService({ existentes: [existente()] });
    await anulada.service.anular('emp-1', 'ren-7', 'u-1', { motivo: 'x' });
    expect(anulada.tx.recibo_cobro_medios_pago.updateMany).toHaveBeenCalledWith({
      where: { recibo_cobro_id: { in: ['r-1', 'r-2'] } },
      data: limpia,
    });

    const observada = crearService({ existentes: [existente({ estado: 'PENDIENTE' })] });
    await observada.service.rechazar('emp-1', 'ren-7', 'u-1', { accion: 'OBSERVADO', motivo: 'x' });
    expect(observada.tx.recibo_cobro_medios_pago.updateMany).not.toHaveBeenCalled();
  });
});

describe('Ola final: verificar y aprobar no se pisan (M6)', () => {
  const multi = (over: Record<string, any> = {}) => ({
    id: 'mpm-1',
    medio: 'EFECTIVO',
    monto: '100',
    importe_verificado: '100',
    verificacion_estado: 'OK',
    ...over,
  });
  const pendienteMulti = () =>
    existente({
      estado: 'PENDIENTE',
      monto_cobrado: '100',
      total_declarado: '100',
      recibos_cobro: [reciboMulti('r-1', 'R-1', [multi()])],
    });
  const conMedio = (ctx: any) => {
    ctx.prisma.recibo_cobro_medios_pago.findUnique = jest
      .fn()
      .mockResolvedValue({ id: 'mpm-1', recibo: { id: 'r-1', rendicion_id: 'ren-7' } });
    return ctx;
  };
  const dtoVerificar = { importe_verificado: 90, verificacion_estado: 'DIFERENCIA' } as any;

  it('verificar bloquea la rendición en PENDIENTE y condiciona el medio a la rendición', async () => {
    const ctx = conMedio(crearService({ existentes: [pendienteMulti()] }));
    await ctx.service.verificarMedioPago('emp-1', 'ren-7', 'mpm-1', 'u-1', dtoVerificar);
    expect(ctx.tx.rendiciones_cobranza.updateMany.mock.calls[0][0]).toEqual({
      where: { id: 'ren-7', estado: { in: ['PENDIENTE'] } },
      data: { estado: 'PENDIENTE' },
    });
    const { where, data } = ctx.tx.recibo_cobro_medios_pago.updateMany.mock.calls[0][0];
    expect(where).toEqual({ id: 'mpm-1', recibo: { rendicion_id: 'ren-7' } });
    expect(data).toMatchObject({ importe_verificado: 90, verificacion_estado: 'DIFERENCIA', verificado_por: 'u-1' });
  });

  it('verificar cuando otro tesorero ya la aprobó → 409 y no toca el medio', async () => {
    const ctx = conMedio(crearService({ existentes: [pendienteMulti()], carrera: 'APROBADO' }));
    await expect(ctx.service.verificarMedioPago('emp-1', 'ren-7', 'mpm-1', 'u-1', dtoVerificar)).rejects.toThrow(
      conflicto('APROBADO'),
    );
    expect(ctx.tx.recibo_cobro_medios_pago.updateMany).not.toHaveBeenCalled();
  });

  it('verificar un medio cuyo recibo salió de la rendición → 409', async () => {
    const ctx = conMedio(crearService({ existentes: [pendienteMulti()] }));
    ctx.tx.recibo_cobro_medios_pago.updateMany.mockResolvedValueOnce({ count: 0 });
    await expect(ctx.service.verificarMedioPago('emp-1', 'ren-7', 'mpm-1', 'u-1', dtoVerificar)).rejects.toThrow(
      new ConflictException('El recibo de este medio ya no está en la rendición. Recargá la pantalla.'),
    );
  });

  it('aprobar calcula el verificado con los medios leídos dentro de la transacción', async () => {
    // findOne vio OK por 100; dentro del tx el medio ya está en DIFERENCIA por 90.
    const ctx = crearService({
      existentes: [pendienteMulti()],
      medios: [{ id: 'mpm-1', monto: '100', importe_verificado: '90', verificacion_estado: 'DIFERENCIA' }],
    });
    await ctx.service.aprobar('emp-1', 'ren-7', 'u-1', {});
    expect(ctx.tx.recibo_cobro_medios_pago.findMany).toHaveBeenCalledTimes(1);
    expect(ctx.prisma.recibo_cobro_medios_pago.findMany).not.toHaveBeenCalled();
    expect(ctx.tx.rendiciones_cobranza.update.mock.calls[0][0].data.total_verificado).toBe(90);
  });

  it('aprobar con un medio sin verificar dentro de la transacción → 400 (rollback) y no marca comisiones', async () => {
    const ctx = crearService({
      existentes: [pendienteMulti()],
      medios: [{ id: 'mpm-1', monto: '100', importe_verificado: null, verificacion_estado: null }],
    });
    await expect(ctx.service.aprobar('emp-1', 'ren-7', 'u-1', {})).rejects.toThrow(
      new BadRequestException('Hay 1 medios de pago sin verificar. Verifique todos antes de aprobar.'),
    );
    expect(ctx.tx.comisiones.updateMany).not.toHaveBeenCalled();
    expect(ctx.tx.rendiciones_cobranza.update).not.toHaveBeenCalled();
  });
});

describe('Ola final: resumen sin residuos de centavos (M1)', () => {
  it('declarado 37.443.167 contra cobrado 37.443.166,66 → diferencia 0,34 exacta', async () => {
    const { service } = crearService({
      rendiciones: [
        rendicion({ monto_cobrado: '37443166.66', total_declarado: '37443167' }),
        rendicion({ monto_cobrado: '0.1', total_declarado: '0.1' }),
        rendicion({ monto_cobrado: '0.2', total_declarado: '0.2' }),
      ],
    });
    const r = await service.getResumen('emp-1', { fecha_desde: '2026-06-01', fecha_hasta: '2026-06-30', moneda_id: PYG.id });
    expect(r.cobrado).toBe(37443166.96);
    expect(r.declarado).toBe(37443167.3);
    expect(r.diferencia).toBe(0.34);
  });
});

describe('Ola final: reporte cobranzas del día (I3)', () => {
  const fila = (over: Record<string, any> = {}) => ({
    ...rendicion(),
    cobrador_id: 'cob-1',
    cobrador: { id: 'cob-1', nombre: 'Kety', apellido: 'G' },
    total_verificado: null,
    ...over,
  });

  it('pide fecha_cobranza en fechas puras: un mes no incluye el 1.º del siguiente', async () => {
    const { service, prisma } = crearService();
    const r = await service.reporteCobranzasDia('emp-1', '2026-06-01', '2026-06-30');
    const { where } = prisma.rendiciones_cobranza.findMany.mock.calls[0][0];
    expect(where.fecha_cobranza).toEqual({
      gte: new Date('2026-06-01T00:00:00.000Z'),
      lte: new Date('2026-06-30T00:00:00.000Z'),
    });
    expect(where.estado).toEqual({ notIn: ['ANULADO'] });
    expect(r).toMatchObject({ fecha_desde: '2026-06-01', fecha_hasta: '2026-06-30', fecha: '2026-06-01' });
  });

  it('fecha mal formada → 400', async () => {
    const { service } = crearService();
    await expect(service.reporteCobranzasDia('emp-1', '2026-06', '2026-06-30')).rejects.toThrow(
      new BadRequestException('Rango de fechas inválido'),
    );
  });

  it('RECHAZADO cuenta en rendiciones y rechazadas, pero no en montos ni recibos; declarado y verificado por cobrador', async () => {
    const { service } = crearService({
      rendiciones: [
        fila({
          estado: 'APROBADO',
          monto_cobrado: '100000',
          monto_efectivo: '100000',
          total_declarado: '100000',
          total_verificado: '95000',
          diferencia: '0',
          cantidad_recibos: 2,
        }),
        fila({
          estado: 'PENDIENTE',
          monto_cobrado: '50000',
          monto_cheque: '50000',
          total_declarado: '40000',
          diferencia: '-10000',
          cantidad_recibos: 1,
        }),
        fila({
          estado: 'RECHAZADO',
          monto_cobrado: '2544000',
          monto_efectivo: '2544000',
          total_declarado: '0',
          diferencia: '-2544000',
          cantidad_recibos: 5,
        }),
      ],
    });
    const r = await service.reporteCobranzasDia('emp-1', '2026-06-01', '2026-06-30');
    expect(r.por_cobrador).toEqual([
      expect.objectContaining({
        cobrador: 'Kety G',
        rendiciones: 3,
        recibos: 3,
        total_cobrado: 150000,
        total_efectivo: 100000,
        total_cheque: 50000,
        declarado: 140000,
        verificado: 135000,
        diferencia: -10000,
        aprobadas: 1,
        pendientes: 1,
        rechazadas: 1,
      }),
    ]);
    expect(r.totales).toEqual({
      rendiciones: 3,
      recibos: 3,
      total_cobrado: 150000,
      total_efectivo: 100000,
      total_cheque: 50000,
      total_transferencia: 0,
      total_tarjeta: 0,
      declarado: 140000,
      verificado: 135000,
      diferencia: -10000,
    });
  });
});

describe('errores estructurados y recibos liberados (I7.1, I7.3)', () => {
  it.each([
    ['enviarATesoreria', 'APROBADO', (sv: any) => sv.enviarATesoreria('emp-1', 'ren-7', 'u-1', {})],
    ['aprobar', 'BORRADOR', (sv: any) => sv.aprobar('emp-1', 'ren-7', 'u-1', {})],
    ['rechazar', 'BORRADOR', (sv: any) => sv.rechazar('emp-1', 'ren-7', 'u-1', { accion: 'RECHAZADO', motivo: 'x' })],
  ])('%s fuera de estado → 409 ESTADO_CAMBIADO', async (_n, estado, accion) => {
    const { service } = crearService({ existentes: [existente({ estado })] });
    const e: any = await accion(service).catch((x: unknown) => x);
    expect(e).toBeInstanceOf(ConflictException);
    expect(e.getResponse()).toMatchObject({ codigo: 'ESTADO_CAMBIADO', estado_actual: estado });
  });

  it('el UPDATE condicionado que pierde la carrera → 409 ESTADO_CAMBIADO con el estado de ahora', async () => {
    const { service, tx } = crearService({ existentes: [existente({ estado: 'BORRADOR' })] });
    tx.rendiciones_cobranza.updateMany = jest.fn().mockResolvedValue({ count: 0 });
    tx.rendiciones_cobranza.findUnique = jest.fn().mockResolvedValue({ estado: 'PENDIENTE' });
    const e: any = await service.anular('emp-1', 'ren-7', 'u-1', { motivo: 'x' }).catch((x: unknown) => x);
    expect(e.getResponse()).toMatchObject({ codigo: 'ESTADO_CAMBIADO', estado_actual: 'PENDIENTE' });
  });

  it.each([
    ['ANULADO', 2, [], true],
    ['RECHAZADO', 1, [], true],
    ['ANULADO', 0, [], false],
    ['BORRADOR', 2, [], false],
  ])('detalle %s con %s recibos al crearla y %j ahora → recibos_liberados %s', async (estado, cantidad, recibos, esperado) => {
    const { service } = crearService({ existentes: [existente({ estado, cantidad_recibos: cantidad, recibos_cobro: recibos })] });
    const r = await service.findOne('emp-1', 'ren-7');
    expect(r.recibos_liberados).toBe(esperado);
  });
});
