import type { BloqueosDePlan } from 'src/auth/guards/acceso-por-plan';
import { IMP_ESTADOS_EMBARQUE } from './dto/importaciones.dto';
import { CODIGOS_IMP, CodigoImp } from './errores-imp';
import { asientoResuelto } from './estado-asiento';

export type EstadoEmbarque = (typeof IMP_ESTADOS_EMBARQUE)[number];

/** Etiquetas de los estados (las del enum del front). Los mensajes al usuario usan estas, nunca los valores crudos. */
export const ETIQUETA_ESTADO: Record<EstadoEmbarque, string> = {
  BORRADOR: 'Borrador',
  EN_TRANSITO: 'En tránsito',
  ARRIBADO: 'Arribado',
  EN_DESPACHO: 'En despacho',
  DESPACHADO: 'Despachado',
  LIBERADO: 'Liberado',
  CERRADO: 'Cerrado',
  SELLADO: 'Sellado',
};

/** Etiquetas de los perfiles (las de la pantalla), para los mensajes: nunca el valor crudo. */
export const ETIQUETA_PERFIL: Record<string, string> = { AUTOS: 'Autos', CONSUMO_MASIVO: 'Consumo masivo' };
export const etiquetaPerfil = (perfil: string): string => ETIQUETA_PERFIL[perfil] ?? perfil;

export const etiquetaEstado = (estado: string): string => ETIQUETA_ESTADO[estado as EstadoEmbarque] ?? estado;

/**
 * Transiciones que acepta `PATCH /embarques/:id/estado` (D8/B5). El resto (despacho, confirmar, liberar, revertir, cerrar,
 * reabrir, sellar) tiene endpoint propio.
 */
export const TRANSICIONES_PATCH: Record<EstadoEmbarque, EstadoEmbarque[]> = {
  BORRADOR: ['EN_TRANSITO'],
  EN_TRANSITO: ['ARRIBADO', 'BORRADOR'],
  ARRIBADO: ['EN_TRANSITO'],
  EN_DESPACHO: [],
  DESPACHADO: [],
  LIBERADO: [],
  CERRADO: [],
  SELLADO: [],
};

export function transicionPatchPermitida(desde: string, hasta: string): boolean {
  return (TRANSICIONES_PATCH[desde as EstadoEmbarque] ?? []).includes(hasta as EstadoEmbarque);
}

export type AccionEmbarque =
  | 'editar'
  | 'eliminar'
  | 'marcar_en_transito'
  | 'marcar_arribado'
  | 'volver_a_borrador'
  | 'volver_a_en_transito'
  | 'volver_a_arribado'
  | 'agregar_item'
  | 'agregar_costo'
  | 'cargar_despacho'
  | 'editar_despacho'
  | 'eliminar_despacho'
  | 'confirmar_despacho'
  | 'liberar'
  | 'revertir_liberacion'
  | 'cerrar'
  | 'reabrir'
  | 'sellar'
  | 'reintentar_asiento_despacho'
  | 'reintentar_asiento_cierre';

/** Acción que el detalle destaca en cada estado (null: el estado es terminal). */
export const ACCION_PRINCIPAL: Record<EstadoEmbarque, AccionEmbarque | null> = {
  BORRADOR: 'marcar_en_transito',
  EN_TRANSITO: 'marcar_arribado',
  ARRIBADO: 'cargar_despacho',
  EN_DESPACHO: 'confirmar_despacho',
  DESPACHADO: 'liberar',
  LIBERADO: 'cerrar',
  CERRADO: 'sellar',
  SELLADO: null,
};

/** Código para la acción que el usuario no puede hacer por permiso (lo resuelve el front, no es un error HTTP del módulo). */
export const SIN_PERMISO = 'SIN_PERMISO';

export interface AccionPermitida {
  accion: AccionEmbarque;
  permitida: boolean;
  codigo?: string;
  motivo?: string;
}

export interface EstadoAcciones {
  estado: EstadoEmbarque | string;
  modulo_operativo_activo: boolean;
  tiene_contabilidad: boolean;
  despacho: { estado: string; asiento_estado: string | null } | null;
  asiento_cierre_estado: string | null;
  perfil_distinto: boolean;
  hay_salidas_posteriores?: boolean;
}

