import { BadRequestException, ConflictException, ForbiddenException } from '@nestjs/common';
import { GUARDS_METADATA } from '@nestjs/common/constants';
import { REQUIRE_PERMISSION_KEY } from '../auth/decorators/require-permission.decorator';
import { PermissionGuard } from '../auth/guards/permission.guard';
import { SeguridadController } from './seguridad.controller';
import { SeguridadService } from './seguridad.service';

/** U6: copias numeradas y nombre único. H4: el editor de perfiles exige permisos. */
describe('SeguridadService — nombres de perfil', () => {
  const crear = (nombres: string[], duplicado: unknown = null) => {
    const service = Object.create(SeguridadService.prototype) as any;
    service.prisma = {
      perfiles: {
        findMany: jest.fn().mockResolvedValue(nombres.map((perfil) => ({ perfil }))),
        findFirst: jest.fn().mockResolvedValue(duplicado),
      },
    };
    return service;
  };

  it('primera copia: «Copia de X»', async () => {
    expect(await crear([]).proximoNombreCopia('emp', 'Cajero')).toBe('Copia de Cajero');
  });

  it('si ya existe, numera: (2), (3)…', async () => {
    expect(await crear(['Copia de Cajero']).proximoNombreCopia('emp', 'Cajero')).toBe('Copia de Cajero (2)');
    expect(
      await crear(['copia de cajero', 'Copia de Cajero (2)']).proximoNombreCopia('emp', 'Cajero'),
    ).toBe('Copia de Cajero (3)');
  });

  it('respeta el largo máximo de 50', async () => {
    const largo = 'X'.repeat(60);
    const nombre = await crear([`Copia de ${largo}`.slice(0, 50)]).proximoNombreCopia('emp', largo);
    expect(nombre.length).toBeLessThanOrEqual(50);
    expect(nombre.endsWith(' (2)')).toBe(true);
  });

  it('crear o renombrar con un nombre que ya existe en la empresa: 409', async () => {
    const service = crear([], { id: 'otro' });
    await expect(service.assertNombreDisponible('emp', 'Cajero', 'p1')).rejects.toBeInstanceOf(ConflictException);
    expect(service.prisma.perfiles.findFirst).toHaveBeenCalledWith({
      where: { empresa_id: 'emp', perfil: { equals: 'Cajero', mode: 'insensitive' }, NOT: { id: 'p1' } },
      select: { id: true },
    });
  });

  it('re-sembrar el catálogo (global) es solo del administrador de la plataforma', async () => {
    const con = (fila: unknown) => {
      const service = Object.create(SeguridadService.prototype) as any;
      service.prisma = { usuario: { findUnique: jest.fn().mockResolvedValue(fila) } };
      return service;
    };
    await expect(con({ is_superadmin: false, empresa_rel: { type: 'holding', parent_id: null } }).exigirSuperadmin('u1')).rejects.toBeInstanceOf(ForbiddenException);
    // El dueño (is_superadmin) de una subsidiaria auto-registrada no toca el catálogo de todas las empresas.
    await expect(con({ is_superadmin: true, empresa_rel: { type: 'subsidiary', parent_id: 'raiz' } }).exigirSuperadmin('u1')).rejects.toBeInstanceOf(ForbiddenException);
    await expect(con({ is_superadmin: true, es_admin_plataforma: true }).exigirSuperadmin('u1')).resolves.toBeUndefined();
  });
});

describe('SeguridadController — permisos (H4)', () => {
  it('usa PermissionGuard', () => {
    const guards = Reflect.getMetadata(GUARDS_METADATA, SeguridadController) as unknown[];
    expect(guards).toContain(PermissionGuard);
  });

  it.each([
    ['getArbol', 'ADM_PER_PERFIL_VER'],
    ['listarPerfiles', 'ADM_PER_PERFIL_VER'],
    ['obtenerPerfil', 'ADM_PER_PERFIL_VER'],
    ['crearPerfil', 'ADM_PER_PERFIL_CREAR'],
    ['actualizarPerfil', 'ADM_PER_PERFIL_EDITAR'],
    ['clonarPerfil', 'ADM_PER_PERFIL_CLONAR'],
    ['eliminarPerfil', 'ADM_PER_PERFIL_ELIMINAR'],
    ['cargarSugeridos', 'ADM_PER_PERFIL_CREAR'],
  ])('%s exige %s', (metodo, privilegio) => {
    const meta = Reflect.getMetadata(REQUIRE_PERMISSION_KEY, (SeguridadController.prototype as any)[metodo]);
    expect(meta).toEqual({ modulo: 'ADMINISTRACION', privilegio });
  });
});

