/**
 * Los seis endpoints que arma el Tablero: cada uno con su permiso y su submódulo, y la sucursal pedida dentro del
 * alcance (fuera de él, o de otra empresa: 403 `SUCURSAL_FUERA_DE_ALCANCE` antes de consultar).
 */
import { ForbiddenException } from '@nestjs/common';
import { REQUIRE_MODULE_KEY, REQUIRE_PERMISSION_KEY, REQUIRE_SUBMODULO_KEY } from 'src/auth/decorators';
import { AlgunPrivilegioGuard, REQUIRE_ALGUN_PRIVILEGIO_KEY } from 'src/auth/guards/algun-privilegio.guard';
import { ModuleGuard } from 'src/auth/guards/module.guard';
import { SubmoduloGuard } from 'src/auth/guards/submodulo.guard';
import { CobrosController } from 'src/cobros/cobros.controller';
import { CobrosService } from 'src/cobros/cobros.service';
import { ComprasController } from 'src/compras/compras.controller';
import { ComprasService } from 'src/compras/compras.service';
import { FacturasController } from 'src/facturas/facturas.controller';
import { FacturasService } from 'src/facturas/facturas.service';
import { PresupuestosDashboardService } from 'src/presupuestos/presupuestos-dashboard.service';
import { PresupuestosController } from 'src/presupuestos/presupuestos.controller';
import { ReportesRentabilidadController } from 'src/reportes-rentabilidad/reportes-rentabilidad.controller';
import { ReportesRentabilidadService } from 'src/reportes-rentabilidad/reportes-rentabilidad.service';
import { TesoreriaController } from 'src/tesoreria/tesoreria.controller';
import { TesoreriaService } from 'src/tesoreria/tesoreria.service';
import { alcanceSucursalUsuario, CODIGO_SUCURSAL_FUERA_DE_ALCANCE } from 'src/utils/alcance-sucursal';

// Tablero «lo mío» (A2): estos tests miran el alcance por sucursal y las monedas, no el alcance propio: TODO.
jest.mock('src/utils/alcance-propio', () => ({
  ...jest.requireActual('src/utils/alcance-propio'),
  resolverAlcancePropio: jest.fn().mockResolvedValue({ tipo: 'TODO' }),
}));
jest.mock('src/utils/alcance-sucursal', () => ({
  ...jest.requireActual('src/utils/alcance-sucursal'),
  alcanceSucursalUsuario: jest.fn(),
}));
const alcanceMock = alcanceSucursalUsuario as jest.Mock;

const meta = (key: string, cls: any, metodo: string) => Reflect.getMetadata(key, cls.prototype[metodo]);
const guardsDe = (cls: any, metodo: string) => (Reflect.getMetadata('__guards__', cls.prototype[metodo]) ?? []) as unknown[];

describe('permiso y submódulo de cada endpoint del Tablero', () => {
  it.each([
    ['GET /facturas/dashboard', FacturasController, 'getDashboardVentas', { modulo: 'VENTAS', privilegio: 'VEN_FAC_FACTURA_VER' }, 'VENTAS_FACTURACION'],
    ['GET /presupuestos/dashboard', PresupuestosController, 'dashboard', { modulo: 'VENTAS', privilegio: 'VEN_PRE_PRESUPUESTO_VER' }, 'VENTAS_PRESUPUESTOS'],
    ['GET /cobros/cuentas-cobrar/dashboard', CobrosController, 'getCuentasCobrarDashboard', { modulo: 'COBRANZAS', privilegio: 'COB_CC_CUENTA_COBRAR_VER' }, 'COB_CUENTAS_COBRAR'],
    ['GET /reportes/rentabilidad/dashboard', ReportesRentabilidadController, 'getDashboard', { modulo: 'REPORTES', privilegio: 'REP_FAC_REPORTE_VER' }, 'REP_FACTURACION'],
    ['GET /tesoreria/movimientos', TesoreriaController, 'getMovimientos', { modulo: 'TESORERIA', privilegio: 'TES_MOV_MOVIMIENTO_VER' }, 'TES_MOVIMIENTOS'],
  ])('%s', (_ruta, cls, metodo, permiso, submodulo) => {
    expect(meta(REQUIRE_PERMISSION_KEY, cls, metodo)).toEqual(permiso);
    expect(meta(REQUIRE_SUBMODULO_KEY, cls, metodo)).toBe(submodulo);
    expect(guardsDe(cls, metodo)).toContain(SubmoduloGuard);
  });

  it('GET /compras/dashboard: módulo COMPRAS, CMP_FAC_FACTURA_PROV_VER o el permiso de reportes admin (F10) y COMP_FACTURAS', () => {
    expect(meta(REQUIRE_MODULE_KEY, ComprasController, 'getDashboard')).toBe('COMPRAS');
    expect(meta(REQUIRE_ALGUN_PRIVILEGIO_KEY, ComprasController, 'getDashboard')).toEqual(['CMP_FAC_FACTURA_PROV_VER', 'REP_AF_REPORTE_VER']);
    expect(meta(REQUIRE_SUBMODULO_KEY, ComprasController, 'getDashboard')).toBe('COMP_FACTURAS');
    expect(guardsDe(ComprasController, 'getDashboard')).toEqual(expect.arrayContaining([ModuleGuard, AlgunPrivilegioGuard, SubmoduloGuard]));
  });

});

