import { ForbiddenException } from '@nestjs/common';
import { exigirAlcanceEmpresa, exigirAltaEnLaRed, exigirCambioDeJerarquia } from './alcance-empresa';

/**
 * Las rutas de `/empresas` con `:id` no miraban de quién era el id: un Administrador de una empresa cambiaba el plan,
 * el estado, el correo o los datos de CUALQUIER otra empresa, o se ponía a sí misma `type: 'holding'` (que saltea el
 * plan). Ahora: lo propio lo toca la propia empresa o una superior; plan, límites, estado y baja, solo una superior
 * (nadie se gestiona a sí mismo, igual que en Suscripciones); el superadmin todo.
 *
 * Red de prueba: holding → kety → sucursalKety; 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' },
  sucursalKety: { parent_id: 'kety', type: 'subsidiary' },
  otra: { parent_id: 'holding', type: 'subsidiary' },
  ajena: { parent_id: null, type: 'standalone' },
};
/**
 * `true` = administrador de la plataforma (is_superadmin de la holding raíz); 'dueno' = is_superadmin de una subsidiaria
 * (el dueño que crea el registro público), que NO es plataforma.
 */
const prismaCon = (superadmin: boolean | 'dueno' = false) =>
  ({
    usuario: {
      findUnique: jest.fn().mockResolvedValue(
        superadmin === 'dueno'
          ? { is_superadmin: true, empresa_rel: { type: 'subsidiary', parent_id: 'holding' } }
          : { 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) },
  }) as any;
const user = (empresa_id: string) => ({ id: 'u1', username: 'x', empresa_id });

describe('alcance de /empresas/:id', () => {
  it.each([
    ['kety', 'kety', 'propia_o_superior', true],
    ['holding', 'kety', 'propia_o_superior', true],
    ['holding', 'sucursalKety', 'propia_o_superior', true],
    ['kety', 'otra', 'propia_o_superior', false],
    ['kety', 'holding', 'propia_o_superior', false],
    ['kety', 'ajena', 'propia_o_superior', false],
    ['kety', 'kety', 'solo_superior', false],
    ['holding', 'kety', 'solo_superior', true],
    ['kety', 'sucursalKety', 'solo_superior', true],
    ['otra', 'sucursalKety', 'solo_superior', false],
  ] as const)('%s sobre %s (%s) → %s', async (caller, target, modo, pasa) => {
    const r = exigirAlcanceEmpresa(prismaCon(), user(caller), target, modo);
    if (pasa) await expect(r).resolves.toBeUndefined();
    else await expect(r).rejects.toBeInstanceOf(ForbiddenException);
  });

  it('el administrador de la plataforma alcanza cualquier empresa', async () => {
    await expect(exigirAlcanceEmpresa(prismaCon(true), user('kety'), 'ajena', 'solo_superior')).resolves.toBeUndefined();
  });

  it('el is_superadmin de una subsidiaria (dueño) no toca otra empresa ni se gestiona a sí mismo', async () => {
    await expect(exigirAlcanceEmpresa(prismaCon('dueno'), user('otra'), 'ajena', 'propia_o_superior')).rejects.toBeInstanceOf(ForbiddenException);
    await expect(exigirAlcanceEmpresa(prismaCon('dueno'), user('otra'), 'kety', 'solo_superior')).rejects.toBeInstanceOf(ForbiddenException);
    await expect(exigirAlcanceEmpresa(prismaCon('dueno'), user('otra'), 'otra', 'solo_superior')).rejects.toBeInstanceOf(ForbiddenException);
    await expect(exigirAlcanceEmpresa(prismaCon('dueno'), user('otra'), 'otra', 'propia_o_superior')).resolves.toBeUndefined();
  });
});

describe('cambio de type / parent_id en PUT /empresas/:id', () => {
  const actual = { id: 'sucursalKety', type: 'subsidiary', parent_id: 'kety', estado_id: 'activa' };

  it('mandar los mismos valores no es un cambio (Datos de la empresa puede reenviar el formulario)', async () => {
    await expect(exigirCambioDeJerarquia(prismaCon(), user('sucursalKety'), actual, { type: 'subsidiary', parent_id: 'kety' })).resolves.toBeUndefined();
  });

  it('una empresa no cambia su propio type ni su padre', async () => {
    await expect(exigirCambioDeJerarquia(prismaCon(), user('sucursalKety'), actual, { type: 'reseller' })).rejects.toBeInstanceOf(ForbiddenException);
    await expect(exigirCambioDeJerarquia(prismaCon(), user('sucursalKety'), actual, { parent_id: 'holding' })).rejects.toBeInstanceOf(ForbiddenException);
  });

  it('la superior la mueve dentro de su red, pero no fuera ni la vuelve holding', async () => {
    await expect(exigirCambioDeJerarquia(prismaCon(), user('holding'), actual, { parent_id: 'otra' })).resolves.toBeUndefined();
    await expect(exigirCambioDeJerarquia(prismaCon(), user('kety'), actual, { parent_id: 'otra' })).rejects.toBeInstanceOf(ForbiddenException);
    await expect(exigirCambioDeJerarquia(prismaCon(), user('holding'), actual, { type: 'holding' })).rejects.toBeInstanceOf(ForbiddenException);
  });

  it('el administrador de la plataforma puede todo', async () => {
    await expect(exigirCambioDeJerarquia(prismaCon(true), user('kety'), actual, { type: 'holding', parent_id: null })).resolves.toBeUndefined();
  });

  it('el dueño (is_superadmin) de una subsidiaria no se vuelve holding ni se cambia el padre', async () => {
    await expect(exigirCambioDeJerarquia(prismaCon('dueno'), user('sucursalKety'), actual, { type: 'holding' })).rejects.toBeInstanceOf(ForbiddenException);
    await expect(exigirCambioDeJerarquia(prismaCon('dueno'), user('sucursalKety'), actual, { parent_id: null })).rejects.toBeInstanceOf(ForbiddenException);
  });

  it('el estado lo cambia la superior, no la propia empresa (reenviar el mismo no es un cambio)', async () => {
    await expect(exigirCambioDeJerarquia(prismaCon(), user('sucursalKety'), actual, { estado_id: 'bloqueada' })).rejects.toBeInstanceOf(ForbiddenException);
    await expect(exigirCambioDeJerarquia(prismaCon('dueno'), user('sucursalKety'), actual, { estado_id: 'bloqueada' })).rejects.toBeInstanceOf(ForbiddenException);
    await expect(exigirCambioDeJerarquia(prismaCon(), user('sucursalKety'), actual, { estado_id: 'activa' })).resolves.toBeUndefined();
    await expect(exigirCambioDeJerarquia(prismaCon(), user('kety'), actual, { estado_id: 'bloqueada' })).resolves.toBeUndefined();
  });

  it('borrar el estado (estado_id: null) también es un cambio de estado', async () => {
    await expect(exigirCambioDeJerarquia(prismaCon(), user('sucursalKety'), actual, { estado_id: null })).rejects.toBeInstanceOf(ForbiddenException);
  });

  it('solo la holding convierte una empresa en reseller (un reseller no crea otro)', async () => {
    await expect(exigirCambioDeJerarquia(prismaCon(), user('kety'), actual, { type: 'reseller' })).rejects.toBeInstanceOf(ForbiddenException);
    await expect(exigirCambioDeJerarquia(prismaCon(), user('holding'), actual, { type: 'reseller' })).resolves.toBeUndefined();
  });

  it('no se mueve una empresa debajo de su propia descendiente (ciclo)', async () => {
    const kety = { id: 'kety', type: 'reseller', parent_id: 'holding', estado_id: 'activa' };
    await expect(exigirCambioDeJerarquia(prismaCon(), user('holding'), kety, { parent_id: 'sucursalKety' })).rejects.toBeInstanceOf(ForbiddenException);
  });
});

describe('alta de empresa (POST /empresas)', () => {
  it('holding o reseller dan de alta dentro de su red', async () => {
    await expect(exigirAltaEnLaRed(prismaCon(), user('holding'), { parent_id: 'kety', type: 'subsidiary' })).resolves.toBeUndefined();
    await expect(exigirAltaEnLaRed(prismaCon(), user('kety'), { parent_id: 'kety', type: 'subsidiary' })).resolves.toBeUndefined();
  });

  it('una subsidiaria no da de alta empresas', async () => {
    await expect(exigirAltaEnLaRed(prismaCon(), user('otra'), { parent_id: 'otra', type: 'subsidiary' })).rejects.toBeInstanceOf(ForbiddenException);
  });

  it('no se cuelga fuera de la red, ni sin padre, ni como holding', async () => {
    await expect(exigirAltaEnLaRed(prismaCon(), user('kety'), { parent_id: 'otra' })).rejects.toBeInstanceOf(ForbiddenException);
    await expect(exigirAltaEnLaRed(prismaCon(), user('holding'), { parent_id: null })).rejects.toBeInstanceOf(ForbiddenException);
    await expect(exigirAltaEnLaRed(prismaCon(), user('holding'), { parent_id: 'holding', type: 'holding' })).rejects.toBeInstanceOf(ForbiddenException);
  });

  it('el administrador de la plataforma da de alta donde sea', async () => {
    await expect(exigirAltaEnLaRed(prismaCon(true), user('ajena'), { parent_id: null, type: 'holding' })).resolves.toBeUndefined();
  });

  it('el dueño (is_superadmin) de una subsidiaria no da de alta empresas', async () => {
    await expect(exigirAltaEnLaRed(prismaCon('dueno'), user('otra'), { parent_id: null, type: 'holding' })).rejects.toBeInstanceOf(ForbiddenException);
    await expect(exigirAltaEnLaRed(prismaCon('dueno'), user('otra'), { parent_id: 'otra', type: 'subsidiary' })).rejects.toBeInstanceOf(ForbiddenException);
  });

  it('un reseller no da de alta otro reseller; la holding sí', async () => {
    await expect(exigirAltaEnLaRed(prismaCon(), user('kety'), { parent_id: 'kety', type: 'reseller' })).rejects.toBeInstanceOf(ForbiddenException);
    await expect(exigirAltaEnLaRed(prismaCon(), user('holding'), { parent_id: 'holding', type: 'reseller' })).resolves.toBeUndefined();
  });
});
