import * as XLSX from 'xlsx';
import { ReportesProveedorService } from './reportes-proveedor.service';
import { alcanceSucursalUsuario } from '../utils/alcance-sucursal';

jest.mock('../utils/alcance-sucursal', () => ({ alcanceSucursalUsuario: jest.fn().mockResolvedValue(null) }));
// Estos tests son de monedas: el usuario ve el costo. El recorte por permiso está en reportes-proveedor.costo.spec.ts.
jest.mock('src/productos/permisos-columnas', () => ({ resolverPermisos: jest.fn((_p: unknown, _u: string, pedidos: string[]) => Promise.resolve(new Set(pedidos))) }));

const MONEDAS: Record<string, string> = { 'm-pyg': 'PYG', 'm-brl': 'BRL' };

/** `base`: id de la moneda principal de la empresa. */
function crear(base = 'm-pyg') {
  const prisma: any = {
    proveedores: { findFirst: jest.fn().mockResolvedValue({ id: 'prov', personas: { razon_social: 'Prov SA', ruc: '80000001', email: 'p@x.com' } }) },
    empresas: { findUnique: jest.fn().mockResolvedValue({ razon_social: 'Emp SA' }) },
    empresa_monedas: { findFirst: jest.fn().mockResolvedValue({ moneda_id: base }) },
    moneda: {
      findFirst: jest.fn().mockResolvedValue({ id: 'm-pyg' }),
      findUnique: jest.fn(({ where }: any) => Promise.resolve(MONEDAS[where.id] ? { id: where.id, codigo: MONEDAS[where.id] } : null)),
    },
    proveedor_marca: { count: jest.fn().mockResolvedValue(2) },
    $queryRaw: jest.fn(),
    $queryRawUnsafe: jest.fn(),
  };
  const mail: any = { sendProveedorVencidosReport: jest.fn() };
  return { service: new ReportesProveedorService(prisma, mail), prisma, mail };
}

/** Texto y valores de una llamada a `$queryRaw` con template tag. */
function sqlDe(call: any[]): { texto: string; valores: unknown[] } {
  const [strings, ...valores] = call;
  return { texto: (strings as string[]).join('?'), valores };
}

function hoja(buffer: Buffer): unknown[][] {
  const wb = XLSX.read(buffer, { type: 'buffer' });
  return XLSX.utils.sheet_to_json(wb.Sheets[wb.SheetNames[0]], { header: 1 });
}

const COMPRAS = [
  { marca_id: 'm1', marca: 'ACME', moneda_codigo: 'PYG', cantidad_compras: 2, cantidad_productos: 1, unidades: 10, monto_total: 1500000.5, vinculado: true },
  { marca_id: 'm1', marca: 'ACME', moneda_codigo: 'USD', cantidad_compras: 1, cantidad_productos: 1, unidades: 4, monto_total: 120.25, vinculado: 't' },
  { marca_id: 'm2', marca: 'BETA', moneda_codigo: 'PYG', cantidad_compras: 1, cantidad_productos: 1, unidades: 1, monto_total: 0.1, vinculado: false },
];

const VENTAS = [
  { marca_id: 'm1', marca: 'ACME', producto_id: 'p1', producto_codigo: 'P1', producto_descripcion: 'Uno', moneda_codigo: 'PYG', cantidad_facturas: 3, unidades: 5, monto_vendido: 500000, costo_total: 300000 },
  { marca_id: 'm1', marca: 'ACME', producto_id: 'p1', producto_codigo: 'P1', producto_descripcion: 'Uno', moneda_codigo: 'USD', cantidad_facturas: 1, unidades: 1, monto_vendido: 15.5, costo_total: 70000 },
];

const LOTES = [
  { lote_id: 'l1', numero_lote: 'L1', fecha_vencimiento: new Date('2020-01-01T00:00:00Z'), producto_id: 'p1', producto_codigo: 'P1', producto_descripcion: 'Uno', marca: 'ACME', deposito: 'Central', stock_actual: 2, costo_unitario: 1000.1, costo_total: 2000.2 },
  { lote_id: 'l2', numero_lote: 'L2', fecha_vencimiento: new Date('2020-02-01T00:00:00Z'), producto_id: 'p1', producto_codigo: 'P1', producto_descripcion: 'Uno', marca: 'ACME', deposito: 'Central', stock_actual: 1, costo_unitario: 0.1, costo_total: 0.1 },
];

