import { ForbiddenException } from '@nestjs/common';
import { GUARDS_METADATA } from '@nestjs/common/constants';
import { Reflector } from '@nestjs/core';
import { REQUIRE_PRIVILEGIO_KEY } from 'src/auth/decorators/require-privilegio.decorator';
import { BancardConfigController } from 'src/bancard/bancard-config.controller';
import { CostosOperacionCreditoController } from 'src/costos-operacion-credito/costos-operacion-credito.controller';
import { OrdenesVentaController } from 'src/pedidos/ordenes-venta.controller';
import { PosConfigController } from 'src/pos-config/pos-config.controller';
import { PresupuestosController } from 'src/presupuestos/presupuestos.controller';
import { SEGURIDAD_SEED } from 'src/seguridad/seeds/seguridad.seed-data';
import { PrivilegioGuard } from './privilegio.guard';
import { REQUIRE_SUBMODULO_PLAN_KEY, SubmoduloPlanGuard } from './submodulo-plan.guard';

/**
 * Las configuraciones de Configuración exigen el submódulo FUNCIONAL contratado, no solo la compuerta vieja de Administración
 * o el módulo (auditoría: `.superpowers/sdd/2026-11-08-configuracion/auditoria-plan.md` del front). Superadmin: bypasea el
 * perfil, no el plan.
 */

const handlerDe = (clase: any, metodo: string) => clase.prototype[metodo];
const guardsDe = (clase: any, metodo: string) => [...(Reflect.getMetadata(GUARDS_METADATA, clase) ?? []), ...(Reflect.getMetadata(GUARDS_METADATA, handlerDe(clase, metodo)) ?? [])];
const subPlanDe = (clase: any, metodo: string) => Reflect.getMetadata(REQUIRE_SUBMODULO_PLAN_KEY, handlerDe(clase, metodo));
const privilegioDe = (clase: any, metodo: string) => Reflect.getMetadata(REQUIRE_PRIVILEGIO_KEY, handlerDe(clase, metodo));
const enSeed = (modulo: string, submodulo: string) => SEGURIDAD_SEED.find((m) => m.codigo === modulo)?.submodulos.find((s) => s.codigo === submodulo);

describe('SubmoduloPlanGuard', () => {
  const EMPRESA = 'emp-a';
  interface Mundo {
    tipo?: string;
    superadmin?: boolean;
    moduloEnPlan?: boolean;
    excluido?: boolean;
    /** Empresa dueña de la suscripción que tiene el submódulo (otra empresa = no es la del token). */
    empresaConPlan?: string;
  }
  const prisma = (m: Mundo = {}): any => {
    const dueña = m.empresaConPlan ?? EMPRESA;
    return {
      usuario: { findUnique: jest.fn().mockResolvedValue({ is_superadmin: !!m.superadmin, username: 'u' }) },
      empresas: { findUnique: jest.fn().mockResolvedValue({ type: m.tipo ?? 'subsidiary' }) },
      submodulos: { findFirst: jest.fn().mockResolvedValue({ id: 'sub-ov', modulo_id: 'mod-ventas', es_addon: false }) },
      suscripciones: { findFirst: jest.fn(({ where }: any) => Promise.resolve(where.empresa_id === dueña ? { id: 'sus-1' } : null)) },
      suscripcion_modulos: { findMany: jest.fn().mockResolvedValue(m.moduloEnPlan === false ? [] : [{ modulo_id: 'mod-ventas' }]) },
      suscripcion_submodulos: { findMany: jest.fn().mockResolvedValue(m.excluido ? [{ submodulo_id: 'sub-ov', active: false, fecha_fin_prueba: null }] : []) },
    };
  };
  const pasar = (m: Mundo = {}, metodo = 'GET') => {
    const guard = new SubmoduloPlanGuard(new Reflector(), prisma(m));
    const ctx: any = {
      getHandler: () => handlerDe(OrdenesVentaController, 'getConfig'),
      getClass: () => OrdenesVentaController,
      switchToHttp: () => ({ getRequest: () => ({ method: metodo, user: { id: 'u1', empresa_id: EMPRESA } }) }),
    };
    return guard.canActivate(ctx);
  };

  it('con el módulo y el submódulo contratados: pasa', async () => {
    await expect(pasar()).resolves.toBe(true);
  });
  it('submódulo excluido del plan: 403', async () => {
    await expect(pasar({ excluido: true })).rejects.toBeInstanceOf(ForbiddenException);
  });
  it('módulo padre fuera del plan: 403', async () => {
    await expect(pasar({ moduloEnPlan: false })).rejects.toBeInstanceOf(ForbiddenException);
  });
  it('superadmin con el submódulo excluido: 403 (bypasea el perfil, no el plan)', async () => {
    await expect(pasar({ superadmin: true, excluido: true })).rejects.toBeInstanceOf(ForbiddenException);
  });
  it('holding pasa sin suscripción propia', async () => {
    await expect(pasar({ tipo: 'holding', moduloEnPlan: false })).resolves.toBe(true);
  });
  it('otra empresa: el plan que vale es el de la empresa del token, no el de otra que sí lo tiene', async () => {
    await expect(pasar({ empresaConPlan: 'emp-b' })).rejects.toBeInstanceOf(ForbiddenException);
  });
});

