import { BadRequestException } from '@nestjs/common';
import * as XLSX from 'xlsx';
import { GastosImportadorService } from './gastos-importador.service';

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

function crearServicio(job: Record<string, unknown> = { id: JOB, empresa_id: EMPRESA, estado: 'mapeado', config_defaults: { sucursal_id: 'suc-1' } }) {
  const prisma = {
    gasto_importacion_jobs: {
      findFirst: jest.fn().mockResolvedValue(job),
      create: jest.fn().mockResolvedValue({ id: JOB }),
      update: jest.fn().mockResolvedValue({}),
      updateMany: jest.fn().mockResolvedValue({ count: 1 }),
    },
    gasto_importacion_alias: { findMany: jest.fn().mockResolvedValue([]) },
    // Tipos de gasto para sugerir por nombre al subir el archivo.
    tipo_gasto: { findMany: jest.fn().mockResolvedValue([]) },
    gasto_importacion_filas: { createMany: jest.fn().mockResolvedValue({ count: 0 }) },
  };
  const queue = { add: jest.fn().mockResolvedValue({}) };
  const gastos = { assertPagoImportacionValido: jest.fn().mockResolvedValue(undefined) };
  const service = new GastosImportadorService(prisma as never, queue as never, gastos as never);
  return { service, prisma, queue, gastos };
}

describe('GastosImportadorService.confirmar (Task 11)', () => {
  it('HISTORICO por defecto: guarda pago HISTORICO en config_defaults sin medio, conservando la sucursal', async () => {
    const { service, prisma, queue } = crearServicio();

    await service.confirmar(EMPRESA, JOB, {});

    expect(prisma.gasto_importacion_jobs.updateMany).toHaveBeenCalledWith({
      where: { id: JOB, empresa_id: EMPRESA, estado: 'mapeado' },
      data: { estado: 'procesando', confirmed_at: expect.any(Date), config_defaults: { sucursal_id: 'suc-1', pago: 'HISTORICO' } },
    });
    expect(queue.add).toHaveBeenCalledWith('procesar-import', { jobId: JOB }, expect.anything());
  });

  it('HISTORICO ignora un medio o una cuenta que vengan en el pedido', async () => {
    const { service, prisma } = crearServicio();

    await service.confirmar(EMPRESA, JOB, { pago: 'HISTORICO', medio_pago_id: MEDIO, cuenta_tesoreria_id: CUENTA });

    expect(prisma.gasto_importacion_jobs.updateMany.mock.calls[0][0].data.config_defaults).toEqual({ sucursal_id: 'suc-1', pago: 'HISTORICO' });
  });

  it('AHORA sin medio → 400 y no encola nada', async () => {
    const { service, prisma, queue } = crearServicio();

    const intento = service.confirmar(EMPRESA, JOB, { pago: 'AHORA' });

    await expect(intento).rejects.toThrow(new BadRequestException('Elegí el medio de pago para registrar el pago de las filas de contado.'));
    expect(prisma.gasto_importacion_jobs.updateMany).not.toHaveBeenCalled();
    expect(queue.add).not.toHaveBeenCalled();
  });

  it('AHORA con medio y cuenta: los guarda en config_defaults', async () => {
    const { service, prisma } = crearServicio({ id: JOB, empresa_id: EMPRESA, estado: 'mapeado', config_defaults: null });

    await service.confirmar(EMPRESA, JOB, { pago: 'AHORA', medio_pago_id: MEDIO, cuenta_tesoreria_id: CUENTA });

    expect(prisma.gasto_importacion_jobs.updateMany.mock.calls[0][0].data.config_defaults).toEqual({
      pago: 'AHORA',
      medio_pago_id: MEDIO,
      cuenta_tesoreria_id: CUENTA,
    });
  });

  it('AHORA valida medio y cuenta con las reglas del alta antes de encolar', async () => {
    const { service, gastos } = crearServicio();

    await service.confirmar(EMPRESA, JOB, { pago: 'AHORA', medio_pago_id: MEDIO, cuenta_tesoreria_id: CUENTA });

    expect(gastos.assertPagoImportacionValido).toHaveBeenCalledWith(EMPRESA, { medioPagoId: MEDIO, cuentaTesoreriaId: CUENTA });
  });

  it('AHORA con cuenta de otra empresa → 400 y no encola', async () => {
    const { service, prisma, queue, gastos } = crearServicio();
    gastos.assertPagoImportacionValido.mockRejectedValue(new BadRequestException('La cuenta elegida en el gasto no está activa o no es de la empresa.'));

    await expect(service.confirmar(EMPRESA, JOB, { pago: 'AHORA', medio_pago_id: MEDIO, cuenta_tesoreria_id: CUENTA })).rejects.toThrow(
      'La cuenta elegida en el gasto no está activa o no es de la empresa.',
    );
    expect(prisma.gasto_importacion_jobs.updateMany).not.toHaveBeenCalled();
    expect(queue.add).not.toHaveBeenCalled();
  });

  it('HISTORICO no valida medio ni cuenta', async () => {
    const { service, gastos } = crearServicio();

    await service.confirmar(EMPRESA, JOB, {});

    expect(gastos.assertPagoImportacionValido).not.toHaveBeenCalled();
  });

  it('un segundo confirmar del mismo job (ya procesando) → 400 y no encola otra vez', async () => {
    const { service, prisma, queue } = crearServicio();
    prisma.gasto_importacion_jobs.updateMany.mockResolvedValue({ count: 0 });

    await expect(service.confirmar(EMPRESA, JOB, {})).rejects.toThrow('El job debe tener el mapeo guardado antes de confirmar');
    expect(queue.add).not.toHaveBeenCalled();
  });
});

describe('GastosImportadorService.subirArchivo (Task 11)', () => {
  it('las columnas opcionales (moneda, moneda extranjera, CDC) no figuran en columnas_faltantes', async () => {
    const { service } = crearServicio();
    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',
      'Monto Gravado 10%',
      'IVA 10%',
      'Monto Gravado 5%',
      'IVA 5%',
      'Monto No Gravado / Exento ',
      'Total Comprobante',
      'TIPO CUENTA CONTABLE- GASTO',
      'TIPO CUENTA CONTABLE- CONTRAPARTIDA PASIVA',
    ];
    const fila = ['80011111', 'EJEMPLO SA', '05/05/2026', 'CONTADO', '12345678', '001-001-0000123', 220000, 20000, 0, 0, 0, 220000, 'COMBUSTIBLE', 'ACREEDORES VARIOS'];
    const wb = XLSX.utils.book_new();
    XLSX.utils.book_append_sheet(wb, XLSX.utils.aoa_to_sheet([headers, fila]), 'Libro');
    const buffer = XLSX.write(wb, { type: 'buffer', bookType: 'xlsx' }) as Buffer;

    const resultado = await service.subirArchivo(EMPRESA, 'usr-1', { originalname: 'libro.xlsx', buffer });

    expect(resultado.columnas_faltantes).toEqual([]);
  });
});