afterEach(() => {
  jest.restoreAllMocks();
  (alcanceSucursalUsuario as jest.Mock).mockClear().mockResolvedValue(null);
});

describe('marcasCompradas: una fila por marca y moneda del documento', () => {
  it('compras en PYG y USD de la misma marca salen en dos filas con su moneda y sus montos', async () => {
    const { service, prisma } = crear();
    prisma.$queryRaw.mockResolvedValue(COMPRAS);
    const rows: any[] = await service.marcasCompradas('emp', 'prov', {});
    expect(rows.map((r) => [r.marca_id, r.moneda.codigo, r.monto_total])).toEqual([
      ['m1', 'PYG', 1500000.5],
      ['m1', 'USD', 120.25],
      ['m2', 'PYG', 0.1],
    ]);
    expect(rows[1].vinculado).toBe(true);
    expect(rows[0]).not.toHaveProperty('moneda_codigo');
  });

  it('agrupa por la moneda de compra_cab y una compra sin moneda cae en la base de la empresa', async () => {
    const { service, prisma } = crear('m-brl');
    prisma.$queryRaw.mockResolvedValue([]);
    await service.marcasCompradas('emp', 'prov', {});
    const { texto, valores } = sqlDe(prisma.$queryRaw.mock.calls[0]);
    expect(texto).toMatch(/LEFT JOIN moneda mo\s+ON mo\.id = cc\.moneda_id/);
    expect(texto).toContain('COALESCE(mo.codigo, ?) AS moneda_codigo');
    expect(texto).toMatch(/GROUP BY m\.id, m\.descripcion, moneda_codigo/);
    expect(valores).toContain('BRL');
  });
});

describe('ventasPorMarca: una fila por marca, producto y moneda de la factura', () => {
  it.each(['lote', 'vinculo'] as const)('modo %s: monto en la moneda de la factura y costo en la base', async (modo) => {
    const { service, prisma } = crear('m-brl');
    (modo === 'lote' ? prisma.$queryRaw : prisma.$queryRawUnsafe).mockResolvedValue(VENTAS);
    const { rows } = (await service.ventasPorMarca('emp', 'prov', { modo }, 'usr')) as any;
    expect(rows.map((r: any) => [r.moneda.codigo, r.monto_vendido, r.moneda_costo, r.costo_total])).toEqual([
      ['PYG', 500000, 'BRL', 300000],
      ['USD', 15.5, 'BRL', 70000],
    ]);
    expect(rows[0]).not.toHaveProperty('moneda_codigo');
  });

  it('modo lote: agrupa por fc.moneda_id con la base para la factura sin moneda', async () => {
    const { service, prisma } = crear('m-brl');
    prisma.$queryRaw.mockResolvedValue([]);
    await service.ventasPorMarca('emp', 'prov', { modo: 'lote' });
    const { texto, valores } = sqlDe(prisma.$queryRaw.mock.calls[0]);
    expect(texto).toMatch(/LEFT JOIN moneda mo\s+ON mo\.id = fc\.moneda_id/);
    expect(texto).toContain('COALESCE(mo.codigo, ?) AS moneda_codigo');
    expect(texto).toMatch(/GROUP BY m\.id, m\.descripcion, p\.id, p\.cod_producto, p\.descripcion, moneda_codigo/);
    expect(texto).toMatch(/ORDER BY m\.descripcion ASC, monto_vendido DESC/);
    expect(valores).toContain('BRL');
  });

  it('modo vínculo: agrupa por fc.moneda_id con la base vinculada como parámetro', async () => {
    const { service, prisma } = crear('m-brl');
    prisma.$queryRawUnsafe.mockResolvedValue([]);
    await service.ventasPorMarca('emp', 'prov', { modo: 'vinculo' });
    const [texto, ...args] = prisma.$queryRawUnsafe.mock.calls[0];
    const n = args.indexOf('BRL') + 1;
    expect(n).toBeGreaterThan(0);
    expect(texto).toMatch(/LEFT JOIN moneda mo\s+ON mo\.id = fc\.moneda_id/);
    expect(texto).toContain(`COALESCE(mo.codigo, $${n}) AS moneda_codigo`);
    expect(texto).toMatch(/GROUP BY .*pm\.es_distribuidor_oficial, moneda_codigo/);
    expect(texto).toMatch(/ORDER BY m\.descripcion ASC, monto_vendido DESC/);
  });
});

