import { BadRequestException, ConflictException, ForbiddenException, NotFoundException } from '@nestjs/common';
import { Prisma } from '@prisma/client';
import { UsersService } from './users.service';

/**
 * Carril D, Task 1 › DELETE /users/:id. Antes borraba sin más (dentro del alcance): el propio actor se borraba, un
 * Administrador borraba al dueño de la empresa y, si el usuario tenía movimientos, la FK reventaba en un 500 (o, con las
 * FK `SetNull`, se borraba dejando asientos, devoluciones o arqueos sin su usuario). Ahora:
 * 404 fuera de alcance · 400 a sí mismo · 403 el dueño, salvo la plataforma · 409 si cualquier tabla lo referencia.
 */
const empresas: Record<string, { parent_id: string | null; type: string }> = {
  holding: { parent_id: null, type: 'holding' },
  kety: { 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 },
  otraPlataforma: { empresa_id: 'holding' },
  adminKety: { empresa_id: 'kety' },
  adminHolding: { empresa_id: 'holding' },
  cajeroKety: { empresa_id: 'kety' },
  duenoKety: { empresa_id: 'kety', is_superadmin: true },
  cajeroAjena: { empresa_id: 'ajena' },
};

const armar = (referencias: Array<{ tabla: string; columna: string }> = []) => {
  const service = Object.create(UsersService.prototype) as any;
  const tx = {
    // El SELECT … FOR UPDATE del usuario devuelve su fila; la revisión de referencias, `referencias`.
    $queryRaw: jest.fn(async (sql: TemplateStringsArray) => (sql.join('?').includes('FOR UPDATE') ? [{ id: 'x' }] : referencias)),
    usuario_perfiles: { deleteMany: jest.fn().mockResolvedValue({ count: 1 }) },
    usuario: { delete: jest.fn(async ({ where }: any) => ({ id: where.id, username: where.id, empresa_id: usuarios[where.id]?.empresa_id, password: 'h', pin_supervisor: null })) },
  };
  service.prisma = {
    usuario: {
      findUnique: jest.fn(async ({ where }: any) => {
        const u = usuarios[where.id];
        if (!u) return null;
        return { id: where.id, username: where.id, nombres: where.id, estado: 'Activo', is_superadmin: false, ...u, es_admin_plataforma: where.id === 'plataforma' || where.id === 'otraPlataforma' };
      }),
      delete: tx.usuario.delete,
    },
    empresas: { findUnique: jest.fn(async ({ where }: any) => (empresas[where.id] ? { id: where.id, ...empresas[where.id] } : null)) },
    $queryRaw: jest.fn().mockResolvedValue([]),
    $transaction: jest.fn(async (fn: (t: typeof tx) => unknown) => fn(tx)),
  };
  service.auditService = { log: jest.fn() };
  service.logger = { log: jest.fn(), error: jest.fn(), warn: jest.fn() };
  return { s: service as any, tx };
};
const de = (id: string) => [id, usuarios[id].empresa_id] as const;

