import { coincideBusqueda, hojasCartera, hojasExtracto, type DatosCartera, type DatosExtracto } from './excel-reportes';

const linea = (fecha: string, descripcion: string, tipo: string, sentido: 'INGRESO' | 'EGRESO', monto: number, saldo: number, categorias: string[] = []) => ({
  id: `l-${fecha}`,
  fecha: new Date(`${fecha}T00:00:00.000Z`),
  descripcion,
  categorias,
  tipo,
  sentido,
  ingreso: sentido === 'INGRESO' ? monto : 0,
  egreso: sentido === 'EGRESO' ? monto : 0,
  saldo,
});

const extracto: DatosExtracto = {
  cuenta: { nombre: 'DOBA S.A. DOLARES', moneda: 'USD' },
  fecha_desde: '2026-06-01',
  fecha_hasta: '2026-06-30',
  saldoAnterior: 0,
  saldoFinal: 50,
  totalIngresos: 100,
  totalEgresos: 50,
  lineas: [
    linea('2026-06-01', 'COMPRA DOLARES', 'TRANSFERENCIA', 'INGRESO', 100, 100),
    linea('2026-06-02', '=CMD()', 'EGRESO', 'EGRESO', 30, 70),
    linea('2026-06-03', 'Compra útiles', 'EGRESO', 'EGRESO', 20, 50),
  ],
};

const hoja = (hojas: Array<{ nombre: string; filas: (string | number)[][] }>, nombre: string) => hojas.find((h) => h.nombre === nombre)!.filas;
const valorDe = (filas: (string | number)[][], concepto: string) => filas.find((f) => f[0] === concepto)?.[1];

const cheque = (over: Partial<DatosCartera['cheques'][number]> = {}): DatosCartera['cheques'][number] => ({
  id: 'ch',
  numero: '0001',
  tipo: 'RECIBIDO',
  banco: 'Itaú',
  titular: 'Juan Pérez',
  monto: 1000,
  moneda: 'PYG',
  emision: new Date('2026-05-01T00:00:00.000Z'),
  vencimiento: new Date('2026-06-01T00:00:00.000Z'),
  recepcion: new Date('2026-06-01T12:00:00.000Z'),
  estado: 'EN_CARTERA',
  cuenta: 'Cuenta Uno',
  ...over,
});

const cartera = (cheques: DatosCartera['cheques'] = [cheque()]): DatosCartera => ({
  resumen: {
    enCartera: 3,
    diferidos: 1,
    depositados: 2,
    debitados: 4,
    vencenPronto: 5,
    diasAlerta: 21,
    porMoneda: [
      { moneda: 'PYG', cantidad: 2, total: 3000, recibidos: 1000, emitidos: 2000 },
      { moneda: 'USD', cantidad: 1, total: 1250.5, recibidos: 1250.5, emitidos: 0 },
    ],
  },
  cheques,
});

describe('coincideBusqueda', () => {
  it('sin q, todas', () => {
    expect(coincideBusqueda(['algo'], undefined)).toBe(true);
    expect(coincideBusqueda(['algo'], '')).toBe(true);
    expect(coincideBusqueda(['algo'], '   ')).toBe(true);
  });
  it('sin acentos ni mayúsculas, en cualquiera de los textos', () => {
    expect(coincideBusqueda([null, 'Compra útiles'], 'UTILES')).toBe(true);
    expect(coincideBusqueda(['COMPRA'], 'comprá')).toBe(true);
    expect(coincideBusqueda(['venta', undefined], 'compra')).toBe(false);
  });
});

describe('hojasExtracto', () => {
  it('Resumen con Moneda, Saldo anterior, Ingresos, Egresos y Saldo final', () => {
    const r = hoja(hojasExtracto(extracto), 'Resumen');
    expect(valorDe(r, 'Cuenta')).toBe('DOBA S.A. DOLARES');
    expect(valorDe(r, 'Moneda')).toBe('USD');
    expect(valorDe(r, 'Saldo anterior')).toBe(0);
    expect(valorDe(r, 'Ingresos')).toBe(100);
    expect(valorDe(r, 'Egresos')).toBe(50);
    expect(valorDe(r, 'Saldo final')).toBe(50);
  });

  it('Extracto con sus encabezados', () => {
    expect(hoja(hojasExtracto(extracto), 'Extracto')[0]).toEqual(['Fecha', 'Descripción', 'Categorías', 'Tipo', 'Sentido', 'Ingreso', 'Egreso', 'Saldo']);
  });

  it('la transferencia de entrada: Tipo Transferencia, Sentido Ingreso, Ingreso 100', () => {
    const fila = hoja(hojasExtracto(extracto), 'Extracto')[1];
    expect(fila.slice(3)).toEqual(['Transferencia', 'Ingreso', 100, '', 100]);
  });

  it('=CMD() sale como texto', () => {
    expect(hoja(hojasExtracto(extracto), 'Extracto')[2][1]).toBe("'=CMD()");
  });

  it('q: "compra" deja 2 filas con los saldos de pantalla', () => {
    const filas = hoja(hojasExtracto(extracto, 'compra'), 'Extracto').slice(1);
    expect(filas.map((f) => f[7])).toEqual([100, 50]);
  });

  it('q: "COMPRÁ" da lo mismo', () => {
    expect(hoja(hojasExtracto(extracto, 'COMPRÁ'), 'Extracto')).toHaveLength(3);
  });

  it('q busca también en las categorías', () => {
    const conCategoria = { ...extracto, lineas: [linea('2026-06-01', 'x', 'INGRESO', 'INGRESO', 1, 1, ['Comisión bancaria'])] };
    expect(hoja(hojasExtracto(conCategoria, 'comision'), 'Extracto')).toHaveLength(2);
  });

  it('q no une las categorías: la pantalla las mira una por una y el Excel trae lo mismo', () => {
    const conDos = { ...extracto, lineas: [linea('2026-06-01', 'x', 'INGRESO', 'INGRESO', 1, 1, ['Compra', 'Mercadería'])] };
    expect(hoja(hojasExtracto(conDos, 'compra mercaderia'), 'Extracto')).toHaveLength(1);
    expect(hoja(hojasExtracto(conDos, 'mercaderia'), 'Extracto')).toHaveLength(2);
  });

  describe('con el servidor en Asunción', () => {
    const tz = process.env.TZ;
    beforeAll(() => (process.env.TZ = 'America/Asuncion'));
    afterAll(() => (process.env.TZ = tz));

    it('la DATE 2026-06-01T00:00:00.000Z sale 01/06/2026', () => {
      expect(hoja(hojasExtracto(extracto), 'Extracto')[1][0]).toBe('01/06/2026');
    });
  });
});

