import { ConflictException, ForbiddenException, NotFoundException } from '@nestjs/common';
import { exigirPermisosVentaPos } from './permisos-pos';
import { marcarSolicitudFacturadaEnTx, validarSolicitudCreditoVenta } from './solicitud-credito-venta';
import { FacturasService } from './facturas.service';

/**
 * I-A (re-revisión de la ola 5 de Existencias): `solicitud_credito_id` se aceptaba sin alcance. Con el id de cualquier
 * solicitud (rechazada, de otro cliente o de otra empresa) se salteaba el privilegio «Vender a crédito», la cuenta a cobrar
 * copiaba su política de cobro y la solicitud nunca pasaba a facturada. Ahora:
 * - se valida por empresa, cliente y estado aprobada ANTES de los permisos (404 / 409);
 * - el privilegio solo se saltea con la solicitud ya validada;
 * - dentro de la transacción se marca facturada con un UPDATE condicional (dos facturas con la misma solicitud → una sola).
 */
const cab = (over: any = {}) => ({ cliente_id: 'cli-1', condicion_operacion_id: 'cond', solicitud_credito_id: 'sol-1', ...over });

describe('validarSolicitudCreditoVenta', () => {
  const prismaCon = (fila: any) => ({ solicitud_credito: { findFirst: jest.fn().mockResolvedValue(fila) } });

  it('sin solicitud no consulta nada', async () => {
    const p = prismaCon(null);
    await expect(validarSolicitudCreditoVenta(p as any, 'emp-1', cab({ solicitud_credito_id: null }))).resolves.toBeNull();
    expect(p.solicitud_credito.findFirst).not.toHaveBeenCalled();
  });

  it('busca solo en la empresa, del cliente de la factura y activa', async () => {
    const p = prismaCon({ id: 'sol-1', estado: 'aprobada' });
    await expect(validarSolicitudCreditoVenta(p as any, 'emp-1', cab())).resolves.toEqual({ id: 'sol-1' });
    expect(p.solicitud_credito.findFirst).toHaveBeenCalledWith(
      expect.objectContaining({ where: { id: 'sol-1', empresa_id: 'emp-1', cliente_id: 'cli-1', active: true } }),
    );
  });

  it('de otra empresa u otro cliente: 404 SOLICITUD_NO_ENCONTRADA, sin datos de la otra', async () => {
    const e = await validarSolicitudCreditoVenta(prismaCon(null) as any, 'emp-1', cab()).catch((x) => x);
    expect(e).toBeInstanceOf(NotFoundException);
    expect(e.getResponse()).toMatchObject({ codigo: 'SOLICITUD_NO_ENCONTRADA' });
  });

  it.each(['rechazada', 'cancelada', 'facturada', 'pendiente_aprobacion'])('en estado %s: 409 SOLICITUD_NO_APROBADA', async (estado) => {
    const e = await validarSolicitudCreditoVenta(prismaCon({ id: 'sol-1', estado }) as any, 'emp-1', cab()).catch((x) => x);
    expect(e).toBeInstanceOf(ConflictException);
    expect(e.getResponse()).toMatchObject({ codigo: 'SOLICITUD_NO_APROBADA' });
  });
});

describe('exigirPermisosVentaPos con solicitud de crédito', () => {
  const prisma = {
    usuario: { findUnique: jest.fn().mockResolvedValue({ is_superadmin: false }) },
    perfiles_privilegios: { findFirst: jest.fn().mockResolvedValue(null) },
    condicion_operacion: { findUnique: jest.fn().mockResolvedValue({ codigo: 2 }) },
  };
  const venta = { cabecera: cab(), items: [], pagos: [] };

  it('el id de una solicitud sin validar no saltea «Vender a crédito» (403)', async () => {
    const e = await exigirPermisosVentaPos(prisma as any, 'u', venta, null).catch((x) => x);
    expect(e).toBeInstanceOf(ForbiddenException);
    expect(e.getResponse()).toMatchObject({ privilegio: 'VEN_POS_VENTA_CREDITO' });
  });

  it('una solicitud validada distinta de la de la venta tampoco', async () => {
    await expect(exigirPermisosVentaPos(prisma as any, 'u', venta, { id: 'otra' })).rejects.toThrow(/Vender a crédito/);
  });

  it('la solicitud aprobada y validada de la venta sí', async () => {
    await expect(exigirPermisosVentaPos(prisma as any, 'u', venta, { id: 'sol-1' })).resolves.toBeUndefined();
  });
});

