import { ForbiddenException, BadRequestException } from '@nestjs/common';
import { GUARDS_METADATA } from '@nestjs/common/constants';
import { TableroController } from './tablero.controller';
import { CODIGO_SIN_VINCULO, TableroPropioService } from './tablero-propio.service';

const PYG = { id: 'm-pyg', codigo: 'PYG', simbolo: 'Gs.' };
const USD = { id: 'm-usd', codigo: 'USD', simbolo: '$' };

const fact = (moneda: any, dfeemide = new Date('2026-11-03T10:00:00Z')) => ({ moneda_id: moneda?.id, dfeemide, moneda });
const com = (tipo: string, estado: string, monto: number, moneda: any) => ({
  tipo, estado, monto_comision: monto, factura_id: 'f', recibo_id: null, observaciones: null,
  factura_cab: fact(moneda), recibos_cobro: null, created_at: new Date(),
});

function crear(opts: { vinculos?: any[]; comisiones?: any[]; promesas?: any[]; proximas?: any[]; sinBase?: boolean }) {
  const promesasFind = jest.fn(({ where }) => (where.estado === 'pendiente' ? opts.proximas ?? [] : opts.promesas ?? []));
  const prisma: any = {
    vendedores_cobradores: { findMany: jest.fn(async () => opts.vinculos ?? []) },
    comisiones: { findMany: jest.fn(async () => opts.comisiones ?? []) },
    recibos_cobro: { findMany: jest.fn(async () => []) },
    promesas_pago: { findMany: promesasFind },
    empresa_monedas: { findFirst: jest.fn(async () => (opts.sinBase ? null : { moneda: PYG })) },
    moneda: { findFirst: jest.fn(async () => (opts.sinBase ? null : PYG)) },
  };
  return { prisma, svc: new TableroPropioService(prisma) };
}