// ─────────────────────────── servicios ───────────────────────────

const SUCURSALES = [
  { id: 's1', empresa_id: 'emp', punto_establecimiento: '001', config: null },
  { id: 's2', empresa_id: 'emp', punto_establecimiento: '002', config: null },
  { id: 'ajena', empresa_id: 'otra', punto_establecimiento: '001', config: null },
];

function crearPrisma() {
  const vacio = () => jest.fn().mockResolvedValue([]);
  const prisma: any = {
    empresas_sucursales: {
      findFirst: jest.fn(({ where }) =>
        Promise.resolve(SUCURSALES.find((s) => s.id === where.id && s.empresa_id === where.empresa_id) ?? null),
      ),
      findMany: jest.fn(({ where }) => {
        const ids: string[] | undefined = where?.id?.in;
        return Promise.resolve(SUCURSALES.filter((s) => (ids ? ids.includes(s.id) : s.empresa_id === where?.empresa_id)));
      }),
    },
    // T3: cada dashboard lee la moneda base para rotular (y convertir).
    empresa_monedas: { findFirst: jest.fn().mockResolvedValue({ moneda_id: 'm-pyg' }) },
    moneda: {
      findFirst: jest.fn().mockResolvedValue({ id: 'm-pyg', codigo: 'PYG' }),
      findUnique: jest.fn().mockResolvedValue({ id: 'm-pyg', codigo: 'PYG' }),
      findMany: vacio(),
    },
    factura_cab: { findMany: vacio() },
    factura_det: { findMany: vacio(), aggregate: jest.fn().mockResolvedValue({ _sum: { dcantproser: 0 } }) },
    factura_cuotas: { findMany: vacio() },
    recibos_cobro: { aggregate: jest.fn().mockResolvedValue({ _sum: { monto_total: 0 } }), groupBy: vacio() },
    compra_cab: { findMany: vacio(), count: jest.fn().mockResolvedValue(0) },
    nota_credito_compra_cab: { findMany: vacio() },
    presupuesto_cab: { groupBy: vacio(), findMany: vacio(), count: jest.fn().mockResolvedValue(0) },
    presupuesto_config: { findUnique: jest.fn().mockResolvedValue(null) },
    movimiento_cajas: { findMany: vacio(), count: jest.fn().mockResolvedValue(0) },
    $queryRaw: jest.fn().mockResolvedValue([]),
    $transaction: jest.fn((ops: Promise<unknown>[]) => Promise.all(ops)),
  };
  return prisma;
}

/** Cada servicio con su llamada al dashboard y el lugar donde se ve el filtro de sucursal. */
type Caso = {
  nombre: string;
  llamar: (prisma: any, sucursal_id: string) => Promise<unknown>;
  /** Las consultas de datos que no deben correr con un 403. */
  consultas: (prisma: any) => jest.Mock[];
  /** Con s1, el where filtra por s1. */
  filtraPorS1: (prisma: any) => void;
};

const crearTesoreria = (prisma: any) => {
  const svc = new TesoreriaService(prisma, undefined as any, undefined as any, undefined as any, undefined as any);
  const s: any = svc;
  jest.spyOn(s, 'enriquecerMovimientosConMedio').mockImplementation(async (_e: unknown, items: unknown) => items);
  jest.spyOn(s, 'referenciasLegibles').mockResolvedValue(new Map());
  jest.spyOn(s, 'totalesMovimientos').mockResolvedValue({});
  jest.spyOn(s, 'totalesPorMedio').mockResolvedValue([]);
  return svc;
};

