import { ForbiddenException } from '@nestjs/common';
import { Reflector } from '@nestjs/core';
import {
  PrivilegioDeModuloGuard,
  REQUIRE_PRIVILEGIO_ALTERNATIVO_KEY,
  REQUIRE_PRIVILEGIO_DE_MODULO_KEY,
  RequireAlgunPrivilegioDeModulo,
  tieneAlgunPrivilegioDeModulo,
} from './algun-privilegio.guard';

/**
 * Guard por módulo: pasa quien tenga cualquier privilegio activo del módulo, con el criterio de las
 * migraciones de permisos («es de COMPRAS» por el submódulo del privilegio o por el `modulo_id` con que
 * se grabó en el perfil). El `where` que arma se evalúa contra filas en memoria, para probar el criterio
 * y no la forma del objeto.
 */

type FilaPP = {
  active: boolean | null;
  user_id: string;
  privilegio: string;
  /** Módulo del submódulo del privilegio. */
  modulo_privilegio: string;
  /** Módulo con que se grabó la fila (`perfiles_privilegios.modulo_id`). */
  modulo_fila: string | null;
};

/** Vista anidada de la fila, con los nombres de relación de Prisma. */
const anidar = (f: FilaPP) => ({
  active: f.active,
  modulos: f.modulo_fila ? { codigo: f.modulo_fila } : null,
  privilegios: { codigo: f.privilegio, submodulos: { modulos: { codigo: f.modulo_privilegio } } },
  perfiles: { usuario_perfiles: [{ user_id: f.user_id }] },
});

/** Evaluador mínimo de un `where` de Prisma (igualdad, `in`, `some`, AND/OR y relaciones anidadas). */
function cumple(where: any, valor: any): boolean {
  if (where === null || typeof where !== 'object' || where instanceof Date) return valor === where;
  return Object.entries(where).every(([k, w]: [string, any]) => {
    if (k === 'AND') return [].concat(w).every((x) => cumple(x, valor));
    if (k === 'OR') return [].concat(w).some((x) => cumple(x, valor));
    if (k === 'NOT') return ![].concat(w).some((x) => cumple(x, valor));
    if (k === 'in') return Array.isArray(w) && w.includes(valor);
    if (k === 'equals') return valor === w;
    if (k === 'some') return Array.isArray(valor) && valor.some((v) => cumple(w, v));
    const hijo = valor?.[k];
    if (w !== null && typeof w === 'object') return hijo != null && cumple(w, hijo);
    return hijo === w;
  });
}

const armarPrisma = (filas: FilaPP[], superadmin = false) => ({
  usuario: { findUnique: jest.fn().mockResolvedValue({ is_superadmin: superadmin }) },
  perfiles_privilegios: {
    findFirst: jest.fn(async ({ where }: any) => (filas.map(anidar).some((f) => cumple(where, f)) ? { id: 'pp-1' } : null)),
  },
});

const ctxDe = (user: any) =>
  ({
    getHandler: () => null,
    getClass: () => null,
    switchToHttp: () => ({ getRequest: () => ({ user }) }),
  }) as any;

