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

/**
 * C0 críticos › gestión de usuarios entre empresas (`resolveActorScope`). Antes era «elevado» (gestiona usuarios de
 * CUALQUIER empresa: listar con `?empresa_id=`, ver, editar —contraseña incluida—, moverlos de empresa, crearlos en
 * otra) quien tuviera `is_superadmin` —el dueño de toda empresa auto-registrada— o fuera de una holding o un reseller,
 * sin mirar la red. Ahora: el administrador de la plataforma alcanza todo; holding y reseller, su red; el resto, su
 * empresa.
 *
 * Red: holding (raíz) → kety (reseller) → clienteKety; holding → otra. ajena no cuelga de nadie.
 */
const empresas: Record<string, { parent_id: string | null; type: string }> = {
  holding: { parent_id: null, type: 'holding' },
  kety: { parent_id: 'holding', type: 'reseller' },
  clienteKety: { parent_id: 'kety', type: 'subsidiary' },
  otra: { parent_id: 'holding', type: 'subsidiary' },
  ajena: { parent_id: null, type: 'subsidiary' },
};
const usuarios: Record<string, { empresa_id: string; is_superadmin?: boolean }> = {
  plataforma: { empresa_id: 'holding', is_superadmin: true },
  adminKety: { empresa_id: 'kety' },
  duenoAjena: { empresa_id: 'ajena', is_superadmin: true },
  cajeroKety: { empresa_id: 'kety' },
  cajeroCliente: { empresa_id: 'clienteKety' },
  cajeroOtra: { empresa_id: 'otra' },
  cajeroAjena: { empresa_id: 'ajena' },
  adminHolding: { empresa_id: 'holding' },
  duenoOtra: { empresa_id: 'otra', is_superadmin: true },
};

const armar = () => {
  const service = Object.create(UsersService.prototype) as any;
  service.prisma = {
    usuario: {
      findUnique: jest.fn(async ({ where }: any) => {
        const u = where.id ? usuarios[where.id] : undefined;
        if (!u) return null;
        return {
          id: where.id,
          username: where.id,
          nombres: where.id,
          estado: 'Activo',
          is_superadmin: false,
          ...u,
          empresa_rel: empresas[u.empresa_id],
          es_admin_plataforma: where.id === 'plataforma',
        };
      }),
      findMany: jest.fn().mockResolvedValue([]),
      count: jest.fn().mockResolvedValue(0),
      update: jest.fn(async ({ where }: any) => ({ id: where.id })),
    },
    empresas: { findUnique: jest.fn(async ({ where }: any) => (empresas[where.id] ? { id: where.id, ...empresas[where.id] } : null)) },
    $transaction: jest.fn(async (ops: Promise<unknown>[]) => Promise.all(ops)),
    usuario_empresas: {
      findFirst: jest.fn().mockResolvedValue(null),
      create: jest.fn().mockResolvedValue({ id: 'ue1', empresa: { razon_social: 'x' }, usuario: { username: 'x' } }),
    },
  };
  service.auditService = { log: jest.fn() };
  service.logger = { log: jest.fn(), error: jest.fn(), warn: jest.fn() };
  return service as any;
};
const de = (id: string) => [id, usuarios[id].empresa_id] as const;

describe('listar usuarios con ?empresa_id=', () => {
  it.each([
    ['el dueño (is_superadmin) de una subsidiaria solo ve los suyos', 'duenoAjena', 'kety', 'ajena'],
    ['un reseller ve los de su red', 'adminKety', 'clienteKety', 'clienteKety'],
    ['un reseller sin filtro ve los suyos (no los de toda la plataforma)', 'adminKety', undefined, 'kety'],
    ['la plataforma ve los de cualquiera', 'plataforma', 'ajena', 'ajena'],
  ] as const)('%s', async (_n, quien, filtro, esperado) => {
    const s = armar();
    await s.findAll(1, 10, filtro, ...de(quien));
    expect(s.prisma.usuario.findMany.mock.calls[0][0].where).toEqual({ empresa_id: esperado });
  });

  it('un reseller no lista usuarios fuera de su red', async () => {
    await expect(armar().findAll(1, 10, 'otra', ...de('adminKety'))).rejects.toBeInstanceOf(ForbiddenException);
  });
});