describe('hojasCartera', () => {
  it('Resumen con una fila Total en cartera por moneda, los contadores y los días de alerta', () => {
    const r = hoja(hojasCartera(cartera()), 'Resumen');
    expect(valorDe(r, 'En cartera')).toBe(3);
    expect(r.some((f) => f[0] === 'En Cartera')).toBe(false);
    expect(valorDe(r, 'Diferidos')).toBe(1);
    expect(valorDe(r, 'Depositados')).toBe(2);
    expect(valorDe(r, 'Debitados')).toBe(4);
    expect(valorDe(r, 'Vencen en 21 días')).toBe(5);
    expect(r.find((f) => f[0] === 'Total en cartera PYG')).toEqual(['Total en cartera PYG', 3000, 1000, 2000]);
    expect(r.find((f) => f[0] === 'Total en cartera USD')).toEqual(['Total en cartera USD', 1250.5, 1250.5, 0]);
  });

  it('Cheques con sus encabezados', () => {
    expect(hoja(hojasCartera(cartera()), 'Cheques')[0]).toEqual([
      'Número',
      'Tipo',
      'Banco',
      'Titular',
      'Moneda',
      'Emisión',
      'Vencimiento',
      'Recepción',
      'Estado',
      'Cuenta',
      'Monto',
    ]);
  });

  it.each([
    ['EN_CARTERA', 'En cartera'],
    ['DIFERIDO', 'Diferido'],
    ['DEPOSITADO', 'Depositado'],
    ['DEBITADO', 'Debitado'],
    ['RECHAZADO', 'Rechazado'],
    ['DEVUELTO', 'Devuelto'],
    ['ANULADO', 'Anulado'],
  ])('estado %s → %s', (estado, etiqueta) => {
    expect(hoja(hojasCartera(cartera([cheque({ estado })])), 'Cheques')[1][8]).toBe(etiqueta);
  });

  it('el tipo sale con su etiqueta', () => {
    expect(hoja(hojasCartera(cartera([cheque({ tipo: 'EMITIDO' })])), 'Cheques')[1][1]).toBe('Emitido');
  });

  it('recepcion 2026-06-01T02:00:00Z → 31/05/2026 (Asunción)', () => {
    expect(hoja(hojasCartera(cartera([cheque({ recepcion: new Date('2026-06-01T02:00:00Z') })])), 'Cheques')[1][7]).toBe('31/05/2026');
  });

  it('F6: sin vencimiento ni emisión → «—», sin lanzar', () => {
    const fila = hoja(hojasCartera(cartera([cheque({ vencimiento: null, emision: null })])), 'Cheques')[1];
    expect(fila[5]).toBe('—');
    expect(fila[6]).toBe('—');
  });

  it('F6: banco, titular y cuenta nulos → «—»', () => {
    const fila = hoja(hojasCartera(cartera([cheque({ banco: null, titular: null, cuenta: null })])), 'Cheques')[1];
    expect([fila[2], fila[3], fila[9]]).toEqual(['—', '—', '—']);
  });

  it('un titular con fórmula sale como texto', () => {
    expect(hoja(hojasCartera(cartera([cheque({ titular: '=HYPERLINK("x")' })])), 'Cheques')[1][3]).toBe('\'=HYPERLINK("x")');
  });

  it.each([
    ['0002', 'numero'],
    ['ACME', 'titular'],
    ['continental', 'banco'],
    ['cuenta dos', 'cuenta'],
  ])('q %s busca por %s', (q) => {
    const lista = [cheque({ id: 'a' }), cheque({ id: 'b', numero: '0002', titular: 'ACME', banco: 'Continental', cuenta: 'Cuenta Dos' })];
    const filas = hoja(hojasCartera(cartera(lista), q), 'Cheques').slice(1);
    expect(filas).toHaveLength(1);
    expect(filas[0][0]).toBe('0002');
  });
});
