import { ForbiddenException } from '@nestjs/common';
import { esReimpresion, exigirPermisosVentaPos, VENTANA_IMPRESION_MIN } from './permisos-pos';

/**
 * H9 (serie POS): VEN_POS_VENTA_CREAR, VENTA_CREDITO y DESCUENTO estaban en los
 * perfiles pero el backend no los miraba. Ahora se exigen al crear la venta.
 */
const prismaCon = (privilegios: string[], codigoCondicion = 1) => ({
  usuario: { findUnique: jest.fn().mockResolvedValue({ is_superadmin: false }) },
  perfiles_privilegios: {
    findFirst: jest.fn(({ where }: any) =>
      Promise.resolve(where.privilegios.codigo.in.some((c: string) => privilegios.includes(c)) ? { id: 'pp' } : null),
    ),
  },
  condicion_operacion: { findUnique: jest.fn().mockResolvedValue({ codigo: codigoCondicion }) },
});

const venta = (over: any = {}) => ({
  cabecera: { condicion_operacion_id: 'cond', ...(over.cabecera ?? {}) },
  items: over.items ?? [{ descuento_global: 0 }],
  pagos: over.pagos ?? [{ sesion_caja_id: 'ses-1' }],
});

describe('exigirPermisosVentaPos', () => {
  it('venta cobrada en caja sin «Crear venta»: 403 con el motivo', async () => {
    const err = await exigirPermisosVentaPos(prismaCon([]) as any, 'u', venta()).catch((e) => e);
    expect(err).toBeInstanceOf(ForbiddenException);
    expect(err.getResponse()).toMatchObject({ codigo: 'SIN_PERMISO_POS', privilegio: 'VEN_POS_VENTA_CREAR' });
    expect(err.message).toMatch(/Crear venta/);
  });

  it('con «Crear venta» pasa; sin caja (cobro diferido o sin pagos) no lo pide', async () => {
    await expect(exigirPermisosVentaPos(prismaCon(['VEN_POS_VENTA_CREAR']) as any, 'u', venta())).resolves.toBeUndefined();
    await expect(
      exigirPermisosVentaPos(prismaCon([]) as any, 'u', venta({ cabecera: { cobro_diferido: true } })),
    ).resolves.toBeUndefined();
    await expect(exigirPermisosVentaPos(prismaCon([]) as any, 'u', venta({ pagos: [] }))).resolves.toBeUndefined();
  });

  it('a crédito pide «Vender a crédito», salvo una solicitud de crédito aprobada', async () => {
    const p = prismaCon([], 2);
    await expect(exigirPermisosVentaPos(p as any, 'u', venta({ pagos: [] }))).rejects.toThrow(/Vender a crédito/);
    await expect(
      exigirPermisosVentaPos(p as any, 'u', venta({ pagos: [], cabecera: { solicitud_credito_id: 'sol' } }), { id: 'sol' }),
    ).resolves.toBeUndefined();
    // El id solo, sin la solicitud validada (empresa, cliente y aprobada), no saltea nada.
    await expect(
      exigirPermisosVentaPos(p as any, 'u', venta({ pagos: [], cabecera: { solicitud_credito_id: 'sol' } }), null),
    ).rejects.toThrow(/Vender a crédito/);
    await expect(exigirPermisosVentaPos(prismaCon(['VEN_POS_VENTA_CREDITO'], 2) as any, 'u', venta({ pagos: [] }))).resolves.toBeUndefined();
  });

  it('descuento global pide «Aplicar descuento», salvo que venga del pedido', async () => {
    const p = prismaCon(['VEN_POS_VENTA_CREAR']);
    await expect(exigirPermisosVentaPos(p as any, 'u', venta({ items: [{ descuento_global: 500 }] }))).rejects.toThrow(
      /Aplicar descuento/,
    );
    await expect(
      exigirPermisosVentaPos(p as any, 'u', venta({ items: [{ descuento_global: 500 }], cabecera: { pedido_id: 'ped' } })),
    ).resolves.toBeUndefined();
  });

  it('superadmin pasa todo', async () => {
    const p = prismaCon([], 2);
    p.usuario.findUnique.mockResolvedValue({ is_superadmin: true });
    await expect(exigirPermisosVentaPos(p as any, 'u', venta({ items: [{ descuento_global: 1 }] }))).resolves.toBeUndefined();
  });
});

