import { resolverConfigCompras, type ConfigComprasAP } from './reglas-config-compras';

const DEFAULT: ConfigComprasAP = {
  habilitar_requisicion_compra: false,
  modo_flujo_compra: 'directo',
  afectar_stock_en_compra_directa: true,
  habilitar_orden_compra: true,
  habilitar_recepcion_compra: true,
  habilitar_matching_3_vias: true,
  habilitar_orden_pago: true,
  requiere_aprobacion: false,
  permite_pago_sin_aprobacion: true,
  generar_cxp_automatico: true,
  permitir_pago_parcial: false,
  usar_workflow: false,
  workflow_obligatorio: false,
  aplicar_pago_al_guardar: true,
  incluir_contado_en_orden_pago: false,
  permitir_editar_gasto_pagado: false,
  plan_pagos_periodicidad: 'SEMANAL',
  plan_pagos_dia_semana: 5,
  plan_pagos_dia_mes: 31,
};
const EN_PLAN = { requisicionesEnPlan: true };

const rechazo = (fn: () => unknown) => {
  try {
    fn();
  } catch (e: any) {
    return e.getResponse();
  }
  throw new Error('no lanzó');
};

describe('resolverConfigCompras', () => {
  it('stock y recepción apagados: CONFIG_SIN_ENTRADA_STOCK con campo afectar_stock_en_compra_directa, sin tocar OC ni recepción', () => {
    const r = rechazo(() => resolverConfigCompras(DEFAULT, { afectar_stock_en_compra_directa: false, habilitar_recepcion_compra: false }, EN_PLAN));
    expect(r).toMatchObject({ codigo: 'CONFIG_SIN_ENTRADA_STOCK', campo: 'afectar_stock_en_compra_directa' });
  });

  it('el mismo caso con lo guardado (el dto solo apaga una de las dos) también se rechaza', () => {
    const guardado = { ...DEFAULT, habilitar_recepcion_compra: false };
    expect(rechazo(() => resolverConfigCompras(guardado, { afectar_stock_en_compra_directa: false }, EN_PLAN))).toMatchObject({
      codigo: 'CONFIG_SIN_ENTRADA_STOCK',
    });
  });

  it('obligatorias con la OC apagada en el dto: REQUISICION_OBLIGATORIA_SIN_OC', () => {
    const r = rechazo(() =>
      resolverConfigCompras(
        DEFAULT,
        { habilitar_requisicion_compra: true, modo_flujo_compra: 'requisicion_obligatoria', habilitar_orden_compra: false },
        EN_PLAN,
      ),
    );
    expect(r).toMatchObject({ codigo: 'REQUISICION_OBLIGATORIA_SIN_OC' });
  });

  it('obligatorias con la OC apagada en lo guardado: REQUISICION_OBLIGATORIA_SIN_OC', () => {
    const guardado = { ...DEFAULT, habilitar_orden_compra: false, habilitar_matching_3_vias: false };
    const r = rechazo(() =>
      resolverConfigCompras(guardado, { habilitar_requisicion_compra: true, modo_flujo_compra: 'requisicion_obligatoria' }, EN_PLAN),
    );
    expect(r).toMatchObject({ codigo: 'REQUISICION_OBLIGATORIA_SIN_OC' });
  });

  it('apagar la OC con requisiciones obligatorias guardadas: REQUISICION_OBLIGATORIA_SIN_OC', () => {
    const guardado = { ...DEFAULT, habilitar_requisicion_compra: true, modo_flujo_compra: 'requisicion_obligatoria' as const };
    expect(rechazo(() => resolverConfigCompras(guardado, { habilitar_orden_compra: false }, EN_PLAN))).toMatchObject({
      codigo: 'REQUISICION_OBLIGATORIA_SIN_OC',
    });
  });

  it('encender requisiciones fuera del plan: REQUISICIONES_FUERA_DEL_PLAN', () => {
    const r = rechazo(() => resolverConfigCompras(DEFAULT, { habilitar_requisicion_compra: true }, { requisicionesEnPlan: false }));
    expect(r).toMatchObject({ codigo: 'REQUISICIONES_FUERA_DEL_PLAN' });
  });

  it('fila ya encendida fuera del plan + PUT de otro campo: pasa', () => {
    const guardado = { ...DEFAULT, habilitar_requisicion_compra: true, modo_flujo_compra: 'requisicion_opcional' as const };
    const r = resolverConfigCompras(guardado, { permitir_pago_parcial: true }, { requisicionesEnPlan: false });
    expect(r).toEqual({ ...guardado, permitir_pago_parcial: true });
  });

  it('requisiciones apagadas con modo requisicion_opcional: MODO_REQUISICION_INVALIDO', () => {
    const r = rechazo(() =>
      resolverConfigCompras(DEFAULT, { habilitar_requisicion_compra: false, modo_flujo_compra: 'requisicion_opcional' }, EN_PLAN),
    );
    expect(r).toMatchObject({ codigo: 'MODO_REQUISICION_INVALIDO', campo: 'modo_flujo_compra' });
  });

  it('apagar las requisiciones (sin mandar el modo) sobre una fila obligatoria u opcional: MODO_REQUISICION_INVALIDO', () => {
    for (const modo of ['requisicion_obligatoria', 'requisicion_opcional'] as const) {
      const guardado = { ...DEFAULT, habilitar_requisicion_compra: true, modo_flujo_compra: modo };
      expect(rechazo(() => resolverConfigCompras(guardado, { habilitar_requisicion_compra: false }, EN_PLAN))).toMatchObject({
        codigo: 'MODO_REQUISICION_INVALIDO',
        campo: 'modo_flujo_compra',
      });
    }
  });

  it('apagar las requisiciones mandando el modo directo pasa; y un PUT de otro campo sobre una fila ya inválida sigue pasando', () => {
    const guardado = { ...DEFAULT, habilitar_requisicion_compra: true, modo_flujo_compra: 'requisicion_opcional' as const };
    expect(resolverConfigCompras(guardado, { habilitar_requisicion_compra: false, modo_flujo_compra: 'directo' }, EN_PLAN)).toMatchObject({
      habilitar_requisicion_compra: false,
      modo_flujo_compra: 'directo',
    });
    const invalida = { ...DEFAULT, habilitar_requisicion_compra: false, modo_flujo_compra: 'requisicion_opcional' as const };
    expect(resolverConfigCompras(invalida, { permitir_pago_parcial: true }, EN_PLAN)).toEqual({ ...invalida, permitir_pago_parcial: true });
  });

  it('OC o recepción apagadas: el matching queda apagado (la única corrección)', () => {
    expect(resolverConfigCompras(DEFAULT, { habilitar_orden_compra: false }, EN_PLAN)).toEqual({
      ...DEFAULT,
      habilitar_orden_compra: false,
      habilitar_matching_3_vias: false,
    });
    expect(resolverConfigCompras(DEFAULT, { habilitar_recepcion_compra: false }, EN_PLAN)).toEqual({
      ...DEFAULT,
      habilitar_recepcion_compra: false,
      habilitar_matching_3_vias: false,
    });
  });

  it('usar_workflow solo ya no prende requiere_aprobacion, ni workflow_obligatorio prende usar_workflow', () => {
    expect(resolverConfigCompras(DEFAULT, { usar_workflow: true }, EN_PLAN)).toEqual({ ...DEFAULT, usar_workflow: true });
    expect(resolverConfigCompras(DEFAULT, { workflow_obligatorio: true }, EN_PLAN)).toEqual({ ...DEFAULT, workflow_obligatorio: true });
  });

  it('nada más cambia: el resultado es { ...actual, ...dto } salvo el matching', () => {
    const dto = {
      habilitar_requisicion_compra: true,
      modo_flujo_compra: 'requisicion_opcional' as const,
      habilitar_orden_pago: false,
      requiere_aprobacion: true,
      permite_pago_sin_aprobacion: false,
      plan_pagos_periodicidad: 'MENSUAL' as const,
      plan_pagos_dia_mes: 15,
      incluir_contado_en_orden_pago: true,
    };
    expect(resolverConfigCompras(DEFAULT, dto, EN_PLAN)).toEqual({ ...DEFAULT, ...dto });
  });

  it('un campo sin enviar (undefined) no pisa lo guardado', () => {
    expect(resolverConfigCompras(DEFAULT, { permitir_pago_parcial: undefined, modo_flujo_compra: undefined }, EN_PLAN)).toEqual(DEFAULT);
  });
});
