/**
 * PUT /presupuestos/config con permiso de configuración (revisión final de Configuración, I1).
 *
 * Mismo criterio que /ordenes-venta/config: ADMINISTRACION + submódulo ADM_PRESUPUESTOS_CFG y alguno de
 * ADM_PRC_CONFIG_EDITAR | ADM_EMP_EMPRESA_EDITAR. Un vendedor (VEN_PRE_PRESUPUESTO_EDITAR) ya no la cambia.
 * GET /presupuestos/config sigue con VEN_PRE_PRESUPUESTO_VER (las pantallas de presupuestos leen vigencia y prefijo).
 * Los guards corren de verdad contra un Prisma falso; solo el JWT se reemplaza.
 */
import { ExecutionContext, INestApplication, ValidationPipe, VersioningType } from '@nestjs/common';
import { Test } from '@nestjs/testing';
import { AuthGuard } from '@nestjs/passport';
import request from 'supertest';
import { PrismaService } from '../prisma/prisma.service';
import { PresupuestosController } from './presupuestos.controller';
import { PresupuestosService } from './presupuestos.service';
import { PresupuestosPdfService } from './presupuestos-pdf.service';
import { PresupuestosPublicoService } from './presupuestos-publico.service';
import { PresupuestosAprobacionService } from './presupuestos-aprobacion.service';
import { PresupuestosConversionService } from './presupuestos-conversion.service';
import { PresupuestosDashboardService } from './presupuestos-dashboard.service';
import { PresupuestosResumenService } from './presupuestos-resumen.service';

const EMPRESA = '11111111-1111-4111-8111-111111111111';

interface Mundo {
  privilegios: string[];
  modulos: string[];
  excluidos: string[];
}

function prismaFalso(mundo: Mundo) {
  const submodulos: Record<string, { id: string; modulo_id: string; es_addon: boolean }> = {
    ADM_PRESUPUESTOS_CFG: { id: 'sub-prc', modulo_id: 'mod-ADMINISTRACION', es_addon: false },
    VENTAS_PRESUPUESTOS: { id: 'sub-pre', modulo_id: 'mod-VENTAS', es_addon: false },
  };
  // Privilegio → submódulo, para PrivilegioGuard (GET /presupuestos/config).
  const privilegio = (codigo: string) =>
    codigo.startsWith('VEN_PRE_') ? { id: `p-${codigo}`, submodulos: { ...submodulos.VENTAS_PRESUPUESTOS, codigo: 'VENTAS_PRESUPUESTOS', modulos: { codigo: 'VENTAS' } } } : null;
  return {
    usuario: { findUnique: jest.fn().mockResolvedValue({ is_superadmin: false, username: 'u' }) },
    empresas: { findUnique: jest.fn().mockResolvedValue({ type: 'empresa' }) },
    suscripciones: { findFirst: jest.fn().mockResolvedValue({ id: 'sus-1' }) },
    suscripcion_modulos: {
      findFirst: jest.fn(async ({ where }: any) => {
        const codigo = where.modulos?.codigo ?? String(where.modulo_id ?? '').replace('mod-', '');
        return mundo.modulos.includes(codigo) ? { id: `sm-${codigo}` } : null;
      }),
      findMany: jest.fn(async () => mundo.modulos.map((m) => ({ modulo_id: `mod-${m}` }))),
    },
    submodulos: { findFirst: jest.fn(async ({ where }: any) => submodulos[where.codigo] ?? null) },
    suscripcion_submodulos: {
      findFirst: jest.fn(async ({ where }: any) => {
        const codigo = Object.entries(submodulos).find(([, s]) => s.id === where.submodulo_id)?.[0];
        if (where.active === false) return codigo && mundo.excluidos.includes(codigo) ? { id: 'excl' } : null;
        return null;
      }),
      findMany: jest.fn(async () => mundo.excluidos.map((c) => ({ submodulo_id: submodulos[c].id, active: false, fecha_fin_prueba: null }))),
    },
    privilegios: { findMany: jest.fn().mockResolvedValue([]), findFirst: jest.fn(async ({ where }: any) => privilegio(where.codigo)) },
    perfiles_privilegios: {
      findFirst: jest.fn(async ({ where }: any) => {
        const pedido = where.privilegios?.codigo;
        const codigos: string[] = typeof pedido === 'string' ? [pedido] : (pedido?.in ?? []);
        return codigos.some((c) => mundo.privilegios.includes(c)) ? { id: 'pp' } : null;
      }),
    },
  };
}