describe('marcarSolicitudFacturadaEnTx', () => {
  const txCon = (count: number) => ({
    solicitud_credito: { updateMany: jest.fn().mockResolvedValue({ count }) },
    solicitud_credito_historial: { create: jest.fn().mockResolvedValue({}) },
  });
  const p = { solicitudId: 'sol-1', empresaId: 'emp-1', facturaId: 'fac-1', numero: '001-001-0000009', usuarioId: 'usr-1' };

  it('reclama la solicitud aprobada de la empresa, la deja facturada con la factura y anota el historial', async () => {
    const tx = txCon(1);
    await marcarSolicitudFacturadaEnTx(tx as any, p);
    expect(tx.solicitud_credito.updateMany).toHaveBeenCalledWith({
      where: { id: 'sol-1', empresa_id: 'emp-1', estado: 'aprobada' },
      data: expect.objectContaining({ estado: 'facturada', factura_id: 'fac-1' }),
    });
    expect(tx.solicitud_credito_historial.create).toHaveBeenCalledWith({
      data: expect.objectContaining({ solicitud_credito_id: 'sol-1', accion: 'facturado', usuario_id: 'usr-1', descripcion: 'Facturada: 001-001-0000009' }),
    });
  });

  it('dos facturas a la vez con la misma solicitud: la segunda no la gana → 409, sin historial', async () => {
    const tx = txCon(0);
    const e = await marcarSolicitudFacturadaEnTx(tx as any, p).catch((x) => x);
    expect(e).toBeInstanceOf(ConflictException);
    expect(e.getResponse()).toMatchObject({ codigo: 'SOLICITUD_NO_APROBADA' });
    expect(tx.solicitud_credito_historial.create).not.toHaveBeenCalled();
  });
});

describe('FacturasService.create: la solicitud se valida antes de los permisos', () => {
  it('con la solicitud de otra empresa: 404, sin mirar privilegios ni límites', async () => {
    const service = Object.create(FacturasService.prototype) as any;
    service.prisma = {
      factura_cab: { findFirst: jest.fn().mockResolvedValue(null) },
      solicitud_credito: { findFirst: jest.fn().mockResolvedValue(null) },
      usuario: { findUnique: jest.fn() },
      perfiles_privilegios: { findFirst: jest.fn() },
      condicion_operacion: { findUnique: jest.fn().mockResolvedValue({ codigo: 2 }) },
    };
    service.planLimits = { checkLimit: jest.fn() };
    service.logger = { error: jest.fn(), log: jest.fn() };
    const dto = { cabecera: cab(), items: [{}], pagos: [], subtotal: {} } as any;
    const e = await service.create(dto, 'emp-1', 'usr-1').catch((x: unknown) => x);
    expect(e).toBeInstanceOf(NotFoundException);
    expect(service.prisma.perfiles_privilegios.findFirst).not.toHaveBeenCalled();
    expect(service.planLimits.checkLimit).not.toHaveBeenCalled();
  });
});