describe('ver / editar un usuario de otra empresa', () => {
  it.each([
    ['dueño de una subsidiaria → usuario ajeno', 'duenoAjena', 'cajeroKety', false],
    ['reseller → usuario fuera de su red', 'adminKety', 'cajeroOtra', false],
    ['reseller → usuario de su red', 'adminKety', 'cajeroCliente', true],
    ['plataforma → cualquiera', 'plataforma', 'cajeroAjena', true],
  ] as const)('%s', async (_n, quien, objetivo, pasa) => {
    const r = armar().findOne(objetivo, ...de(quien));
    if (pasa) await expect(r).resolves.toBeDefined();
    else await expect(r).rejects.toBeInstanceOf(NotFoundException);
  });

  it('el dueño de una subsidiaria no le cambia la contraseña a un usuario de otra empresa', async () => {
    const s = armar();
    await expect(s.update('cajeroKety', { password: 'robada' } as any, ...de('duenoAjena'))).rejects.toBeInstanceOf(NotFoundException);
    expect(s.prisma.usuario.update).not.toHaveBeenCalled();
  });

  it('un reseller no mueve un usuario a una empresa fuera de su red; el dueño de una subsidiaria no lo mueve', async () => {
    const s = armar();
    await expect(s.update('cajeroKety', { empresa_id: 'ajena' } as any, ...de('adminKety'))).rejects.toBeInstanceOf(ForbiddenException);
    const d = armar();
    await d.update('cajeroAjena', { empresa_id: 'kety' } as any, ...de('duenoAjena'));
    expect(d.prisma.usuario.update.mock.calls[0][0].data).not.toHaveProperty('empresa_rel');
  });
});

describe('crear un usuario en otra empresa', () => {
  it('un reseller no crea usuarios fuera de su red', async () => {
    const s = armar();
    await expect(s.create({ username: 'nuevo', password: 'x', empresa_id: 'ajena' } as any, ...de('adminKety'))).rejects.toBeInstanceOf(ForbiddenException);
  });
});

describe('C0 ronda 2: PIN de supervisor de otro usuario (POST /users/:id/configurar-pin)', () => {
  it('fuera del alcance de usuarios → no encontrado y no se graba', async () => {
    const s = armar();
    await expect(s.configurarPin('cajeroKety', '1234', ...de('duenoAjena'))).rejects.toBeInstanceOf(NotFoundException);
    await expect(s.configurarPin('cajeroOtra', '1234', ...de('adminKety'))).rejects.toBeInstanceOf(NotFoundException);
    await expect(s.configurarPin('plataforma', '1234', ...de('adminKety'))).rejects.toBeInstanceOf(NotFoundException);
    expect(s.prisma.usuario.update).not.toHaveBeenCalled();
  });

  it('dentro del alcance (su red) y el propio PIN, sí', async () => {
    const s = armar();
    await expect(s.configurarPin('cajeroCliente', '1234', ...de('adminKety'))).resolves.toBeDefined();
    // El propio, aunque esté trabajando en otra empresa activa.
    await expect(s.configurarPin('duenoAjena', '1234', 'duenoAjena', 'kety')).resolves.toBeDefined();
    expect(s.prisma.usuario.update).toHaveBeenCalledTimes(2);
  });
});