/** Privilegio (módulo IMPORTACIONES) de cada acción: tabla de permisos de la Global, igual que el front. */
const PERMISO_DE_ACCION: Record<AccionEmbarque, string> = {
  editar: 'IMP_EMB_EMBARQUE_EDITAR',
  eliminar: 'IMP_EMB_EMBARQUE_ELIMINAR',
  marcar_en_transito: 'IMP_EMB_EMBARQUE_EDITAR',
  marcar_arribado: 'IMP_EMB_EMBARQUE_EDITAR',
  volver_a_borrador: 'IMP_EMB_EMBARQUE_EDITAR',
  volver_a_en_transito: 'IMP_EMB_EMBARQUE_EDITAR',
  volver_a_arribado: 'IMP_EMB_EMBARQUE_EDITAR',
  agregar_item: 'IMP_EMB_EMBARQUE_EDITAR',
  agregar_costo: 'IMP_COS_COSTO_CREAR',
  cargar_despacho: 'IMP_DES_DESPACHO_CREAR',
  editar_despacho: 'IMP_DES_DESPACHO_EDITAR',
  eliminar_despacho: 'IMP_DES_DESPACHO_ELIMINAR',
  confirmar_despacho: 'IMP_DES_DESPACHO_PROCESAR',
  liberar: 'IMP_EMB_EMBARQUE_CERRAR',
  revertir_liberacion: 'IMP_EMB_EMBARQUE_CERRAR',
  cerrar: 'IMP_EMB_EMBARQUE_CERRAR',
  reabrir: 'IMP_EMB_EMBARQUE_CERRAR',
  sellar: 'IMP_EMB_EMBARQUE_CERRAR',
  reintentar_asiento_despacho: 'IMP_DES_DESPACHO_PROCESAR',
  reintentar_asiento_cierre: 'IMP_EMB_EMBARQUE_CERRAR',
};

/** Submódulo del endpoint de cada acción (`@RequireSubmodulo` del controller, tabla de la Global). */
export const SUBMODULO_DE_ACCION: Record<AccionEmbarque, string> = {
  editar: 'IMP_EMBARQUES',
  eliminar: 'IMP_EMBARQUES',
  marcar_en_transito: 'IMP_EMBARQUES',
  marcar_arribado: 'IMP_EMBARQUES',
  volver_a_borrador: 'IMP_EMBARQUES',
  volver_a_en_transito: 'IMP_EMBARQUES',
  volver_a_arribado: 'IMP_EMBARQUES',
  agregar_item: 'IMP_EMBARQUES',
  agregar_costo: 'IMP_COSTOS',
  cargar_despacho: 'IMP_DESPACHOS',
  editar_despacho: 'IMP_DESPACHOS',
  eliminar_despacho: 'IMP_DESPACHOS',
  confirmar_despacho: 'IMP_DESPACHOS',
  liberar: 'IMP_EMBARQUES',
  revertir_liberacion: 'IMP_EMBARQUES',
  cerrar: 'IMP_EMBARQUES',
  reabrir: 'IMP_EMBARQUES',
  sellar: 'IMP_EMBARQUES',
  reintentar_asiento_despacho: 'IMP_DESPACHOS',
  reintentar_asiento_cierre: 'IMP_EMBARQUES',
};

/** Lo que hay que preguntarle al plan de la empresa para armar las acciones (`bloqueosDePlan`). */
export const SUBMODULOS_DE_ACCIONES: readonly string[] = [...new Set(Object.values(SUBMODULO_DE_ACCION))];
export const PRIVILEGIOS_DE_ACCIONES: readonly string[] = [...new Set(Object.values(PERMISO_DE_ACCION))];

/** Código de la acción que el plan de la empresa no deja (403 de SubmoduloGuard o de la capa 1.2 de PermissionGuard). */
export const SUBMODULO_NO_DISPONIBLE = 'SUBMODULO_NO_DISPONIBLE';

/** Qué acciones corresponden a cada estado (las que no corresponden no se listan). */
const ACCIONES_POR_ESTADO: Record<EstadoEmbarque, AccionEmbarque[]> = {
  BORRADOR: ['editar', 'eliminar', 'marcar_en_transito', 'agregar_item', 'agregar_costo'],
  EN_TRANSITO: ['editar', 'eliminar', 'marcar_arribado', 'volver_a_borrador', 'agregar_item', 'agregar_costo'],
  ARRIBADO: ['editar', 'eliminar', 'volver_a_en_transito', 'cargar_despacho', 'agregar_item', 'agregar_costo'],
  // EN_DESPACHO sin despacho (legado o ida y vuelta, P2): se carga desde ahí; con despacho, se edita, elimina o confirma.
  EN_DESPACHO: ['editar', 'eliminar', 'cargar_despacho', 'editar_despacho', 'eliminar_despacho', 'confirmar_despacho', 'agregar_item', 'agregar_costo'],
  DESPACHADO: ['editar', 'eliminar', 'agregar_costo', 'liberar', 'reintentar_asiento_despacho'],
  LIBERADO: ['editar', 'eliminar', 'revertir_liberacion', 'cerrar', 'reintentar_asiento_despacho'],
  // CERRADO y SELLADO legados (anteriores a B1) pueden tener el asiento del despacho pendiente: se ofrece reintentarlo.
  CERRADO: ['editar', 'eliminar', 'reabrir', 'sellar', 'reintentar_asiento_despacho', 'reintentar_asiento_cierre'],
  SELLADO: ['editar', 'eliminar', 'reintentar_asiento_despacho'],
};

/** Los reintentos de asiento siguen disponibles con el módulo operativo apagado: no escriben sobre el embarque. */
const REINTENTOS: readonly AccionEmbarque[] = ['reintentar_asiento_despacho', 'reintentar_asiento_cierre'];
const ACCIONES_DE_DESPACHO: readonly AccionEmbarque[] = ['editar_despacho', 'eliminar_despacho', 'confirmar_despacho'];


