import { alcanceSucursalUsuario } from 'src/utils/alcance-sucursal';
import { PagosProveedorService } from './pagos-proveedor.service';

jest.mock('src/utils/alcance-sucursal', () => ({ alcanceSucursalUsuario: jest.fn() }));
const alcanceMock = alcanceSucursalUsuario as jest.MockedFunction<typeof alcanceSucursalUsuario>;

/**
 * `GET /pagos-proveedor/config-flujo` (FlujoOp): la config de OP ya resuelta para el formulario, con la
 * fórmula de aprobación de un solo lugar (`reglas-op.ts`), el fin del período del plan de pagos en la
 * fecha de Paraguay y las sucursales del alcance del usuario.
 */
describe('PagosProveedorService.getConfigFlujo (pagos-proveedor/config-flujo)', () => {
  /** Fila 1 de la matriz: real de las 9 empresas locales. */
  const REAL = {
    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 SUCURSALES = [
    { id: 's-1', descripcion: 'Casa central', config: null },
    { id: 's-2', descripcion: 'Sucursal Este', config: { requiere_caja_pagos_proveedor: true } },
  ];

  const armar = (config: Record<string, unknown>, opts: { numeradas?: string[]; sucursales?: any[] } = {}) => {
    const prisma: any = {
      config_compras: { findUnique: jest.fn().mockResolvedValue(config), create: jest.fn() },
      empresas_sucursales: { findMany: jest.fn().mockResolvedValue(opts.sucursales ?? SUCURSALES) },
      $queryRaw: jest.fn().mockResolvedValue((opts.numeradas ?? ['s-1']).map((sucursal_id) => ({ sucursal_id }))),
    };
    prisma.$transaction = jest.fn((cb: (tx: any) => unknown) => cb(prisma));
    return { service: new PagosProveedorService(prisma, {} as any, {} as any, {} as any), prisma };
  };

  beforeEach(() => {
    // Lunes 2026-10-05 10:00 en Paraguay (-03): la fecha fija de la red e2e.
    jest.useFakeTimers({ now: new Date('2026-10-05T13:00:00.000Z') });
    alcanceMock.mockReset();
    alcanceMock.mockResolvedValue(null);
  });
  afterEach(() => jest.useRealTimers());

  describe('requiere_aprobacion_orden y aplica_pago_al_guardar con las filas de la matriz', () => {
    const filas: Array<[string, Record<string, unknown>, boolean, boolean]> = [
      ['fila 1 (real): sin aprobación, paga al guardar', {}, false, true],
      ['fila 3: sin aprobación y aplicar_pago_al_guardar = false', { aplicar_pago_al_guardar: false }, false, false],
      ['fila 4: requiere_aprobacion sin permite_pago_sin_aprobacion', { requiere_aprobacion: true, permite_pago_sin_aprobacion: false }, true, false],
      ['fila 5: requiere_aprobacion + permite_pago_sin_aprobacion', { requiere_aprobacion: true }, false, true],
      ['fila 6: workflow_obligatorio (con permite_pago_sin_aprobacion)', { workflow_obligatorio: true }, true, false],
    ];
    it.each(filas)('%s', async (_n, cambios, aprob, aplica) => {
      const { service } = armar({ ...REAL, ...cambios });
      const flujo = await service.getConfigFlujo('emp-1', 'u-1');
      expect(flujo.requiere_aprobacion_orden).toBe(aprob);
      expect(flujo.aplica_pago_al_guardar).toBe(aplica);
    });

    it('trae los demás campos de la config, tal cual los resuelve getConfigCompras', async () => {
      const { service } = armar({ ...REAL, permitir_pago_parcial: true, incluir_contado_en_orden_pago: true, generar_cxp_automatico: false });
      const flujo = await service.getConfigFlujo('emp-1', 'u-1');
      expect(flujo).toMatchObject({
        habilitar_orden_pago: true,
        permitir_pago_parcial: true,
        generar_cxp_automatico: false,
        incluir_contado_en_orden_pago: true,
      });
      expect(Object.keys(flujo).sort()).toEqual(
        [
          'habilitar_orden_pago',
          'requiere_aprobacion_orden',
          'aplica_pago_al_guardar',
          'permitir_pago_parcial',
          'generar_cxp_automatico',
          'incluir_contado_en_orden_pago',
          'plan_pagos',
          'sucursales',
        ].sort(),
      );
    });
  });

  describe('plan_pagos.fin_periodo_actual el lunes 2026-10-05', () => {
    it.each([
      ['SEMANAL', '2026-10-11'],
      ['QUINCENAL', '2026-10-15'],
      ['MENSUAL', '2026-10-31'],
    ])('%s → %s', async (periodicidad, fin) => {
      const { service } = armar({ ...REAL, plan_pagos_periodicidad: periodicidad });
      const flujo = await service.getConfigFlujo('emp-1', 'u-1');
      expect(flujo.plan_pagos).toEqual({ periodicidad, fin_periodo_actual: fin });
    });

    it('el domingo 11/10 a las 22:30 de Paraguay (01:30 UTC del lunes 12) sigue en la semana del 05 al 11', async () => {
      jest.setSystemTime(new Date('2026-10-12T01:30:00.000Z'));
      const { service } = armar({ ...REAL, plan_pagos_periodicidad: 'SEMANAL' });
      expect((await service.getConfigFlujo('emp-1', 'u-1')).plan_pagos.fin_periodo_actual).toBe('2026-10-11');
    });
  });

  describe('sucursales del alcance con tiene_numeracion y requiere_caja', () => {
    it('con alcance restringido lista solo esas sucursales activas y resuelve numeración y caja por sucursal', async () => {
      alcanceMock.mockResolvedValue({ sucursalIds: ['s-1', 's-2'], puntosEstablecimiento: [], depositoIds: [] });
      const { service, prisma } = armar(REAL, { numeradas: ['s-1'] });
      const flujo = await service.getConfigFlujo('emp-1', 'u-1');

      expect(alcanceMock).toHaveBeenCalledWith(prisma, 'u-1', 'emp-1');
      expect(prisma.empresas_sucursales.findMany.mock.calls[0][0].where).toEqual({
        empresa_id: 'emp-1',
        active: true,
        id: { in: ['s-1', 's-2'] },
      });
      expect(flujo.sucursales).toEqual([
        { id: 's-1', nombre: 'Casa central', tiene_numeracion: true, requiere_caja: false },
        { id: 's-2', nombre: 'Sucursal Este', tiene_numeracion: false, requiere_caja: true },
      ]);
    });

    it('tiene_numeracion usa la consulta de getNextNumeroOrdenPago (código 400, activa) sin FOR UPDATE', async () => {
      const { service, prisma } = armar(REAL);
      await service.getConfigFlujo('emp-1', 'u-1');
      expect(prisma.$queryRaw).toHaveBeenCalledTimes(1);
      const sql = prisma.$queryRaw.mock.calls[0][0];
      const texto = String(sql.sql ?? sql).replace(/\s+/g, ' ');
      expect(texto).toContain('td.codigo = 400');
      expect(texto).toContain('nd.active = true');
      expect(texto).not.toContain('FOR UPDATE');
      expect(sql.values).toEqual(expect.arrayContaining(['emp-1', 's-1', 's-2']));
    });

    it('tiene_numeracion excluye las numeraciones agotadas (numero_actual >= numero_final), con el mismo fragmento que el alta', async () => {
      const { service, prisma } = armar(REAL);
      await service.getConfigFlujo('emp-1', 'u-1');
      const texto = String(prisma.$queryRaw.mock.calls[0][0].sql).replace(/\s+/g, ' ');
      // numero_actual es el próximo número a usar: con numero_actual = numero_final ya no queda ninguno (como Facturas).
      expect(texto).toContain('AND (nd.numero_final IS NULL OR nd.numero_actual < nd.numero_final OR nd.numero_final = 0)');
      const fin = 'nd.numero_final = 0)';
      const desde = (s: string) => s.slice(s.indexOf('FROM numeraciones_documento'), s.indexOf(fin) + fin.length);
      const alta = String((service as any).desdeNumeracionesOrdenPago('emp-1', ['s-1', 's-2']).sql).replace(/\s+/g, ' ');
      expect(desde(texto)).toBe(desde(alta));
    });

    it('sin restricción (alcance null) no filtra por id; sin sucursales no consulta numeraciones', async () => {
      const { service, prisma } = armar(REAL, { sucursales: [] });
      const flujo = await service.getConfigFlujo('emp-1', 'u-1');
      expect(prisma.empresas_sucursales.findMany.mock.calls[0][0].where).toEqual({ empresa_id: 'emp-1', active: true });
      expect(prisma.$queryRaw).not.toHaveBeenCalled();
      expect(flujo.sucursales).toEqual([]);
    });
  });
});