describe('TableroPropioService', () => {
  it('sin vínculo: 403 SIN_VINCULO_VENDEDOR_COBRADOR en ambos endpoints', async () => {
    const { svc } = crear({ vinculos: [] });
    for (const f of [() => svc.miComision('e', 'u'), () => svc.misPromesas('e', 'u')]) {
      const err: any = await f().catch((e) => e);
      expect(err).toBeInstanceOf(ForbiddenException);
      expect(err.getResponse().codigo).toBe(CODIGO_SIN_VINCULO);
    }
  });

  it('busca el vínculo activo por empresa y usuario', async () => {
    const { svc, prisma } = crear({ vinculos: [{ id: 'v1', tipo: 'vendedor' }] });
    await svc.miComision('emp', 'usr');
    expect(prisma.vendedores_cobradores.findMany.mock.calls[0][0].where).toEqual({ empresa_id: 'emp', usuario_id: 'usr', active: true });
  });

  it('desde > hasta: 400', async () => {
    const { svc } = crear({ vinculos: [{ id: 'v1', tipo: 'vendedor' }] });
    await expect(svc.miComision('e', 'u', '2026-11-30', '2026-11-01')).rejects.toBeInstanceOf(BadRequestException);
  });

  it('mi comisión agrupa por moneda, tipo y estado sin mezclar monedas', async () => {
    const { svc, prisma } = crear({
      vinculos: [{ id: 'v1', tipo: 'ambos' }],
      comisiones: [
        com('venta', 'pendiente', 100, PYG),
        com('venta', 'pendiente', 50, PYG),
        com('venta', 'liquidada', 30, PYG),
        com('cobranza', 'aprobada', 7, USD),
        { ...com('venta', 'pendiente', 5, null), factura_cab: null, recibos_cobro: null, factura_id: null, created_at: new Date() }, // sin moneda propia: base
      ],
    });
    const r = await svc.miComision('e', 'u', '2026-11-01', '2026-11-30');
    expect(r.por_moneda.map((m) => m.moneda.codigo)).toEqual(['PYG', 'USD']);
    const pyg = r.por_moneda[0];
    expect(pyg.por_tipo).toEqual([
      { tipo: 'venta', por_estado: [
        { estado: 'liquidada', monto: 30, cantidad: 1 },
        { estado: 'pendiente', monto: 155, cantidad: 3 },
      ] },
    ]);
    expect(r.por_moneda[1].por_tipo).toEqual([{ tipo: 'cobranza', por_estado: [{ estado: 'aprobada', monto: 7, cantidad: 1 }] }]);
    // período por fecha del documento (no created_at) y solo las del vínculo
    const w = prisma.comisiones.findMany.mock.calls[0][0].where;
    expect(w.vendedor_cobrador_id).toEqual({ in: ['v1'] });
    expect(JSON.stringify(w)).toContain('dfeemide');
    expect(JSON.stringify(w)).not.toContain('created_at');
  });

  it('mis promesas: vendedor puro -> aplica:false y no consulta promesas', async () => {
    const { svc, prisma } = crear({ vinculos: [{ id: 'v1', tipo: 'vendedor' }] });
    expect(await svc.misPromesas('e', 'u')).toEqual({ aplica: false });
    expect(prisma.promesas_pago.findMany).not.toHaveBeenCalled();
  });

  it('mis promesas agrupa por estado y moneda de la factura; monto null cuenta pero no suma', async () => {
    const { svc, prisma } = crear({
      vinculos: [{ id: 'c1', tipo: 'cobrador' }],
      promesas: [
        { estado: 'pendiente', monto_prometido: 100, factura: { moneda: PYG } },
        { estado: 'pendiente', monto_prometido: null, factura: { moneda: PYG } },
        { estado: 'pendiente', monto_prometido: 9, factura: { moneda: USD } },
        { estado: 'cumplida', monto_prometido: 40, factura: { moneda: PYG } },
      ],
      proximas: [
        { id: 'p1', fecha_prometida: new Date('2026-11-10T00:00:00Z'), monto_prometido: 100, cliente: { nombre_fantasia: 'Fant', personas: { razon_social: 'Cliente SA' } }, factura: { moneda: USD } },
        { id: 'p2', fecha_prometida: new Date('2026-11-11T00:00:00Z'), monto_prometido: null, cliente: { nombre_fantasia: 'Solo Fant', personas: null }, factura: { moneda: null } },
      ],
    });
    const r: any = await svc.misPromesas('e', 'u', '2026-11-01', '2026-11-30');
    expect(r.aplica).toBe(true);
    expect(r.por_estado).toEqual([
      { estado: 'cumplida', cantidad: 1, monto: 40, moneda: { codigo: 'PYG' } },
      { estado: 'pendiente', cantidad: 2, monto: 100, moneda: { codigo: 'PYG' } },
      { estado: 'pendiente', cantidad: 1, monto: 9, moneda: { codigo: 'USD' } },
    ]);
    expect(r.proximas).toEqual([
      { id: 'p1', cliente: 'Cliente SA', fecha: '2026-11-10', monto: 100, moneda: { codigo: 'USD' } },
      { id: 'p2', cliente: 'Solo Fant', fecha: '2026-11-11', monto: null, moneda: { codigo: 'PYG' } },
    ]);
    const wProx = prisma.promesas_pago.findMany.mock.calls[1][0];
    expect(wProx.take).toBe(10);
    expect(wProx.where.cobrador_id).toEqual({ in: ['c1'] });
  });
});