describe('C0 ronda 3: nadie que no sea la plataforma sube un dueño (is_superadmin) a la holding raíz', () => {
  it('un admin de la raíz (con editar usuarios) muda a un dueño a la raíz → 403, sin grabar', async () => {
    const s = armar();
    await expect(s.update('duenoOtra', { empresa_id: 'holding' } as any, ...de('adminHolding'))).rejects.toBeInstanceOf(ForbiddenException);
    expect(s.prisma.usuario.update).not.toHaveBeenCalled();
  });

  it('ni le cambia la empresa principal a un dueño dentro de la red', async () => {
    const s = armar();
    await expect(s.update('duenoOtra', { empresa_id: 'kety' } as any, ...de('adminHolding'))).rejects.toBeInstanceOf(ForbiddenException);
  });

  it('ni le asigna acceso a la raíz', async () => {
    const s = armar();
    await expect(s.asignarEmpresa('duenoOtra', 'holding', 'admin', 'adminHolding', ...de('adminHolding'))).rejects.toBeInstanceOf(ForbiddenException);
    expect(s.prisma.usuario_empresas.create).not.toHaveBeenCalled();
  });

  it('a un usuario común sí lo mueve o le asigna la raíz (dentro de la red); la plataforma, también al dueño', async () => {
    const s = armar();
    await s.update('cajeroOtra', { empresa_id: 'holding' } as any, ...de('adminHolding'));
    await s.asignarEmpresa('cajeroOtra', 'holding', 'operador', 'adminHolding', ...de('adminHolding'));
    await s.update('duenoOtra', { empresa_id: 'holding' } as any, ...de('plataforma'));
    expect(s.prisma.usuario.update).toHaveBeenCalledTimes(2);
    expect(s.prisma.usuario_empresas.create).toHaveBeenCalledTimes(1);
  });
});

describe('Carril D: reactivar el acceso de un dueño a la holding raíz (PUT /users/toggle-acceso-empresa)', () => {
  const conAsignacion = (s: ReturnType<typeof armar>, active: boolean) => {
    s.prisma.usuario_empresas.findFirst = jest.fn().mockResolvedValue({ id: 'ue1', active });
    s.prisma.usuario_empresas.update = jest.fn(async ({ data }: any) => ({
      id: 'ue1',
      active: data.active,
      empresa: { razon_social: 'x' },
      usuario: { username: 'x' },
    }));
    return s;
  };

  it('un admin de la raíz activa la asignación inactiva de un dueño a la raíz → 403, sin grabar', async () => {
    const s = conAsignacion(armar(), false);
    await expect(s.toggleAccesoEmpresa('duenoOtra', 'holding', ...de('adminHolding'))).rejects.toThrow(
      'El acceso de un dueño de empresa a la holding raíz solo lo da un administrador de la plataforma.',
    );
    expect(s.prisma.usuario_empresas.update).not.toHaveBeenCalled();
  });

  it('desactivarla sí puede', async () => {
    const s = conAsignacion(armar(), true);
    await expect(s.toggleAccesoEmpresa('duenoOtra', 'holding', ...de('adminHolding'))).resolves.toEqual(
      expect.objectContaining({ message: 'Acceso desactivado' }),
    );
    expect(s.prisma.usuario_empresas.update).toHaveBeenCalledTimes(1);
  });

  it('la plataforma la activa; a un usuario común, también el admin de la raíz', async () => {
    const s = conAsignacion(armar(), false);
    await s.toggleAccesoEmpresa('duenoOtra', 'holding', ...de('plataforma'));
    await s.toggleAccesoEmpresa('cajeroOtra', 'holding', ...de('adminHolding'));
    expect(s.prisma.usuario_empresas.update).toHaveBeenCalledTimes(2);
  });
});

describe('listar usuarios: is_superadmin', () => {
  it('cada usuario trae is_superadmin (solo lectura) para que la pantalla oculte «Eliminar» al dueño', async () => {
    const s = armar();
    s.prisma.usuario.findMany.mockResolvedValue([
      { id: 'd', username: 'd', estado: 'Activo', active: true, verificado: true, is_superadmin: true, pin_supervisor: null },
      { id: 'e', username: 'e', estado: 'Activo', active: true, verificado: true, is_superadmin: false, pin_supervisor: null },
    ]);
    const r = await s.findAll(1, 10, undefined, ...de('adminKety'));
    expect(s.prisma.usuario.findMany.mock.calls[0][0].select.is_superadmin).toBe(true);
    expect(r.items.map((u: any) => [u.id, u.is_superadmin])).toEqual([['d', true], ['e', false]]);
  });
});
