import { HttpException } from '@nestjs/common';
import { submoduloHabilitado } from 'src/auth/guards/submodulo.guard';
import { validarDto } from 'src/common/utils/validar-dto.testutil';
import { UpdateConfigComprasDto } from './dto/update-config-compras.dto';
import { PagosProveedorService } from './pagos-proveedor.service';
import { requiereAprobacionOrdenPago } from './reglas-op';

jest.mock('src/auth/guards/submodulo.guard', () => ({
  ...jest.requireActual('src/auth/guards/submodulo.guard'),
  submoduloHabilitado: jest.fn(),
}));
const enPlan = (si: boolean) => (submoduloHabilitado as jest.Mock).mockResolvedValue({ habilitado: si });

/**
 * Configuración de Compras (Opciones) según la configuración: filas 1–11 del spec («Probar según configuración») contra el
 * servicio real con una fila de `config_compras` en memoria. Cada guardado deja una sola fila de auditoría con lo que cambió.
 */
const EMPRESA = 'emp-1';
const USUARIO = 'usr-1';

/** Una empresa común de local (R§3): lo que el alta de la fila deja por default. */
const DEFAULT_DB = {
  id: 'cfg-1',
  empresa_id: EMPRESA,
  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_edicion_cxp: false,
  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,
};

function montar(fila: Record<string, unknown> | null = { ...DEFAULT_DB }, niveles: Array<{ origen_tipo: string; n: number }> = []) {
  let guardada = fila ? { ...fila } : null;
  const config_compras = {
    findUnique: jest.fn(async () => (guardada ? { ...guardada } : null)),
    create: jest.fn(async ({ data }: any) => {
      guardada = { id: 'cfg-1', ...data };
      return { ...guardada };
    }),
    update: jest.fn(async ({ data }: any) => {
      guardada = { ...guardada, ...data };
      return { ...guardada };
    }),
  };
  const tx = {
    config_compras,
    requisicion_aprobacion_config: {
      groupBy: jest.fn(async () => niveles.map((x) => ({ origen_tipo: x.origen_tipo, _count: { _all: x.n } }))),
    },
  };
  const prisma = { $transaction: jest.fn(async (fn: any) => fn(tx)) };
  const audit = { logEnTransaccion: jest.fn() };
  const service = new PagosProveedorService(prisma as any, {} as any, audit as any, {} as any);
  return { service, tx, audit, config_compras, guardada: () => guardada };
}

const put = (m: ReturnType<typeof montar>, dto: UpdateConfigComprasDto) => m.service.updateConfigCompras(EMPRESA, dto, USUARIO);
const rechazo = async (p: Promise<unknown>) => {
  try {
    await p;
  } catch (e) {
    return (e as HttpException).getResponse() as Record<string, unknown>;
  }
  throw new Error('no lanzó');
};

beforeEach(() => {
  jest.clearAllMocks();
  enPlan(true);
});

