/**
 * Configuración de Órdenes de venta con su propio permiso (carril A de Configuración, T1).
 *
 * GET/PUT /ordenes-venta/config: ADMINISTRACION + submódulo ADM_ORDEN_VENTA_CFG y alguno de
 *   leer:    ADM_OVC_CONFIG_VER | ADM_OVC_CONFIG_EDITAR | ADM_EMP_EMPRESA_EDITAR
 *   guardar: ADM_OVC_CONFIG_EDITAR | ADM_EMP_EMPRESA_EDITAR
 * Los guards corren de verdad (ModuleGuard, PermissionGuard, SubmoduloGuard, AlgunPrivilegioGuard) contra un Prisma
 * falso que modela la suscripción y los privilegios del usuario; 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 { AuditInterceptor } from '../audit/audit.interceptor';
import { PrismaService } from '../prisma/prisma.service';
import { OrdenFacturacionService } from './orden-facturacion.service';
import { OrdenesVentaController } from './ordenes-venta.controller';
import { PedidosService } from './pedidos.service';

const EMPRESA = '11111111-1111-4111-8111-111111111111';
const OTRA = '22222222-2222-4222-8222-222222222222';
const MONEDA_USD = 'moneda-usd';

interface Mundo {
  privilegios: string[];
  modulos: string[];
  /** Submódulos excluidos para la empresa (`suscripcion_submodulos.active = false`). */
  excluidos: string[];
}

function prismaFalso(mundo: Mundo) {
  const submodulos: Record<string, { id: string; modulo_id: string; es_addon: boolean }> = {
    ADM_ORDEN_VENTA_CFG: { id: 'sub-ovc', modulo_id: 'mod-ADMINISTRACION', es_addon: false },
    VENTAS_ORDEN_VENTA: { id: 'sub-ov', modulo_id: 'mod-VENTAS', es_addon: false },
  };
  const empresa = {
    id: EMPRESA,
    type: 'empresa',
    orden_requiere_aprobacion: true,
    orden_monto_aprobacion: { toString: () => '1500000.50' },
    presupuesto_facturar_sin_ov: false,
  };
  return {
    usuario: { findUnique: jest.fn().mockResolvedValue({ is_superadmin: false, username: 'u' }) },
    empresas: {
      findUnique: jest.fn(async ({ where, select }: any) => {
        if (where.id !== EMPRESA) return null;
        return Object.fromEntries(Object.keys(select).map((k) => [k, (empresa as any)[k]]));
      }),
      update: jest.fn(async ({ data, select }: any) => {
        Object.assign(empresa, data);
        return Object.fromEntries(Object.keys(select).map((k) => [k, (empresa as any)[k]]));
      }),
    },
    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([]) },
    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;
      }),
    },
    empresa_monedas: { findFirst: jest.fn().mockResolvedValue({ moneda_id: MONEDA_USD }) },
    moneda: {
      findUnique: jest.fn(async ({ where }: any) => (where.id === MONEDA_USD ? { id: MONEDA_USD, codigo: 'USD' } : null)),
      findFirst: jest.fn().mockResolvedValue(null),
    },
    _empresa: empresa,
  };
}

