/**
 * Permisos de la IA en el back (antes bastaba el submódulo para ver, recalcular, chatear y cambiar la API key):
 * cada handler con su privilegio del módulo REPORTES (F26: `PermissionGuard` compara `modulos.codigo`), el submódulo
 * `REP_DASHBOARD_IA` y, donde se ve la empresa entera, `AlcanceTotalGuard`. La configuración no pide alcance total:
 * el holding la usa desde Suscripciones › Consumo IA.
 */
import { AuthGuard } from '@nestjs/passport';
import { REQUIRE_PERMISSION_KEY, REQUIRE_SUBMODULO_KEY } from 'src/auth/decorators';
import { PermissionGuard, SubmoduloGuard } from 'src/auth/guards';
import { AiConfigController } from './ai-config/ai-config.controller';
import { AiDashboardController } from './ai-dashboard.controller';
import { ChatController } from './chat/chat.controller';
import { InsightsService } from './insights/insights.service';
import { PredictionsService } from './predictions/predictions.service';
import { AlcanceTotalGuard } from './shared/alcance-total.guard';
import { MONEDA_CONSOLIDACION_IA } from './shared/moneda-ia';

const VER = { modulo: 'REPORTES', privilegio: 'REP_DIA_DASHBOARD_VER' };
const RECALCULAR = { modulo: 'REPORTES', privilegio: 'REP_DIA_RECALCULAR' };
const CHAT = { modulo: 'REPORTES', privilegio: 'REP_DIA_CHAT_USAR' };
const CONFIG = { modulo: 'REPORTES', privilegio: 'REP_DIA_DASHBOARD_CONFIG' };

/** El permiso que mira `PermissionGuard` (`getAllAndOverride`: el del handler gana al de la clase). */
const permisoDe = (cls: any, metodo: string) =>
  Reflect.getMetadata(REQUIRE_PERMISSION_KEY, cls.prototype[metodo]) ?? Reflect.getMetadata(REQUIRE_PERMISSION_KEY, cls);
const submoduloDe = (cls: any, metodo: string) =>
  Reflect.getMetadata(REQUIRE_SUBMODULO_KEY, cls.prototype[metodo]) ?? Reflect.getMetadata(REQUIRE_SUBMODULO_KEY, cls);
/** Guards que corren en el handler: los de la clase y después los del método. */
const guardsDe = (cls: any, metodo: string) => [
  ...((Reflect.getMetadata('__guards__', cls) ?? []) as unknown[]),
  ...((Reflect.getMetadata('__guards__', cls.prototype[metodo]) ?? []) as unknown[]),
];
const handlersDe = (cls: any) =>
  Object.getOwnPropertyNames(cls.prototype).filter((m) => m !== 'constructor' && typeof cls.prototype[m] === 'function');