describe('DELETE /users/:id — borrar usuario seguro', () => {
  it('un actor de la empresa borra un usuario sin movimientos → borra (con sus perfiles), audita y responde { message }', async () => {
    const { s, tx } = armar();
    const res = await s.remove('cajeroKety', ...de('adminKety'));
    expect(tx.usuario.delete).toHaveBeenCalledWith({ where: { id: 'cajeroKety' } });
    expect(tx.usuario_perfiles.deleteMany).toHaveBeenCalledWith({ where: { user_id: 'cajeroKety' } });
    // Primero bloquea la fila del usuario, después revisa referencias, recién ahí borra (todo en la transacción).
    expect(tx.$queryRaw.mock.calls[0][0].join('?')).toContain('FOR UPDATE');
    expect(tx.$queryRaw.mock.calls[1][0].join('?')).toContain('pg_constraint');
    expect(tx.$queryRaw.mock.invocationCallOrder[1]).toBeLessThan(tx.usuario.delete.mock.invocationCallOrder[0]);
    expect(res).toEqual(expect.objectContaining({ message: expect.any(String) }));
    expect(JSON.stringify(res)).not.toContain('"password"');
    expect(s.auditService.log).toHaveBeenCalledWith(expect.objectContaining({ action: 'DELETE', entity_id: 'cajeroKety', user_id: 'adminKety' }));
  });

  it('con movimientos (lo referencia otra tabla, ej. su sesión de caja de una factura) → 409 USUARIO_CON_MOVIMIENTOS, sin borrar', async () => {
    const { s, tx } = armar([{ tabla: 'sesiones_caja', columna: 'user_id' }]);
    const err = await s.remove('cajeroKety', ...de('adminKety')).catch((e: unknown) => e);
    expect(err).toBeInstanceOf(ConflictException);
    expect((err as ConflictException).getResponse()).toEqual(expect.objectContaining({ codigo: 'USUARIO_CON_MOVIMIENTOS', message: expect.any(String) }));
    expect(tx.usuario.delete).not.toHaveBeenCalled();
    expect(s.auditService.log).not.toHaveBeenCalled();
  });

  it('una referencia que entra entre la revisión y el borrado (P2003) → 409, no 500', async () => {
    const { s, tx } = armar();
    tx.usuario.delete.mockRejectedValueOnce(new Prisma.PrismaClientKnownRequestError('fk', { code: 'P2003', clientVersion: 'x' }));
    const err = await s.remove('cajeroKety', ...de('adminKety')).catch((e: unknown) => e);
    expect(err).toBeInstanceOf(ConflictException);
    expect((err as ConflictException).getResponse()).toEqual(expect.objectContaining({ codigo: 'USUARIO_CON_MOVIMIENTOS' }));
    expect(s.auditService.log).not.toHaveBeenCalled();
  });

  it('a sí mismo → 400 NO_PUEDE_BORRARSE_A_SI_MISMO', async () => {
    const { s, tx } = armar();
    const err = await s.remove('adminKety', ...de('adminKety')).catch((e: unknown) => e);
    expect(err).toBeInstanceOf(BadRequestException);
    expect((err as BadRequestException).getResponse()).toEqual(expect.objectContaining({ codigo: 'NO_PUEDE_BORRARSE_A_SI_MISMO' }));
    expect(tx.usuario.delete).not.toHaveBeenCalled();
  });

  it('un Administrador borra al dueño (is_superadmin) de su empresa → 403', async () => {
    const { s, tx } = armar();
    await expect(s.remove('duenoKety', ...de('adminKety'))).rejects.toBeInstanceOf(ForbiddenException);
    expect(tx.usuario.delete).not.toHaveBeenCalled();
  });

  it('un administrador de la plataforma (es_admin_plataforma, aunque no sea is_superadmin) solo lo borra la plataforma', async () => {
    const { s, tx } = armar();
    await expect(s.remove('otraPlataforma', ...de('adminHolding'))).rejects.toBeInstanceOf(ForbiddenException);
    expect(tx.usuario.delete).not.toHaveBeenCalled();
    await s.remove('otraPlataforma', ...de('plataforma'));
    expect(tx.usuario.delete).toHaveBeenCalledWith({ where: { id: 'otraPlataforma' } });
  });

  it('un usuario de otra empresa fuera de la red → 404, sin borrar', async () => {
    const { s, tx } = armar();
    await expect(s.remove('cajeroAjena', ...de('adminKety'))).rejects.toBeInstanceOf(NotFoundException);
    expect(tx.usuario.delete).not.toHaveBeenCalled();
    expect(tx.$queryRaw).not.toHaveBeenCalled();
  });

  it('la plataforma borra a un dueño sin movimientos → 200', async () => {
    const { s, tx } = armar();
    await expect(s.remove('duenoKety', ...de('plataforma'))).resolves.toEqual(expect.objectContaining({ message: expect.any(String) }));
    expect(tx.usuario.delete).toHaveBeenCalledWith({ where: { id: 'duenoKety' } });
  });
});