describe('esReimpresion', () => {
  it(`dentro de ${VENTANA_IMPRESION_MIN} min de la venta es la impresión de la venta; después, reimpresión`, () => {
    const ahora = new Date('2026-10-25T12:00:00Z');
    expect(esReimpresion(new Date('2026-10-25T11:55:00Z'), ahora)).toBe(false);
    expect(esReimpresion(new Date('2026-10-25T11:40:00Z'), ahora)).toBe(true);
  });
});

describe('KudeController — reimpresión del ticket', () => {
  // eslint-disable-next-line @typescript-eslint/no-require-imports
  const { KudeController } = require('../kude/kude.controller');
  const crear = (creada: Date, privilegios: string[]) => {
    const c = Object.create(KudeController.prototype);
    c.prisma = { ...prismaCon(privilegios), factura_cab: { findFirst: jest.fn().mockResolvedValue({ created_at: creada, dest: '001', dpunexp: '001', dnumdoc: '1' }) } };
    c.kudeService = { generateKudeFactura: jest.fn().mockResolvedValue({ pdfBuffer: Buffer.from('x'), contentType: 'application/pdf' }) };
    return c;
  };
  const res = () => ({ set: jest.fn(), send: jest.fn(), json: jest.fn() });
  const user = { id: 'u', empresa_id: 'e' };

  it('ticket de una venta vieja sin «Reimprimir comprobante»: 403', async () => {
    const c = crear(new Date(Date.now() - 60 * 60_000), []);
    await expect(c.generateKude({ documento_id: 'f', tipo_documento: 1, ticket: true }, user, res())).rejects.toThrow(/Reimprimir comprobante/);
    expect(c.kudeService.generateKudeFactura).not.toHaveBeenCalled();
  });

  it('el ticket recién vendida (o el KuDE A4) no lo pide', async () => {
    const c = crear(new Date(), []);
    await c.generateKude({ documento_id: 'f', tipo_documento: 1, ticket: true }, user, res());
    const c2 = crear(new Date(Date.now() - 60 * 60_000), []);
    await c2.generateKude({ documento_id: 'f', tipo_documento: 1, ticket: false }, user, res());
    expect(c.kudeService.generateKudeFactura).toHaveBeenCalled();
    expect(c2.kudeService.generateKudeFactura).toHaveBeenCalled();
  });

  it('KuDE A4 pedido desde el POS pasados 10 min: mismo criterio que el ticket', async () => {
    const vieja = crear(new Date(Date.now() - 60 * 60_000), []);
    await expect(
      vieja.generateKude({ documento_id: 'f', tipo_documento: 1, ticket: false, origen: 'pos' }, user, res()),
    ).rejects.toThrow(/reimprimir la factura.*Reimprimir comprobante/);
    expect(vieja.kudeService.generateKudeFactura).not.toHaveBeenCalled();

    const conPermiso = crear(new Date(Date.now() - 60 * 60_000), ['VEN_POS_REIMPRIMIR']);
    await conPermiso.generateKude({ documento_id: 'f', tipo_documento: 1, ticket: false, origen: 'pos' }, user, res());
    expect(conPermiso.kudeService.generateKudeFactura).toHaveBeenCalled();

    const recien = crear(new Date(), []);
    await recien.generateKude({ documento_id: 'f', tipo_documento: 1, ticket: false, origen: 'pos' }, user, res());
    expect(recien.kudeService.generateKudeFactura).toHaveBeenCalled();
  });
});
