import { ForbiddenException } from '@nestjs/common';
import { GUARDS_METADATA } from '@nestjs/common/constants';
import { REQUIRE_PERMISSION_KEY } from 'src/auth/decorators/require-permission.decorator';
import { REQUIRE_SUBMODULO_KEY } from 'src/auth/decorators/require-submodulo.decorator';
import { PermissionGuard } from 'src/auth/guards/permission.guard';
import { SubmoduloGuard } from 'src/auth/guards/submodulo.guard';
import { SuperadminGuard } from 'src/auth/guards/superadmin.guard';
import { AiHoldingController } from './ai-holding.controller';
import { AiHoldingService } from './ai-holding.service';

/**
 * C0b › `/ai-holding`. Antes todas las rutas pedían solo sesión y el servicio dejaba pasar a cualquier empresa SIN
 * padre: una empresa suelta (o cualquier usuario de la holding, un cajero) subía su propia cuota de tokens o cambiaba
 * las tarifas de IA, que son una tabla GLOBAL (el costo en USD de todas las empresas).
 *
 * - Consumo y cuotas de la red: PLAN_SUSCRIPCION + submódulo SUS_PLAN + SUS_PLA_PLAN_VER / _EDITAR (la pantalla vive en
 *   Suscripciones, cuya ruta pide SUS_PLA_PLAN_VER) y el servicio exige que la empresa sea una holding.
 * - Tarifas (tabla global): solo superadmin de la plataforma.
 */
type M = keyof AiHoldingController;
const handler = (m: string) => Object.getOwnPropertyDescriptor(AiHoldingController.prototype, m)!.value as object;
const guardsDe = (m: string) => [...(Reflect.getMetadata(GUARDS_METADATA, AiHoldingController) ?? []), ...(Reflect.getMetadata(GUARDS_METADATA, handler(m)) ?? [])];
const meta = (k: string, m: string) => Reflect.getMetadata(k, handler(m));

const VER: M[] = ['consumo'];
const EDITAR: M[] = ['setCuota', 'recalcularCostos'];
const SUPERADMIN: M[] = ['listarTarifas', 'upsertTarifa', 'eliminarTarifa'];

describe('C0b: permisos de /ai-holding', () => {
  it('cada ruta está clasificada', () => {
    const rutas = Object.getOwnPropertyNames(AiHoldingController.prototype).filter((m) => m !== 'constructor');
    expect(rutas.sort()).toEqual([...VER, ...EDITAR, ...SUPERADMIN].sort());
  });

  it.each([...VER.map((m) => [m, 'SUS_PLA_PLAN_VER']), ...EDITAR.map((m) => [m, 'SUS_PLA_PLAN_EDITAR'])])(
    '%s pide PLAN_SUSCRIPCION + SUS_PLAN + %s',
    (m, priv) => {
      expect(meta(REQUIRE_PERMISSION_KEY, m)).toEqual({ modulo: 'PLAN_SUSCRIPCION', privilegio: priv });
      expect(meta(REQUIRE_SUBMODULO_KEY, m)).toBe('SUS_PLAN');
      expect(guardsDe(m)).toEqual(expect.arrayContaining([PermissionGuard, SubmoduloGuard]));
    },
  );

  it.each(SUPERADMIN)('%s (tarifas globales) es solo superadmin', (m) => {
    expect(guardsDe(m)).toContain(SuperadminGuard);
  });
});

describe('C0b: el servicio de IA de la red exige una holding', () => {
  const empresas: Record<string, { parent_id: string | null; type: string | null }> = {
    holding: { parent_id: null, type: 'holding' },
    suelta: { parent_id: null, type: null },
    hija: { parent_id: 'holding', type: 'subsidiary' },
  };
  const prisma = {
    empresas: {
      findUnique: jest.fn(async ({ where }: any) => (empresas[where.id] ? { id: where.id, ...empresas[where.id] } : null)),
      findMany: jest.fn(async ({ where }: any) =>
        Object.entries(empresas)
          .filter(([, e]) => e.parent_id && where.parent_id.in.includes(e.parent_id))
          .map(([id, e]) => ({ id, ...e })),
      ),
    },
    ai_empresa_config: { upsert: jest.fn().mockResolvedValue({}) },
  } as any;
  const service = new AiHoldingService(prisma);

  beforeEach(() => prisma.ai_empresa_config.upsert.mockClear());

  it('una empresa suelta (sin padre, no holding) no se sube su propia cuota', async () => {
    await expect(service.setCuota('suelta', 'suelta', { limite_tokens_mensual: 999999 })).rejects.toBeInstanceOf(ForbiddenException);
    expect(prisma.ai_empresa_config.upsert).not.toHaveBeenCalled();
  });

  it('una subsidiaria no administra la IA de la red', async () => {
    await expect(service.setCuota('hija', 'hija', { limite_tokens_mensual: 1 })).rejects.toBeInstanceOf(ForbiddenException);
  });

  it('la holding ajusta la cuota de una empresa de su red', async () => {
    await expect(service.setCuota('holding', 'hija', { limite_tokens_mensual: 100 })).resolves.toEqual({ ok: true });
    expect(prisma.ai_empresa_config.upsert).toHaveBeenCalledTimes(1);
  });

  it('la holding no toca una empresa fuera de su red', async () => {
    await expect(service.setCuota('holding', 'suelta', { limite_tokens_mensual: 100 })).rejects.toThrow('no pertenece a tu red');
  });
});