describe('PUT /presupuestos/config', () => {
  let app: INestApplication;
  let mundo: Mundo;
  const servicio = {
    getConfig: jest.fn().mockResolvedValue({ empresa_id: EMPRESA, dias_vigencia: 15 }),
    updateConfig: jest.fn().mockResolvedValue({ empresa_id: EMPRESA, monto_umbral_aprobacion: 1 }),
  };

  beforeEach(async () => {
    jest.clearAllMocks();
    mundo = { privilegios: [], modulos: ['ADMINISTRACION', 'VENTAS'], excluidos: [] };
    const vacio = {};
    const modulo = await Test.createTestingModule({
      controllers: [PresupuestosController],
      providers: [
        { provide: PresupuestosService, useValue: servicio },
        { provide: PresupuestosPdfService, useValue: vacio },
        { provide: PresupuestosPublicoService, useValue: vacio },
        { provide: PresupuestosAprobacionService, useValue: vacio },
        { provide: PresupuestosConversionService, useValue: vacio },
        { provide: PresupuestosDashboardService, useValue: vacio },
        { provide: PresupuestosResumenService, useValue: vacio },
        { provide: PrismaService, useValue: prismaFalso(mundo) },
      ],
    })
      .overrideGuard(AuthGuard('jwt'))
      .useValue({
        canActivate: (ctx: ExecutionContext) => {
          ctx.switchToHttp().getRequest().user = { id: 'usr-1', empresa_id: EMPRESA };
          return true;
        },
      })
      .compile();
    app = modulo.createNestApplication();
    app.enableVersioning({ type: VersioningType.URI });
    app.useGlobalPipes(new ValidationPipe({ whitelist: true, transform: true }));
    await app.init();
  });

  afterEach(async () => {
    await app.close();
  });

  const http = () => request(app.getHttpServer());
  const cuerpo = { monto_umbral_aprobacion: 99999999 };

  it('un vendedor (VEN_PRE_PRESUPUESTO_EDITAR) → 403 y no escribe', async () => {
    mundo.privilegios = ['VEN_PRE_PRESUPUESTO_VER', 'VEN_PRE_PRESUPUESTO_EDITAR'];
    expect((await http().put('/v1/presupuestos/config').send(cuerpo)).status).toBe(403);
    expect(servicio.updateConfig).not.toHaveBeenCalled();
  });

  it('con ADM_PRC_CONFIG_VER solo → 403', async () => {
    mundo.privilegios = ['ADM_PRC_CONFIG_VER'];
    expect((await http().put('/v1/presupuestos/config').send(cuerpo)).status).toBe(403);
    expect(servicio.updateConfig).not.toHaveBeenCalled();
  });

  it.each(['ADM_PRC_CONFIG_EDITAR', 'ADM_EMP_EMPRESA_EDITAR'])('con %s → 200 en la empresa del token', async (priv) => {
    mundo.privilegios = [priv];
    expect((await http().put('/v1/presupuestos/config').send(cuerpo)).status).toBe(200);
    expect(servicio.updateConfig).toHaveBeenCalledWith(EMPRESA, expect.objectContaining(cuerpo));
  });

  it('sin el submódulo ADM_PRESUPUESTOS_CFG → 403', async () => {
    mundo.privilegios = ['ADM_PRC_CONFIG_EDITAR'];
    mundo.excluidos = ['ADM_PRESUPUESTOS_CFG'];
    expect((await http().put('/v1/presupuestos/config').send(cuerpo)).status).toBe(403);
  });

  it('sin el módulo ADMINISTRACION → 403', async () => {
    mundo.privilegios = ['ADM_PRC_CONFIG_EDITAR'];
    mundo.modulos = ['VENTAS'];
    expect((await http().put('/v1/presupuestos/config').send(cuerpo)).status).toBe(403);
  });

  it('sin el submódulo funcional VENTAS_PRESUPUESTOS (con la compuerta y el permiso) → 403 y no escribe', async () => {
    mundo.privilegios = ['ADM_PRC_CONFIG_EDITAR'];
    mundo.excluidos = ['VENTAS_PRESUPUESTOS'];
    expect((await http().put('/v1/presupuestos/config').send(cuerpo)).status).toBe(403);
    expect(servicio.updateConfig).not.toHaveBeenCalled();
  });

  it('GET /presupuestos/config sigue con VEN_PRE_PRESUPUESTO_VER', async () => {
    mundo.privilegios = ['VEN_PRE_PRESUPUESTO_VER'];
    expect((await http().get('/v1/presupuestos/config')).status).toBe(200);
    expect(servicio.getConfig).toHaveBeenCalledWith(EMPRESA);
  });

  it('GET /presupuestos/config sin VENTAS_PRESUPUESTOS en el plan → 403', async () => {
    mundo.privilegios = ['VEN_PRE_PRESUPUESTO_VER'];
    mundo.excluidos = ['VENTAS_PRESUPUESTOS'];
    expect((await http().get('/v1/presupuestos/config')).status).toBe(403);
  });

  it('GET /presupuestos/config sin el permiso → 403', async () => {
    mundo.privilegios = ['VEN_PRE_PRESUPUESTO_EDITAR'];
    expect((await http().get('/v1/presupuestos/config')).status).toBe(403);
  });
});