const crearRentabilidad = (prisma: any) => {
  const svc = new ReportesRentabilidadService(prisma);
  jest.spyOn(svc as any, 'computeOverlayPorFactura').mockResolvedValue(new Map());
  return svc;
};

const whereDe = (mock: jest.Mock, n = 0) => JSON.stringify(mock.mock.calls[n][0].where);

const CASOS: Caso[] = [
  {
    nombre: 'facturas (ventas)',
    llamar: (prisma, sucursal_id) =>
      new (FacturasService as any)(prisma).getDashboardVentas('emp', { sucursalId: sucursal_id, usuarioId: 'usr' }),
    consultas: (p) => [p.factura_cab.findMany, p.factura_det.aggregate],
    filtraPorS1: (p) => {
      expect(whereDe(p.factura_cab.findMany)).toContain('"dest":{"in":["001"]}');
      expect(whereDe(p.factura_cab.findMany)).not.toContain('"002"');
    },
  },
  {
    nombre: 'compras',
    llamar: (prisma, sucursal_id) => new (ComprasService as any)(prisma).getDashboard('emp', { sucursal_id, usuarioId: 'usr' }),
    consultas: (p) => [p.compra_cab.findMany, p.compra_cab.count, p.nota_credito_compra_cab.findMany],
    filtraPorS1: (p) => {
      expect(p.compra_cab.findMany.mock.calls[0][0].where.sucursal_id).toBe('s1');
      expect(p.compra_cab.findMany.mock.calls[1][0].where.sucursal_id).toBe('s1');
    },
  },
  {
    nombre: 'presupuestos',
    llamar: (prisma, sucursal_id) => new PresupuestosDashboardService(prisma).getDashboard('emp', { sucursal_id }, 'usr'),
    consultas: (p) => [p.presupuesto_cab.groupBy, p.presupuesto_cab.findMany, p.presupuesto_cab.count, p.$queryRaw],
    filtraPorS1: (p) => {
      expect(p.presupuesto_cab.groupBy.mock.calls[0][0].where.sucursal_id).toBe('s1');
      expect(p.presupuesto_cab.count.mock.calls[0][0].where.sucursal_id).toBe('s1');
      for (const [arg] of p.presupuesto_cab.findMany.mock.calls) expect(arg.where.sucursal_id).toBe('s1');
      // La serie mensual (SQL crudo) también: el arreglo de sucursales va como parámetro.
      for (const [, ...valores] of p.$queryRaw.mock.calls) expect(JSON.stringify(valores)).toContain('["s1"]');
    },
  },
  {
    nombre: 'cuentas a cobrar',
    llamar: (prisma, sucursal_id) =>
      new (CobrosService as any)(prisma).getCuentasCobrarDashboard('emp', { sucursal_id }, 'usr'),
    consultas: (p) => [p.factura_cuotas.findMany, p.recibos_cobro.aggregate, p.recibos_cobro.groupBy],
    filtraPorS1: (p) => {
      expect(whereDe(p.factura_cuotas.findMany)).toContain('"dest":{"in":["001"]}');
      expect(whereDe(p.factura_cuotas.findMany)).not.toContain('"002"');
      expect(p.recibos_cobro.aggregate.mock.calls[0][0].where.sucursal_id).toBe('s1');
      expect(p.recibos_cobro.groupBy.mock.calls[0][0].where.sucursal_id).toBe('s1');
    },
  },
  {
    nombre: 'rentabilidad',
    llamar: (prisma, sucursal_id) => crearRentabilidad(prisma).getRentabilidadDashboard('emp', { sucursal_id }, 'usr'),
    consultas: (p) => [p.factura_det.findMany],
    filtraPorS1: (p) => {
      expect(whereDe(p.factura_det.findMany)).toContain('"dest":{"in":["001"]}');
      expect(whereDe(p.factura_det.findMany)).not.toContain('"002"');
    },
  },
  {
    nombre: 'movimientos de caja',
    llamar: (prisma, sucursal_id) => crearTesoreria(prisma).getMovimientos('emp', { sucursal_id, usuarioId: 'usr' }),
    consultas: (p) => [p.movimiento_cajas.findMany, p.movimiento_cajas.count],
    filtraPorS1: (p) => {
      // Sucursal de la sesión o, si es nula, la de su caja (mismo criterio que las sesiones).
      expect(p.movimiento_cajas.findMany.mock.calls[0][0].where.sesiones_caja).toEqual({ OR: [{ sucursal_id: 's1' }, { sucursal_id: null, cajas: { is: { sucursal_id: 's1' } } }] });
    },
  },
];

