import { BadRequestException } from '@nestjs/common';
import type { Job } from 'bullmq';
import { GastosImportadorProcessor } from './gastos-importador.processor';
import { resolverMapeoColumnas } from './normalizadores/libro-compras-set.normalizador';

const EMPRESA = 'emp-1';
const USUARIO = 'usr-1';
const JOB = 'job-1';
const MEDIO = '11111111-1111-4111-8111-111111111111';
const CUENTA = '22222222-2222-4222-8222-222222222222';
const CDC = '01800111111001001000012322026050510000000001';

const HEADERS = [
  'RUC / Nº de Identificacion del Informado',
  'Nombre o Razón Social del Informado',
  'Fecha de Emisión',
  'Condicion de la Operacion',
  'Timbrado del Comprobante',
  'Numero de Comprobante',
  'CDC',
  'Monto Gravado 10%',
  'IVA 10%',
  'Total Comprobante',
  'TIPO CUENTA CONTABLE- GASTO',
  'TIPO CUENTA CONTABLE- CONTRAPARTIDA PASIVA',
];

function fila(id: string, forma: 'CONTADO' | 'CREDITO', cdc = '') {
  return {
    id,
    job_id: JOB,
    empresa_id: EMPRESA,
    fila_numero: 1,
    estado: 'valida',
    ruc: '80011111',
    razon_social: 'EJEMPLO SA',
    tipo_gasto_id: 'tg-1',
    tipo_gasto_texto: 'COMBUSTIBLE',
    fecha_emision: new Date('2026-05-05T00:00:00.000Z'),
    timbrado: '12345678',
    establecimiento: '001',
    punto_expedicion: '001',
    numero_factura: '0000123',
    forma_pago: forma,
    monto_gravado_10: '220000',
    monto_gravado_5: '0',
    monto_no_gravado: '0',
    total_comprobante: '220000',
    raw: {
      'RUC / Nº de Identificacion del Informado': '80011111',
      'Nombre o Razón Social del Informado': 'EJEMPLO SA',
      'Fecha de Emisión': '05/05/2026',
      'Condicion de la Operacion': forma,
      'Timbrado del Comprobante': '12345678',
      'Numero de Comprobante': '001-001-0000123',
      CDC: cdc,
      'Monto Gravado 10%': 220000,
      'IVA 10%': 20000,
      'Total Comprobante': 220000,
      'TIPO CUENTA CONTABLE- GASTO': 'COMBUSTIBLE',
      'TIPO CUENTA CONTABLE- CONTRAPARTIDA PASIVA': 'ACREEDORES VARIOS',
    },
  };
}

function crearProcesador(configDefaults: Record<string, unknown> | null, filas: ReturnType<typeof fila>[]) {
  const prisma = {
    gasto_importacion_jobs: {
      findUnique: jest.fn().mockResolvedValue({
        id: JOB,
        empresa_id: EMPRESA,
        usuario_id: USUARIO,
        nombre_archivo: 'libro.xlsx',
        mapeo_columnas: resolverMapeoColumnas(HEADERS),
        config_defaults: configDefaults,
      }),
      update: jest.fn().mockResolvedValue({}),
    },
    gasto_importacion_filas: {
      findMany: jest.fn().mockResolvedValue(filas),
      updateMany: jest.fn().mockResolvedValue({ count: 1 }),
    },
    // El medio "Pago por anticipo" (código SIFEN 11) para las filas de anticipo de viático.
    medio_pago: { findFirst: jest.fn().mockResolvedValue({ id: 'mp-anticipo' }) },
  };
  const gastosService = {
    create: jest.fn().mockResolvedValue({ id: 'gasto-creado' }),
    crearImportado: jest.fn().mockResolvedValue({ id: 'gasto-creado' }),
    crearHistoricoImportado: jest.fn().mockResolvedValue({ id: 'gasto-historico' }),
  };
  const proveedorResolver = {
    resolverTipoEntidad: jest.fn().mockReturnValue({ tipoEntidad: 'ACREEDOR_VARIO', esExtranjero: false }),
    findOrCreateProveedor: jest.fn().mockResolvedValue({ proveedorId: 'prov-1', creado: false }),
  };
  const procesador = new GastosImportadorProcessor(prisma as never, gastosService as never, proveedorResolver as never);
  const correr = () => procesador.process({ data: { jobId: JOB } } as Job<{ jobId: string }>);
  return { correr, prisma, gastosService };
}

