import { REQUIRE_PERMISSION_KEY } from 'src/auth/decorators/require-permission.decorator';
import { REQUIRE_SUBMODULO_KEY } from 'src/auth/decorators/require-submodulo.decorator';
import { validarDto } from 'src/common/utils/validar-dto.testutil';
import { AprobadoresConfigService } from './aprobadores-config.service';
import { AsignarAprobadoresDto } from './dto/aprobadores-config.dto';
import { RequisicionesController } from './requisiciones.controller';

const EMP = 'emp-1';
const YO = 'usr-yo';
const PA = '11111111-1111-4111-8111-111111111111';
const PB = '22222222-2222-4222-8222-222222222222';
const GLOBAL = '55555555-5555-4555-8555-555555555555';
const AJENO = '33333333-3333-4333-8333-333333333333';
const U1 = '44444444-4444-4444-8444-444444444441';
const U2 = '44444444-4444-4444-8444-444444444442';

type Opciones = {
  privilegios?: string[] | 'TODOS';
  nivelesPerfil?: string[];
  /** Niveles guardados con la empresa de su perfil (null = perfil global). Si se pasa, reemplaza a nivelesPerfil. */
  nivelesConEmpresa?: Array<{ perfil_id: string; empresa: string | null }>;
  habilitados?: string[];
  usuariosTodos?: any[];
  actuales?: Array<{ user_id: string; perfil_id: string }>;
};

function montar(o: Opciones = {}) {
  const privilegios = o.privilegios ?? ['ADM_USR_USUARIO_VER', 'ADM_USR_USUARIO_EDITAR'];
  const tx: any = {
    requisicion_aprobacion_config: {
      // Respeta el cruce con la empresa del perfil (`perfiles: { empresa_id }`), como la consulta real.
      findMany: jest.fn(async ({ where }: any = {}) => {
        const filas = o.nivelesConEmpresa ?? (o.nivelesPerfil ?? [PA, PB]).map((perfil_id) => ({ perfil_id, empresa: EMP }));
        const empresa = where?.perfiles?.empresa_id;
        return filas.filter((f) => empresa === undefined || f.empresa === empresa).map(({ perfil_id }) => ({ perfil_id }));
      }),
    },
    usuario: {
      findMany: jest.fn(async ({ where }: any) =>
        where.id ? (o.habilitados ?? [U1, U2]).filter((id) => where.id.in.includes(id)).map((id) => ({ id })) : (o.usuariosTodos ?? []),
      ),
      findUnique: jest.fn().mockResolvedValue({ is_superadmin: privilegios === 'TODOS' }),
    },
    perfiles: { findMany: jest.fn(async ({ where }: any) => [{ id: PA, perfil: 'A', desc_perfil: 'Perfil A' }, { id: PB, perfil: 'B', desc_perfil: 'Perfil B' }, { id: GLOBAL, perfil: 'superAdmin', desc_perfil: null }].filter((p) => where.id.in.includes(p.id))) },
    perfiles_privilegios: {
      findMany: jest.fn().mockResolvedValue(privilegios === 'TODOS' ? [] : privilegios.map((codigo) => ({ privilegios: { codigo } }))),
    },
    usuario_perfiles: {
      findMany: jest.fn().mockResolvedValue(o.actuales ?? []),
      deleteMany: jest.fn().mockResolvedValue({ count: 1 }),
      createMany: jest.fn().mockResolvedValue({ count: 1 }),
    },
  };
  const prisma: any = { ...tx, $transaction: jest.fn(async (cb: any) => cb(tx)) };
  const audit = { logEnTransaccion: jest.fn() };
  return { service: new AprobadoresConfigService(prisma, audit as any), tx, prisma, audit };
}
const respuesta = async (p: Promise<unknown>) => {
  try {
    await p;
  } catch (e: any) {
    return { status: e.getStatus(), ...e.getResponse() };
  }
  throw new Error('no lanzó');
};
const dto = (...asignaciones: Array<{ usuario_id: string; perfil_ids: string[] }>) => ({ asignaciones }) as AsignarAprobadoresDto;