describe('FacturasService.getDocumentosVinculados: solicitud y pedido de la empresa', () => {
  it('busca la solicitud y el pedido de origen con la empresa', async () => {
    const service = Object.create(FacturasService.prototype) as any;
    const vacio = jest.fn().mockResolvedValue([]);
    service.prisma = new Proxy(
      {
        factura_cab: { findFirst: jest.fn().mockResolvedValue({ id: 'fac-1', moneda: { codigo: 'PYG' }, pedido_id: 'ped-1', solicitud_credito_id: 'sol-1' }) },
        solicitud_credito: { findFirst: jest.fn().mockResolvedValue(null), findUnique: jest.fn().mockResolvedValue({ id: 'sol-1' }) },
        pedidos: { findFirst: jest.fn().mockResolvedValue(null), findUnique: jest.fn().mockResolvedValue({ id: 'ped-1' }) },
      } as any,
      { get: (t, k) => t[k] ?? { findMany: vacio, findFirst: jest.fn().mockResolvedValue(null), aggregate: jest.fn().mockResolvedValue({ _sum: {} }) } },
    );
    await service.getDocumentosVinculados('fac-1', 'emp-1').catch(() => undefined);
    expect(service.prisma.solicitud_credito.findUnique).not.toHaveBeenCalled();
    expect(service.prisma.solicitud_credito.findFirst).toHaveBeenCalledWith(expect.objectContaining({ where: { id: 'sol-1', empresa_id: 'emp-1' } }));
    expect(service.prisma.pedidos.findUnique).not.toHaveBeenCalled();
    expect(service.prisma.pedidos.findFirst).toHaveBeenCalledWith(expect.objectContaining({ where: { id: 'ped-1', empresa_id: 'emp-1' } }));
  });
});

describe('SolicitudesCreditoService.marcarFacturada (lo que llama la pantalla después de crear la factura)', () => {
  // eslint-disable-next-line @typescript-eslint/no-require-imports
  const { SolicitudesCreditoService } = require('src/solicitudes-credito/solicitudes-credito.service');
  const crear = (fila: any) => {
    const service = Object.create(SolicitudesCreditoService.prototype) as any;
    service.prisma = {
      solicitud_credito: { findFirst: jest.fn().mockResolvedValue(fila) },
      factura_cab: { findFirst: jest.fn().mockResolvedValue({ dest: '001', dpunexp: '001', dnumdoc: '0000001' }) },
      $transaction: jest.fn(),
    };
    service.findOneInternal = jest.fn().mockResolvedValue({ id: 'sol-1' });
    return service;
  };

  it('ya facturada por esa misma factura (la marcó la venta): responde bien sin escribir de nuevo', async () => {
    const service = crear({ id: 'sol-1', empresa_id: 'emp-1', estado: 'facturada', factura_id: 'fac-1' });
    await expect(service.marcarFacturada('sol-1', 'fac-1', 'emp-1', 'usr-1')).resolves.toMatchObject({ data: { id: 'sol-1' } });
    expect(service.prisma.$transaction).not.toHaveBeenCalled();
  });

  it('facturada por otra factura: sigue rechazando', async () => {
    const service = crear({ id: 'sol-1', empresa_id: 'emp-1', estado: 'facturada', factura_id: 'fac-otra' });
    await expect(service.marcarFacturada('sol-1', 'fac-1', 'emp-1', 'usr-1')).rejects.toThrow();
  });

  it('la solicitud y la factura se leen solo en la empresa, y la factura tiene que usar esa solicitud (m-E, ola 7)', async () => {
    const service = crear({ id: 'sol-1', empresa_id: 'emp-1', estado: 'facturada', factura_id: 'fac-1' });
    await service.marcarFacturada('sol-1', 'fac-1', 'emp-1', 'usr-1');
    expect(service.prisma.solicitud_credito.findFirst).toHaveBeenCalledWith({ where: { id: 'sol-1', empresa_id: 'emp-1' } });
    expect(service.prisma.factura_cab.findFirst).toHaveBeenCalledWith(
      expect.objectContaining({ where: expect.objectContaining({ id: 'fac-1', empresa_id: 'emp-1', solicitud_credito_id: 'sol-1' }) }),
    );
  });
});