describe('exports de marcas y ventas: columna Moneda y un total por moneda', () => {
  it('Excel de marcas compradas: columna Moneda y una fila de total por moneda', async () => {
    const { service, prisma } = crear();
    prisma.$queryRaw.mockResolvedValue(COMPRAS);
    const filas = hoja(await service.exportarMarcasCompradasExcel('emp', 'prov', {}, 'usr'));
    const enc = filas[0] as string[];
    expect(enc).toContain('Moneda');
    const iMarca = enc.indexOf('Marca');
    const iMoneda = enc.indexOf('Moneda');
    const iMonto = enc.indexOf('Monto Total');
    const totales = filas.filter((f: any[]) => String(f[iMarca]).startsWith('Total'));
    expect(totales.map((f: any[]) => [f[iMoneda], f[iMonto]])).toEqual([
      ['PYG', 1500000.6],
      ['USD', 120.25],
    ]);
    expect(filas.slice(1, 4).map((f: any[]) => f[iMoneda])).toEqual(['PYG', 'USD', 'PYG']);
  });

  it('Excel de ventas por marca: Moneda, Moneda costo y un total por moneda', async () => {
    const { service, prisma } = crear();
    prisma.$queryRawUnsafe.mockResolvedValue(VENTAS);
    const filas = hoja(await service.exportarVentasPorMarcaExcel('emp', 'prov', {}, 'usr'));
    const enc = filas[0] as string[];
    expect(enc).toEqual(expect.arrayContaining(['Moneda', 'Monto Vendido', 'Moneda costo', 'Costo']));
    const i = (c: string) => enc.indexOf(c);
    const totales = filas.filter((f: any[]) => String(f[i('Marca')]).startsWith('Total'));
    expect(totales.map((f: any[]) => [f[i('Moneda')], f[i('Monto Vendido')], f[i('Moneda costo')], f[i('Costo')]])).toEqual([
      ['PYG', 500000, 'PYG', 300000],
      ['USD', 15.5, 'PYG', 70000],
    ]);
  });

  it('PDF de marcas: columna de moneda y totales por moneda, nunca uno solo', async () => {
    const { service, prisma } = crear();
    prisma.$queryRaw.mockResolvedValue(COMPRAS);
    const fetchMock = jest.spyOn(global, 'fetch' as any).mockResolvedValue({ ok: true, arrayBuffer: () => Promise.resolve(new ArrayBuffer(1)) } as any);
    await service.exportarMarcasCompradasPDF('emp', 'prov', {}, 'usr');
    const body = JSON.parse((fetchMock.mock.calls[0][1] as any).body);
    expect(body.columns.map((c: any) => c.key)).toContain('moneda_codigo');
    expect(body.columns.find((c: any) => c.key === 'monto_total').type).toBe('number');
    expect(body.rows.map((r: any) => r.moneda_codigo)).toEqual(['PYG', 'USD', 'PYG']);
    expect(body.totales).toEqual([
      { label: 'Total compras PYG', value: 1500000.6, type: 'number' },
      { label: 'Total compras USD', value: 120.25, type: 'number' },
    ]);
  });

  it('PDF de ventas con una sola moneda: monto como moneda de esa moneda y su total', async () => {
    const { service, prisma } = crear();
    prisma.$queryRawUnsafe.mockResolvedValue([{ ...VENTAS[1] }]);
    const fetchMock = jest.spyOn(global, 'fetch' as any).mockResolvedValue({ ok: true, arrayBuffer: () => Promise.resolve(new ArrayBuffer(1)) } as any);
    await service.exportarVentasPorMarcaPDF('emp', 'prov', {}, 'usr');
    const body = JSON.parse((fetchMock.mock.calls[0][1] as any).body);
    expect(body.moneda).toBe('USD');
    expect(body.columns.find((c: any) => c.key === 'monto_vendido').type).toBe('currency');
    expect(body.totales).toEqual([{ label: 'Total vendido USD', value: 15.5, type: 'currency' }]);
  });

  it('los exports respetan el alcance de sucursal del usuario', async () => {
    const { service, prisma } = crear();
    prisma.$queryRaw.mockResolvedValue([]);
    prisma.$queryRawUnsafe.mockResolvedValue([]);
    await service.exportarMarcasCompradasExcel('emp', 'prov', {}, 'usr-1');
    await service.exportarVentasPorMarcaExcel('emp', 'prov', {}, 'usr-2');
    const usuarios = (alcanceSucursalUsuario as jest.Mock).mock.calls.map((c) => c[1]);
    expect(usuarios).toEqual(expect.arrayContaining(['usr-1', 'usr-2']));
  });
});