describe('Configuración de Compras según la configuración (Opciones)', () => {
  describe('fila 1: default (empresa común de local)', () => {
    it('el GET devuelve la config guardada y niveles_activos en 0, y no escribe', async () => {
      const m = montar();
      const r = await m.service.leerConfigComprasPantalla(EMPRESA);
      expect(r).toMatchObject({ habilitar_orden_compra: true, modo_flujo_compra: 'directo', niveles_activos: { compra: 0, gasto: 0 } });
      expect(r).not.toHaveProperty('permitir_edicion_cxp');
      expect(m.config_compras.update).not.toHaveBeenCalled();
      expect(m.audit.logEnTransaccion).not.toHaveBeenCalled();
    });

    it('un PUT sin cambios ni escribe ni audita (el mismo valor tampoco cuenta)', async () => {
      const m = montar();
      await put(m, {});
      await put(m, { habilitar_orden_compra: true, plan_pagos_dia_semana: 5 });
      expect(m.config_compras.update).not.toHaveBeenCalled();
      expect(m.audit.logEnTransaccion).not.toHaveBeenCalled();
    });

    it('niveles_activos cuenta por origen solo los activos', async () => {
      const m = montar(undefined, [{ origen_tipo: 'compra', n: 3 }, { origen_tipo: 'gasto', n: 1 }]);
      expect((await m.service.leerConfigComprasPantalla(EMPRESA)).niveles_activos).toEqual({ compra: 3, gasto: 1 });
      expect(m.tx.requisicion_aprobacion_config.groupBy).toHaveBeenCalledWith(
        expect.objectContaining({ where: { empresa_id: EMPRESA, activo: true } }),
      );
    });
  });

  describe('Review Focus: empresa sin fila', () => {
    it('el GET devuelve los defaults con niveles_activos en 0 y el primer PUT audita el default como "antes"', async () => {
      const m = montar(null);
      const r = await m.service.leerConfigComprasPantalla(EMPRESA);
      expect(r).toMatchObject({
        habilitar_requisicion_compra: false,
        afectar_stock_en_compra_directa: true,
        permite_pago_sin_aprobacion: true,
        aplicar_pago_al_guardar: true,
        niveles_activos: { compra: 0, gasto: 0 },
      });
      expect(m.config_compras.create).toHaveBeenCalledTimes(1);

      await put(m, { permitir_pago_parcial: true });
      expect(m.audit.logEnTransaccion).toHaveBeenCalledTimes(1);
      expect(m.audit.logEnTransaccion.mock.calls[0][1]).toMatchObject({
        action: 'CONFIG_COMPRAS_GUARDADA',
        old_value: { permitir_pago_parcial: false },
        new_value: { permitir_pago_parcial: true },
      });
    });
  });

  describe('fila 2: MISTERHOME (permitir_edicion_cxp en false)', () => {
    it('el ValidationPipe rechaza permitir_edicion_cxp con 400', async () => {
      await expect(validarDto(UpdateConfigComprasDto, { permitir_edicion_cxp: true })).rejects.toMatchObject({ status: 400 });
    });

    it('un PUT de otro campo no toca la columna, que sigue en false', async () => {
      const m = montar();
      await put(m, { permitir_pago_parcial: true });
      expect(Object.keys(m.config_compras.update.mock.calls[0][0].data)).not.toContain('permitir_edicion_cxp');
      expect((m.guardada() as any).permitir_edicion_cxp).toBe(false);
    });
  });

  describe('fila 3: DOBA (contado en OP y editar gastos pagados)', () => {
    it('los dos switches se guardan y se auditan juntos en una sola fila', async () => {
      const m = montar();
      const r = await put(m, { incluir_contado_en_orden_pago: true, permitir_editar_gasto_pagado: true });
      expect(r).toMatchObject({ incluir_contado_en_orden_pago: true, permitir_editar_gasto_pagado: true });
      expect(m.audit.logEnTransaccion).toHaveBeenCalledTimes(1);
      expect(m.audit.logEnTransaccion.mock.calls[0][1]).toMatchObject({
        empresa_id: EMPRESA,
        user_id: USUARIO,
        action: 'CONFIG_COMPRAS_GUARDADA',
        entity_type: 'config_compras',
        entity_id: 'cfg-1',
        old_value: { incluir_contado_en_orden_pago: false, permitir_editar_gasto_pagado: false },
        new_value: { incluir_contado_en_orden_pago: true, permitir_editar_gasto_pagado: true },
      });
    });
  });

  describe('fila 4: Agogó (requisiciones encendidas con modo directo)', () => {
    it('un PUT de permitir_pago_parcial no manda ni cambia modo_flujo_compra', async () => {
      const m = montar({ ...DEFAULT_DB, habilitar_requisicion_compra: true, modo_flujo_compra: 'directo' });
      const dto = await validarDto(UpdateConfigComprasDto, { permitir_pago_parcial: true });
      expect(dto.modo_flujo_compra).toBeUndefined();
      const r = await put(m, dto);
      expect(r).toMatchObject({ habilitar_requisicion_compra: true, modo_flujo_compra: 'directo', permitir_pago_parcial: true });
      expect(m.audit.logEnTransaccion.mock.calls[0][1].new_value).toEqual({ permitir_pago_parcial: true });
    });
  });

  describe('fila 5: obligatorias sin OC', () => {
    it('REQUISICION_OBLIGATORIA_SIN_OC y no se guarda ni audita nada', async () => {
      const m = montar({ ...DEFAULT_DB, habilitar_orden_compra: false, habilitar_matching_3_vias: false });
      const r = await rechazo(put(m, { habilitar_requisicion_compra: true, modo_flujo_compra: 'requisicion_obligatoria' }));
      expect(r).toMatchObject({ codigo: 'REQUISICION_OBLIGATORIA_SIN_OC' });
      expect(m.config_compras.update).not.toHaveBeenCalled();
      expect(m.audit.logEnTransaccion).not.toHaveBeenCalled();
    });
  });

  describe('fila 6: requisiciones fuera del plan', () => {
    it('encenderlas da REQUISICIONES_FUERA_DEL_PLAN', async () => {
      enPlan(false);
      const m = montar();
      expect(await rechazo(put(m, { habilitar_requisicion_compra: true, modo_flujo_compra: 'requisicion_opcional' }))).toMatchObject({
        codigo: 'REQUISICIONES_FUERA_DEL_PLAN',
      });
      expect(submoduloHabilitado).toHaveBeenCalledWith(expect.anything(), EMPRESA, 'COMP_REQUISICIONES');
      expect(m.audit.logEnTransaccion).not.toHaveBeenCalled();
    });

    it('una fila ya encendida fuera del plan no traba el guardado de otros campos (ni pregunta por el plan)', async () => {
      enPlan(false);
      const m = montar({ ...DEFAULT_DB, habilitar_requisicion_compra: true, modo_flujo_compra: 'requisicion_opcional' });
      await expect(put(m, { permitir_pago_parcial: true })).resolves.toMatchObject({ permitir_pago_parcial: true });
      expect(submoduloHabilitado).not.toHaveBeenCalled();
    });
  });

  describe('fila 7: stock + recepción', () => {
    it('CONFIG_SIN_ENTRADA_STOCK con campo afectar_stock_en_compra_directa', async () => {
      const m = montar();
      expect(await rechazo(put(m, { afectar_stock_en_compra_directa: false, habilitar_recepcion_compra: false }))).toMatchObject({
        codigo: 'CONFIG_SIN_ENTRADA_STOCK',
        campo: 'afectar_stock_en_compra_directa',
      });
      expect(m.audit.logEnTransaccion).not.toHaveBeenCalled();
    });

    it('F9: una fila ya inválida (stock y recepción apagados) se lee sin error y el PUT que la arregla pasa', async () => {
      const m = montar({ ...DEFAULT_DB, afectar_stock_en_compra_directa: false, habilitar_recepcion_compra: false, habilitar_matching_3_vias: false });
      await expect(m.service.leerConfigComprasPantalla(EMPRESA)).resolves.toMatchObject({ habilitar_recepcion_compra: false });
      await expect(put(m, { habilitar_recepcion_compra: true })).resolves.toMatchObject({ habilitar_recepcion_compra: true });
      expect(m.audit.logEnTransaccion.mock.calls[0][1]).toMatchObject({
        old_value: { habilitar_recepcion_compra: false },
        new_value: { habilitar_recepcion_compra: true },
      });
    });
  });

  describe('fila 8: OC apagada', () => {
    it('el matching queda guardado en false y la constancia lo incluye', async () => {
      const m = montar();
      const r = await put(m, { habilitar_orden_compra: false });
      expect(r).toMatchObject({ habilitar_orden_compra: false, habilitar_matching_3_vias: false });
      expect((m.guardada() as any).habilitar_matching_3_vias).toBe(false);
      expect(m.audit.logEnTransaccion.mock.calls[0][1]).toMatchObject({
        old_value: { habilitar_orden_compra: true, habilitar_matching_3_vias: true },
        new_value: { habilitar_orden_compra: false, habilitar_matching_3_vias: false },
      });
    });
  });

  describe('filas 9–11: aprobación de OC y OP', () => {
    it('para las combinaciones de requiere / workflow / obligatorio / pago sin aprobación, la aprobación de la OP da lo mismo antes y después', async () => {
      const servicio = montar().service as any;
      const bool = [false, true];
      let n = 0;
      for (const requiere_aprobacion of bool)
        for (const usar_workflow of bool)
          for (const workflow_obligatorio of bool)
            for (const permite_pago_sin_aprobacion of bool) {
              const crudo = { ...DEFAULT_DB, requiere_aprobacion, usar_workflow, workflow_obligatorio, permite_pago_sin_aprobacion };
              // Antes: el normalizador de hoy derivaba usar_workflow y requiere_aprobacion al guardar.
              const antes = requiereAprobacionOrdenPago(servicio.normalizeConfigCompras(crudo));
              // Después: se guarda lo que manda el control, sin derivar nada.
              const m = montar({ ...DEFAULT_DB, permite_pago_sin_aprobacion: !permite_pago_sin_aprobacion });
              const guardado = await put(m, { requiere_aprobacion, usar_workflow, workflow_obligatorio, permite_pago_sin_aprobacion });
              expect(requiereAprobacionOrdenPago(guardado)).toBe(antes);
              n++;
            }
      expect(n).toBe(16);
    });

    it('los tres valores del control (D7) se guardan tal cual: no, sí, obligatoria', async () => {
      for (const [dto, esperado] of [
        [{ requiere_aprobacion: false, usar_workflow: false, workflow_obligatorio: false }, false],
        [{ requiere_aprobacion: true, usar_workflow: true, workflow_obligatorio: false }, true],
        [{ requiere_aprobacion: true, usar_workflow: true, workflow_obligatorio: true }, true],
      ] as const) {
        const m = montar({ ...DEFAULT_DB, permite_pago_sin_aprobacion: false });
        const r = await put(m, dto);
        expect(r).toMatchObject(dto);
        expect(requiereAprobacionOrdenPago(r)).toBe(esperado);
      }
    });
  });

  describe('plan de pagos', () => {
    it('el DTO acepta SEMANAL/QUINCENAL/MENSUAL, día de semana 1–7 y día del mes 1–31, y rechaza el resto con 400', async () => {
      for (const ok of [{ plan_pagos_periodicidad: 'QUINCENAL' }, { plan_pagos_dia_semana: 1 }, { plan_pagos_dia_semana: 7 }, { plan_pagos_dia_mes: 1 }, { plan_pagos_dia_mes: 31 }]) {
        await expect(validarDto(UpdateConfigComprasDto, ok)).resolves.toBeDefined();
      }
      for (const mal of [{ plan_pagos_periodicidad: 'DIARIA' }, { plan_pagos_dia_semana: 0 }, { plan_pagos_dia_semana: 8 }, { plan_pagos_dia_mes: 0 }, { plan_pagos_dia_mes: 32 }, { plan_pagos_dia_mes: 1.5 }]) {
        await expect(validarDto(UpdateConfigComprasDto, mal)).rejects.toMatchObject({ status: 400 });
      }
    });

    it('cambiar la periodicidad se guarda y se audita', async () => {
      const m = await montar();
      await put(m, { plan_pagos_periodicidad: 'MENSUAL', plan_pagos_dia_mes: 15 });
      expect(m.audit.logEnTransaccion.mock.calls[0][1]).toMatchObject({
        old_value: { plan_pagos_periodicidad: 'SEMANAL', plan_pagos_dia_mes: 31 },
        new_value: { plan_pagos_periodicidad: 'MENSUAL', plan_pagos_dia_mes: 15 },
      });
    });
  });

  describe('modo de requisiciones', () => {
    it('PUT { habilitar_requisicion_compra: false } sobre una fila obligatoria: MODO_REQUISICION_INVALIDO, sin escribir ni auditar', async () => {
      const m = montar({ ...DEFAULT_DB, habilitar_requisicion_compra: true, modo_flujo_compra: 'requisicion_obligatoria' });
      expect(await rechazo(put(m, { habilitar_requisicion_compra: false }))).toMatchObject({ codigo: 'MODO_REQUISICION_INVALIDO' });
      expect(m.config_compras.update).not.toHaveBeenCalled();
      expect(m.audit.logEnTransaccion).not.toHaveBeenCalled();
    });

    it('apagadas con modo opcional: MODO_REQUISICION_INVALIDO', async () => {
      const m = montar();
      expect(await rechazo(put(m, { habilitar_requisicion_compra: false, modo_flujo_compra: 'requisicion_opcional' }))).toMatchObject({
        codigo: 'MODO_REQUISICION_INVALIDO',
      });
    });
  });
});
