import 'reflect-metadata';
import { HttpException } from '@nestjs/common';
import { plainToInstance } from 'class-transformer';
import { validate } from 'class-validator';
import { alcanceSucursalUsuario } from '../utils/alcance-sucursal';
import { EnviarVencidosEmailDto } from './dto/enviar-vencidos-email.dto';
import { fechaParaGeneradorPdf, ReportesProveedorService } from './reportes-proveedor.service';

jest.mock('../utils/alcance-sucursal', () => ({ alcanceSucursalUsuario: jest.fn().mockResolvedValue(null) }));
jest.mock('src/productos/permisos-columnas', () => ({ resolverPermisos: jest.fn((_p: unknown, _u: string, pedidos: string[]) => Promise.resolve(new Set(pedidos))) }));

const LOTE = { lote_id: 'l1', numero_lote: 'L1', fecha_vencimiento: new Date('2026-09-30T00:00:00Z'), producto_id: 'p1', producto_codigo: 'P1', producto_descripcion: 'Uno', marca: 'ACME', deposito: 'Central', stock_actual: 2, costo_unitario: 1000, costo_total: 2000 };
const MARCA = { marca_id: 'm1', marca: 'ACME', moneda_codigo: 'PYG', cantidad_compras: 1, cantidad_productos: 1, unidades: 2, monto_total: 5000, ultima_compra: new Date('2026-11-06T00:00:00Z'), primera_compra: new Date('2026-11-01T00:00:00Z'), vinculado: true };

function crear() {
  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: 'm-pyg' }) },
    moneda: { findFirst: jest.fn().mockResolvedValue({ id: 'm-pyg' }), findUnique: jest.fn().mockResolvedValue({ id: 'm-pyg', codigo: 'PYG' }) },
    proveedor_marca: { count: jest.fn().mockResolvedValue(1) },
    $queryRaw: jest.fn().mockResolvedValue([MARCA]),
    $queryRawUnsafe: jest.fn().mockResolvedValue([LOTE]),
  };
  const mail: any = { sendProveedorVencidosReport: jest.fn() };
  return { service: new ReportesProveedorService(prisma, mail), prisma, mail };
}
const cuerpo = (f: jest.SpyInstance) => JSON.parse((f.mock.calls[0][1] as any).body);
const fetchOk = () => jest.spyOn(global, 'fetch' as any).mockResolvedValue({ ok: true, arrayBuffer: () => Promise.resolve(new ArrayBuffer(1)) } as any);

beforeEach(() => (alcanceSucursalUsuario as jest.Mock).mockResolvedValue(null));
afterEach(() => jest.restoreAllMocks());

describe('PDF del reporte por proveedor: las fechas de día van al mediodía UTC', () => {
  it('fechaParaGeneradorPdf: Date o YYYY-MM-DD; lo demás pasa igual', () => {
    expect(fechaParaGeneradorPdf(new Date('2026-09-30T00:00:00Z'))).toBe('2026-09-30T12:00:00.000Z');
    expect(fechaParaGeneradorPdf('2026-11-05')).toBe('2026-11-05T12:00:00.000Z');
    expect(fechaParaGeneradorPdf(null)).toBeNull();
    expect(fechaParaGeneradorPdf('TOTAL')).toBe('TOTAL');
  });

  it('vencidos con costo: desde, hasta, generado (hora de Asunción) y vencimiento del lote', async () => {
    jest.useFakeTimers({ now: new Date('2026-11-08T01:30:00Z'), doNotFake: ['nextTick', 'setImmediate', 'setTimeout', 'setInterval', 'queueMicrotask'] });
    try {
      const f = fetchOk();
      await crear().service.exportarVencidosPDF('emp', 'prov', { desde: '2026-09-01', hasta: '2026-11-05' }, 'usr');
      const b = cuerpo(f);
      expect(b.desde).toBe('2026-09-01T12:00:00.000Z');
      expect(b.hasta).toBe('2026-11-05T12:00:00.000Z');
      expect(b.generado_en).toBe('2026-11-07T12:00:00.000Z');
      expect(b.items[0].fecha_vencimiento).toBe('2026-09-30T12:00:00.000Z');
      // Con un proceso en UTC-3 o en UTC el día que lee el generador es el mismo.
      for (const iso of [b.desde, b.hasta, b.generado_en, b.items[0].fecha_vencimiento]) expect(new Date(iso).toISOString().slice(0, 10)).toBe(iso.slice(0, 10));
    } finally {
      jest.useRealTimers();
    }
  });

  it('marcas compradas: «Última» al mediodía UTC', async () => {
    const f = fetchOk();
    await crear().service.exportarMarcasCompradasPDF('emp', 'prov', { desde: '2026-11-01', hasta: '2026-11-07' }, 'usr');
    const b = cuerpo(f);
    expect(b.desde).toBe('2026-11-01T12:00:00.000Z');
    expect(b.rows[0].ultima_compra).toBe('2026-11-06T12:00:00.000Z');
  });
});

describe('enviar por email', () => {
  it('error del SMTP: 502 con mensaje de dominio, sin exponer el error original', async () => {
    const { service, prisma, mail } = crear();
    prisma.$queryRawUnsafe.mockResolvedValue([LOTE]);
    mail.sendProveedorVencidosReport.mockRejectedValue(Object.assign(new Error('Invalid login: 535 smtp-user@x.com BadCredentials'), { code: 'EAUTH' }));
    const e: any = await service.enviarVencidosEmail('emp', 'prov', {}, 'usr').catch((x) => x);
    expect(e).toBeInstanceOf(HttpException);
    expect(e.getStatus()).toBe(502);
    expect(e.getResponse().message).toMatch(/^No se pudo enviar el correo: revisá la configuración de correo/);
    expect(JSON.stringify(e.getResponse())).not.toMatch(/535|smtp-user|BadCredentials/);
  });

  it('DTO: un destino mal formado es 400 con mensaje claro; vacío o ausente se acepta', async () => {
    const errores = async (o: object) => validate(plainToInstance(EnviarVencidosEmailDto, o));
    const mal = await errores({ email: 'no-es-mail' });
    expect(mal[0].constraints?.isEmail).toBe('El email de destino no es válido.');
    expect(await errores({ email: 'ok@dominio.com', desde: '2026-11-01' })).toHaveLength(0);
    expect(await errores({ email: '' })).toHaveLength(0);
    expect(await errores({})).toHaveLength(0);
  });
});