describe('GastosImportadorProcessor (Task 11)', () => {
  it('HISTORICO: la fila contado va por crearHistoricoImportado con la fila y sin medio', async () => {
    const { correr, gastosService } = crearProcesador({ sucursal_id: 'suc-1', pago: 'HISTORICO' }, [fila('f-1', 'CONTADO')]);

    await correr();

    expect(gastosService.crearImportado).not.toHaveBeenCalled();
    expect(gastosService.crearHistoricoImportado).toHaveBeenCalledTimes(1);
    const [dto, filaId] = gastosService.crearHistoricoImportado.mock.calls[0];
    expect(filaId).toBe('f-1');
    expect(dto.cabecera).toEqual(expect.objectContaining({ proveedor_id: 'prov-1', sucursal_id: 'suc-1', forma_pago: 'CONTADO' }));
    expect(dto.cabecera.medio_pago_id).toBeUndefined();
    expect(dto.cabecera.cuenta_tesoreria_id).toBeUndefined();
  });

  it('AHORA: la fila contado lleva medio y cuenta y va por crearImportado con la fila', async () => {
    const { correr, gastosService } = crearProcesador({ pago: 'AHORA', medio_pago_id: MEDIO, cuenta_tesoreria_id: CUENTA }, [fila('f-1', 'CONTADO')]);

    await correr();

    expect(gastosService.crearHistoricoImportado).not.toHaveBeenCalled();
    expect(gastosService.create).not.toHaveBeenCalled();
    const [dto, filaId] = gastosService.crearImportado.mock.calls[0];
    expect(filaId).toBe('f-1');
    expect(dto.cabecera).toEqual(expect.objectContaining({ forma_pago: 'CONTADO', medio_pago_id: MEDIO, cuenta_tesoreria_id: CUENTA }));
  });

  it.each(['HISTORICO', 'AHORA'])('%s: la fila crédito va por crearImportado sin medio ni vencimiento', async (pago) => {
    const { correr, gastosService } = crearProcesador({ pago, medio_pago_id: MEDIO }, [fila('f-1', 'CREDITO')]);

    await correr();

    expect(gastosService.crearHistoricoImportado).not.toHaveBeenCalled();
    const [dto, filaId] = gastosService.crearImportado.mock.calls[0];
    expect(filaId).toBe('f-1');
    expect(dto.cabecera.forma_pago).toBe('CREDITO');
    expect(dto.cabecera.medio_pago_id).toBeUndefined();
    expect(dto.cabecera.fecha_vencimiento).toBeUndefined();
  });

  it('CDC de 44 dígitos → es_preimpreso false; sin CDC → true', async () => {
    const { correr, gastosService } = crearProcesador({ pago: 'HISTORICO' }, [fila('f-1', 'CREDITO', CDC), fila('f-2', 'CREDITO')]);

    await correr();

    expect(gastosService.crearImportado.mock.calls[0][0].cabecera.es_preimpreso).toBe(false);
    expect(gastosService.crearImportado.mock.calls[1][0].cabecera.es_preimpreso).toBe(true);
  });

  it('guarda el CDC solo si su dígito verificador es válido (los separadores se limpian)', async () => {
    const valido = '01800111111001001000012322026050510000000007';
    const { correr, gastosService } = crearProcesador({ pago: 'HISTORICO' }, [
      fila('f-1', 'CREDITO', `0180 0111 ${valido.slice(8)}`),
      fila('f-2', 'CREDITO', CDC),
    ]);

    await correr();

    expect(gastosService.crearImportado.mock.calls[0][0].cabecera).toMatchObject({ cdc: valido, es_preimpreso: false });
    // 44 dígitos con el verificador mal: electrónico, pero el CDC no se guarda.
    expect(gastosService.crearImportado.mock.calls[1][0].cabecera.cdc).toBeUndefined();
  });

  it('graba el proveedor en la fila (todavía valida) antes del alta, que la toma en su transacción', async () => {
    const { correr, prisma, gastosService } = crearProcesador({ pago: 'HISTORICO' }, [fila('f-1', 'CONTADO')]);
    const orden: string[] = [];
    prisma.gasto_importacion_filas.updateMany.mockImplementation(async () => (orden.push('proveedor'), { count: 1 }));
    gastosService.crearHistoricoImportado.mockImplementation(async () => (orden.push('alta'), { id: 'gasto-historico' }));

    await correr();

    expect(prisma.gasto_importacion_filas.updateMany).toHaveBeenCalledTimes(1);
    expect(prisma.gasto_importacion_filas.updateMany).toHaveBeenCalledWith({
      where: { id: 'f-1', estado: 'valida' },
      data: { proveedor_id: 'prov-1', proveedor_es_nuevo: false },
    });
    expect(orden).toEqual(['proveedor', 'alta']);
    expect(prisma.gasto_importacion_jobs.update).toHaveBeenCalledWith({
      where: { id: JOB },
      data: { estado: 'completado', filas_importadas: 1, finished_at: expect.any(Date) },
    });
  });

  it('el error de una fila queda en la fila con su mensaje real y el job termina con errores', async () => {
    const { correr, prisma, gastosService } = crearProcesador({ pago: 'HISTORICO' }, [fila('f-1', 'CONTADO')]);
    gastosService.crearHistoricoImportado.mockRejectedValue(new BadRequestException('La fila de importación ya generó un gasto o no es válida'));

    await correr();

    expect(prisma.gasto_importacion_filas.updateMany).toHaveBeenLastCalledWith({
      where: { id: 'f-1', estado: 'valida' },
      data: { estado: 'error', errores: ['La fila de importación ya generó un gasto o no es válida'] },
    });
    expect(prisma.gasto_importacion_jobs.update.mock.calls[0][0].data.estado).toBe('completado_con_errores');
  });

  it('un job sin pago elegido (confirmado antes de este cambio) no se registra como histórico', async () => {
    const { correr, gastosService } = crearProcesador({ sucursal_id: 'suc-1' }, [fila('f-1', 'CONTADO')]);

    await correr();

    expect(gastosService.crearHistoricoImportado).not.toHaveBeenCalled();
    expect(gastosService.crearImportado).toHaveBeenCalledTimes(1);
  });

  it('una fila que otra ejecución ya importó no se pisa con error ni cuenta como error', async () => {
    const { correr, prisma, gastosService } = crearProcesador({ pago: 'HISTORICO' }, [fila('f-1', 'CONTADO')]);
    gastosService.crearHistoricoImportado.mockRejectedValue(new BadRequestException('La fila de importación ya generó un gasto o no es válida'));
    prisma.gasto_importacion_filas.updateMany.mockResolvedValue({ count: 0 });

    await correr();

    expect(prisma.gasto_importacion_filas.updateMany).toHaveBeenLastCalledWith(expect.objectContaining({ where: { id: 'f-1', estado: 'valida' } }));
    expect(prisma.gasto_importacion_jobs.update.mock.calls[0][0].data.estado).toBe('completado');
  });
});