const TABLA: Array<[string, any, string, { modulo: string; privilegio: string }, boolean]> = [
  ['GET ai-dashboard/active-domains', AiDashboardController, 'getActiveDomains', VER, true],
  ['GET ai-dashboard/resumen', AiDashboardController, 'getResumen', VER, true],
  ['GET ai-dashboard/alertas', AiDashboardController, 'getAlertas', VER, true],
  ['PATCH ai-dashboard/alertas/:id/leer', AiDashboardController, 'marcarLeida', VER, true],
  ['PATCH ai-dashboard/alertas/:id/resolver', AiDashboardController, 'marcarResuelta', VER, true],
  ['GET ai-dashboard/timeline', AiDashboardController, 'getTimeline', VER, true],
  ['GET ai-dashboard/predicciones', AiDashboardController, 'getPredicciones', VER, true],
  ['GET ai-dashboard/predicciones/nomina', AiDashboardController, 'getProyeccionNomina', VER, true],
  ['GET ai-dashboard/predicciones/rrhh-riesgo-desvinculacion', AiDashboardController, 'getRiesgoDesvinculacion', VER, true],
  ['GET ai-dashboard/predicciones/cobranza', AiDashboardController, 'getProyeccionCobranza', VER, true],
  ['GET ai-dashboard/predicciones/riesgo', AiDashboardController, 'getClientesRiesgo', VER, true],
  ['GET ai-dashboard/predicciones/ventas', AiDashboardController, 'getProyeccionVentas', VER, true],
  ['GET ai-dashboard/predicciones/compras', AiDashboardController, 'getProyeccionCompras', VER, true],
  ['GET ai-dashboard/predicciones/reorden', AiDashboardController, 'getProductosReorden', VER, true],
  ['GET ai-dashboard/metricas', AiDashboardController, 'getMetricas', VER, true],
  ['GET ai-dashboard/metricas/rrhh', AiDashboardController, 'getMetricasRRHH', VER, true],
  ['POST ai-dashboard/recalcular', AiDashboardController, 'recalcular', RECALCULAR, true],
  ['POST ai-chat/sesiones', ChatController, 'crearSesion', CHAT, true],
  ['GET ai-chat/sesiones', ChatController, 'listarSesiones', CHAT, true],
  ['GET ai-chat/sesiones/:id', ChatController, 'getSesion', CHAT, true],
  ['POST ai-chat/sesiones/:id/mensajes', ChatController, 'enviarMensaje', CHAT, true],
  ['POST ai-chat/favoritos', ChatController, 'guardarFavorito', CHAT, true],
  ['GET ai-chat/favoritos', ChatController, 'listarFavoritos', CHAT, true],
  ['DELETE ai-chat/favoritos/:id', ChatController, 'eliminarFavorito', CHAT, true],
  ['POST ai-chat/favoritos/:id/ejecutar', ChatController, 'ejecutarFavorito', CHAT, true],
  ['GET ai-config', AiConfigController, 'getConfig', VER, false],
  ['GET ai-config/consumo', AiConfigController, 'getConsumo', VER, false],
  ['GET ai-config/tokens/estado', AiConfigController, 'estadoTokens', VER, false],
  ['POST ai-config', AiConfigController, 'upsert', CONFIG, false],
  ['POST ai-config/test', AiConfigController, 'testConexion', CONFIG, false],
  ['POST ai-config/modelos', AiConfigController, 'listarModelos', CONFIG, false],
];

describe('permisos de cada handler de la IA', () => {
  it.each(TABLA)('%s', (_ruta, cls, metodo, permiso, alcanceTotal) => {
    expect(permisoDe(cls, metodo)).toEqual(permiso);
    expect(submoduloDe(cls, metodo)).toBe('REP_DASHBOARD_IA');
    const guards = guardsDe(cls, metodo);
    expect(guards).toContain(SubmoduloGuard);
    expect(guards).toContain(PermissionGuard);
    if (alcanceTotal) expect(guards).toContain(AlcanceTotalGuard);
    else expect(guards).not.toContain(AlcanceTotalGuard);
    // JWT primero: el resto lee request.user.
    expect(guards[0]).toBe(AuthGuard('jwt'));
  });

  it('la tabla cubre todos los handlers de los tres controladores (uno nuevo no queda sin permiso)', () => {
    for (const cls of [AiDashboardController, ChatController, AiConfigController]) {
      const enTabla = TABLA.filter(([, c]) => c === cls).map(([, , m]) => m).sort();
      expect(handlersDe(cls).sort()).toEqual(enTabla);
    }
  });

  it('el permiso de la clase es el más restrictivo de cada controlador (un handler sin decorador no queda abierto)', () => {
    expect(Reflect.getMetadata(REQUIRE_PERMISSION_KEY, AiDashboardController)).toEqual(VER);
    expect(Reflect.getMetadata(REQUIRE_PERMISSION_KEY, ChatController)).toEqual(CHAT);
    expect(Reflect.getMetadata(REQUIRE_PERMISSION_KEY, AiConfigController)).toEqual(CONFIG);
  });
});

