import { Prisma } from '@prisma/client';
import { tieneAlgunPrivilegio } from 'src/auth/guards/algun-privilegio.guard';
import { disponiblesRequisicion } from 'src/ordenes-compra/disponible-requisicion';
import type { EstadoOc } from 'src/ordenes-compra/reglas-oc';
import { PrismaService } from 'src/prisma/prisma.service';

/**
 * Lo que comparten el listado y el detalle: el armado de lo que dice qué se puede hacer con una requisición
 * (`nivel_pendiente`, `puedo_aprobar`, `ordenes_abiertas`, `con_disponible_oc`, `con_pendiente`,
 * `ejecutado_sobre_aprobado`). Una sola función para las dos respuestas (ruling F8): la pantalla arma sus acciones
 * con `accionesDeRequisicion(fila | detalle)` y no puede haber dos criterios.
 */

export const PRIVILEGIO_REQUISICION_APROBAR = 'CMP_REQ_REQUISICION_APROBAR';

/** Una OC en estos estados ya no bloquea cancelar la requisición ni cuenta como «abierta». */
export const ESTADOS_OC_CERRADOS: EstadoOc[] = ['cancelada', 'completada'];

/** Estados desde los que una requisición se ejecuta (OC, factura o gasto). */
export const ESTADOS_REQUISICION_EJECUTABLES = ['aprobada', 'ejecutada_parcial'];

const num = (v: unknown): number => {
  if (v == null) return 0;
  const n = Number(v);
  return Number.isFinite(n) ? n : 0;
};

export const redondear2 = (n: number): number => Math.round((n + Number.EPSILON) * 100) / 100;

/** Nombre del perfil para mostrar: la descripción y, si no tiene, la clave (ruling F8). */
export const nombrePerfil = (p: { perfil: string | null; desc_perfil: string | null }): string => p.desc_perfil ?? p.perfil ?? '';

export interface NivelPendiente {
  nivel: number;
  perfil: { id: string; nombre: string };
}

/** El nivel que toca aprobar, con el perfil que lo aprueba. */
export type NivelPendienteConPerfil = NivelPendiente & { perfil_id: string };

/** El menor nivel pendiente de las aprobaciones de una requisición (el que `aprobar` resuelve), o null. */
export function menorNivelPendiente(
  aprobaciones: Array<{ nivel: number; estado: unknown; perfil_id: string; perfiles: { id: string; perfil: string | null; desc_perfil: string | null } | null }>,
): NivelPendienteConPerfil | null {
  let menor: (typeof aprobaciones)[number] | null = null;
  for (const a of aprobaciones) {
    if (String(a.estado) !== 'pendiente') continue;
    if (!menor || a.nivel < menor.nivel) menor = a;
  }
  if (!menor) return null;
  return {
    nivel: menor.nivel,
    perfil_id: menor.perfil_id,
    perfil: { id: menor.perfil_id, nombre: menor.perfiles ? nombrePerfil(menor.perfiles) : '' },
  };
}

/** Lo que el usuario puede aprobar: el privilegio `_APROBAR` y sus perfiles (una consulta cada uno por pedido). */
export interface Aprobador {
  tieneAprobar: boolean;
  perfiles: Set<string>;
}

export async function aprobadorDe(db: PrismaService, usuarioId: string | undefined): Promise<Aprobador> {
  if (!usuarioId) return { tieneAprobar: false, perfiles: new Set() };
  const tieneAprobar = await tieneAlgunPrivilegio(db, usuarioId, [PRIVILEGIO_REQUISICION_APROBAR]);
  if (!tieneAprobar) return { tieneAprobar, perfiles: new Set() };
  const filas = await db.usuario_perfiles.findMany({ where: { user_id: usuarioId }, select: { perfil_id: true } });
  return { tieneAprobar, perfiles: new Set(filas.map((f) => f.perfil_id).filter((p): p is string => Boolean(p))) };
}

/** Aprobar exige `_APROBAR` y el perfil del nivel pendiente (sin excepción para el superadmin). */
export const puedeAprobar = (aprobador: Aprobador, nivel: NivelPendienteConPerfil | null): boolean =>
  Boolean(nivel) && aprobador.tieneAprobar && aprobador.perfiles.has(nivel!.perfil_id);

/** Nivel pendiente de cada requisición (en lote): una consulta para todas las de la página. */
export async function nivelesPendientesDe(db: PrismaService, requisicionIds: string[]): Promise<Map<string, NivelPendienteConPerfil>> {
  const out = new Map<string, NivelPendienteConPerfil>();
  if (!requisicionIds.length) return out;
  const filas = await db.requisicion_aprobacion.findMany({
    where: { requisicion_id: { in: requisicionIds }, estado: 'pendiente' },
    include: { perfiles: { select: { id: true, perfil: true, desc_perfil: true } } },
    orderBy: { nivel: 'asc' },
  });
  for (const id of requisicionIds) {
    const nivel = menorNivelPendiente(filas.filter((f) => f.requisicion_id === id));
    if (nivel) out.set(id, nivel);
  }
  return out;
}

/**
 * Ids de las requisiciones pendientes (dentro del `where` ya con alcance y filtros) cuyo nivel pendiente, el menor,
 * es de un perfil del usuario con `_APROBAR`. Una consulta sobre las pendientes de aprobación (pocas por empresa).
 */