describe('vencidos, próximos y resumen: el costo rotulado en la base', () => {
  it('cada fila de vencidos trae moneda_costo = base', async () => {
    const { service, prisma } = crear('m-brl');
    prisma.$queryRawUnsafe.mockResolvedValue(LOTES);
    const rows = await service.vencidos('emp', 'prov', {}, 'usr');
    expect(rows.map((r) => r.moneda_costo)).toEqual(['BRL', 'BRL']);
  });

  it('próximos a vencer: filas y totales con moneda_costo', async () => {
    const { service, prisma } = crear('m-brl');
    prisma.$queryRawUnsafe.mockResolvedValue([]);
    const r: any = await service.proximosVencer('emp', 'prov', { dias: 30 }, 'usr');
    expect(r.moneda_costo).toBe('BRL');
  });

  it('resumen: moneda_costo y el valor vencido sumado sin error de coma flotante', async () => {
    const { service, prisma } = crear('m-brl');
    prisma.$queryRawUnsafe.mockResolvedValueOnce(LOTES).mockResolvedValueOnce([]);
    const r: any = await service.resumen('emp', 'prov', 'usr');
    expect(r.moneda_costo).toBe('BRL');
    expect(r.valor_lotes_vencidos).toBe(2000.3);
  });

  it('stock por marcas: valor_total rotulado con moneda_costo = base', async () => {
    const { service, prisma } = crear('m-brl');
    prisma.$queryRawUnsafe.mockResolvedValue([{ marca_id: 'm1', marca: 'ACME', cantidad_productos: 1, stock_total: 3, valor_total: 3000.3 }]);
    const rows: any[] = await service.stockMarcas('emp', 'prov', {}, 'usr');
    expect(rows).toEqual([expect.objectContaining({ valor_total: 3000.3, moneda_costo: 'BRL' })]);
  });

  it('resumen consulta la moneda base una sola vez', async () => {
    const { service, prisma } = crear('m-brl');
    prisma.$queryRawUnsafe.mockResolvedValue([]);
    await service.resumen('emp', 'prov', 'usr');
    expect(prisma.empresa_monedas.findFirst).toHaveBeenCalledTimes(1);
  });

  it('Excel de vencidos rotula el costo con su moneda', async () => {
    const { service, prisma } = crear('m-brl');
    prisma.$queryRawUnsafe.mockResolvedValue(LOTES);
    const filas = hoja(await service.exportarVencidosExcel('emp', 'prov', {}, 'usr'));
    const enc = filas[0] as string[];
    expect(enc).toContain('Moneda costo');
    expect(filas.slice(1).map((f: any[]) => f[enc.indexOf('Moneda costo')])).toEqual(['BRL', 'BRL']);
  });

  it('PDF de vencidos va con la moneda base, no PYG fijo', async () => {
    const { service, prisma } = crear('m-brl');
    prisma.$queryRawUnsafe.mockResolvedValue(LOTES);
    const fetchMock = jest.spyOn(global, 'fetch' as any).mockResolvedValue({ ok: true, arrayBuffer: () => Promise.resolve(new ArrayBuffer(1)) } as any);
    await service.exportarVencidosPDF('emp', 'prov', {}, 'usr');
    expect(JSON.parse((fetchMock.mock.calls[0][1] as any).body).moneda).toBe('BRL');
  });

  it('email de vencidos: el total con el código de la base y el adjunto con el alcance del usuario', async () => {
    const { service, prisma, mail } = crear('m-pyg');
    prisma.$queryRawUnsafe.mockResolvedValue(LOTES);
    const r: any = await service.enviarVencidosEmail('emp', 'prov', {}, 'usr-9');
    expect(mail.sendProveedorVencidosReport.mock.calls[0][0].totalCosto).toBe('Gs. 2.000');
    expect(r.moneda_costo).toBe('PYG');
    expect((alcanceSucursalUsuario as jest.Mock).mock.calls.every((c) => c[1] === 'usr-9')).toBe(true);
  });
});
