import { Injectable } from '@nestjs/common';
import { bloqueoPorPrueba, contextoPlanEmpresa, submoduloHabilitado } from 'src/auth/guards/submodulo.guard';
import { escaparLike } from 'src/common/utils/busqueda-texto.util';
import { whereProductoPorRubro } from 'src/common/utils/rubros.util';
import { FacturasService } from 'src/facturas/facturas.service';
import { PrismaService } from 'src/prisma/prisma.service';
import { rubrosFiltroUsuario } from 'src/utils/alcance-rubro';
import { formatDateResponse } from 'src/utils/utilidades';

/** Resultados por grupo del buscador global. */
export const MAX_POR_GRUPO = 5;

/**
 * Lo que exige cada grupo: lo mismo que la pantalla de ese dato (módulo + submódulo + permiso VER). Comprobantes es el
 * listado de facturas (`GET /facturas`: VENTAS_FACTURACION + VEN_FAC_FACTURA_VER).
 */
export const ACCESO_GRUPOS = {
  clientes: { modulo: 'VENTAS', submodulo: 'VENTAS_CLIENTES', privilegio: 'VEN_CLI_CLIENTE_VER' },
  productos: { modulo: 'INVENTARIO', submodulo: 'INV_PRODUCTOS', privilegio: 'INV_PRD_PRODUCTO_VER' },
  comprobantes: { modulo: 'VENTAS', submodulo: 'VENTAS_FACTURACION', privilegio: 'VEN_FAC_FACTURA_VER' },
} as const;

type Grupo = keyof typeof ACCESO_GRUPOS;
const GRUPOS = Object.keys(ACCESO_GRUPOS) as Grupo[];

export interface ResultadoBusqueda {
  clientes?: Array<{ id: string; nombre: string; ruc: string | null }>;
  productos?: Array<{ id: string; codigo: string | null; nombre: string }>;
  comprobantes?: Array<{ id: string; numero: string; fecha: string | null; cliente: string | null; total: number; moneda: { codigo: string } | null }>;
}

/**
 * Buscador global (`GET /busqueda`). Un grupo ausente = el usuario no lo puede ver (permiso, submódulo o módulo): el
 * front no muestra nada de ese grupo. Todo de la empresa del token.
 */
@Injectable()
export class BusquedaService {
  constructor(
    private readonly prisma: PrismaService,
    private readonly facturas: FacturasService,
  ) {}

  async buscar(texto: string, empresaId: string, usuarioId: string): Promise<ResultadoBusqueda> {
    const q = texto.trim();
    const permitidos = await this.gruposPermitidos(empresaId, usuarioId);
    const [clientes, productos, comprobantes] = await Promise.all([
      permitidos.has('clientes') ? this.clientes(q, empresaId) : undefined,
      permitidos.has('productos') ? this.productos(q, empresaId, usuarioId) : undefined,
      permitidos.has('comprobantes') ? this.comprobantes(q, empresaId, usuarioId) : undefined,
    ]);
    return {
      ...(clientes ? { clientes } : {}),
      ...(productos ? { productos } : {}),
      ...(comprobantes ? { comprobantes } : {}),
    };
  }

  /**
   * Mismo criterio que `SubmoduloGuard` + `PermissionGuard` para un GET: submódulo habilitado en el plan (con su módulo
   * padre, addon contratado, sin exclusión y sin prueba bloqueada) y el privilegio por un perfil del usuario, grabado
   * con ese módulo. El superadmin pasa el privilegio, no el plan (como `PermissionGuard`).
   */
  private async gruposPermitidos(empresaId: string, usuarioId: string): Promise<Set<Grupo>> {
    const contexto = await contextoPlanEmpresa(this.prisma as never, empresaId);
    const conPlan = await Promise.all(
      GRUPOS.map(async (g) => {
        const { submodulo } = ACCESO_GRUPOS[g];
        const estado = await submoduloHabilitado(this.prisma as never, empresaId, submodulo, contexto);
        return estado.habilitado && bloqueoPorPrueba(estado.fechaFinPrueba, submodulo, 'GET') === null ? g : null;
      }),
    );
    const enPlan = conPlan.filter((g): g is Grupo => g !== null);
    if (!enPlan.length) return new Set();

    const usuario = await this.prisma.usuario.findUnique({ where: { id: usuarioId }, select: { is_superadmin: true } });
    if (usuario?.is_superadmin) return new Set(enPlan);

    const filas = await this.prisma.perfiles_privilegios.findMany({
      where: {
        active: true,
        privilegios: { codigo: { in: enPlan.map((g) => ACCESO_GRUPOS[g].privilegio) } },
        perfiles: { usuario_perfiles: { some: { user_id: usuarioId } } },
      },
      select: { privilegios: { select: { codigo: true } }, modulos: { select: { codigo: true } } },
    });
    const tiene = new Set(filas.map((f) => `${f.modulos?.codigo}:${f.privilegios?.codigo}`));
    return new Set(enPlan.filter((g) => tiene.has(`${ACCESO_GRUPOS[g].modulo}:${ACCESO_GRUPOS[g].privilegio}`)));
  }