export async function idsEsperanMiAprobacion(
  db: PrismaService,
  aprobador: Aprobador,
  whereBase: Prisma.requisicion_cabWhereInput,
): Promise<string[]> {
  if (!aprobador.tieneAprobar || !aprobador.perfiles.size) return [];
  if (whereBase.estado !== undefined && whereBase.estado !== 'pendiente_aprobacion') return [];
  const pendientes = await db.requisicion_aprobacion.findMany({
    where: { estado: 'pendiente', requisicion_cab: { ...whereBase, estado: 'pendiente_aprobacion' } },
    select: { requisicion_id: true, nivel: true, perfil_id: true },
  });
  const menor = new Map<string, { nivel: number; perfil_id: string }>();
  for (const p of pendientes) {
    const actual = menor.get(p.requisicion_id);
    if (!actual || p.nivel < actual.nivel) menor.set(p.requisicion_id, { nivel: p.nivel, perfil_id: p.perfil_id });
  }
  return [...menor.entries()].filter(([, n]) => aprobador.perfiles.has(n.perfil_id)).map(([id]) => id);
}

export interface AccionesRequisicion {
  nivel_pendiente: NivelPendiente | null;
  puedo_aprobar: boolean;
  ordenes_abiertas: Array<{ id: string; numero_orden: string | null }>;
  con_disponible_oc: boolean;
  con_pendiente: boolean;
  ejecutado_sobre_aprobado: boolean;
}

/** Lo armado para una requisición y, aparte, lo ejecutado en guaraníes (Σ de las líneas) que el detalle muestra. */
export interface LecturaRequisicion {
  acciones: AccionesRequisicion;
  /** Σ `monto_ejecutado` de las líneas: la única fuente de `ejecutado_sobre_aprobado` y del `excedente`. */
  equivalente: number;
}

/**
 * El armado compartido, en lote para una o varias requisiciones (el detalle pasa una):
 * - `ordenes_abiertas`: OC de la requisición que no están canceladas ni completadas (las que frenan cancelar);
 * - `con_disponible_oc` (R21): compra, aprobada o ejecutada en parte, y alguna línea con disponible para pedir
 *   (`disponiblesRequisicion`: una OC cancelada no cuenta, así que la primera OC cancelada no apaga la siguiente);
 * - `con_pendiente`: aprobada o ejecutada en parte con alguna línea por ejecutar (para facturar o registrar el gasto);
 * - `ejecutado_sobre_aprobado` (matriz 17): la suma de lo ejecutado de las líneas (`equivalente`) por encima de
 *   `total_estimado`; el detalle saca de la misma suma su `excedente`.
 * Las consultas son una por tipo para toda la página, nunca una por fila.
 */
export async function accionesDeRequisiciones(
  db: PrismaService,
  empresaId: string,
  aprobador: Aprobador,
  reqs: Array<{ id: string; estado: unknown; origen_tipo: unknown; total_estimado: unknown; total_ejecutado: unknown }>,
  niveles: Map<string, NivelPendienteConPerfil>,
): Promise<Map<string, LecturaRequisicion>> {
  const compraIds = reqs.filter((r) => String(r.origen_tipo) === 'compra').map((r) => r.id);
  const ids = reqs.map((r) => r.id);
  const ejecutables = new Set(reqs.filter((r) => ESTADOS_REQUISICION_EJECUTABLES.includes(String(r.estado))).map((r) => r.id));

  const [ordenes, lineas] = await Promise.all([
    compraIds.length
      ? db.orden_compra_cab.findMany({
          where: {
            requisicion_id: { in: compraIds },
            empresa_id: empresaId,
            // Mismo filtro que Documentos del detalle (`findOne`): una OC dada de baja no cuenta como abierta.
            activo: { not: false },
            OR: [{ estado: null }, { estado: { notIn: ESTADOS_OC_CERRADOS } }],
          },
          select: { id: true, numero_orden: true, requisicion_id: true },
          orderBy: { numero_orden: 'asc' },
        })
      : Promise.resolve([]),
    ids.length
      ? db.requisicion_det.findMany({
          where: { requisicion_id: { in: ids } },
          select: { id: true, requisicion_id: true, cantidad_solicitada: true, cantidad_ejecutada: true, monto_ejecutado: true },
        })
      : Promise.resolve([]),
  ]);

  const lineasCompra = lineas.filter((l) => compraIds.includes(l.requisicion_id) && ejecutables.has(l.requisicion_id));
  const disponibles = lineasCompra.length ? await disponiblesRequisicion(db, empresaId, lineasCompra, null) : new Map<string, number>();

  const out = new Map<string, LecturaRequisicion>();
  for (const r of reqs) {
    const propias = lineas.filter((l) => l.requisicion_id === r.id);
    const compra = String(r.origen_tipo) === 'compra';
    const nivel = niveles.get(r.id) ?? null;
    const puedeEjecutar = ejecutables.has(r.id);
    const equivalente = redondear2(propias.reduce((suma, l) => suma + num(l.monto_ejecutado), 0));
    out.set(r.id, {
      equivalente,
      acciones: {
        nivel_pendiente: nivel ? { nivel: nivel.nivel, perfil: nivel.perfil } : null,
        puedo_aprobar: puedeAprobar(aprobador, nivel),
        ordenes_abiertas: ordenes.filter((o) => o.requisicion_id === r.id).map((o) => ({ id: o.id, numero_orden: o.numero_orden })),
        con_disponible_oc: compra && puedeEjecutar && propias.some((l) => (disponibles.get(l.id) ?? 0) > 0),
        con_pendiente: puedeEjecutar && propias.some((l) => num(l.cantidad_solicitada) > num(l.cantidad_ejecutada)),
        ejecutado_sobre_aprobado: equivalente > num(r.total_estimado),
      },
    });
  }
  return out;
}
