import { ForbiddenException, NotFoundException } from '@nestjs/common';
import { GUARDS_METADATA } from '@nestjs/common/constants';
import { SuperadminGuard } from 'src/auth/guards/superadmin.guard';
import { ComisionesController } from './comisiones.controller';

/**
 * C0b › `/empresas/comisiones`. El permiso (ADM_CFG_CONFIG_VER / _EDITAR) estaba, pero las rutas con id de empresa en
 * la URL no miraban de quién era: con el id de otra empresa se leían sus comisiones, métricas, dashboard y jerarquía;
 * `marcar-pagadas` marcaba comisiones de cualquiera; `generar/:suscripcionId` y `generar-mensuales` (global) generaban
 * comisiones de cualquier suscripción; y `jerarquia/:id/suscripcion-estado` solo dejaba tocar la PROPIA suscripción
 * (la empresa se gestionaba a sí misma, y el front, que manda la subsidiaria, recibía 403).
 *
 * Ahora: lecturas de reseller/holding/jerarquía → la propia o una de su red (superior); escrituras sobre una
 * suscripción → solo una superior; generar-mensuales → superadmin. El superadmin alcanza todo.
 *
 * Red: holding → kety (reseller) → clienteKety; holding → otra. ajena no cuelga del holding.
 */
const padres: Record<string, { parent_id: string | null; type: string }> = {
  holding: { parent_id: null, type: 'holding' },
  kety: { parent_id: 'holding', type: 'reseller' },
  clienteKety: { parent_id: 'kety', type: 'subsidiary' },
  otra: { parent_id: 'holding', type: 'subsidiary' },
  ajena: { parent_id: null, type: 'reseller' },
};
const comisiones: Record<string, string> = { cKety: 'kety', cHolding: 'holding', cAjena: 'ajena' };
const suscripciones: Record<string, string> = { sClienteKety: 'clienteKety', sKety: 'kety', sAjena: 'ajena' };

/** `true` = administrador de la plataforma (is_superadmin de la holding raíz); 'dueno' = is_superadmin de 'ajena'. */
const armar = (superadmin: boolean | 'dueno' = false) => {
  const prisma = {
    usuario: {
      findUnique: jest.fn().mockResolvedValue(
        superadmin === 'dueno'
          ? { is_superadmin: true, empresa_rel: padres.ajena }
          : { is_superadmin: superadmin, es_admin_plataforma: superadmin, empresa_rel: { type: 'holding', parent_id: null } },
      ),
    },
    empresas: { findUnique: jest.fn(async ({ where }: any) => padres[where.id] ?? null) },
    comisiones_nuevas: {
      findMany: jest.fn(async ({ where }: any) =>
        where.id.in.filter((id: string) => comisiones[id]).map((id: string) => ({ empresa_beneficiaria_id: comisiones[id] })),
      ),
    },
    suscripciones: {
      findUnique: jest.fn(async ({ where }: any) => (suscripciones[where.id] ? { empresa_id: suscripciones[where.id] } : null)),
    },
  } as any;
  const ok = jest.fn().mockResolvedValue({});
  const comisionesService = new Proxy({}, { get: () => ok }) as any;
  const jerarquiaService = new Proxy({}, { get: () => ok }) as any;
  const suscripcionesService = new Proxy({}, { get: () => ok }) as any;
  const controller = new ComisionesController(comisionesService, jerarquiaService, suscripcionesService, prisma);
  return { controller, ok };
};
const user = (empresa_id: string) => ({ id: 'u1', username: 'x', empresa_id }) as any;

type Llamada = (c: ComisionesController, u: any, id: string) => Promise<unknown>;
const LECTURAS: [string, Llamada][] = [
  ['reseller/:id/resumen', (c, u, id) => c.getResumenComisionesReseller(id, u)],
  ['reseller/:id/pendientes', (c, u, id) => c.getComisionesPendientes(id, u)],
  ['reseller/:id/historial', (c, u, id) => c.getHistorialComisiones(u, id)],
  ['reseller/:id/validar-limites', (c, u, id) => c.validarLimitesReseller(id, u)],
  ['reseller/:id/metricas', (c, u, id) => c.getMetricasReseller(id, u)],
  ['holding/:id/resumen-comisiones', (c, u, id) => c.getResumenComisionesHolding(id, u)],
  ['holding/:id/agrupadas', (c, u, id) => c.getComisionesAgrupadas(id, 'todos', u)],
  ['holding/:id/historial-pagos', (c, u, id) => c.getHistorialPagosHolding(id, '10', u)],
  ['holding/:id/metricas', (c, u, id) => c.getMetricasHolding(id, u)],
  ['holding/:id/dashboard', (c, u, id) => c.getDashboardHolding(id, u)],
  ['jerarquia/:id', (c, u, id) => c.getJerarquiaCompleta(id, u)],
  ['jerarquia/:id/hijos', (c, u, id) => c.getHijosDirectos(u, id)],
  ['jerarquia/:id/holding', (c, u, id) => c.getHolding(id, u)],
];