describe('Configuración: cada endpoint exige su submódulo funcional', () => {
  it.each([
    ['GET /ordenes-venta/config', OrdenesVentaController, 'getConfig', 'VENTAS', 'VENTAS_ORDEN_VENTA'],
    ['PUT /ordenes-venta/config', OrdenesVentaController, 'updateConfig', 'VENTAS', 'VENTAS_ORDEN_VENTA'],
    ['PUT /presupuestos/config', PresupuestosController, 'updateConfig', 'VENTAS', 'VENTAS_PRESUPUESTOS'],
    ['POST /pos-config', PosConfigController, 'create', 'VENTAS', 'VENTAS_POS'],
    ['PATCH /pos-config/caja/:cajaId', PosConfigController, 'update', 'VENTAS', 'VENTAS_POS'],
    ['DELETE /pos-config/:id', PosConfigController, 'remove', 'VENTAS', 'VENTAS_POS'],
  ])('%s: SubmoduloPlanGuard con el submódulo funcional', (_r, clase, metodo, modulo, submodulo) => {
    expect(enSeed(modulo, submodulo)).toBeDefined();
    expect(guardsDe(clase, metodo)).toContain(SubmoduloPlanGuard);
    expect(subPlanDe(clase, metodo)).toEqual([submodulo]);
  });

  it.each([
    ['GET /presupuestos/config', PresupuestosController, 'getConfig', 'VEN_PRE_PRESUPUESTO_VER', 'VENTAS', 'VENTAS_PRESUPUESTOS'],
    ['GET /bancard/config', BancardConfigController, 'getConfig', 'FIS_BAN_BANCARD_CONFIG', 'FISCAL', 'FIS_BANCARD'],
    ['PUT /bancard/config', BancardConfigController, 'upsertConfig', 'FIS_BAN_BANCARD_CONFIG', 'FISCAL', 'FIS_BANCARD'],
    ['GET /costos-operacion-credito', CostosOperacionCreditoController, 'get', 'REP_ROC_CONFIG_VER', 'REPORTES', 'REP_OPERACION_CREDITO'],
    ['PUT /costos-operacion-credito', CostosOperacionCreditoController, 'upsert', 'REP_ROC_CONFIG_EDITAR', 'REPORTES', 'REP_OPERACION_CREDITO'],
  ])('%s: PrivilegioGuard (módulo + submódulo del privilegio)', (_r, clase, metodo, privilegio, modulo, submodulo) => {
    expect(enSeed(modulo, submodulo)?.privilegios.map((p) => p.codigo)).toContain(privilegio);
    expect(guardsDe(clase, metodo)).toContain(PrivilegioGuard);
    expect(privilegioDe(clase, metodo)).toBe(privilegio);
  });

  it('las lecturas de la caja (cajero al abrir/cerrar/vender) no se atan al POS', () => {
    for (const metodo of ['findByCaja', 'findOne']) expect(subPlanDe(PosConfigController, metodo)).toBeUndefined();
  });

  describe('PrivilegioGuard en GET /bancard/config', () => {
    const prismaPriv = (m: { excluido?: boolean; superadmin?: boolean } = {}): any => ({
      usuario: { findUnique: jest.fn().mockResolvedValue({ is_superadmin: !!m.superadmin, username: 'u' }) },
      empresas: { findUnique: jest.fn().mockResolvedValue({ type: 'subsidiary' }) },
      privilegios: {
        findFirst: jest.fn().mockResolvedValue({ id: 'p1', submodulos: { id: 's1', codigo: 'FIS_BANCARD', es_addon: false, modulo_id: 'm1', modulos: { codigo: 'FISCAL' } } }),
      },
      suscripciones: { findFirst: jest.fn().mockResolvedValue({ id: 'sus-1' }) },
      suscripcion_modulos: { findFirst: jest.fn().mockResolvedValue({ id: 'sm-1' }) },
      suscripcion_submodulos: { findFirst: jest.fn().mockResolvedValue(m.excluido ? { id: 'ex-1' } : null) },
      perfiles_privilegios: { findFirst: jest.fn().mockResolvedValue({ id: 'pp-1' }) },
    });
    const pasar = (m: { excluido?: boolean; superadmin?: boolean } = {}) =>
      new PrivilegioGuard(new Reflector(), prismaPriv(m)).canActivate({
        getHandler: () => handlerDe(BancardConfigController, 'getConfig'),
        getClass: () => BancardConfigController,
        switchToHttp: () => ({ getRequest: () => ({ user: { id: 'u1', empresa_id: 'emp-a' } }) }),
      } as any);

    it('FIS_BANCARD excluido: 403, también para el superadmin', async () => {
      await expect(pasar({ excluido: true })).rejects.toBeInstanceOf(ForbiddenException);
      await expect(pasar({ excluido: true, superadmin: true })).rejects.toBeInstanceOf(ForbiddenException);
    });
    it('contratado y con permiso: pasa', async () => {
      await expect(pasar()).resolves.toBe(true);
    });
  });
});
