import { ForbiddenException, NotFoundException } from '@nestjs/common';
import { GUARDS_METADATA } from '@nestjs/common/constants';
import { Reflector } from '@nestjs/core';
import { PrivilegioGuard } from 'src/auth/guards/privilegio.guard';
import { SEGURIDAD_SEED } from 'src/seguridad/seeds/seguridad.seed-data';
import { ClientesController } from './clientes.controller';
import { ClientesService } from './clientes.service';

/**
 * `PATCH /clientes/:id/credito` cambia el límite, el bloqueo y la mora máxima del cliente (dinero) y pedía solo JWT:
 * el servicio exigía «Editar cliente» únicamente si el cuerpo cambiaba algo, y nunca miraba el plan. Ahora la ruta lleva
 * `PrivilegioGuard` con VEN_CLI_CLIENTE_EDITAR (módulo VENTAS + submódulo VENTAS_CLIENTES contratados + permiso), y el
 * servicio busca el cliente siempre dentro de la empresa del token.
 */
describe('PATCH /clientes/:id/credito: módulo + submódulo + permiso + empresa', () => {
  const handler = (ClientesController.prototype as any).updateCreditConfig;
  const EMPRESA = 'emp-1';

  interface Mundo {
    tienePrivilegio?: boolean;
    submoduloExcluido?: boolean;
    moduloEnPlan?: boolean;
  }

  const prismaGuard = (m: Mundo = {}): any => ({
    usuario: { findUnique: jest.fn().mockResolvedValue({ is_superadmin: false, username: 'u' }) },
    empresas: { findUnique: jest.fn().mockResolvedValue({ type: 'subsidiary' }) },
    privilegios: {
      findFirst: jest.fn(({ where }: any) =>
        Promise.resolve(
          where.codigo === 'VEN_CLI_CLIENTE_EDITAR'
            ? { id: 'p1', submodulos: { id: 's1', codigo: 'VENTAS_CLIENTES', es_addon: false, modulo_id: 'm1', modulos: { codigo: 'VENTAS' } } }
            : null,
        ),
      ),
    },
    suscripciones: { findFirst: jest.fn().mockResolvedValue({ id: 'sus-1' }) },
    suscripcion_modulos: { findFirst: jest.fn().mockResolvedValue(m.moduloEnPlan === false ? null : { id: 'sm-1' }) },
    suscripcion_submodulos: { findFirst: jest.fn().mockResolvedValue(m.submoduloExcluido ? { id: 'ex-1' } : null) },
    perfiles_privilegios: { findFirst: jest.fn().mockResolvedValue(m.tienePrivilegio === false ? null : { id: 'pp-1' }) },
  });

  const pasarGuard = (m: Mundo = {}) => {
    const guard = new PrivilegioGuard(new Reflector(), prismaGuard(m));
    const ctx: any = {
      getHandler: () => handler,
      getClass: () => ClientesController,
      switchToHttp: () => ({ getRequest: () => ({ user: { id: 'u1', empresa_id: EMPRESA } }) }),
    };
    return guard.canActivate(ctx);
  };

  const servicio = (clienteDeLaEmpresa: boolean) => {
    const service = Object.create(ClientesService.prototype) as any;
    service.logger = { log: jest.fn() };
    service.auditService = { log: jest.fn() };
    service.prisma = {
      clientes: {
        findFirst: jest.fn(({ where }: any) =>
          Promise.resolve(
            clienteDeLaEmpresa && where?.personas?.empresa_id === EMPRESA
              ? { id: 'c1', bloqueado_credito: true, limite_credito: 1000, credito_habilitado: true }
              : null,
          ),
        ),
        update: jest.fn().mockResolvedValue({ id: 'c1' }),
      },
      usuario: { findUnique: jest.fn().mockResolvedValue({ is_superadmin: false }) },
      perfiles_privilegios: { findFirst: jest.fn().mockResolvedValue({ id: 'pp' }) },
    };
    return service;
  };

  it('el privilegio existe en el seed, en VENTAS › VENTAS_CLIENTES', () => {
    const sub = SEGURIDAD_SEED.find((m) => m.codigo === 'VENTAS')?.submodulos.find((s) => s.codigo === 'VENTAS_CLIENTES');
    expect(sub?.privilegios.map((p) => p.codigo)).toContain('VEN_CLI_CLIENTE_EDITAR');
  });

  it('la ruta lleva PrivilegioGuard', () => {
    const guards = Reflect.getMetadata(GUARDS_METADATA, handler) ?? [];
    expect(guards).toContain(PrivilegioGuard);
  });

  it('sin el permiso: 403', async () => {
    await expect(pasarGuard({ tienePrivilegio: false })).rejects.toBeInstanceOf(ForbiddenException);
  });

  it('con el submódulo Clientes fuera del plan: 403', async () => {
    await expect(pasarGuard({ submoduloExcluido: true })).rejects.toBeInstanceOf(ForbiddenException);
  });

  it('sin el módulo Ventas en el plan: 403', async () => {
    await expect(pasarGuard({ moduloEnPlan: false })).rejects.toBeInstanceOf(ForbiddenException);
  });

  it('cliente de otra empresa: 404 y no escribe', async () => {
    const service = servicio(false);
    await expect(service.updateCreditConfig('c1', { bloqueado_credito: false }, EMPRESA, 'u1')).rejects.toBeInstanceOf(
      NotFoundException,
    );
    expect(service.prisma.clientes.update).not.toHaveBeenCalled();
  });

  it('sin empresa en el token: no busca el cliente sin filtro', async () => {
    const service = servicio(true);
    await expect(service.updateCreditConfig('c1', { bloqueado_credito: false }, undefined, 'u1')).rejects.toBeInstanceOf(
      ForbiddenException,
    );
    expect(service.prisma.clientes.update).not.toHaveBeenCalled();
  });

  it('con módulo, submódulo, permiso y cliente propio: pasa y actualiza', async () => {
    await expect(pasarGuard()).resolves.toBe(true);
    const service = servicio(true);
    await service.updateCreditConfig('c1', { bloqueado_credito: false }, EMPRESA, 'u1');
    expect(service.prisma.clientes.update).toHaveBeenCalled();
  });
});
