import { Prisma } from '@prisma/client';

export type CondicionVenta = 'CONTADO' | 'CREDITO' | 'COBRO_RUTA';

/** Ventas de un turno por condición y moneda. Solo informa: nunca entra al arqueo. */
export interface VentaPorCondicion {
  condicion: CondicionVenta;
  moneda: string;
  cantidad: number;
  /** Total de las facturas al emitirlas. */
  bruto: number;
  /** Notas de crédito aplicadas a esas facturas (devoluciones, ajustes, cancelación por NC). */
  notas_credito: number;
  neto: number;
}

const ORDEN: Record<CondicionVenta, number> = { CONTADO: 0, CREDITO: 1, COBRO_RUTA: 2 };

/**
 * Ventas por condición de cada sesión: contado, crédito y cobro en ruta.
 *
 * Una factura es de la sesión si lo dice `factura_cab.sesion_caja_id` (existe desde el 13/11/2026)
 * o si alguno de sus pagos entró a esa sesión (`factura_forma_pagos.sesion_caja_id`, de siempre).
 * Así el contado sale completo también en sesiones abiertas antes del cambio; el crédito, que no
 * tiene pagos, se registra por sesión desde el 13/11/2026. No cuentan las anuladas,
 * canceladas ni inutilizadas en SIFEN. Una factura cancelada por NC sigue Aprobada: su NC se
 * resta en `notas_credito` (nunca más que el total de la factura), así el neto queda en 0.
 * El total real está en `factura_subtotales`; `total_factura` está vacío en la práctica.
 */
export async function ventasPorCondicion(
  prisma: { $queryRaw: Prisma.TransactionClient['$queryRaw'] },
  empresaId: string,
  sesionIds: string[],
): Promise<Map<string, VentaPorCondicion[]>> {
  const porSesion = new Map<string, VentaPorCondicion[]>();
  if (sesionIds.length === 0) return porSesion;

  const filas = await prisma.$queryRaw<
    { sesion_caja_id: string; condicion: CondicionVenta; moneda: string; cantidad: number; bruto: number; notas_credito: number }[]
  >`
    WITH de_la_sesion AS (
      SELECT fc.id, fc.sesion_caja_id AS sesion
      FROM factura_cab fc
      WHERE fc.empresa_id = ${empresaId}::uuid
        AND fc.sesion_caja_id = ANY(${sesionIds}::uuid[])
      UNION
      SELECT ffp.factura_cab_id, ffp.sesion_caja_id
      FROM factura_forma_pagos ffp
      WHERE ffp.empresa_id = ${empresaId}::uuid
        AND ffp.sesion_caja_id = ANY(${sesionIds}::uuid[])
    )
    SELECT
      ds.sesion::text AS sesion_caja_id,
      CASE
        WHEN co.codigo = 2 THEN 'CREDITO'
        WHEN COALESCE(fc.cobro_diferido, false) THEN 'COBRO_RUTA'
        ELSE 'CONTADO'
      END AS condicion,
      COALESCE(m.codigo, 'PYG') AS moneda,
      COUNT(*)::int AS cantidad,
      COALESCE(SUM(t.total), 0)::float AS bruto,
      COALESCE(SUM(LEAST(COALESCE(fc.total_notas_credito, 0), t.total)), 0)::float AS notas_credito
    FROM de_la_sesion ds
    JOIN factura_cab fc ON fc.id = ds.id
    LEFT JOIN condicion_operacion co ON co.id = fc.condicion_operacion_id
    LEFT JOIN moneda m ON m.id = fc.moneda_id
    CROSS JOIN LATERAL (
      SELECT COALESCE(
        (SELECT s.dtotgralope FROM factura_subtotales s WHERE s.factura_cab_id = fc.id LIMIT 1),
        fc.total_factura,
        0
      ) AS total
    ) t
    WHERE fc.empresa_id = ${empresaId}::uuid
      AND COALESCE(fc.estado, '') NOT IN ('Anulado', 'Anulada', 'Cancelado', 'Inutilizado')
    GROUP BY 1, 2, 3
  `;

  for (const f of filas) {
    const bruto = Number(f.bruto);
    const notas = Number(f.notas_credito);
    const lista = porSesion.get(f.sesion_caja_id) ?? [];
    lista.push({ condicion: f.condicion, moneda: f.moneda, cantidad: Number(f.cantidad), bruto, notas_credito: notas, neto: +(bruto - notas).toFixed(2) });
    porSesion.set(f.sesion_caja_id, lista);
  }
  for (const lista of porSesion.values()) {
    lista.sort((a, b) => ORDEN[a.condicion] - ORDEN[b.condicion] || a.moneda.localeCompare(b.moneda));
  }
  return porSesion;
}

let creditoPorSesionDesde: Promise<Date | null> | null = null;

/**
 * Desde cuándo las facturas guardan su sesión (lo que permite ver el crédito del turno): el momento
 * en que se aplicó la migración `factura_sesion_caja` en esta base. En prod es el día del deploy,
 * no una fecha fija. Una sesión abierta antes tiene el contado completo pero el crédito parcial.
 */
export function inicioCreditoPorSesion(prisma: { $queryRaw: Prisma.TransactionClient['$queryRaw'] }): Promise<Date | null> {
  creditoPorSesionDesde ??= prisma
    .$queryRaw<{ finished_at: Date | null }[]>`
      SELECT finished_at FROM _prisma_migrations
      WHERE migration_name = '20261113130000_factura_sesion_caja' AND rolled_back_at IS NULL
      ORDER BY finished_at LIMIT 1
    `
    .then((r) => r[0]?.finished_at ?? null)
    .catch((e) => {
      creditoPorSesionDesde = null; // que el próximo pedido reintente
      throw e;
    });
  return creditoPorSesionDesde;
}

/** La sesión empezó antes de que se registrara el crédito por sesión: su crédito puede estar incompleto. */
export const creditoIncompleto = (aperturaSesion: Date | string | null | undefined, desde: Date | null) =>
  !!desde && !!aperturaSesion && new Date(aperturaSesion).getTime() < desde.getTime();
