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 { PuntoExpedicionesController } from 'src/punto-expediciones/punto-expediciones.controller';
import { PERFILES_SISTEMA_SEED, SEGURIDAD_SEED } from 'src/seguridad/seeds/seguridad.seed-data';
import { PrivilegioSelector, resolverSelectores } from 'src/seguridad/seeds/selectores';
import { UsersController } from 'src/users/users.controller';
import { EmpresasController } from './empresas.controller';

/**
 * C0 › `/empresas`, `DELETE /users/:id` y `DELETE /punto-expediciones/:id`.
 * - Borrar (`DELETE :id`, `DELETE :id/force`) pide ADM_EMP_EMPRESA_ELIMINAR (antes EDITAR); dar de alta, CREAR (antes
 *   EDITAR); cambiar el estado, ACTIVAR (antes EDITAR). Todas con el submódulo ADM_EMPRESAS salvo `GET :id`, el arranque
 *   del front para la propia empresa.
 * - `GET /empresas` listaba TODAS las empresas de la plataforma a cualquiera con _VER (Supervisor incluido): solo superadmin.
 * - Cada ruta con `:id` pregunta además SOBRE QUÉ empresa (alcance-empresa.spec.ts tiene la regla).
 * - `DELETE /users/:id` ya pedía ADM_USR_USUARIO_ELIMINAR y `DELETE /punto-expediciones/:id` ADM_SUC_SUCURSAL_EDITAR (como
 *   cajas): el relevamiento los daba como abiertos; quedan fijados acá.
 */
type Ctl = { prototype: object; name: string };
const handler = (c: Ctl, m: string) => {
  const h = Object.getOwnPropertyDescriptor(c.prototype, m)?.value as object | undefined;
  if (!h) throw new Error(`${c.name}.${m} no existe`);
  return h;
};
const guardsDe = (c: Ctl, m: string) => [...(Reflect.getMetadata(GUARDS_METADATA, c) ?? []), ...(Reflect.getMetadata(GUARDS_METADATA, handler(c, m)) ?? [])];
const permisoDe = (c: Ctl, m: string) => Reflect.getMetadata(REQUIRE_PERMISSION_KEY, handler(c, m))?.privilegio;
const submoduloDe = (c: Ctl, m: string) => Reflect.getMetadata(REQUIRE_SUBMODULO_KEY, handler(c, m)) ?? Reflect.getMetadata(REQUIRE_SUBMODULO_KEY, c);

/** método → privilegio */
const EMPRESAS: Record<string, string> = {
  create: 'ADM_EMP_EMPRESA_CREAR',
  uploadCertificadoDigital: 'ADM_EMP_EMPRESA_EDITAR',
  changePlan: 'ADM_EMP_EMPRESA_EDITAR',
  applyLimiteOverride: 'ADM_EMP_EMPRESA_EDITAR',
  clearLimiteOverride: 'ADM_EMP_EMPRESA_EDITAR',
  findAll: 'ADM_EMP_EMPRESA_VER',
  getEstados: 'ADM_EMP_EMPRESA_VER',
  uploadLogo: 'ADM_EMP_EMPRESA_EDITAR',
  update: 'ADM_EMP_EMPRESA_EDITAR',
  cambiarEstado: 'ADM_EMP_EMPRESA_ACTIVAR',
  remove: 'ADM_EMP_EMPRESA_ELIMINAR',
  forceDelete: 'ADM_EMP_EMPRESA_ELIMINAR',
  getCorreo: 'ADM_EMP_EMPRESA_VER',
  upsertCorreo: 'ADM_EMP_EMPRESA_EDITAR',
  deleteCorreo: 'ADM_EMP_EMPRESA_EDITAR',
  testCorreo: 'ADM_EMP_EMPRESA_EDITAR',
  getFirmaReciboImagen: 'ADM_EMP_EMPRESA_VER',
  uploadFirmaReciboImagen: 'ADM_EMP_EMPRESA_EDITAR',
  deleteFirmaReciboImagen: 'ADM_EMP_EMPRESA_EDITAR',
};

const privilegios: PrivilegioSelector[] = SEGURIDAD_SEED.flatMap((m) =>
  m.submodulos.flatMap((s) => s.privilegios.map((p) => ({ id: p.codigo, codigo: p.codigo, accion: p.accion, submodulos: { codigo: s.codigo, modulo_id: m.codigo } }))),
);
const modulos = SEGURIDAD_SEED.map((m) => ({ id: m.codigo, codigo: m.codigo }));
const delPerfil = (nombre: string) => new Set(resolverSelectores(PERFILES_SISTEMA_SEED.find((x) => x.perfil === nombre)!.selectores, privilegios, modulos));