/** Los privilegios de un perfil deben existir y pertenecer a lo contratado por la empresa (mismo filtro que `getArbol`). */
describe('SeguridadService — privilegios contratados', () => {
  const CONTRATADO = { id: 'p-ok', codigo: 'VEN_FACT_VER' };
  const NO_CONTRATADO = { id: 'p-rrhh', codigo: 'RRHH_LEG_VER' };
  const INEXISTENTE = 'p-nada';
  const arbol = [{ id: 'm1', submodulos: [{ id: 's1', privilegios: [{ id: CONTRATADO.id, codigo: CONTRATADO.codigo }] }] }];

  const crear = (perfilActual: unknown = null) => {
    const service = Object.create(SeguridadService.prototype) as any;
    service.getArbol = jest.fn().mockResolvedValue(arbol);
    service.audit = { log: jest.fn() };
    service.prisma = {
      privilegios: {
        findMany: jest.fn(({ where }: any) => {
          const todos = [
            { ...CONTRATADO, active: true, submodulos: { modulo_id: 'm1' } },
            { ...NO_CONTRATADO, active: true, submodulos: { modulo_id: 'm9' } },
          ];
          return Promise.resolve(todos.filter((p) => where.id.in.includes(p.id)));
        }),
      },
      perfiles: {
        findFirst: jest.fn(({ where }: any) => Promise.resolve(where.perfil ? null : perfilActual)),
        findMany: jest.fn().mockResolvedValue([]),
        create: jest.fn().mockResolvedValue({ id: 'nuevo', perfil: 'X' }),
        update: jest.fn(),
      },
      perfiles_privilegios: { deleteMany: jest.fn() },
      $transaction: jest.fn().mockResolvedValue([]),
    };
    return service;
  };
  const dto = (ids: string[]) => ({ perfil: 'Vendedor', privilegio_ids: ids });
  const rechazo = async (p: Promise<unknown>) => {
    const e = await p.then(() => null, (err) => err);
    expect(e).toBeInstanceOf(BadRequestException);
    return e.getResponse();
  };

  it('crear con un privilegio de módulo no contratado: 400 con la lista', async () => {
    const s = crear();
    const r = await rechazo(s.crearPerfil('emp', dto([CONTRATADO.id, NO_CONTRATADO.id]), {}));
    expect(r.rechazados).toEqual([{ id: NO_CONTRATADO.id, codigo: NO_CONTRATADO.codigo, motivo: 'no_contratado' }]);
    expect(s.getArbol).toHaveBeenCalledWith('emp');
    expect(s.prisma.perfiles.create).not.toHaveBeenCalled();
  });

  it('crear con un privilegio inexistente: 400', async () => {
    const s = crear();
    const r = await rechazo(s.crearPerfil('emp', dto([INEXISTENTE]), {}));
    expect(r.rechazados).toEqual([{ id: INEXISTENTE, codigo: null, motivo: 'inexistente' }]);
    expect(s.prisma.perfiles.create).not.toHaveBeenCalled();
  });

  it('crear solo con privilegios contratados: ok', async () => {
    const s = crear();
    await s.crearPerfil('emp', dto([CONTRATADO.id]), {});
    expect(s.prisma.perfiles.create).toHaveBeenCalled();
  });

  it('editar agregando un privilegio no contratado: 400', async () => {
    const s = crear({ id: 'p1', is_sistema: false, perfiles_privilegios: [] });
    const r = await rechazo(s.actualizarPerfil('emp', 'p1', dto([NO_CONTRATADO.id]), {}));
    expect(r.rechazados.map((x: any) => x.id)).toEqual([NO_CONTRATADO.id]);
    expect(s.prisma.$transaction).not.toHaveBeenCalled();
  });

  it('editar conservando uno no contratado que el perfil ya tenía: ok (no se tocan los existentes)', async () => {
    const s = crear({ id: 'p1', is_sistema: false, perfiles_privilegios: [{ privilegio_id: NO_CONTRATADO.id }] });
    s.obtenerPerfil = jest.fn().mockResolvedValue({});
    await s.actualizarPerfil('emp', 'p1', dto([CONTRATADO.id, NO_CONTRATADO.id]), {});
    expect(s.prisma.$transaction).toHaveBeenCalled();
  });

  it('editar con un privilegio inexistente: 400', async () => {
    const s = crear({ id: 'p1', is_sistema: false, perfiles_privilegios: [] });
    const r = await rechazo(s.actualizarPerfil('emp', 'p1', dto([INEXISTENTE]), {}));
    expect(r.rechazados[0].motivo).toBe('inexistente');
  });

  it('clonar copia solo lo contratado (un perfil de sistema trae todo el catálogo)', async () => {
    const s = crear({ id: 'sis', perfil: 'Administrador', perfiles_privilegios: [{ privilegio_id: CONTRATADO.id }, { privilegio_id: NO_CONTRATADO.id }] });
    const r = await s.clonarPerfil('emp', 'sis', {});
    const data = s.prisma.perfiles.create.mock.calls[0][0].data;
    expect(data.perfiles_privilegios.create.map((x: any) => x.privilegio_id)).toEqual([CONTRATADO.id]);
    expect(r.privilegios_omitidos).toBe(1);
  });
});
