import {
  AVISO_CUENTA_ELEGIDA_NO_SIRVE,
  AVISO_REGLA_MEDIO_INACTIVA,
  AVISO_SIN_REGLA_PAGO_GASTO,
  resolverCuentaPagoGasto,
} from './cuenta-pago-gasto.util';

const cuenta = (id: string, moneda: string, extra: Record<string, unknown> = {}) => ({
  id,
  nombre: `Cuenta ${id}`,
  moneda,
  cuenta_contable_id: `cc-${id}`,
  activo: true,
  empresa_id: 'emp',
  ...extra,
});

const regla = (medio: string | null, moneda: string | null, c: ReturnType<typeof cuenta> | null, activo = true) => ({
  medio_pago_id: medio,
  moneda_id: moneda,
  activo,
  cuenta_id: c?.id ?? null,
  cuenta: c,
});

function db(reglas: any[], cuentas: Record<string, any> = {}) {
  return {
    tes_cuentas: {
      findFirst: jest.fn().mockImplementation(({ where }) => {
        const c = cuentas[where.id];
        if (!c || !c.activo || c.empresa_id !== where.empresa_id) return null;
        const { id, nombre, moneda, cuenta_contable_id } = c;
        return { id, nombre, moneda, cuenta_contable_id };
      }),
    },
    tes_reglas: { findMany: jest.fn().mockResolvedValue(reglas) },
    moneda: { findFirst: jest.fn().mockResolvedValue({ id: 'mon-pyg' }) },
  } as any;
}