describe('C0: permisos de /empresas', () => {
  it.each(Object.entries(EMPRESAS))('%s pide %s con el submódulo ADM_EMPRESAS', (m, priv) => {
    expect(permisoDe(EmpresasController, m)).toBe(priv);
    expect(submoduloDe(EmpresasController, m)).toBe('ADM_EMPRESAS');
    expect(guardsDe(EmpresasController, m)).toEqual(expect.arrayContaining([PermissionGuard, SubmoduloGuard]));
  });

  it('el mapa cubre todas las rutas del controller', () => {
    const rutas = Object.getOwnPropertyNames(EmpresasController.prototype).filter((m) => m !== 'constructor' && m !== 'findOne');
    expect(rutas.sort()).toEqual(Object.keys(EMPRESAS).sort());
  });

  it('GET /empresas/:id (arranque del front) no pide submódulo ni permiso: el alcance lo decide el servicio', () => {
    expect(permisoDe(EmpresasController, 'findOne')).toBeUndefined();
    expect(Reflect.getMetadata(REQUIRE_SUBMODULO_KEY, handler(EmpresasController, 'findOne'))).toBeUndefined();
  });

  it('GET /empresas (todas las empresas de la plataforma) es solo superadmin', () => {
    expect(guardsDe(EmpresasController, 'findAll')).toContain(SuperadminGuard);
  });

  it.each(PERFILES_SISTEMA_SEED.map((p) => p.perfil))('perfil de fábrica %s: crea, borra o cambia el estado de empresas solo si es Administrador', (perfil) => {
    const suyos = delPerfil(perfil);
    const puede = ['ADM_EMP_EMPRESA_CREAR', 'ADM_EMP_EMPRESA_ELIMINAR', 'ADM_EMP_EMPRESA_ACTIVAR', 'ADM_EMP_EMPRESA_EDITAR'].map((c) => suyos.has(c));
    expect(puede.every((x) => x === (perfil === 'Administrador'))).toBe(true);
  });

  describe('cada ruta con :id pregunta el alcance antes de actuar', () => {
    const user = { id: 'u1', username: 'x', empresa_id: 'e1' };
    const crear = () => {
      const service = new Proxy(
        { exigirAlcance: jest.fn().mockRejectedValue(new Error('corta')), exigirCambioDeJerarquia: jest.fn(), exigirAltaEnLaRed: jest.fn().mockRejectedValue(new Error('corta')) } as any,
        { get: (t, k) => (k in t ? t[k] : jest.fn().mockResolvedValue({})) },
      );
      return { service, controller: new EmpresasController(service) as any };
    };

    it.each([
      ['changePlan', ['otra', {}, user], 'solo_superior'],
      ['applyLimiteOverride', ['otra', {}, user], 'solo_superior'],
      ['clearLimiteOverride', ['otra', user], 'solo_superior'],
      ['cambiarEstado', ['otra', 'estado', user], 'solo_superior'],
      ['remove', ['otra', user], 'solo_superior'],
      ['update', ['otra', {}, user], 'propia_o_superior'],
      ['getCorreo', ['otra', user], 'propia_o_superior'],
      ['upsertCorreo', ['otra', {}, user], 'propia_o_superior'],
      ['deleteCorreo', ['otra', user], 'propia_o_superior'],
      ['testCorreo', ['otra', {}, user], 'propia_o_superior'],
      ['getFirmaReciboImagen', ['otra', user], 'propia_o_superior'],
      ['uploadFirmaReciboImagen', ['otra', {}, user], 'propia_o_superior'],
      ['deleteFirmaReciboImagen', ['otra', user], 'propia_o_superior'],
    ] as const)('%s → %s', async (m, args, modo) => {
      const { service, controller } = crear();
      await expect(controller[m](...args)).rejects.toThrow('corta');
      expect(service.exigirAlcance).toHaveBeenCalledWith(user, 'otra', modo);
    });

    it('create pregunta si el alta cae en la red del usuario', async () => {
      const { service, controller } = crear();
      const dto = { parent_id: 'x' };
      await expect(controller.create(dto, user)).rejects.toThrow('corta');
      expect(service.exigirAltaEnLaRed).toHaveBeenCalledWith(user, dto);
    });
  });
});

describe('C0: borrados de usuarios y puntos de expedición (ya cerrados, fijados)', () => {
  it('DELETE /users/:id pide ADM_USR_USUARIO_ELIMINAR (no _VER)', () => {
    expect(permisoDe(UsersController, 'remove')).toBe('ADM_USR_USUARIO_ELIMINAR');
    expect(guardsDe(UsersController, 'remove')).toContain(PermissionGuard);
  });

  it('DELETE /punto-expediciones/:id pide ADM_SUC_SUCURSAL_EDITAR, como borrar una caja', () => {
    expect(permisoDe(PuntoExpedicionesController, 'remove')).toBe('ADM_SUC_SUCURSAL_EDITAR');
    expect(guardsDe(PuntoExpedicionesController, 'remove')).toContain(PermissionGuard);
  });
});