describe('GET/PUT /ordenes-venta/config', () => {
  let app: INestApplication;
  let mundo: Mundo;
  let prisma: ReturnType<typeof prismaFalso>;
  const pedidos = { findOneOrden: jest.fn().mockResolvedValue({ message: 'ok', data: { id: 'ov-1' } }) };

  beforeEach(async () => {
    mundo = { privilegios: [], modulos: ['ADMINISTRACION', 'VENTAS'], excluidos: [] };
    prisma = prismaFalso(mundo);
    const servicio = Object.assign(Object.create(PedidosService.prototype), { prisma }, pedidos);
    const modulo = await Test.createTestingModule({
      controllers: [OrdenesVentaController],
      providers: [
        { provide: PedidosService, useValue: servicio },
        { provide: OrdenFacturacionService, useValue: {} },
        { provide: PrismaService, useValue: prisma },
      ],
    })
      .overrideGuard(AuthGuard('jwt'))
      .useValue({
        canActivate: (ctx: ExecutionContext) => {
          ctx.switchToHttp().getRequest().user = { id: 'usr-1', empresa_id: EMPRESA };
          return true;
        },
      })
      .overrideInterceptor(AuditInterceptor)
      .useValue({ intercept: (_: unknown, next: any) => next.handle() })
      .compile();
    app = modulo.createNestApplication();
    app.enableVersioning({ type: VersioningType.URI });
    app.useGlobalPipes(new ValidationPipe({ whitelist: true, forbidNonWhitelisted: true, transform: true }));
    await app.init();
  });

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

  const http = () => request(app.getHttpServer());

  it.each(['ADM_OVC_CONFIG_VER', 'ADM_OVC_CONFIG_EDITAR', 'ADM_EMP_EMPRESA_EDITAR'])('leer con %s → 200', async (priv) => {
    mundo.privilegios = [priv];
    const res = await http().get('/v1/ordenes-venta/config');
    expect(res.status).toBe(200);
    expect(res.body).toEqual({
      message: expect.any(String),
      data: {
        orden_requiere_aprobacion: true,
        orden_monto_aprobacion: '1500000.50',
        presupuesto_facturar_sin_ov: false,
        moneda: { codigo: 'USD' },
      },
    });
  });

  it('leer sin ninguno de los tres → 403', async () => {
    mundo.privilegios = ['VEN_OV_ORDEN_VENTA_VER', 'ADM_EMP_EMPRESA_VER'];
    expect((await http().get('/v1/ordenes-venta/config')).status).toBe(403);
  });

  it('leer sin el submódulo ADM_ORDEN_VENTA_CFG → 403', async () => {
    mundo.privilegios = ['ADM_OVC_CONFIG_VER'];
    mundo.excluidos = ['ADM_ORDEN_VENTA_CFG'];
    expect((await http().get('/v1/ordenes-venta/config')).status).toBe(403);
  });

  it('leer sin el submódulo funcional VENTAS_ORDEN_VENTA (con la compuerta y el permiso) → 403', async () => {
    mundo.privilegios = ['ADM_OVC_CONFIG_VER'];
    mundo.excluidos = ['VENTAS_ORDEN_VENTA'];
    expect((await http().get('/v1/ordenes-venta/config')).status).toBe(403);
  });

  it('leer y guardar sin VENTAS en el plan → 403 y no escribe', async () => {
    mundo.privilegios = ['ADM_OVC_CONFIG_VER', 'ADM_OVC_CONFIG_EDITAR'];
    mundo.modulos = ['ADMINISTRACION'];
    expect((await http().get('/v1/ordenes-venta/config')).status).toBe(403);
    expect((await http().put('/v1/ordenes-venta/config').send({ presupuesto_facturar_sin_ov: true })).status).toBe(403);
    expect(prisma.empresas.update).not.toHaveBeenCalled();
  });

  it('guardar sin VENTAS_ORDEN_VENTA → 403 y no escribe', async () => {
    mundo.privilegios = ['ADM_OVC_CONFIG_EDITAR'];
    mundo.excluidos = ['VENTAS_ORDEN_VENTA'];
    expect((await http().put('/v1/ordenes-venta/config').send({ presupuesto_facturar_sin_ov: true })).status).toBe(403);
    expect(prisma.empresas.update).not.toHaveBeenCalled();
  });

  it('leer sin el módulo ADMINISTRACION → 403', async () => {
    mundo.privilegios = ['ADM_OVC_CONFIG_VER'];
    mundo.modulos = ['VENTAS'];
    expect((await http().get('/v1/ordenes-venta/config')).status).toBe(403);
  });

  it('guardar con ADM_OVC_CONFIG_VER solo → 403 y no escribe', async () => {
    mundo.privilegios = ['ADM_OVC_CONFIG_VER'];
    const res = await http().put('/v1/ordenes-venta/config').send({ orden_requiere_aprobacion: false });
    expect(res.status).toBe(403);
    expect(prisma.empresas.update).not.toHaveBeenCalled();
  });

  it.each(['ADM_OVC_CONFIG_EDITAR', 'ADM_EMP_EMPRESA_EDITAR'])('guardar con %s → 200', async (priv) => {
    mundo.privilegios = [priv];
    const res = await http()
      .put('/v1/ordenes-venta/config')
      .send({ orden_requiere_aprobacion: false, orden_monto_aprobacion: 2500000, presupuesto_facturar_sin_ov: true });
    expect(res.status).toBe(200);
    expect(res.body.data).toMatchObject({ orden_requiere_aprobacion: false, presupuesto_facturar_sin_ov: true, moneda: { codigo: 'USD' } });
  });

  it('un campo fuera de la whitelist (ruc) → 400 y no escribe', async () => {
    mundo.privilegios = ['ADM_OVC_CONFIG_EDITAR'];
    const res = await http().put('/v1/ordenes-venta/config').send({ orden_requiere_aprobacion: true, ruc: '80000000-1' });
    expect(res.status).toBe(400);
    expect(prisma.empresas.update).not.toHaveBeenCalled();
  });

  it('un monto negativo → 400', async () => {
    mundo.privilegios = ['ADM_OVC_CONFIG_EDITAR'];
    expect((await http().put('/v1/ordenes-venta/config').send({ orden_monto_aprobacion: -1 })).status).toBe(400);
  });

  it('el PUT solo escribe los tres campos y en la empresa del token', async () => {
    mundo.privilegios = ['ADM_OVC_CONFIG_EDITAR'];
    await http()
      .put('/v1/ordenes-venta/config?empresa_id=' + OTRA)
      .send({ orden_requiere_aprobacion: false, orden_monto_aprobacion: 0, presupuesto_facturar_sin_ov: true })
      .expect(200);
    expect(prisma.empresas.update).toHaveBeenCalledTimes(1);
    const arg = prisma.empresas.update.mock.calls[0][0];
    expect(arg.where).toEqual({ id: EMPRESA });
    expect(Object.keys(arg.data).sort()).toEqual(['orden_monto_aprobacion', 'orden_requiere_aprobacion', 'presupuesto_facturar_sin_ov']);
  });

  it('el PUT parcial solo escribe lo que llega', async () => {
    mundo.privilegios = ['ADM_OVC_CONFIG_EDITAR'];
    await http().put('/v1/ordenes-venta/config').send({ presupuesto_facturar_sin_ov: true }).expect(200);
    expect(prisma.empresas.update.mock.calls[0][0].data).toEqual({ presupuesto_facturar_sin_ov: true });
  });

  it('GET /ordenes-venta/:id sigue resolviendo (config no lo tapa)', async () => {
    mundo.privilegios = ['VEN_OV_ORDEN_VENTA_VER'];
    const id = '33333333-3333-4333-8333-333333333333';
    const res = await http().get(`/v1/ordenes-venta/${id}`);
    expect(res.status).toBe(200);
    expect(pedidos.findOneOrden).toHaveBeenCalledWith(id, EMPRESA);
  });
});