describe('tieneAlgunPrivilegioDeModulo / PrivilegioDeModuloGuard', () => {
  const USER = { id: 'u-1', empresa_id: 'emp-1' };
  const reflector = { getAllAndOverride: jest.fn().mockReturnValue('COMPRAS') } as unknown as Reflector;
  const guardCon = (prisma: any) => new PrivilegioDeModuloGuard(reflector, prisma);

  it('un perfil con solo TES_GAS_GASTO_VER (privilegio de COMPRAS por su submódulo TES_GASTOS, grabado sin modulo_id) pasa', async () => {
    const prisma = armarPrisma([
      { active: true, user_id: 'u-1', privilegio: 'TES_GAS_GASTO_VER', modulo_privilegio: 'COMPRAS', modulo_fila: null },
    ]);
    await expect(tieneAlgunPrivilegioDeModulo(prisma as any, 'u-1', 'COMPRAS')).resolves.toBe(true);
    await expect(guardCon(prisma).canActivate(ctxDe(USER))).resolves.toBe(true);
  });

  it('un perfil con un privilegio de otro módulo grabado con modulo_id COMPRAS pasa', async () => {
    const prisma = armarPrisma([
      { active: true, user_id: 'u-1', privilegio: 'VEN_FAC_FACTURA_VER', modulo_privilegio: 'VENTAS', modulo_fila: 'COMPRAS' },
    ]);
    await expect(tieneAlgunPrivilegioDeModulo(prisma as any, 'u-1', 'COMPRAS')).resolves.toBe(true);
    await expect(guardCon(prisma).canActivate(ctxDe(USER))).resolves.toBe(true);
  });

  it('un perfil sin nada de COMPRAS recibe 403', async () => {
    const prisma = armarPrisma([
      { active: true, user_id: 'u-1', privilegio: 'VEN_FAC_FACTURA_VER', modulo_privilegio: 'VENTAS', modulo_fila: 'VENTAS' },
      // De COMPRAS, pero inactivo o de otro usuario: no cuenta.
      { active: false, user_id: 'u-1', privilegio: 'CMP_OP_ORDEN_PAGO_VER', modulo_privilegio: 'COMPRAS', modulo_fila: 'COMPRAS' },
      { active: null, user_id: 'u-1', privilegio: 'CMP_OP_ORDEN_PAGO_VER', modulo_privilegio: 'COMPRAS', modulo_fila: 'COMPRAS' },
      { active: true, user_id: 'u-2', privilegio: 'CMP_OP_ORDEN_PAGO_VER', modulo_privilegio: 'COMPRAS', modulo_fila: 'COMPRAS' },
    ]);
    await expect(tieneAlgunPrivilegioDeModulo(prisma as any, 'u-1', 'COMPRAS')).resolves.toBe(false);
    await expect(guardCon(prisma).canActivate(ctxDe(USER))).rejects.toBeInstanceOf(ForbiddenException);
  });

  it('superadmin pasa', async () => {
    const prisma = armarPrisma([], true);
    await expect(tieneAlgunPrivilegioDeModulo(prisma as any, 'u-1', 'COMPRAS')).resolves.toBe(true);
    await expect(guardCon(prisma).canActivate(ctxDe(USER))).resolves.toBe(true);
    expect(prisma.perfiles_privilegios.findFirst).not.toHaveBeenCalled();
  });

  it('sin usuario autenticado, 403; sin metadata en el handler, no decide (pasa)', async () => {
    const prisma = armarPrisma([]);
    await expect(guardCon(prisma).canActivate(ctxDe(undefined))).rejects.toBeInstanceOf(ForbiddenException);
    await expect(tieneAlgunPrivilegioDeModulo(prisma as any, undefined, 'COMPRAS')).resolves.toBe(false);
    const sinMeta = new PrivilegioDeModuloGuard({ getAllAndOverride: jest.fn() } as any, prisma as any);
    await expect(sinMeta.canActivate(ctxDe(USER))).resolves.toBe(true);
  });

  it('RequireAlgunPrivilegioDeModulo graba el módulo en REQUIRE_PRIVILEGIO_DE_MODULO_KEY', () => {
    class X {
      @RequireAlgunPrivilegioDeModulo('COMPRAS')
      m() {}
    }
    expect(Reflect.getMetadata(REQUIRE_PRIVILEGIO_DE_MODULO_KEY, X.prototype.m)).toBe('COMPRAS');
  });

  describe('privilegios alternativos (O con el módulo)', () => {
    const conAlternativos = (prisma: any) =>
      new PrivilegioDeModuloGuard(
        { getAllAndOverride: jest.fn((clave: string) => (clave === REQUIRE_PRIVILEGIO_DE_MODULO_KEY ? 'COMPRAS' : ['ADM_CCFG_CONFIG_VER'])) } as any,
        prisma,
      );

    it('RequireAlgunPrivilegioDeModulo(modulo, ...tambien) graba también los alternativos', () => {
      class X {
        @RequireAlgunPrivilegioDeModulo('COMPRAS', 'ADM_CCFG_CONFIG_VER')
        m() {}
        @RequireAlgunPrivilegioDeModulo('COMPRAS')
        n() {}
      }
      expect(Reflect.getMetadata(REQUIRE_PRIVILEGIO_DE_MODULO_KEY, X.prototype.m)).toBe('COMPRAS');
      expect(Reflect.getMetadata(REQUIRE_PRIVILEGIO_ALTERNATIVO_KEY, X.prototype.m)).toEqual(['ADM_CCFG_CONFIG_VER']);
      expect(Reflect.getMetadata(REQUIRE_PRIVILEGIO_ALTERNATIVO_KEY, X.prototype.n)).toBeUndefined();
    });

    it('un perfil con solo ADM_CCFG_CONFIG_VER (sin nada de COMPRAS) pasa', async () => {
      const prisma = armarPrisma([{ active: true, user_id: 'u-1', privilegio: 'ADM_CCFG_CONFIG_VER', modulo_privilegio: 'ADMINISTRACION', modulo_fila: 'ADMINISTRACION' }]);
      await expect(conAlternativos(prisma).canActivate(ctxDe(USER))).resolves.toBe(true);
    });

    it('un perfil sin COMPRAS ni el alternativo recibe 403', async () => {
      const prisma = armarPrisma([{ active: true, user_id: 'u-1', privilegio: 'ADM_CCFG_CONFIG_EDITAR', modulo_privilegio: 'ADMINISTRACION', modulo_fila: 'ADMINISTRACION' }]);
      await expect(conAlternativos(prisma).canActivate(ctxDe(USER))).rejects.toBeInstanceOf(ForbiddenException);
    });
  });
});
