import { Injectable } from '@nestjs/common';
import { monedaBaseId } from 'src/monedas/moneda-base';
import { PrismaService } from 'src/prisma/prisma.service';
import { resolverAlcancePropio } from 'src/utils/alcance-propio';
import { alcanceCubreEmpresa, alcanceSucursalUsuario, esAlcanceTotal } from 'src/utils/alcance-sucursal';

/** Lo que el front del Tablero no puede saber solo: si el alcance es total, qué sucursales ofrecer y qué monedas. */
export interface ContextoTablero {
  /** Ve la empresa entera (con el rubro elegido): el filtro de sucursal ofrece «Todas». */
  alcance_total: boolean;
  /** Las sucursales del alcance (todas las activas si es total). */
  sucursales: Array<{ id: string; nombre: string }>;
  /** `null` solo si la empresa no tiene principal y el catálogo no tiene PYG: el front no tiene con qué rotular. */
  moneda_base: { id: string; codigo: string } | null;
  /** Monedas activas de la empresa (no «las que tienen movimientos»: así no depende del permiso de ventas). */
  monedas: Array<{ id: string; codigo: string; descripcion: string }>;
  /**
   * Por qué la IA (que exige alcance total) no se puede usar, para que el front lo explique en vez de esconderla:
   * `SOLO_PROPIO` = en el Tablero ve solo sus números (va primero: lo explica aunque también tenga sucursal o rubro);
   * `RUBRO_ELEGIDO` = ve toda la empresa pero eligió un rubro (se arregla eligiendo «Todos los rubros»);
   * `SUCURSALES_LIMITADAS` = su usuario está asignado a parte de las sucursales (con o sin rubro); `null` = no hay
   * bloqueo. No dice nada del permiso ni del submódulo: eso lo decide el front con los permisos del login.
   */
  ia_bloqueada: IaBloqueada;
  /**
   * `null` = ve los números de la empresa (con su alcance de sucursal/rubro). Objeto = alcance propio
   * (`resolverAlcancePropio`, regla estricta: sin `REP_DSH_VER_TODO`): vinculado como vendedor (`vendedor`) y/o cobrador
   * (`cobrador`); `nombre` es el del vínculo, para el aviso «Ves solo tus números (<nombre>)». `sin_vinculo` = no está
   * vinculado (los dos en `false`, `nombre` vacío): los dashboards con `vista=tablero` le dan todo vacío y el front avisa
   * «no vinculado» sin pedir tarjetas.
   */
  solo_propio: SoloPropio;
}

export type IaBloqueada = 'SOLO_PROPIO' | 'RUBRO_ELEGIDO' | 'SUCURSALES_LIMITADAS' | null;

export type SoloPropio = null | { vendedor: boolean; cobrador: boolean; nombre: string; sin_vinculo: boolean };

@Injectable()
export class TableroService {
  constructor(private readonly prisma: PrismaService) {}

  async contexto(empresaId: string, usuarioId: string): Promise<ContextoTablero> {
    const [propio, alcance, alcanceTotal, activas, baseId, monedasEmpresa] = await Promise.all([
      resolverAlcancePropio(this.prisma, usuarioId, empresaId),
      alcanceSucursalUsuario(this.prisma, usuarioId, empresaId),
      esAlcanceTotal(this.prisma, usuarioId, empresaId),
      this.prisma.empresas_sucursales.findMany({
        where: { empresa_id: empresaId, active: { not: false } },
        select: { id: true, descripcion: true },
        orderBy: { descripcion: 'asc' },
      }),
      monedaBaseId(this.prisma, empresaId),
      this.prisma.empresa_monedas.findMany({
        where: { empresa_id: empresaId, active: { not: false } },
        select: { moneda: { select: { id: true, codigo: true, descripcion: true } } },
        orderBy: { es_principal: 'desc' },
      }),
    ]);

    // Las que ofrece el filtro: las del alcance con el rubro aplicado.
    const visibles = alcance === null ? activas : activas.filter((s) => alcance.sucursalIds.includes(s.id));
    const soloPropio: SoloPropio =
      propio.tipo === 'PROPIO'
        ? {
            vendedor: !!propio.vendedorId,
            cobrador: !!propio.cobradorId,
            nombre: propio.nombre,
            sin_vinculo: propio.sinVinculo,
          }
        : null;
    // El alcance propio primero (mismo orden que AlcanceTotalGuard); si no, solo si no es total: ¿lo recorta el rubro
    // elegido o la asignación de sucursales?
    const iaBloqueada: IaBloqueada = soloPropio
      ? 'SOLO_PROPIO'
      : alcanceTotal
      ? null
      : (await alcanceCubreEmpresa(this.prisma, usuarioId, empresaId))
        ? 'RUBRO_ELEGIDO'
        : 'SUCURSALES_LIMITADAS';
    const base = baseId ? await this.prisma.moneda.findUnique({ where: { id: baseId }, select: { id: true, codigo: true } }) : null;

    return {
      alcance_total: alcanceTotal,
      sucursales: visibles.map((s) => ({ id: s.id, nombre: s.descripcion })),
      moneda_base: base?.codigo ? { id: base.id, codigo: base.codigo } : null,
      monedas: monedasEmpresa
        .map((m) => m.moneda)
        .filter((m): m is NonNullable<typeof m> => !!m)
        .map((m) => ({ id: m.id, codigo: m.codigo ?? '', descripcion: m.descripcion ?? m.codigo ?? '' })),
      ia_bloqueada: iaBloqueada,
      solo_propio: soloPropio,
    };
  }
}
