import { Icon } from "@iconify/react";
import { AsientosEjemploPanel } from "./AsientosEjemploPanel";
import { MediosPagoMapeoCard } from "./MediosPagoMapeoCard";
import { Alert, Button, Chip, MenuItem, TextField, Tooltip } from "@mui/material";
import { CuentaMapeoAutocomplete } from "./CuentaMapeoAutocomplete";
import { ReglasConceptoPanel } from "./ReglasConceptoPanel";
import { CONCEPTOS_MAPEO } from "./conceptosMapeo";
import { VistaPreviaDocumentoDialog } from "./VistaPreviaDocumentoDialog";
import { useMemo, useState } from "react";
import { usePermission } from "../../hooks/usePermission";
import { useSubmodulo } from "../../hooks/useSubmodulo";
import { useAuthStore } from "../../store/AuthStore";
import styled from "styled-components";
import { toast } from "sonner";
import {
esCuentaLegacy,
useActualizarMapeoMutation,
useConfirmarMapeoMutation,
useMapeoCuentasQuery,
usePlanCuentasQuery,
useRecomendacionesMapeoQuery,
useSembrarMapeosFaltantesMutation,
} from "../../tanstack/ContabilidadStack";
const CONCEPTOS = CONCEPTOS_MAPEO;
// Valor de `localMap`/`currentMap` para los conceptos en modo "sumar a la cuenta
// principal": no apuntan a una cuenta propia, el monto va a la del costo o gasto.
const SUMAR = "__SUMAR__";
// Tono del estado de cada concepto → color semántico del kit (MUI palette).
const COLOR_ESTADO = { error: "error", alerta: "warning", info: "info", ok: "success" };
const AVISO_DOBLE_INGRESO =
"La factura del exterior y el pago al proveedor van a la misma cuenta: el costo del proveedor entraría dos veces. " +
"Elegí un esquema: (a) el pago a Importaciones en curso y la factura a otra cuenta, o (b) la factura a Importaciones " +
"en curso y el pago a la cuenta del proveedor del exterior.";
/** Cómo está hoy el concepto según lo guardado: sin fila, precargado sin confirmar o confirmado. */
function estadoDelConcepto(fila) {
if (!fila) return { texto: "Sin mapear", tono: "error" };
if (!fila.confirmado_at) return { texto: "Cargado por el sistema — sin confirmar", tono: "alerta" };
const quien = fila.confirmado_por_nombre ?? "—";
if (fila.distinto_de_recomendacion) return { texto: `Confirmado por ${quien} · distinto de lo recomendado`, tono: "info" };
return { texto: `Confirmado por ${quien}`, tono: "ok" };
}
function flattenCuentas(cuentas, depth = 0) {
const result = [];
for (const c of cuentas) {
result.push({ ...c, depth });
if (c.children?.length) result.push(...flattenCuentas(c.children, depth + 1));
}
return result;
}
export function MapeoCuentasTab() {
const { can } = usePermission("CONTABILIDAD");
const canConfig = can("CONT_MAP_MAPEO_EDITAR");
const hasModulePlan = useAuthStore((s) => s.hasModulePlan);
// Solo mostramos grupos cuyo módulo esté activo en el plan de la empresa
// (los grupos sin `modulo` son de contabilidad base y se muestran siempre).
// Un grupo puede pedir un submódulo del plan (más fino que el módulo). Hoy sólo
// Comisiones lo usa; si se suman más, conviene pasar esto a un mapa.
const { hasAccess: planIncluyeComisiones } = useSubmodulo("COB_COMISIONES");
const submodulosDelPlan = useMemo(
() => ({ COB_COMISIONES: planIncluyeComisiones }),
[planIncluyeComisiones],
);
const gruposCatalogo = useMemo(
() =>
CONCEPTOS.filter((g) => {
if (g.submodulo) return !!submodulosDelPlan[g.submodulo];
return !g.modulo || hasModulePlan(g.modulo);
}),
[hasModulePlan, submodulosDelPlan],
);
const { data: mapeos = [], isLoading: loadingMapeos } = useMapeoCuentasQuery();
const { data: planCuentas = [], isLoading: loadingPlan } = usePlanCuentasQuery();
const { data: recomendaciones = {} } = useRecomendacionesMapeoQuery();
const actualizarMutation = useActualizarMapeoMutation();
const confirmarMutation = useConfirmarMapeoMutation();
const sembrarMutation = useSembrarMapeosFaltantesMutation();
const [localMap, setLocalMap] = useState({});
// Desde el dibujo del asiento se salta al concepto que falta mapear; queda
// resaltado unos segundos porque la fila puede caer lejos en la grilla.
const [conceptoResaltado, setConceptoResaltado] = useState(null);
const [vistaPrevia, setVistaPrevia] = useState(false);
const irAConcepto = (concepto) => {
if (!concepto) return;
document.getElementById(`concepto-${concepto}`)?.scrollIntoView({ behavior: "smooth", block: "center" });
setConceptoResaltado(concepto);
setTimeout(() => setConceptoResaltado((actual) => (actual === concepto ? null : actual)), 3000);
};
// Nombre legible de cada concepto: en el dibujo del asiento no puede aparecer
// "IVA_DEBITO_10" sino "IVA débito fiscal 10%".
const etiquetasConcepto = useMemo(
() => Object.fromEntries(CONCEPTOS.flatMap((g) => g.items.map((i) => [i.key, i.label]))),
[],
);
const flatCuentas = useMemo(() => {
const aceptan = flattenCuentas(planCuentas).filter(c => c.acepta_movimientos && !esCuentaLegacy(c));
return aceptan;
}, [planCuentas]);
// Un mapeo viejo puede apuntar a una cuenta que ya no es elegible: dada de
// baja, del plan reemplazado (OLD-) o de agrupación. Esas ni siquiera vienen
// en el árbol del plan, así que el nombre se saca del propio mapeo, que lo
// trae. Sin esto la fila mostraba el punto verde de "mapeado" con el campo en
// blanco, sin decir a qué apuntaba ni que hay que arreglarlo: es el caso de
// las comisiones de DOBA, que por eso no se contabilizan.
const cuentaDelMapeo = useMemo(
() => new Map(mapeos.map((m) => [m.concepto, m.cuenta])),
[mapeos],
);
const mapeosPorConcepto = useMemo(() => new Map(mapeos.map((m) => [m.concepto, m])), [mapeos]);
// Lo guardado: cuenta elegida o SUMAR para los que suman a la cuenta principal.
const mapaGuardado = useMemo(() => {
const base = {};
for (const m of mapeos) base[m.concepto] = m.modo === "SUMAR_A_PRINCIPAL" ? SUMAR : m.cuenta_id;
return base;
}, [mapeos]);
const currentMap = useMemo(() => ({ ...mapaGuardado, ...localMap }), [mapaGuardado, localMap]);
// Solo viaja lo que el contador tocó: el backend registra cada concepto guardado
// como confirmado a su nombre, así que reenviar todo confirmaría lo que no revisó.
// Un valor vacío (p. ej. pasar de "Sumar" a "Una cuenta" sin elegir cuenta) no es
// un cambio: el backend no borra mapeos, así que habilitar "Guardar" sería mentir.
// La fila lo avisa con un texto de ayuda (ver `faltaElegirCuenta`).
const cambios = useMemo(
() => Object.entries(localMap).filter(([concepto, valor]) => !!valor && valor !== (mapaGuardado[concepto] ?? null)),
[localMap, mapaGuardado],
);
const dirty = cambios.length > 0;
const sinConfirmar = useMemo(() => mapeos.filter((m) => !m.confirmado_at).length, [mapeos]);
const dobleIngresoImportacion =
!!currentMap.IMPORTACION_COMPRA &&
currentMap.IMPORTACION_COMPRA !== SUMAR &&
currentMap.IMPORTACION_COMPRA === currentMap.IMPORTACION_PAGO_PROVEEDOR;
// El catálogo de arriba está escrito a mano, así que se desfasa apenas alguien agrega
// un concepto en el backend: quedaba mapeado en la base pero sin forma de verlo ni
// editarlo desde acá. Este grupo recoge todo lo que el backend devuelve y el catálogo
// no contempla, para que ningún concepto vuelva a quedar invisible.
const gruposVisibles = useMemo(() => {
// Se compara contra TODOS los conceptos del catálogo, no solo los visibles, para no
// mostrar acá lo que está oculto a propósito por no tener el módulo contratado.
const todosDelCatalogo = new Set(CONCEPTOS.flatMap((g) => g.items.map((i) => i.key)));
const huerfanos = mapeos
.map((m) => m.concepto)
.filter((c) => c && !todosDelCatalogo.has(c))
.sort();
if (huerfanos.length === 0) return gruposCatalogo;
return [
...gruposCatalogo,
{
grupo: "Otros conceptos",
items: huerfanos.map((key) => ({
key,
// Sin etiqueta curada: se arma una legible a partir del código.
label: key.toLowerCase().replace(/_/g, " ").replace(/^./, (c) => c.toUpperCase()),
icon: "lucide:circle-dot",
})),
},
];
}, [gruposCatalogo, mapeos]);
const handleChange = (concepto, cuentaId) => {
setLocalMap(prev => ({ ...prev, [concepto]: cuentaId }));
};
/** "Una cuenta" vuelve a la cuenta guardada (si la había); "Sumar" deja el concepto sin cuenta propia. */
const handleModo = (concepto, modo) => {
if (modo === "SUMAR_A_PRINCIPAL") return handleChange(concepto, SUMAR);
const guardado = mapaGuardado[concepto];
handleChange(concepto, guardado && guardado !== SUMAR ? guardado : null);
};
/** Pone la cuenta recomendada (por código) en el selector; sin código, el modo "sumar". */
const usarRecomendacion = (concepto, codigo, conModo) => {
if (!codigo) {
if (conModo) handleChange(concepto, SUMAR);
return;
}
const cuenta = flatCuentas.find((c) => c.codigo === codigo);
if (!cuenta) {
toast.error(`La cuenta ${codigo} no está en el plan o no acepta movimientos`);
return;
}
handleChange(concepto, cuenta.id);
};
const handleGuardar = () => {
// Un concepto vaciado no viaja: el backend no borra mapeos y exige cuenta.
const payload = cambios
.filter(([, valor]) => valor)
.map(([concepto, valor]) =>
valor === SUMAR
? { concepto, cuenta_id: null, modo: "SUMAR_A_PRINCIPAL" }
: { concepto, cuenta_id: valor, modo: "CUENTA" },
);
if (payload.length === 0) {
setLocalMap({});
return;
}
actualizarMutation.mutate(payload, {
onSuccess: () => setLocalMap({}),
});
};
const isLoading = loadingMapeos || loadingPlan;
if (isLoading) {
return (
Cargando configuración...
);
}
if (planCuentas.length === 0) {
return (
Primero cargá el Plan de Cuentas
Podés crear el plan estándar y los mapeos del sistema automáticamente.