import { ForbiddenException } from '@nestjs/common';
import { ImportacionesService } from 'src/importaciones/services/importaciones.service';
import { PermissionGuard } from './permission.guard';

/**
 * PermissionGuard (plan de Importaciones, Task 16, spec punto 6). El guard ya no corta IMPORTACIONES por el módulo operativo
 * apagado («Capa 1.1»): la lectura, los catálogos y los reintentos de asiento siguen, y las escrituras operativas llegan al
 * servicio, que responde `MODULO_INACTIVO` con código (si el guard cortaba con un 403 sin código, el front no lo veía nunca).
 * Las capas 1 (módulo en la suscripción), 1.2 (submódulo addon contratado) y 2 (privilegio del perfil) no cambian.
 */
describe('PermissionGuard', () => {
  const EMPRESA = 'emp-1';

  interface Mundo {
    superadmin?: boolean;
    tipoEmpresa?: string;
    moduloEnSuscripcion?: boolean;
    submoduloDelPrivilegio?: { id: string; codigo: string; es_addon: boolean } | null;
    addonContratado?: boolean;
    tienePrivilegio?: boolean;
    moduloOperativo?: boolean;
  }

  const armar = (meta: { modulo: string; privilegio: string }, m: Mundo = {}, metodo = 'GET') => {
    const prisma: any = {
      $transaction: jest.fn((cb: any) => cb(prisma) as Promise<unknown>),
      $executeRaw: jest.fn(),
      usuario: { findUnique: jest.fn().mockResolvedValue({ is_superadmin: m.superadmin ?? false }) },
      empresas: { findUnique: jest.fn().mockResolvedValue({ type: m.tipoEmpresa ?? 'subsidiary' }) },
      suscripcion_modulos: { findFirst: jest.fn().mockResolvedValue(m.moduloEnSuscripcion === false ? null : { id: 'sm-1' }) },
      privilegios: {
        findMany: jest.fn(({ where }: any) =>
          Promise.resolve(
            (where.codigo.in as string[]).map((codigo) => ({ codigo, submodulos: m.submoduloDelPrivilegio ?? { id: 'sub-1', codigo: 'IMP_EMBARQUES', es_addon: false } })),
          ),
        ),
      },
      suscripcion_submodulos: { findMany: jest.fn().mockResolvedValue(m.addonContratado ? [{ submodulo_id: m.submoduloDelPrivilegio?.id }] : []) },
      perfiles_privilegios: { findFirst: jest.fn().mockResolvedValue(m.tienePrivilegio === false ? null : { id: 'pp-1' }) },
      imp_config_empresa: {
        findUnique: jest.fn().mockResolvedValue({ empresa_id: EMPRESA, modulo_operativo_activo: m.moduloOperativo ?? true, perfil_activo: 'AUTOS' }),
        create: jest.fn(),
      },
      // Catálogos (POST /conceptos de punta a punta): sin conceptos previos, el alta crea.
      imp_conceptos_costo: { findFirst: jest.fn().mockResolvedValue(null), create: jest.fn(({ data }: any) => Promise.resolve({ id: 'con-nuevo', ...data })) },
    };
    const reflector: any = { getAllAndOverride: jest.fn().mockReturnValue(meta) };
    const ctx: any = {
      getHandler: () => null,
      getClass: () => null,
      switchToHttp: () => ({ getRequest: () => ({ user: { id: 'u-1', empresa_id: EMPRESA }, method: metodo, url: '/x' }) }),
    };
    return { guard: new PermissionGuard(reflector, prisma), ctx, prisma };
  };
  const imp = (privilegio: string) => ({ modulo: 'IMPORTACIONES', privilegio });

  describe('módulo operativo de Importaciones apagado (spec punto 6)', () => {
    it.each(['IMP_EMB_EMBARQUE_VER', 'IMP_COS_COSTO_VER', 'IMP_DES_DESPACHO_VER'])('lectura %s pasa', async (privilegio) => {
      const { guard, ctx, prisma } = armar(imp(privilegio), { moduloOperativo: false });
      await expect(guard.canActivate(ctx)).resolves.toBe(true);
      // El guard no lee ni crea la configuración: eso es del servicio.
      expect(prisma.imp_config_empresa.findUnique).not.toHaveBeenCalled();
      expect(prisma.imp_config_empresa.create).not.toHaveBeenCalled();
    });

    it.each([
      ['reintento del asiento del despacho', 'IMP_DES_DESPACHO_PROCESAR'],
      ['reintento del asiento de cierre', 'IMP_EMB_EMBARQUE_CERRAR'],
      ['reintento del asiento de un costo', 'IMP_COS_COSTO_EDITAR'],
      ['catálogos (conceptos e ISC)', 'IMP_CFG_CONFIG_EDITAR'],
    ])('%s pasa', async (_n, privilegio) => {
      const { guard, ctx } = armar(imp(privilegio), { moduloOperativo: false }, 'POST');
      await expect(guard.canActivate(ctx)).resolves.toBe(true);
    });

    it('catálogo de punta a punta: POST /conceptos pasa el guard y el servicio crea el concepto con el módulo apagado', async () => {
      const { guard, ctx, prisma } = armar(imp('IMP_CFG_CONFIG_EDITAR'), { moduloOperativo: false }, 'POST');
      await expect(guard.canActivate(ctx)).resolves.toBe(true);
      const service = new ImportacionesService(prisma, {} as any, {} as any, {} as any, {} as any, {} as any, {} as any);
      await expect(service.crearConcepto({ codigo: 'flete_aereo', nombre: 'Flete aéreo' } as any, EMPRESA)).resolves.toMatchObject({ id: 'con-nuevo', codigo: 'FLETE_AEREO' });
      expect(prisma.imp_conceptos_costo.create).toHaveBeenCalled();
    });

    it('una escritura operativa (PATCH /estado) pasa el guard y el servicio responde 400 MODULO_INACTIVO con código', async () => {
      const { guard, ctx, prisma } = armar(imp('IMP_EMB_EMBARQUE_EDITAR'), { moduloOperativo: false }, 'PATCH');
      await expect(guard.canActivate(ctx)).resolves.toBe(true);
      const service = new ImportacionesService(prisma, {} as any, {} as any, {} as any, {} as any, {} as any, {} as any);
      const error = await service.updateEstado('emb-1', { estado: 'EN_TRANSITO' }, EMPRESA, 'u-1').catch((e: any) => e);
      expect({ status: error.getStatus(), ...error.getResponse() }).toMatchObject({ status: 400, codigo: 'MODULO_INACTIVO' });
    });
  });

  describe('lo que no cambia', () => {
    it('capa 1: sin el módulo en la suscripción → 403', async () => {
      const { guard, ctx } = armar(imp('IMP_EMB_EMBARQUE_VER'), { moduloEnSuscripcion: false });
      await expect(guard.canActivate(ctx)).rejects.toBeInstanceOf(ForbiddenException);
    });

    it('capa 1.2: privilegio de un submódulo addon no contratado → 403, también para el superadmin; contratado pasa', async () => {
      const addon = { id: 'sub-addon', codigo: 'IMP_COSTOS', es_addon: true };
      for (const superadmin of [false, true]) {
        const { guard, ctx } = armar(imp('IMP_COS_COSTO_VER'), { submoduloDelPrivilegio: addon, superadmin });
        await expect(guard.canActivate(ctx)).rejects.toThrow('El submódulo "IMP_COSTOS" requiere un addon no contratado en su plan');
      }
      const { guard, ctx } = armar(imp('IMP_COS_COSTO_VER'), { submoduloDelPrivilegio: addon, addonContratado: true });
      await expect(guard.canActivate(ctx)).resolves.toBe(true);
    });

    it('capa 1.2: holding y reseller quedan exceptuados', async () => {
      const addon = { id: 'sub-addon', codigo: 'IMP_COSTOS', es_addon: true };
      const { guard, ctx } = armar(imp('IMP_COS_COSTO_VER'), { submoduloDelPrivilegio: addon, tipoEmpresa: 'holding' });
      await expect(guard.canActivate(ctx)).resolves.toBe(true);
    });

    it('capa 2: sin el privilegio → 403; el superadmin pasa', async () => {
      const sinPermiso = armar(imp('IMP_EMB_EMBARQUE_EDITAR'), { tienePrivilegio: false });
      await expect(sinPermiso.guard.canActivate(sinPermiso.ctx)).rejects.toBeInstanceOf(ForbiddenException);
      const superadmin = armar(imp('IMP_EMB_EMBARQUE_EDITAR'), { tienePrivilegio: false, superadmin: true });
      await expect(superadmin.guard.canActivate(superadmin.ctx)).resolves.toBe(true);
    });

    it('otro módulo: mismo criterio de siempre (no mira la configuración de Importaciones)', async () => {
      const { guard, ctx, prisma } = armar({ modulo: 'COMPRAS', privilegio: 'CMP_FAC_FACTURA_CREAR' }, { moduloOperativo: false }, 'POST');
      await expect(guard.canActivate(ctx)).resolves.toBe(true);
      expect(prisma.imp_config_empresa.findUnique).not.toHaveBeenCalled();
    });
  });
});