  /** Mismo `where` que `GET /clientes/search` (razón social, RUC o documento), con lo mínimo para listar. */
  private async clientes(texto: string, empresaId: string): Promise<NonNullable<ResultadoBusqueda['clientes']>> {
    // Prisma no escapa los comodines de LIKE: `%`/`_` del usuario van como texto.
    const q = escaparLike(texto);
    const filas = await this.prisma.clientes.findMany({
      where: {
        deleted: false,
        personas: {
          empresa_id: empresaId,
          OR: [
            { razon_social: { contains: q, mode: 'insensitive' } },
            { ruc: { contains: q, mode: 'insensitive' } },
            { nro_documento: { contains: q, mode: 'insensitive' } },
          ],
        },
      },
      select: { id: true, personas: { select: { razon_social: true, ruc: true, dv: true, nro_documento: true } } },
      orderBy: { personas: { razon_social: 'asc' } },
      take: MAX_POR_GRUPO,
    });
    return filas.map((c) => {
      const p = c.personas;
      const ruc = p?.ruc ? (p.dv ? `${p.ruc}-${p.dv}` : p.ruc) : (p?.nro_documento ?? null);
      return { id: c.id, nombre: p?.razon_social ?? '', ruc };
    });
  }

  /** Mismo `where` que `GET /productos/search` (descripción, código, código de barras) y el mismo filtro de rubro. */
  private async productos(texto: string, empresaId: string, usuarioId: string): Promise<NonNullable<ResultadoBusqueda['productos']>> {
    // `contains` con el texto escapado; el `equals` de presentaciones no usa LIKE y va tal cual.
    const q = escaparLike(texto);
    const where: any = {
      deleted: false,
      empresa_id: empresaId,
      OR: [
        { descripcion: { contains: q, mode: 'insensitive' } },
        { cod_producto: { contains: q, mode: 'insensitive' } },
        { codigo_barra: { contains: q, mode: 'insensitive' } },
        { producto_presentaciones: { some: { codigo_barra: { equals: texto, mode: 'insensitive' }, active: true } } },
      ],
    };
    const porRubro = whereProductoPorRubro(await rubrosFiltroUsuario(this.prisma, usuarioId, empresaId));
    if (porRubro.AND) where.AND = [...porRubro.AND];
    const filas = await this.prisma.productos.findMany({
      where,
      select: { id: true, cod_producto: true, descripcion: true },
      orderBy: { descripcion: 'asc' },
      take: MAX_POR_GRUPO,
    });
    return filas.map((p) => ({ id: p.id, codigo: p.cod_producto ?? null, nombre: p.descripcion ?? '' }));
  }

  /** Mismo alcance que el listado de Comprobantes (sucursal del usuario), sin alcance propio: el buscador no filtra distinto. */
  private async comprobantes(q: string, empresaId: string, usuarioId: string): Promise<NonNullable<ResultadoBusqueda['comprobantes']>> {
    const filas = await this.facturas.buscarPorNumero(q, empresaId, usuarioId, MAX_POR_GRUPO);
    return filas.map((f) => ({
      id: f.id,
      numero: `${f.dest}-${f.dpunexp}-${f.dnumdoc}`,
      fecha: formatDateResponse(f.dfeemide),
      cliente: f.clientes?.personas?.razon_social ?? null,
      total: Number(f.factura_subtotales?.[0]?.dtotgralope ?? 0),
      moneda: f.moneda?.codigo ? { codigo: f.moneda.codigo } : null,
    }));
  }
}