const sinPermiso = (permiso: string) => `No tenés el permiso ${permiso} para esta acción.`;

function bloqueoPorDatos(accion: AccionEmbarque, e: EstadoAcciones, estado: EstadoEmbarque): { codigo: CodigoImp; motivo: string } | null {
  switch (accion) {
    case 'editar':
      if (estado === 'CERRADO' || estado === 'SELLADO') {
        return { codigo: CODIGOS_IMP.EMBARQUE_NO_EDITABLE, motivo: `Un embarque ${ETIQUETA_ESTADO[estado].toLowerCase()} no se edita.` };
      }
      if (e.perfil_distinto) {
        return { codigo: CODIGOS_IMP.PERFIL_DISTINTO, motivo: 'El embarque es de un perfil distinto del activo en la configuración.' };
      }
      return null;
    case 'eliminar':
      // F20: desde DESPACHADO no se elimina; antes decide el servicio por los movimientos (sin leerlos acá).
      if (estado === 'DESPACHADO' || estado === 'LIBERADO' || estado === 'CERRADO' || estado === 'SELLADO') {
        return {
          codigo: CODIGOS_IMP.EMBARQUE_CON_MOVIMIENTOS,
          motivo: `Un embarque ${ETIQUETA_ESTADO[estado].toLowerCase()} ya tiene efectos y no se elimina.`,
        };
      }
      return null;
    case 'liberar':
      if (e.tiene_contabilidad && !asientoResuelto(e.despacho?.asiento_estado)) {
        return { codigo: CODIGOS_IMP.ASIENTO_DESPACHO_PENDIENTE, motivo: 'El asiento del despacho no está generado: reintentalo antes de liberar.' };
      }
      return null;
    case 'revertir_liberacion':
      if (e.hay_salidas_posteriores) {
        return { codigo: CODIGOS_IMP.REVERSION_CON_SALIDAS, motivo: 'La mercadería liberada ya tuvo salidas o movimientos: no se puede revertir.' };
      }
      return null;
    case 'sellar':
      if (e.tiene_contabilidad && !asientoResuelto(e.asiento_cierre_estado)) {
        return { codigo: CODIGOS_IMP.ASIENTO_CIERRE_PENDIENTE, motivo: 'El asiento de cierre no está generado: reintentalo antes de sellar.' };
      }
      return null;
    default:
      return null;
  }
}

/**
 * Acciones del embarque para el detalle (`acciones_permitidas`) y las filas del listado. Combina plan de la empresa
 * (submódulo del endpoint y addon del privilegio, `plan` = `bloqueosDePlan`, con el mensaje del guard), módulo operativo,
 * permiso, estado y datos, en ese orden de prioridad. Una acción que no corresponde al estado no se lista; una que corresponde pero no
 * se puede viene con `permitida: false`, `codigo` y `motivo`. Los estados de asiento que recibe son los VIGENTES
 * (`estadoAsientoVigente`, F5), no las columnas. `permisos = 'TODOS'` es el superadmin (`privilegiosDelUsuario`).
 */
export function accionesPermitidas(e: EstadoAcciones, permisos: Set<string> | 'TODOS', plan: BloqueosDePlan): AccionPermitida[] {
  const estado = e.estado as EstadoEmbarque;
  const lista = ACCIONES_POR_ESTADO[estado];
  if (!lista) return [];

  const resultado: AccionPermitida[] = [];
  for (const accion of lista) {
    if (ACCIONES_DE_DESPACHO.includes(accion) && !e.despacho) continue;
    if (accion === 'cargar_despacho' && estado === 'EN_DESPACHO' && e.despacho) continue;
    if (accion === 'reintentar_asiento_despacho' && !(e.tiene_contabilidad && e.despacho && !asientoResuelto(e.despacho.asiento_estado))) continue;
    if (accion === 'reintentar_asiento_cierre' && !(e.tiene_contabilidad && !asientoResuelto(e.asiento_cierre_estado))) continue;

    const permiso = PERMISO_DE_ACCION[accion];
    const porPlan = plan.submodulos.get(SUBMODULO_DE_ACCION[accion]) ?? plan.privilegios.get(permiso);
    if (porPlan) {
      resultado.push({ accion, permitida: false, codigo: SUBMODULO_NO_DISPONIBLE, motivo: porPlan });
      continue;
    }
    if (!e.modulo_operativo_activo && !REINTENTOS.includes(accion)) {
      resultado.push({
        accion,
        permitida: false,
        codigo: CODIGOS_IMP.MODULO_INACTIVO,
        motivo: 'El módulo operativo de Importaciones está desactivado en la configuración.',
      });
      continue;
    }
    if (permisos !== 'TODOS' && !permisos.has(permiso)) {
      resultado.push({ accion, permitida: false, codigo: SIN_PERMISO, motivo: sinPermiso(permiso) });
      continue;
    }
    const bloqueo = bloqueoPorDatos(accion, e, estado);
    resultado.push(bloqueo ? { accion, permitida: false, codigo: bloqueo.codigo, motivo: bloqueo.motivo } : { accion, permitida: true });
  }
  return resultado;
}