describe('C0b: lecturas de /empresas/comisiones con empresa en la URL', () => {
  describe.each(LECTURAS)('%s', (_ruta, llamar) => {
    it.each([
      ['kety', 'kety', true],
      ['holding', 'kety', true],
      ['holding', 'holding', true],
      ['kety', 'holding', false],
      ['kety', 'otra', false],
      ['otra', 'kety', false],
      ['kety', 'ajena', false],
    ])('%s pide la de %s → %s', async (propia, target, pasa) => {
      const { controller, ok } = armar();
      const r = llamar(controller, user(propia), target);
      if (pasa) await expect(r).resolves.toBeDefined();
      else {
        await expect(r).rejects.toBeInstanceOf(ForbiddenException);
        expect(ok).not.toHaveBeenCalled();
      }
    });

    it('el administrador de la plataforma lee cualquiera', async () => {
      const { controller } = armar(true);
      await expect(llamar(controller, user('kety'), 'ajena')).resolves.toBeDefined();
    });

    it('el dueño (is_superadmin) de otra empresa no lee las de la holding', async () => {
      const { controller, ok } = armar('dueno');
      await expect(llamar(controller, user('ajena'), 'holding')).rejects.toBeInstanceOf(ForbiddenException);
      expect(ok).not.toHaveBeenCalled();
    });
  });

  it('holding/:id/detalle/:reseller: el reseller también tiene que ser de la red', async () => {
    const { controller, ok } = armar();
    await expect(controller.getDetalleComisionesReseller('holding', 'kety', 'todos', '10', user('holding'))).resolves.toBeDefined();
    await expect(controller.getDetalleComisionesReseller('holding', 'ajena', 'todos', '10', user('holding'))).rejects.toBeInstanceOf(ForbiddenException);
    await expect(controller.getDetalleComisionesReseller('ajena', 'ajena', 'todos', '10', user('holding'))).rejects.toBeInstanceOf(ForbiddenException);
    expect(ok).toHaveBeenCalledTimes(1);
  });
});

describe('C0b: escrituras de /empresas/comisiones', () => {
  it('marcar-pagadas: solo comisiones cuyo beneficiario es la propia o de su red', async () => {
    const { controller, ok } = armar();
    await expect(controller.marcarComisionesPagadas({ comision_ids: ['cKety', 'cHolding'] }, user('holding'))).resolves.toBeDefined();
    await expect(controller.marcarComisionesPagadas({ comision_ids: ['cKety', 'cAjena'] }, user('holding'))).rejects.toBeInstanceOf(ForbiddenException);
    await expect(controller.marcarComisionesPagadas({ comision_ids: ['cHolding'] }, user('kety'))).rejects.toBeInstanceOf(ForbiddenException);
    expect(ok).toHaveBeenCalledTimes(1);
  });

  it('marcar-pagadas: el administrador de la plataforma marca cualquiera; el dueño de otra empresa, no', async () => {
    const { controller } = armar(true);
    await expect(controller.marcarComisionesPagadas({ comision_ids: ['cAjena'] }, user('holding'))).resolves.toBeDefined();
    const dueno = armar('dueno');
    await expect(dueno.controller.marcarComisionesPagadas({ comision_ids: ['cKety'] }, user('ajena'))).rejects.toBeInstanceOf(ForbiddenException);
  });

  it('generar/:suscripcionId: solo una superior de la empresa de la suscripción', async () => {
    const { controller, ok } = armar();
    await expect(controller.generarComisiones('sClienteKety', {}, user('kety'))).resolves.toBeDefined();
    await expect(controller.generarComisiones('sClienteKety', {}, user('holding'))).resolves.toBeDefined();
    await expect(controller.generarComisiones('sKety', {}, user('kety'))).rejects.toBeInstanceOf(ForbiddenException);
    await expect(controller.generarComisiones('sAjena', {}, user('holding'))).rejects.toBeInstanceOf(ForbiddenException);
    await expect(controller.generarComisiones('noExiste', {}, user('holding'))).rejects.toBeInstanceOf(NotFoundException);
    expect(ok).toHaveBeenCalledTimes(2);
  });

  it('generar-mensuales (todas las suscripciones) es solo superadmin', () => {
    const h = Object.getOwnPropertyDescriptor(ComisionesController.prototype, 'generarComisionesMensuales')!.value;
    expect(Reflect.getMetadata(GUARDS_METADATA, h)).toContain(SuperadminGuard);
  });

  it('jerarquia/:id/suscripcion-estado: la cambia una superior (lo que manda el front), nunca la propia', async () => {
    const { controller, ok } = armar();
    await expect(controller.cambiarEstadoSuscripcionEmpresa('clienteKety', { estado: 'Activo' }, user('kety'))).resolves.toBeDefined();
    await expect(controller.cambiarEstadoSuscripcionEmpresa('kety', { estado: 'Activo' }, user('holding'))).resolves.toBeDefined();
    await expect(controller.cambiarEstadoSuscripcionEmpresa('kety', { estado: 'Activo' }, user('kety'))).rejects.toBeInstanceOf(ForbiddenException);
    await expect(controller.cambiarEstadoSuscripcionEmpresa('otra', { estado: 'Activo' }, user('kety'))).rejects.toBeInstanceOf(ForbiddenException);
    await expect(controller.cambiarEstadoSuscripcionEmpresa('ajena', { estado: 'Activo' }, user('holding'))).rejects.toBeInstanceOf(ForbiddenException);
    expect(ok).toHaveBeenCalledTimes(2);
  });
});
