/**
 * Tablero «lo mío»: en alcance propio el pipeline de presupuestos cuenta solo los del vendedor, en las 5 consultas
 * (groupBy y findMany de `whereBase`, la serie por documento, `vencenPronto` y los 2 SQL de `serieMensual`).
 */
import { PresupuestosDashboardService } from './presupuestos-dashboard.service';
import { resolverAlcancePropio, UUID_NULO } from 'src/utils/alcance-propio';

jest.mock('src/utils/alcance-sucursal', () => ({
  ...jest.requireActual('src/utils/alcance-sucursal'),
  alcanceSucursalUsuario: jest.fn().mockResolvedValue(null),
}));
jest.mock('src/utils/alcance-propio', () => ({
  ...jest.requireActual('src/utils/alcance-propio'),
  resolverAlcancePropio: jest.fn(),
}));
const alcanceMock = resolverAlcancePropio as jest.Mock;

function crearPrisma() {
  return {
    empresa_monedas: { findFirst: jest.fn().mockResolvedValue({ moneda_id: 'm-pyg' }) },
    moneda: {
      findFirst: jest.fn().mockResolvedValue({ id: 'm-pyg', codigo: 'PYG' }),
      findUnique: jest.fn().mockResolvedValue({ id: 'm-pyg', codigo: 'PYG' }),
      findMany: jest.fn().mockResolvedValue([]),
    },
    empresas_sucursales: { findMany: jest.fn().mockResolvedValue([]), findFirst: jest.fn().mockResolvedValue(null) },
    presupuesto_cab: {
      groupBy: jest.fn().mockResolvedValue([]),
      findMany: jest.fn().mockResolvedValue([]),
      count: jest.fn().mockResolvedValue(0),
    },
    presupuesto_config: { findUnique: jest.fn().mockResolvedValue(null) },
    $queryRaw: jest.fn().mockResolvedValue([]),
  } as any;
}

async function correr(alcance: unknown, vista: 'tablero' | null = 'tablero') {
  alcanceMock.mockReset().mockResolvedValue(alcance);
  const prisma = crearPrisma();
  await new PresupuestosDashboardService(prisma).getDashboard('emp', { desde: '2026-11-01', hasta: '2026-11-07' }, 'usr', vista ?? undefined);
  const wheres = [
    prisma.presupuesto_cab.groupBy.mock.calls[0][0].where,
    ...prisma.presupuesto_cab.findMany.mock.calls.map((c: any[]) => c[0].where),
    prisma.presupuesto_cab.count.mock.calls[0][0].where,
  ];
  // Cada $queryRaw: [strings, ...valores]. El SQL se arma con Prisma.sql anidado: se mira texto y valores aplanados.
  const sqls = prisma.$queryRaw.mock.calls.map(([strings, ...valores]: any[]) => ({
    texto: strings.join('?') + JSON.stringify(valores.map((v: any) => v?.strings ?? v)),
    valores: JSON.stringify(valores),
  }));
  return { prisma, wheres, sqls };
}

describe('PresupuestosDashboardService.getDashboard en alcance propio', () => {
  it('PROPIO vendedor: las 3 consultas Prisma (4 llamadas) y los 2 SQL filtran por su vendedor_id', async () => {
    const { wheres, sqls } = await correr({ tipo: 'PROPIO', vendedorId: 'v1', cobradorId: null, nombre: 'Ana' });
    expect(alcanceMock).toHaveBeenCalledWith(expect.anything(), 'usr', 'emp');
    expect(wheres).toHaveLength(4);
    for (const w of wheres) expect(w.vendedor_id).toBe('v1');
    expect(sqls).toHaveLength(2);
    for (const s of sqls) {
      expect(s.texto).toContain('vendedor_id =');
      expect(s.valores).toContain('"v1"');
    }
  });

  it('PROPIO sin vendedor (cobrador puro): UUID_NULO en todo', async () => {
    const { wheres, sqls } = await correr({ tipo: 'PROPIO', vendedorId: null, cobradorId: 'c1', nombre: 'Ana' });
    for (const w of wheres) expect(w.vendedor_id).toBe(UUID_NULO);
    for (const s of sqls) expect(s.valores).toContain(UUID_NULO);
  });

  it('TODO: los where y el SQL son los de siempre (sin vendedor_id)', async () => {
    const { wheres, sqls } = await correr({ tipo: 'TODO' });
    const desde = new Date('2026-11-01');
    const hasta = new Date('2026-11-07');
    expect(wheres[0]).toEqual({ empresa_id: 'emp', deleted: false, fecha_emision: { gte: desde, lte: hasta } });
    expect(wheres[1]).toEqual(wheres[0]);
    expect(Object.keys(wheres[2]).sort()).toEqual(['AND', 'deleted', 'empresa_id']);
    expect(Object.keys(wheres[3]).sort()).toEqual(['deleted', 'empresa_id', 'estado', 'fecha_vigencia']);
    for (const w of wheres) expect(JSON.stringify(w)).not.toContain('vendedor_id');
    for (const s of sqls) expect(s.texto).not.toContain('vendedor_id');
  });

  it('sin vista=tablero (pantallas viejas): ni consulta el alcance propio, sin vendedor_id', async () => {
    const { wheres, sqls } = await correr({ tipo: 'PROPIO', vendedorId: 'v1', cobradorId: null, nombre: 'Ana', sinVinculo: false }, null);
    expect(alcanceMock).not.toHaveBeenCalled();
    for (const w of wheres) expect(JSON.stringify(w)).not.toContain('vendedor_id');
    for (const s of sqls) expect(s.texto).not.toContain('vendedor_id');
  });

  it('vista=tablero sin vínculo: UUID_NULO en todo', async () => {
    const { wheres, sqls } = await correr({ tipo: 'PROPIO', vendedorId: null, cobradorId: null, nombre: '', sinVinculo: true });
    for (const w of wheres) expect(w.vendedor_id).toBe(UUID_NULO);
    for (const s of sqls) expect(s.valores).toContain(UUID_NULO);
  });
});