describe('TableroPropioService (ronda 1)', () => {
  it('comisión sin moneda resoluble va a sin_moneda (por tipo), no se descarta ni se suma', async () => {
    const huerfana = (tipo: string) => ({ ...com(tipo, 'pendiente', 5, null), factura_cab: null, recibos_cobro: null, factura_id: null });
    const { svc } = crear({
      vinculos: [{ id: 'v1', tipo: 'ambos' }],
      sinBase: true,
      comisiones: [com('venta', 'pendiente', 10, PYG), huerfana('venta'), huerfana('cobranza'), huerfana('venta')],
    });
    const r = await svc.miComision('e', 'u');
    expect(r.sin_moneda).toEqual({ cantidad: 3, por_tipo: [{ tipo: 'cobranza', cantidad: 1 }, { tipo: 'venta', cantidad: 2 }] });
    expect(r.por_moneda).toHaveLength(1);
    expect(r.por_moneda[0].por_tipo[0].por_estado).toEqual([{ estado: 'pendiente', monto: 10, cantidad: 1 }]);
  });

  it('sin comisiones sin moneda: sin_moneda en cero', async () => {
    const { svc } = crear({ vinculos: [{ id: 'v1', tipo: 'vendedor' }], comisiones: [] });
    expect((await svc.miComision('e', 'u')).sin_moneda).toEqual({ cantidad: 0, por_tipo: [] });
  });

  it('un tipo desconocido no se pierde: va en su propio grupo tras venta y cobranza', async () => {
    const { svc } = crear({
      vinculos: [{ id: 'v1', tipo: 'ambos' }],
      comisiones: [com('bono', 'pendiente', 3, PYG), com('cobranza', 'pendiente', 2, PYG), com('venta', 'pendiente', 1, PYG)],
    });
    const r = await svc.miComision('e', 'u');
    expect(r.por_moneda[0].por_tipo.map((t) => t.tipo)).toEqual(['venta', 'cobranza', 'bono']);
  });

  it('promesas: varios cobradores activos y ambos -> cobrador_id in [todos los cobrador/ambos]', async () => {
    const { svc, prisma } = crear({
      vinculos: [{ id: 'c1', tipo: 'cobrador' }, { id: 'a1', tipo: 'ambos' }, { id: 'v1', tipo: 'vendedor' }],
    });
    const r: any = await svc.misPromesas('e', 'u');
    expect(r.aplica).toBe(true);
    for (const call of prisma.promesas_pago.findMany.mock.calls) {
      expect(call[0].where.cobrador_id).toEqual({ in: ['c1', 'a1'] });
    }
  });

  it('promesas: solo vínculo ambos aplica', async () => {
    const { svc } = crear({ vinculos: [{ id: 'a1', tipo: 'ambos' }] });
    expect((await svc.misPromesas('e', 'u') as any).aplica).toBe(true);
  });

  it('promesas sin moneda resoluble: sin_moneda cuenta; la próxima conserva fila con moneda null', async () => {
    const { svc } = crear({
      vinculos: [{ id: 'c1', tipo: 'cobrador' }],
      sinBase: true,
      promesas: [
        { estado: 'pendiente', monto_prometido: 100, factura: { moneda: PYG } },
        { estado: 'pendiente', monto_prometido: 50, factura: { moneda: null } },
      ],
      proximas: [{ id: 'p1', fecha_prometida: new Date('2026-11-10T00:00:00Z'), monto_prometido: 50, cliente: { nombre_fantasia: 'X', personas: null }, factura: { moneda: null } }],
    });
    const r: any = await svc.misPromesas('e', 'u');
    expect(r.sin_moneda).toEqual({ cantidad: 1 });
    expect(r.por_estado).toEqual([{ estado: 'pendiente', cantidad: 1, monto: 100, moneda: { codigo: 'PYG' } }]);
    expect(r.proximas[0].moneda).toBeNull();
  });
});

describe('TableroController (endpoints propios)', () => {
  it.each(['miComision', 'misPromesas'])('%s lleva SubmoduloGuard y PermissionGuard', (m) => {
    const guards = Reflect.getMetadata(GUARDS_METADATA, (TableroController.prototype as any)[m]) as any[];
    expect(guards.map((g) => g.name)).toEqual(['SubmoduloGuard', 'PermissionGuard']);
  });
});