describe('AprobadoresConfigService (D10)', () => {
  describe('permiso de Usuarios', () => {
    it('sin ADM_USR_USUARIO_VER ni _EDITAR: 403 PERMISO_USUARIOS_REQUERIDO en la lectura y en el PUT', async () => {
      const m = montar({ privilegios: ['ADM_CCFG_CONFIG_EDITAR'] });
      expect(await respuesta(m.service.getAprobadores(EMP, YO))).toMatchObject({ status: 403, codigo: 'PERMISO_USUARIOS_REQUERIDO' });
      expect(await respuesta(m.service.asignarAprobadores(EMP, dto({ usuario_id: U1, perfil_ids: [PA] }), YO))).toMatchObject({ status: 403, codigo: 'PERMISO_USUARIOS_REQUERIDO' });
      expect(m.prisma.$transaction).not.toHaveBeenCalled();
    });

    it('con _VER lee y no escribe: el PUT da 403', async () => {
      const m = montar({ privilegios: ['ADM_USR_USUARIO_VER'] });
      await expect(m.service.getAprobadores(EMP, YO)).resolves.toBeDefined();
      expect(await respuesta(m.service.asignarAprobadores(EMP, dto({ usuario_id: U1, perfil_ids: [PA] }), YO))).toMatchObject({ status: 403 });
      expect(m.tx.usuario_perfiles.createMany).not.toHaveBeenCalled();
    });

    it('con _EDITAR solo (sin _VER) también lee y escribe; el superadmin (TODOS) pasa', async () => {
      await expect(montar({ privilegios: ['ADM_USR_USUARIO_EDITAR'] }).service.getAprobadores(EMP, YO)).resolves.toBeDefined();
      await expect(montar({ privilegios: 'TODOS' }).service.getAprobadores(EMP, YO)).resolves.toBeDefined();
    });
  });

  describe('lectura', () => {
    it('columnas = perfiles de cualquier nivel guardado, activo o no (sin filtrar por activo)', async () => {
      const m = montar();
      await m.service.getAprobadores(EMP, YO);
      expect(m.tx.requisicion_aprobacion_config.findMany.mock.calls[0][0].where).toEqual({ empresa_id: EMP, perfiles: { empresa_id: EMP } });
      expect(m.tx.perfiles.findMany.mock.calls[0][0].where).toEqual({ id: { in: [PA, PB] }, empresa_id: EMP });
    });

    it('600 usuarios habilitados: aparecen los 600 (sin tope), con filtro de habilitado y ordenados por nombres, username', async () => {
      const muchos = Array.from({ length: 600 }, (_, i) => ({ id: `u${i}`, username: `u${i}`, nombres: 'N', apellidos: 'A', usuario_perfiles: i % 2 ? [{ perfil_id: PA }] : [] }));
      const m = montar({ usuariosTodos: muchos });
      const r = await m.service.getAprobadores(EMP, YO);
      expect(r.usuarios).toHaveLength(600);
      expect(r.usuarios[1].perfil_ids).toEqual([PA]);
      expect(r.usuarios[0].perfil_ids).toEqual([]);
      const arg = m.tx.usuario.findMany.mock.calls[0][0];
      expect(arg.take).toBeUndefined();
      expect(arg.where).toEqual({ empresa_id: EMP, estado: 'Activo', OR: [{ active: true }, { active: null }] });
      expect(arg.orderBy).toEqual([{ nombres: 'asc' }, { username: 'asc' }]);
      expect(arg.select.usuario_perfiles.where).toEqual({ perfil_id: { in: [PA, PB] } });
    });
  });

  describe('perfiles de otra empresa o globales (nivel viejo guardado)', () => {
    const niveles = [
      { perfil_id: PA, empresa: EMP },
      { perfil_id: GLOBAL, empresa: null },
      { perfil_id: PB, empresa: 'otra-empresa' },
    ];

    it('no se ofrecen como columna: solo los perfiles de nivel de la propia empresa', async () => {
      const m = montar({ nivelesConEmpresa: niveles });
      const r = await m.service.getAprobadores(EMP, YO);
      expect(r.perfiles.map((p) => p.id)).toEqual([PA]);
      expect(m.tx.usuario.findMany.mock.calls[0][0].select.usuario_perfiles.where).toEqual({ perfil_id: { in: [PA] } });
    });

    it('no se pueden asignar: PERFIL_NO_ES_DE_NIVEL y no se escribe nada', async () => {
      for (const ajeno of [GLOBAL, PB]) {
        const m = montar({ nivelesConEmpresa: niveles });
        expect(await respuesta(m.service.asignarAprobadores(EMP, dto({ usuario_id: U1, perfil_ids: [ajeno] }), YO))).toMatchObject({
          status: 400,
          codigo: 'PERFIL_NO_ES_DE_NIVEL',
          linea: 1,
        });
        expect(m.tx.usuario_perfiles.createMany).not.toHaveBeenCalled();
      }
    });

    it('el de la propia empresa sigue pudiéndose asignar', async () => {
      const m = montar({ nivelesConEmpresa: niveles });
      await expect(m.service.asignarAprobadores(EMP, dto({ usuario_id: U1, perfil_ids: [PA] }), YO)).resolves.toEqual({ usuarios_actualizados: 1 });
    });
  });

  describe('asignar', () => {
    it('un usuario inactivo (o de otra empresa) no aparece y asignarlo da USUARIO_NO_ENCONTRADO con linea', async () => {
      const m = montar({ habilitados: [U1] });
      const r = await respuesta(m.service.asignarAprobadores(EMP, dto({ usuario_id: U1, perfil_ids: [PA] }, { usuario_id: U2, perfil_ids: [PA] }), YO));
      expect(r).toMatchObject({ status: 400, codigo: 'USUARIO_NO_ENCONTRADO', linea: 2 });
      expect(m.tx.usuario.findMany.mock.calls[0][0].where).toMatchObject({ empresa_id: EMP, estado: 'Activo', OR: [{ active: true }, { active: null }] });
    });

    it('un perfil que no es de nivel: PERFIL_NO_ES_DE_NIVEL con linea', async () => {
      const m = montar();
      expect(await respuesta(m.service.asignarAprobadores(EMP, dto({ usuario_id: U1, perfil_ids: [AJENO] }), YO))).toMatchObject({
        status: 400,
        codigo: 'PERFIL_NO_ES_DE_NIVEL',
        linea: 1,
      });
    });

    it('usuario repetido: USUARIO_REPETIDO', async () => {
      const m = montar();
      expect(await respuesta(m.service.asignarAprobadores(EMP, dto({ usuario_id: U1, perfil_ids: [PA] }, { usuario_id: U1, perfil_ids: [PB] }), YO))).toMatchObject({
        codigo: 'USUARIO_REPETIDO',
        linea: 2,
      });
    });

    it('agrega los marcados, saca los desmarcados y no toca sus perfiles que no son de nivel', async () => {
      const m = montar({ actuales: [{ user_id: U1, perfil_id: PB }] });
      const r = await m.service.asignarAprobadores(EMP, dto({ usuario_id: U1, perfil_ids: [PA] }), YO);
      expect(r).toEqual({ usuarios_actualizados: 1 });
      expect(m.tx.usuario_perfiles.deleteMany).toHaveBeenCalledWith({ where: { user_id: U1, perfil_id: { in: [PB] } } });
      expect(m.tx.usuario_perfiles.createMany).toHaveBeenCalledWith({ data: [{ user_id: U1, perfil_id: PA }] });
      // Solo mira (y borra) entre los perfiles de nivel: los demás perfiles del usuario ni se leen.
      expect(m.tx.usuario_perfiles.findMany.mock.calls[0][0].where.perfil_id).toEqual({ in: [PA, PB] });
    });

    it('un usuario de dos empresas no pierde los perfiles de la otra (solo se tocan perfiles de nivel de esta empresa)', async () => {
      const m = montar({ nivelesPerfil: [PA], actuales: [{ user_id: U1, perfil_id: PA }] });
      await m.service.asignarAprobadores(EMP, dto({ usuario_id: U1, perfil_ids: [] }), YO);
      expect(m.tx.usuario_perfiles.deleteMany).toHaveBeenCalledTimes(1);
      expect(m.tx.usuario_perfiles.deleteMany).toHaveBeenCalledWith({ where: { user_id: U1, perfil_id: { in: [PA] } } });
    });

    it('sin cambios reales no escribe ni cuenta al usuario', async () => {
      const m = montar({ actuales: [{ user_id: U1, perfil_id: PA }] });
      expect(await m.service.asignarAprobadores(EMP, dto({ usuario_id: U1, perfil_ids: [PA] }), YO)).toEqual({ usuarios_actualizados: 0 });
      expect(m.tx.usuario_perfiles.deleteMany).not.toHaveBeenCalled();
      expect(m.tx.usuario_perfiles.createMany).not.toHaveBeenCalled();
    });

    it('dos usuarios, el segundo inválido: no se guarda ninguno (se valida todo antes de escribir, en una $transaction)', async () => {
      const m = montar();
      const r = await respuesta(m.service.asignarAprobadores(EMP, dto({ usuario_id: U1, perfil_ids: [PA] }, { usuario_id: U2, perfil_ids: [AJENO] }), YO));
      expect(r).toMatchObject({ codigo: 'PERFIL_NO_ES_DE_NIVEL', linea: 2 });
      expect(m.prisma.$transaction).toHaveBeenCalledTimes(1);
      expect(m.tx.usuario_perfiles.createMany).not.toHaveBeenCalled();
      expect(m.tx.usuario_perfiles.deleteMany).not.toHaveBeenCalled();
      expect(m.audit.logEnTransaccion).not.toHaveBeenCalled();
    });

    it('un guardado sin cambios no escribe en la auditoría', async () => {
      const m = montar({ actuales: [{ user_id: U1, perfil_id: PA }] });
      const r = await m.service.asignarAprobadores(EMP, dto({ usuario_id: U1, perfil_ids: [PA] }), YO);
      expect(r).toEqual({ usuarios_actualizados: 0 });
      expect(m.audit.logEnTransaccion).not.toHaveBeenCalled();
    });

    it('audita APROBADORES_ASIGNADOS una sola vez con el antes y el después por usuario', async () => {
      const m = montar({ actuales: [{ user_id: U1, perfil_id: PB }] });
      await m.service.asignarAprobadores(EMP, dto({ usuario_id: U1, perfil_ids: [PA] }, { usuario_id: U2, perfil_ids: [PA, PB] }), YO);
      expect(m.audit.logEnTransaccion).toHaveBeenCalledTimes(1);
      expect(m.audit.logEnTransaccion.mock.calls[0][1]).toMatchObject({
        empresa_id: EMP,
        user_id: YO,
        action: 'APROBADORES_ASIGNADOS',
        entity_type: 'usuario_perfiles',
        old_value: { [U1]: [PB], [U2]: [] },
        new_value: { [U1]: [PA], [U2]: [PA, PB] },
      });
    });
  });

  describe('DTO (ValidationPipe real)', () => {
    it('acepta asignaciones válidas', async () => {
      await expect(validarDto(AsignarAprobadoresDto, { asignaciones: [{ usuario_id: U1, perfil_ids: [PA] }] })).resolves.toBeDefined();
    });
    it('rechaza lista vacía, ids que no son uuid y campos de más', async () => {
      for (const mal of [
        { asignaciones: [] },
        { asignaciones: [{ usuario_id: 'x', perfil_ids: [] }] },
        { asignaciones: [{ usuario_id: U1, perfil_ids: ['y'] }] },
        { asignaciones: [{ usuario_id: U1, perfil_ids: [] , otro: 1 }] },
        {},
      ]) {
        await expect(validarDto(AsignarAprobadoresDto, mal)).rejects.toMatchObject({ status: 400 });
      }
    });
  });

  describe('guards del controller', () => {
    const proto = RequisicionesController.prototype as any;
    it('GET pide ADM_CCFG_CONFIG_VER y PUT _EDITAR, detrás del submódulo COMP_REQUISICIONES de la clase', () => {
      expect(Reflect.getMetadata(REQUIRE_PERMISSION_KEY, proto.getAprobadores)).toEqual({ modulo: 'ADMINISTRACION', privilegio: 'ADM_CCFG_CONFIG_VER' });
      expect(Reflect.getMetadata(REQUIRE_PERMISSION_KEY, proto.asignarAprobadores)).toEqual({ modulo: 'ADMINISTRACION', privilegio: 'ADM_CCFG_CONFIG_EDITAR' });
      expect(Reflect.getMetadata(REQUIRE_SUBMODULO_KEY, RequisicionesController)).toBe('COMP_REQUISICIONES');
    });
  });
});