const RESTRINGIDO_A_S1 = { sucursalIds: ['s1'], puntosEstablecimiento: ['001'], depositoIds: [] };

async function errorDe(p: Promise<unknown>) {
  try {
    await p;
  } catch (e) {
    return e;
  }
  return null;
}

describe.each(CASOS)('servicio de $nombre', ({ llamar, consultas, filtraPorS1 }) => {
  beforeEach(() => alcanceMock.mockReset());

  const esperar403 = async (prisma: any, sucursal: string) => {
    const e: any = await errorDe(llamar(prisma, sucursal));
    expect(e).toBeInstanceOf(ForbiddenException);
    expect(e.getResponse()).toEqual(expect.objectContaining({ codigo: CODIGO_SUCURSAL_FUERA_DE_ALCANCE, campo: 'sucursal_id' }));
    for (const consulta of consultas(prisma)) expect(consulta).not.toHaveBeenCalled();
  };

  it('restringido a s1 que pide s2: 403 sin consultar', async () => {
    alcanceMock.mockResolvedValue(RESTRINGIDO_A_S1);
    await esperar403(crearPrisma(), 's2');
  });

  it('alcance null que pide una sucursal de otra empresa: 403 sin consultar (F6)', async () => {
    alcanceMock.mockResolvedValue(null);
    await esperar403(crearPrisma(), 'ajena');
  });

  it('con alcance s1 y s2, pide s1: el where filtra solo por s1', async () => {
    alcanceMock.mockResolvedValue({ sucursalIds: ['s1', 's2'], puntosEstablecimiento: ['001', '002'], depositoIds: [] });
    const prisma = crearPrisma();
    await llamar(prisma, 's1');
    filtraPorS1(prisma);
  });
});

describe('NC de compra en el dashboard de compras', () => {
  beforeEach(() => alcanceMock.mockReset());

  it('con s1: la NC se ata a la sucursal por su factura o por su depósito', async () => {
    alcanceMock.mockResolvedValue(RESTRINGIDO_A_S1);
    const prisma = crearPrisma();
    await new (ComprasService as any)(prisma).getDashboard('emp', { sucursal_id: 's1', usuarioId: 'usr' });
    expect(prisma.nota_credito_compra_cab.findMany.mock.calls[0][0].where.OR).toEqual([
      { compra_cab: { sucursal_id: 's1' } },
      { depositos: { sucursal_id: 's1' } },
    ]);
  });

  it('restringido a s1 sin pedir sucursal: las NC de su alcance', async () => {
    alcanceMock.mockResolvedValue({ ...RESTRINGIDO_A_S1, sucursalIds: ['s1', 's2'] });
    const prisma = crearPrisma();
    await new (ComprasService as any)(prisma).getDashboard('emp', { usuarioId: 'usr' });
    expect(prisma.nota_credito_compra_cab.findMany.mock.calls[0][0].where.OR).toEqual([
      { compra_cab: { sucursal_id: { in: ['s1', 's2'] } } },
      { depositos: { sucursal_id: { in: ['s1', 's2'] } } },
    ]);
  });

  it('alcance null y sin filtro: no se filtra por sucursal', async () => {
    alcanceMock.mockResolvedValue(null);
    const prisma = crearPrisma();
    await new (ComprasService as any)(prisma).getDashboard('emp', { usuarioId: 'usr' });
    expect(prisma.nota_credito_compra_cab.findMany.mock.calls[0][0].where.OR).toBeUndefined();
  });
});

describe('cuentas a cobrar recibe { sucursal_id, moneda_id } y no un período', () => {
  it('la firma es (empresa, filtros, usuario)', async () => {
    alcanceMock.mockResolvedValue(null);
    const prisma = crearPrisma();
    await new (CobrosService as any)(prisma).getCuentasCobrarDashboard('emp', { sucursal_id: undefined, moneda_id: undefined }, 'usr');
    expect(alcanceMock).toHaveBeenCalledWith(prisma, 'usr', 'emp');
    // Sin período: la cartera es la pendiente a hoy, sin rango de fechas de emisión.
    expect(prisma.factura_cuotas.findMany.mock.calls[0][0].where.factura_cab.dfeemide).toBeUndefined();
  });
});
