import { ForbiddenException, NotFoundException } from '@nestjs/common';
import { UsersService } from './users.service';

/**
 * C0b › acceso de usuarios a otras empresas (`usuario_empresas`). Una asignación deja al usuario CAMBIARSE a esa
 * empresa (selector de empresa) con su perfil: antes, con ADM_USR_USUARIO_EDITAR, un Administrador de cualquier empresa
 * se asignaba a sí mismo (o a cualquier usuario) a CUALQUIER empresa de la plataforma y entraba a sus datos; y con
 * _VER listaba las asignaciones de cualquier usuario.
 *
 * Ahora: el usuario tiene que ser de la empresa del actor o de su red, y la empresa a asignar / revocar / activar
 * también. El superadmin alcanza todo.
 *
 * Red: holding → kety → clienteKety; holding → otra. ajena no cuelga del holding.
 */
const padres: Record<string, { parent_id: string | null }> = {
  holding: { parent_id: null },
  kety: { parent_id: 'holding' },
  clienteKety: { parent_id: 'kety' },
  otra: { parent_id: 'holding' },
  ajena: { parent_id: null },
};
const usuarios: Record<string, { empresa_id: string; is_superadmin?: boolean }> = {
  adminKety: { empresa_id: 'kety' },
  cajeroKety: { empresa_id: 'kety' },
  cajeroCliente: { empresa_id: 'clienteKety' },
  cajeroOtra: { empresa_id: 'otra' },
  adminAjena: { empresa_id: 'ajena' },
  adminHolding: { empresa_id: 'holding' },
  // Administrador de la plataforma: is_superadmin de la holding raíz.
  superadmin: { empresa_id: 'holding', is_superadmin: true },
  // Dueño de una empresa auto-registrada: is_superadmin, pero de 'ajena' (no es plataforma).
  duenoAjena: { empresa_id: 'ajena', is_superadmin: true },
};

const armar = () => {
  const service = Object.create(UsersService.prototype) as any;
  const asignacion = { id: 'a1', rol: 'operador', active: true, empresa: { razon_social: 'x' }, usuario: { username: 'x' } };
  service.prisma = {
    usuario: {
      findUnique: jest.fn(async ({ where }: any) =>
        usuarios[where.id]
          ? {
              id: where.id,
              username: where.id,
              is_superadmin: false,
              ...usuarios[where.id],
              empresa_rel: { type: usuarios[where.id].empresa_id === 'holding' ? 'holding' : 'subsidiary', ...padres[usuarios[where.id].empresa_id] },
              // La marca de plataforma la pone solo la migración: al superadmin de la holding raíz.
              es_admin_plataforma: where.id === 'superadmin',
            }
          : null,
      ),
    },
    empresas: {
      findUnique: jest.fn(async ({ where }: any) => (padres[where.id] ? { id: where.id, ...padres[where.id] } : null)),
    },
    usuario_empresas: {
      findFirst: jest.fn().mockResolvedValue(asignacion),
      findMany: jest.fn().mockResolvedValue([]),
      create: jest.fn().mockResolvedValue(asignacion),
      update: jest.fn().mockResolvedValue(asignacion),
      delete: jest.fn().mockResolvedValue(asignacion),
    },
  };
  service.auditService = { log: jest.fn().mockResolvedValue(undefined) };
  service.logger = { log: jest.fn(), error: jest.fn() };
  return service as UsersService & { prisma: any };
};
const actor = (id: string) => ({ id, empresa: usuarios[id].empresa_id });

type Op = 'asignar' | 'revocar' | 'toggle';
const correr = (s: UsersService, op: Op, usuarioId: string, empresaId: string, a: { id: string; empresa: string }) =>
  op === 'asignar'
    ? s.asignarEmpresa(usuarioId, empresaId, 'operador', a.id, a.id, a.empresa)
    : op === 'revocar'
      ? s.revocarEmpresa(usuarioId, empresaId, a.id, a.empresa)
      : s.toggleAccesoEmpresa(usuarioId, empresaId, a.id, a.empresa);

describe('C0b: asignar / revocar / activar acceso de un usuario a una empresa', () => {
  describe.each(['asignar', 'revocar', 'toggle'] as Op[])('%s', (op) => {
    it.each([
      // actor, usuario, empresa, resultado
      ['adminKety', 'cajeroKety', 'clienteKety', 'ok'],
      ['adminKety', 'adminKety', 'clienteKety', 'ok'],
      ['adminHolding', 'cajeroCliente', 'otra', 'ok'],
      ['adminKety', 'adminKety', 'ajena', 'empresa'],
      ['adminKety', 'adminKety', 'holding', 'empresa'],
      ['adminKety', 'cajeroKety', 'otra', 'empresa'],
      ['adminKety', 'cajeroOtra', 'kety', 'usuario'],
      ['adminAjena', 'cajeroKety', 'ajena', 'usuario'],
      ['superadmin', 'cajeroKety', 'ajena', 'ok'],
      ['duenoAjena', 'cajeroKety', 'ajena', 'usuario'],
      ['duenoAjena', 'duenoAjena', 'kety', 'empresa'],
    ])('%s: %s → %s = %s', async (a, usuarioId, empresaId, esperado) => {
      const s = armar();
      const r = correr(s, op, usuarioId, empresaId, actor(a));
      if (esperado === 'ok') await expect(r).resolves.toBeDefined();
      else {
        await expect(r).rejects.toBeInstanceOf(esperado === 'usuario' ? NotFoundException : ForbiddenException);
        expect(s.prisma.usuario_empresas.create).not.toHaveBeenCalled();
        expect(s.prisma.usuario_empresas.update).not.toHaveBeenCalled();
        expect(s.prisma.usuario_empresas.delete).not.toHaveBeenCalled();
      }
    });
  });
});

describe('C0b: ver las empresas asignadas de un usuario', () => {
  it.each([
    ['adminKety', 'cajeroKety', true],
    ['adminKety', 'cajeroCliente', true],
    ['adminKety', 'cajeroOtra', false],
    ['adminAjena', 'cajeroKety', false],
    ['superadmin', 'cajeroKety', true],
    ['duenoAjena', 'cajeroKety', false],
  ])('%s ve las de %s → %s', async (a, usuarioId, pasa) => {
    const s = armar();
    const r = s.getEmpresasAsignadas(usuarioId, actor(a).id, actor(a).empresa);
    if (pasa) await expect(r).resolves.toBeDefined();
    else await expect(r).rejects.toBeInstanceOf(NotFoundException);
  });
});