describe('moneda de los montos de la IA', () => {
  const MONEDA = { codigo: 'PYG' };

  it('la moneda de consolidación es PYG (el SQL de insights multiplica por dticam, en Gs. por unidad)', () => {
    expect(MONEDA_CONSOLIDACION_IA).toBe('PYG');
  });

  const dominios = ['VENTAS', 'COBRANZAS', 'COMPRAS', 'INVENTARIO', 'TESORERIA', 'CLIENTES', 'RRHH'];
  const crearControlador = (over: Partial<Record<string, any>> = {}) => {
    const insights = { calcularMetricasPeriodo: jest.fn().mockResolvedValue({ totalFacturado: 1000, anterior: {} }) };
    const predictions = {
      todasLasPredicciones: jest.fn().mockResolvedValue({
        cobranza: { esperado: 10 },
        clientesEnRiesgo: [],
        ventas: null,
        compras: null,
        reorden: [],
        flujoCaja: null,
        nominaRRHH: null,
        empleadosRiesgo: null,
      }),
      proyeccionCobranza: jest.fn().mockResolvedValue({ esperado: 10 }),
      proyeccionVentas: jest.fn().mockResolvedValue({ proximoMesEstimado: 5 }),
      proyeccionCompras: jest.fn().mockResolvedValue({ proximoMesEstimado: 5 }),
      clientesEnRiesgo: jest.fn().mockResolvedValue([{ clienteId: 'c1', saldoPendiente: 100 }]),
      proyeccionNominaRRHH: jest.fn().mockResolvedValue(null),
    };
    const prisma = {
      ai_insights: { findFirst: jest.fn().mockResolvedValue({ id: 'i1', tipo: 'resumen_ejecutivo' }) },
      ai_alertas: { findMany: jest.fn().mockResolvedValue([{ id: 'a1', tipo: 'mora', dominio: 'COBRANZAS' }]) },
    };
    const timeline = { getEventosRecientes: jest.fn().mockResolvedValue([{ id: 'e1', dominio: 'VENTAS' }]) };
    const rrhh = { puedeVerRRHH: jest.fn().mockResolvedValue(true) };
    const modules = { getActiveDomains: jest.fn().mockResolvedValue(dominios) };
    const ctl = new AiDashboardController(
      (over.insights ?? insights),
      {} as any,
      timeline as any,
      {} as any,
      (over.predictions ?? predictions),
      prisma as any,
      rrhh as any,
      modules as any,
    );
    return { ctl, predictions };
  };
  const user = { id: 'u', empresa_id: 'e' } as any;

  it('getMetricas responde moneda: { codigo: "PYG" }', async () => {
    const { ctl } = crearControlador();
    expect(await ctl.getMetricas(user, '2026-11')).toMatchObject({ moneda: MONEDA });
  });

  it('getPredicciones, resumen, alertas, timeline y las sub-rutas con montos responden la moneda', async () => {
    const { ctl } = crearControlador();
    expect(await ctl.getPredicciones(user)).toMatchObject({ moneda: MONEDA });
    expect(await ctl.getResumen(user)).toMatchObject({ moneda: MONEDA });
    expect(await ctl.getAlertas(user)).toEqual([expect.objectContaining({ moneda: MONEDA })]);
    expect(await ctl.getTimeline(user)).toEqual([expect.objectContaining({ moneda: MONEDA })]);
    expect(await ctl.getProyeccionCobranza(user)).toMatchObject({ moneda: MONEDA });
    expect(await ctl.getProyeccionVentas(user)).toMatchObject({ moneda: MONEDA });
    expect(await ctl.getProyeccionCompras(user)).toMatchObject({ moneda: MONEDA });
    expect(await ctl.getClientesRiesgo(user)).toEqual([expect.objectContaining({ moneda: MONEDA })]);
    // Sin datos sigue siendo null (el front lo trata como «no aplica»).
    expect(await ctl.getProyeccionNomina(user)).toBeNull();
  });

  it('calcularMetricasPeriodo responde moneda: { codigo: "PYG" }', async () => {
    const prisma = { $queryRaw: jest.fn().mockResolvedValue([]) };
    const svc = new InsightsService(prisma as any, {} as any, {} as any, {} as any);
    expect(await svc.calcularMetricasPeriodo('e', '2026-11')).toMatchObject({ moneda: MONEDA });
  });

  it('todasLasPredicciones responde moneda: { codigo: "PYG" }', async () => {
    const svc = new PredictionsService({} as any, {} as any);
    for (const m of [
      'proyeccionCobranza',
      'clientesEnRiesgo',
      'proyeccionVentas',
      'proyeccionCompras',
      'productosParaReordenar',
      'proyeccionFlujoCaja',
      'proyeccionNominaRRHH',
      'empleadosRiesgoDesvinculacion',
    ] as const) {
      jest.spyOn(svc, m).mockResolvedValue(null as any);
    }
    expect(await svc.todasLasPredicciones('e', 'u')).toMatchObject({ moneda: MONEDA });
  });
});