describe('resolverCuentaPagoGasto', () => {
  it('cuenta elegida activa gana', async () => {
    const r = await resolverCuentaPagoGasto(
      db([regla(null, null, cuenta('gral', 'PYG'))], { usd: cuenta('usd', 'USD') }),
      'emp',
      { cuentaTesoreriaId: 'usd', medioPagoId: 'mp', monedaId: 'mon-usd' },
    );
    expect(r).toEqual({
      cuenta: { id: 'usd', nombre: 'Cuenta usd', moneda: 'USD', cuenta_contable_id: 'cc-usd' },
      origen: 'CUENTA_ELEGIDA',
      avisos: [],
    });
  });

  // I13: la cuenta elegida manda; si ya no sirve, el código no decide de dónde sale la plata.
  it('cuenta elegida inactiva: null con el aviso, sin caer a la regla', async () => {
    const reglas = db([regla(null, null, cuenta('gral', 'PYG'))], { vieja: cuenta('vieja', 'PYG', { activo: false }) });
    const r = await resolverCuentaPagoGasto(reglas, 'emp', { cuentaTesoreriaId: 'vieja' });
    expect(r).toEqual({ cuenta: null, origen: null, avisos: [AVISO_CUENTA_ELEGIDA_NO_SIRVE] });
    expect(reglas.tes_reglas.findMany).not.toHaveBeenCalled();
  });

  it('cuenta elegida de otra empresa: null con el aviso', async () => {
    const r = await resolverCuentaPagoGasto(
      db([regla(null, null, cuenta('gral', 'PYG'))], { ajena: cuenta('ajena', 'PYG', { empresa_id: 'otra' }) }),
      'emp',
      { cuentaTesoreriaId: 'ajena' },
    );
    expect(r).toEqual({ cuenta: null, origen: null, avisos: [AVISO_CUENTA_ELEGIDA_NO_SIRVE] });
  });

  it('regla medio + moneda sin cuenta que cae a la del medio: avisa con el motivo real', async () => {
    const r = await resolverCuentaPagoGasto(
      db([regla('mp', 'mon-usd', null), regla('mp', null, cuenta('medio', 'PYG'))]),
      'emp',
      { medioPagoId: 'mp', monedaId: 'mon-usd' },
    );
    expect(r.origen).toBe('REGLA_MEDIO');
    expect(r.avisos).toEqual([
      'La regla de Tesorería "Pago de gasto" del medio y la moneda no tiene cuenta asignada; se usó la del medio.',
    ]);
  });

  it('regla medio + USD gana sobre la del medio', async () => {
    const r = await resolverCuentaPagoGasto(
      db([
        regla('mp', null, cuenta('medio', 'PYG')),
        regla('mp', 'mon-usd', cuenta('medio-usd', 'USD')),
        regla(null, null, cuenta('gral', 'PYG')),
      ]),
      'emp',
      { medioPagoId: 'mp', monedaId: 'mon-usd' },
    );
    expect(r.origen).toBe('REGLA_MEDIO_MONEDA');
    expect(r.cuenta?.id).toBe('medio-usd');
    expect(r.avisos).toEqual([]);
  });

  it('medio inactiva se saltea con aviso y cae a general + moneda', async () => {
    const r = await resolverCuentaPagoGasto(
      db([
        regla('mp', null, cuenta('medio', 'PYG'), false),
        regla(null, 'mon-usd', cuenta('gral-usd', 'USD')),
        regla(null, null, cuenta('gral', 'PYG')),
      ]),
      'emp',
      { medioPagoId: 'mp', monedaId: 'mon-usd' },
    );
    expect(r.origen).toBe('REGLA_GENERAL_MONEDA');
    expect(r.cuenta?.id).toBe('gral-usd');
    expect(r.avisos).toEqual([AVISO_REGLA_MEDIO_INACTIVA]);
  });

  it('una regla del medio con la cuenta inactiva también se saltea', async () => {
    const r = await resolverCuentaPagoGasto(
      db([regla('mp', null, cuenta('medio', 'PYG', { activo: false })), regla(null, null, cuenta('gral', 'PYG'))]),
      'emp',
      { medioPagoId: 'mp', monedaId: 'mon-pyg' },
    );
    expect(r.origen).toBe('REGLA_GENERAL');
    expect(r.avisos).toEqual([
      'La regla de Tesorería "Pago de gasto" del medio tiene la cuenta inactiva; se usó la general.',
    ]);
  });

  // M5: el aviso distingue la cuenta de otra empresa de la que ya no existe.
  it.each([
    ['de otra empresa', cuenta('ajena', 'PYG', { empresa_id: 'otra' }), 'tiene una cuenta de otra empresa'],
    ['que no existe', null, 'tiene una cuenta que no existe'],
  ])('una regla del medio con una cuenta %s se saltea con ese motivo', async (_caso, c, motivo) => {
    const rota = { ...regla('mp', null, c), cuenta_id: 'ajena' };
    const r = await resolverCuentaPagoGasto(db([rota, regla(null, null, cuenta('gral', 'PYG'))]), 'emp', {
      medioPagoId: 'mp',
      monedaId: 'mon-pyg',
    });
    expect(r.origen).toBe('REGLA_GENERAL');
    expect(r.avisos).toEqual([`La regla de Tesorería "Pago de gasto" del medio ${motivo}; se usó la general.`]);
  });

  it('sin moneda en la regla vale para cualquiera', async () => {
    const reglas = [regla(null, null, cuenta('gral', 'PYG'))];
    for (const monedaId of ['mon-usd', 'mon-eur', null]) {
      const r = await resolverCuentaPagoGasto(db(reglas), 'emp', { medioPagoId: 'mp', monedaId });
      expect(r.origen).toBe('REGLA_GENERAL');
      expect(r.cuenta?.id).toBe('gral');
    }
  });

  it('una regla de otra moneda no se usa', async () => {
    const r = await resolverCuentaPagoGasto(db([regla(null, 'mon-usd', cuenta('gral-usd', 'USD'))]), 'emp', {
      monedaId: 'mon-pyg',
    });
    expect(r).toEqual({ cuenta: null, origen: null, avisos: [AVISO_SIN_REGLA_PAGO_GASTO] });
  });

  it('gasto sin moneda: toma las reglas de PYG', async () => {
    const r = await resolverCuentaPagoGasto(db([regla(null, 'mon-pyg', cuenta('gral-pyg', 'PYG'))]), 'emp', {
      monedaId: null,
    });
    expect(r.origen).toBe('REGLA_GENERAL_MONEDA');
  });

  it('sin reglas → null con el aviso de hoy', async () => {
    const r = await resolverCuentaPagoGasto(db([]), 'emp', { medioPagoId: 'mp', monedaId: 'mon-usd' });
    expect(r).toEqual({ cuenta: null, origen: null, avisos: [AVISO_SIN_REGLA_PAGO_GASTO] });
    expect(r.avisos[0]).toMatch(/^No existe una regla de Tesorería para "Pago de gasto"/);
  });

  it('solo la general inactiva → el aviso de regla inactiva', async () => {
    const r = await resolverCuentaPagoGasto(db([regla(null, null, cuenta('gral', 'PYG'), false)]), 'emp', {});
    expect(r.cuenta).toBeNull();
    expect(r.avisos[0]).toContain('está inactiva');
  });
});
