informe-comercial-alfa/app/components/plan/AgendadorPanel.js

567 lines
35 KiB
JavaScript
Raw Permalink Normal View History

"use client";
import { Fragment, useEffect, useMemo, useState, useTransition } from "react";
import { useRouter } from "next/navigation";
import { money, actividadUrl } from "../../lib/constants";
import { diaCorto } from "../../lib/plan";
import {
AGENDADOR, TIPOS_AGENDADOR, OBJETIVOS_AGENDADOR, NIVELES_PRIO, proponer, validar, horasDe, minAHora, sumarFijos, baseItem, textoHorario,
ventanaDe, fechaMaxima, calcularPrioridades,
} from "../../lib/agendador";
import { crearLoteAction, deshacerLoteAction } from "../../agendador/agendadorActions";
const NOMBRE_PLURAL = { Llamada: "llamadas", Cita: "visitas", Tarea: "tareas" };
const fechaHora = (iso) =>
new Intl.DateTimeFormat("es-NI", { timeZone: "America/Managua", day: "2-digit", month: "2-digit", hour: "2-digit", minute: "2-digit" }).format(new Date(iso));
const fechaLarga = (iso) => { const [y, m, d] = iso.split("-"); return `${d}/${m}/${y.slice(2)}`; };
const fechaCorta = (iso) => iso.split("-").reverse().slice(0, 2).join("/");
const sinAcentos = (t) => String(t || "").normalize("NFD").replace(/[̀-ͯ]/g, "").toLowerCase();
const pctDe = (s) => parseInt(s, 10) || 0;
// Filtros para afinar qué oportunidades se quieren agendar. Dentro de un filtro, las opciones suman
// (o); entre filtros se combinan (y). Vacío = todas. NINGÚN filtro de menú viene activado de entrada (el ejecutivo ve
// todas sus oportunidades abiertas, 2026-11-06); desde 2026-11-11 sí viene activado «Ocultar las que ya tienen actividad».
// `visible`: a la vista en la franja; el resto queda bajo «Más filtros».
// «Cierre estimado» se mide contra los días de agendado (ventana).
const ORDEN_CIERRE = ["Vencida (antes de esos días)", "En esos días", "Resto del mes", "Mes siguiente", "Más adelante", "Sin fecha"];
const finDeMes = (iso, sumar = 0) => {
const [y, m] = iso.split("-").map(Number);
return new Date(Date.UTC(y, m + sumar, 0)).toISOString().slice(0, 10);
};
function bucketCierre(c, v) {
const d = c.cierre;
if (!d) return ORDEN_CIERRE[5];
if (d < v.desde) return ORDEN_CIERRE[0];
if (d <= v.hasta) return ORDEN_CIERRE[1];
if (d <= finDeMes(v.desde)) return ORDEN_CIERRE[2];
if (d <= finDeMes(v.desde, 1)) return ORDEN_CIERRE[3];
return ORDEN_CIERRE[4];
}
const FILTROS = [
{ k: "tipo", lbl: "Tipo de oportunidad", visible: true, valor: (c) => c.tipo || "(sin tipo)" },
{ k: "prio", lbl: "Prioridad", visible: true, valor: (c) => c.prioNivel, orden: NIVELES_PRIO },
{ k: "plan", lbl: "Plan de cierre", valor: (c) => c.plan || "Sin plan de cierre" },
{ k: "forecast", lbl: "Categoría de previsión", valor: (c) => c.forecast || "Sin categoría" },
{ k: "cierre", lbl: "Cierre", visible: true, valor: (c, v) => bucketCierre(c, v), orden: ORDEN_CIERRE },
];
const SIN_FILTROS = { prio: [], tipo: [], plan: [], forecast: [], cierre: [] };
const pasa = (c, filtros, v, salvo) => FILTROS.every((f) => f.k === salvo || !filtros[f.k].length || filtros[f.k].includes(f.valor(c, v)));
// Orden de la tabla. Por defecto, VALOR de mayor a menor (2026-11-06); los encabezados con ▲▼ cambian el orden.
const ORDENES = {
valor: (x, y) => (y.valor || 0) - (x.valor || 0),
prio: (x, y) => (x.prioRank ?? 9) - (y.prioRank ?? 9) || (y.valor || 0) - (x.valor || 0),
cliente: (x, y) => String(x.cliente || x.nombre || "").localeCompare(String(y.cliente || y.nombre || ""), "es"),
cierre: (x, y) => (x.cierre || "9999-12-31").localeCompare(y.cierre || "9999-12-31"),
forecast: (x, y) => (y.pct || 0) - (x.pct || 0),
};
const ORDEN_INICIAL = { k: "valor", dir: 1 };
// Agendador de actividades (PILOTO). Página propia: trae TODAS las oportunidades abiertas del ejecutivo;
// se elige desde qué fecha agendar (hasta 30 días) y se reparte en 5 días hábiles a partir de ahí. La
// persona marca las que va a agendar y ajusta día/hora/tipo/objetivo; lo marcado o editado a mano queda
// FIJO y el resto se acomoda alrededor. «Crear en Dynamics» las crea con el propietario de la
// oportunidad; nada se escribe antes. Diseño: agendador-automatico-diseno.md.
export default function AgendadorPanel({ fechaInicial, ownerEmail, ownerName, hoy, ahoraMin, candidatos, actPorOpp, existentes, bloques, lotes }) {
const router = useRouter();
const [pendiente, empezar] = useTransition();
const maxFecha = fechaMaxima(hoy);
const [fecha, setFecha] = useState(fechaInicial || hoy);
const dias = useMemo(() => ventanaDe(fecha, hoy), [fecha, hoy]);
const ventana = useMemo(() => ({ desde: dias[0] || hoy, hasta: dias[dias.length - 1] || hoy }), [dias, hoy]);
const base = { dias, existentes, bloques, hoy, ahoraMin };
const [tipoTodas, setTipoTodas] = useState("Llamada");
const [filtros, setFiltros] = useState(SIN_FILTROS);
const [busqueda, setBusqueda] = useState("");
const [ocultarConAct, setOcultarConAct] = useState(true);
const [masFiltros, setMasFiltros] = useState(false);
const [orden, setOrden] = useState(ORDEN_INICIAL);
const [abierto, setAbierto] = useState(null); // filtro con el menú desplegado
// Lo que la persona decidió a mano, por oportunidad: { tipo, dia, hora, objetivo, incluir, tocada }.
const [edits, setEdits] = useState({});
const [creadas, setCreadas] = useState([]); // filas ya creadas en esta sesión (con su creada)
const [resultado, setResultado] = useState(null);
const [aviso, setAviso] = useState(null);
// Cierra el menú al hacer clic fuera o con Escape.
useEffect(() => {
if (!abierto) return;
const fuera = (e) => { if (!(e.target instanceof Element) || !e.target.closest(".agd-filtro")) setAbierto(null); };
const tecla = (e) => { if (e.key === "Escape") setAbierto(null); };
document.addEventListener("mousedown", fuera);
document.addEventListener("keydown", tecla);
return () => { document.removeEventListener("mousedown", fuera); document.removeEventListener("keydown", tecla); };
}, [abierto]);
// Prioridad sugerida de cada oportunidad (sobre la cartera completa del ejecutivo).
const conPrio = useMemo(() => {
const m = calcularPrioridades(candidatos, hoy);
return candidatos.map((c) => ({ ...c, ...m.get(c.id) }));
}, [candidatos, hoy]);
// ¿Ya tiene una actividad agendada (no cancelada) en los días que se planifican?
const conActividad = (c) => (actPorOpp[c.id] || []).some((d) => d >= ventana.desde && d <= ventana.hasta);
const fechaActividad = (c) => (actPorOpp[c.id] || []).filter((d) => d >= ventana.desde && d <= ventana.hasta).sort()[0];
const idsCreadas = useMemo(() => new Set(creadas.map((c) => c.oppId)), [creadas]);
const disponibles = useMemo(() => conPrio.filter((c) => !idsCreadas.has(c.id)), [conPrio, idsCreadas]);
const q = sinAcentos(busqueda.trim());
// Lo que pasa búsqueda y «ocultar» (antes de los filtros de menú).
const baseVisible = useMemo(
() => disponibles.filter((c) => (!q || sinAcentos(`${c.cliente || ""} ${c.nombre || ""}`).includes(q)) && !(ocultarConAct && conActividad(c))),
[disponibles, q, ocultarConAct, ventana, actPorOpp] // eslint-disable-line react-hooks/exhaustive-deps
);
const coinciden = useMemo(() => baseVisible.filter((c) => pasa(c, filtros, ventana)), [baseVisible, filtros, ventana]);
const marcadasIds = Object.keys(edits).filter((k) => edits[k].incluir);
// Opciones de cada filtro con su conteo FRENTE A LOS OTROS filtros (las que quedarían en 0 se ven en gris).
const opciones = useMemo(() => {
const out = {};
for (const f of FILTROS) {
const total = new Map();
conPrio.forEach((c) => total.set(f.valor(c, ventana), (total.get(f.valor(c, ventana)) || 0) + 1));
const visibles = new Map();
baseVisible.filter((c) => pasa(c, filtros, ventana, f.k)).forEach((c) => visibles.set(f.valor(c, ventana), (visibles.get(f.valor(c, ventana)) || 0) + 1));
out[f.k] = [...total.entries()]
.sort((a, b) =>
f.orden ? f.orden.indexOf(a[0]) - f.orden.indexOf(b[0])
: (f.k === "forecast" ? pctDe(b[0]) - pctDe(a[0]) : 0) || b[1] - a[1] || a[0].localeCompare(b[0], "es"))
.map(([v]) => [v, visibles.get(v) || 0]);
}
return out;
}, [conPrio, baseVisible, filtros, ventana]);
// Filas visibles = las que coinciden + las marcadas que el filtro/búsqueda dejó fuera.
const filas = useMemo(() => {
const porId = new Map(conPrio.map((c) => [c.id, c]));
const marcadasFuera = marcadasIds.filter((id) => porId.has(id) && !coinciden.some((c) => c.id === id)).map((id) => porId.get(id));
const visibles = [...coinciden, ...marcadasFuera];
// Filas sin decisión a mano: se acomodan alrededor de las marcadas (que quedan fijas). Las que ya
// tienen actividad en esos días no se proponen.
const fijas = marcadasIds.map((id) => ({ ...edits[id] }));
const { existentes: ex, bloques: bl } = sumarFijos(existentes, bloques, fijas);
const auto = proponer({ candidatos: visibles.filter((c) => !edits[c.id] && !conActividad(c)), ...base, existentes: ex, bloques: bl, tipo: tipoTodas });
const autoPorId = new Map(auto.map((i) => [i.oppId, { ...i, incluir: false }]));
const filasV = visibles.map((c) => {
const e = edits[c.id];
if (!e) {
if (conActividad(c)) return { ...baseItem(c, tipoTodas), dia: null, hora: null, sinCupo: false, incluir: false, conActividad: fechaActividad(c) };
return autoPorId.get(c.id);
}
return { ...baseItem(c, e.tipo), tipo: e.tipo, dia: e.dia, hora: e.hora, objetivo: e.objetivo, gv: !!e.gv && e.tipo !== "Tarea", incluir: !!e.incluir, sinCupo: !e.dia, tocada: !!e.tocada, fueraDelFiltro: !coinciden.some((x) => x.id === c.id) };
});
const cmp = ORDENES[orden.k];
return filasV.sort((x, y) => orden.dir * cmp(x, y) || ORDENES.valor(x, y));
}, [conPrio, coinciden, edits, tipoTodas, dias, existentes, bloques, hoy, ahoraMin, orden, actPorOpp]); // eslint-disable-line react-hooks/exhaustive-deps
const marcadas = filas.filter((f) => f.incluir);
const val = useMemo(() => validar({ items: marcadas, ...base }), [filas, dias, existentes, bloques, hoy, ahoraMin]); // eslint-disable-line react-hooks/exhaustive-deps
const congelar = (f, extra = {}) => ({ tipo: f.tipo, dia: f.dia, hora: f.hora, objetivo: f.objetivo, gv: !!f.gv, incluir: !!f.incluir, tocada: !!f.tocada, ...extra });
const editar = (f, cambios) => setEdits((p) => ({ ...p, [f.key]: congelar(f, { ...cambios, tocada: true }) }));
const marcar = (f, valor) =>
setEdits((p) => {
const n = { ...p };
if (valor) n[f.key] = congelar(f, { incluir: true });
else if (f.tocada) n[f.key] = congelar(f, { incluir: false });
else delete n[f.key];
return n;
});
const marcarTodas = (valor) =>
setEdits((p) => {
const n = { ...p };
filas.forEach((f) => {
if (valor) { if (f.dia && !f.conActividad) n[f.key] = congelar(f, { incluir: true }); }
else if (f.incluir) { if (f.tocada) n[f.key] = congelar(f, { incluir: false }); else delete n[f.key]; }
});
return n;
});
// «Marcar GV en las seleccionadas»: solo llamadas y visitas (las tareas no llevan GV).
const marcarGV = () =>
setEdits((p) => Object.fromEntries(Object.entries(p).map(([k, e]) => [k, e.incluir && e.tipo !== "Tarea" ? { ...e, gv: true } : e])));
const restablecer = () => setEdits((p) => Object.fromEntries(Object.entries(p).filter(([, e]) => e.incluir)));
const cambiarTipo = (f, tipo) => {
const horas = horasDe(tipo).map(minAHora);
const hora = tipo === "Tarea" ? minAHora(AGENDADOR.horaTarea) : horas.includes(f.hora) ? f.hora : horas[0];
editar(f, { tipo, hora: f.dia ? hora : null, gv: tipo === "Tarea" ? false : f.gv });
};
const cambiarDia = (f, dia) => {
const horas = horasDe(f.tipo).map(minAHora);
const hora = f.tipo === "Tarea" ? minAHora(AGENDADOR.horaTarea) : f.hora && horas.includes(f.hora) ? f.hora : horas[0] || "";
editar(f, { dia: dia || null, hora: dia ? hora : null });
};
// Cambiar la fecha cambia los días de agendado: lo marcado se descarta (sus días ya no valdrían).
const cambiarFecha = (nueva) => {
if (!nueva) return;
const f = nueva < hoy ? hoy : nueva > maxFecha ? maxFecha : nueva;
if (f === fecha) return;
if (marcadasIds.length && !window.confirm("Al cambiar la fecha se desmarcan las oportunidades que habías marcado. ¿Continuar?")) return;
setEdits({});
setFecha(f);
};
const ordenarPor = (k) => setOrden((o) => (o.k === k ? { k, dir: -o.dir } : { k, dir: k === "valor" || k === "forecast" ? 1 : 1 }));
const flecha = (k) => (orden.k === k ? (orden.dir === 1 ? " ▼" : " ▲") : "");
const crear = () => {
setAviso(null);
if (!marcadas.length || !val.ok) return;
const resumen = TIPOS_AGENDADOR.map((t) => [t, marcadas.filter((i) => i.tipo === t).length]).filter(([, n]) => n).map(([t, n]) => `${n} ${NOMBRE_PLURAL[t]}`).join(", ");
const nGV = marcadas.filter((i) => i.gv).length;
const textoGV = nGV ? ` ${nGV} llevan a Gerencia Comercial (GV): se marca su participación en la oportunidad${marcadas.some((i) => i.gv && i.tipo === "Cita") ? " y las visitas se envían como invitación a Marco" : ""}.` : "";
if (!window.confirm(`Se crearán en Dynamics ${marcadas.length} actividades (${resumen}) para ${ownerName}, a su nombre.${textoGV} ¿Continuar?`)) return;
const enviadas = marcadas;
empezar(async () => {
const r = await crearLoteAction({
ownerEmail,
fecha,
items: enviadas.map((i) => ({ oppId: i.oppId, nombre: i.nombre, cliente: i.cliente, tipo: i.tipo, objetivo: i.objetivo, dia: i.dia, hora: i.hora, gv: !!i.gv })),
});
if (!r.ok) { setAviso({ mal: true, texto: r.error }); return; }
const hechas = new Map(r.resultados.filter((x) => x.estado === "creada").map((x) => [x.oppId, x]));
setCreadas((p) => [...enviadas.filter((f) => hechas.has(f.oppId)).map((f) => ({ ...f, incluir: false, creada: hechas.get(f.oppId) })), ...p]);
setEdits((p) => Object.fromEntries(Object.entries(p).filter(([id]) => !hechas.has(id))));
setResultado(r);
router.refresh();
});
};
const deshacer = (id) => {
if (!window.confirm("Se cancelarán en Dynamics las actividades de esa tanda que sigan abiertas. ¿Deshacer?")) return;
empezar(async () => {
const r = await deshacerLoteAction(id);
setAviso(r.ok ? { texto: `Tanda deshecha: ${r.canceladas} cancelada(s)${r.yaCerradas ? `, ${r.yaCerradas} ya estaban cerradas` : ""}${r.oppRestauradas ? `, ${r.oppRestauradas} oportunidad(es) sin la marca de GV que puso la tanda` : ""}${r.errores ? `, ${r.errores} con error` : ""}.` } : { mal: true, texto: r.error });
router.refresh();
});
};
const hayFiltros = FILTROS.some((f) => filtros[f.k].length);
const hayCitas = marcadas.some((i) => i.tipo === "Cita");
const nGV = marcadas.filter((i) => i.gv).length;
const sinCupo = filas.filter((i) => i.sinCupo && !i.dia).length;
const fueraDeFiltro = filas.filter((f) => f.fueraDelFiltro).length;
const filasTabla = [...creadas, ...filas];
const nMalos = marcadas.filter((i) => (val.porItem[i.key] || []).length).length;
const nExtra = FILTROS.filter((f) => !f.visible).reduce((n, f) => n + filtros[f.k].length, 0);
const quitarTodo = () => { setFiltros(SIN_FILTROS); setBusqueda(""); setOcultarConAct(false); };
const nTipo = (t) => marcadas.filter((i) => i.tipo === t).length;
// Un menú de filtro (botón + lista de opciones con casillas).
const menuFiltro = (f) => {
const sel = filtros[f.k];
const resumen = sel.length === 0 ? "Todos" : sel.length === 1 ? sel[0] : `${sel.length} seleccionados`;
return (
<div key={f.k} className={`agd-filtro${abierto === f.k ? " abierto" : ""}`}>
<button type="button" className="agd-filtro-b agd-filtro-c" aria-expanded={abierto === f.k} onClick={() => setAbierto(abierto === f.k ? null : f.k)}>
<span className="agd-filtro-l">{f.lbl}:</span> <b>{resumen}</b>
</button>
{abierto === f.k && (
<div className="agd-opts" role="menu">
{opciones[f.k].map(([v, n]) => {
const activo = sel.includes(v);
return (
<label key={v} className={n === 0 && !activo ? "agd-opt-0" : ""}>
<input type="checkbox" checked={activo} onChange={() => setFiltros((p) => ({ ...p, [f.k]: activo ? sel.filter((x) => x !== v) : [...sel, v] }))} /> {v} <span className="agd-n">({n})</span>
</label>
);
})}
{sel.length > 0 && <button type="button" className="agd-btn-sec" onClick={() => setFiltros((p) => ({ ...p, [f.k]: [] }))}>Quitar este filtro</button>}
</div>
)}
</div>
);
};
// Aviso en línea bajo la fila: solo si hay algo que decir.
const avisoDe = (it, probs) => {
if (it.creada) {
return (
<span className="agd-ok">
✓ Creada{it.creada.gv ? " con GV" : ""} ·{" "}
<a href={actividadUrl({ tipo: it.creada.tipo, id: it.creada.activityId })} target="_blank" rel="noreferrer">abrir en CRM</a>
{it.creada.avisoOpp ? <span className="agd-mal"> · {it.creada.avisoOpp}</span> : null}
</span>
);
}
if (it.conActividad) return { info: `Ya tiene una actividad agendada el ${fechaLarga(it.conActividad)}.` };
if (it.sinCupo && !it.dia) return { info: "Sin cupo en esos días con estos máximos: elige un día a mano." };
if (it.incluir && probs.length) return { mal: `⚠ ${probs.join(" ")}` };
if (it.fueraDelFiltro) return { info: "Marcada; no coincide con el filtro actual." };
if (it.incluir && it.gv) {
return { info: it.tipo === "Cita" ? "Con GV: Marco recibe la invitación en su calendario y se marca «Participación de GV» en la oportunidad." : "Con GV: Gerencia Comercial queda como participante y se marca «Participación de GV» en la oportunidad." };
}
return null;
};
return (
<section className="plan-agd agd-pag no-print">
<details className="agd-ayuda-d">
<summary>
<span className="agd-ayuda-i">ⓘ</span>
<span><b>Elige la fecha → marca las oportunidades → «Crear».</b> Nada se crea hasta ese paso y queda a nombre del dueño de la oportunidad.</span>
<span className="agd-ayuda-lk">¿Cómo funciona?</span>
</summary>
<div className="agd-ayuda">
<ol>
<li><b>Elige la fecha</b> desde la que quieres agendar (hasta 30 días) y, si quieres, <b>busca o filtra</b> las oportunidades.</li>
<li><b>Marca</b> las que vas a agendar y ajusta el tipo, el día, la hora o el objetivo. Con «👥 Con GV» invitas a Gerencia Comercial.</li>
<li>Pulsa <b>«Crear … en Dynamics»</b>. No se crea nada hasta ese paso, y las actividades quedan a nombre del propietario de la oportunidad.</li>
</ol>
<p>
<b>Reglas:</b> de lunes a viernes, {textoHorario()}. Llamadas de {AGENDADOR.duracion.Llamada} min (horas cada {AGENDADOR.paso.Llamada} min) y visitas de {AGENDADOR.duracion.Cita} min (horas cada {AGENDADOR.paso.Cita} min).
Máximo por día: {AGENDADOR.topes.Llamada} llamadas, {AGENDADOR.topes.Cita} visitas y {AGENDADOR.topes.Tarea} tareas (las tareas vencen a las {minAHora(AGENDADOR.horaTarea)}).
Se muestran <b>todas las oportunidades abiertas</b> del ejecutivo, sin importar su fecha de cierre.
</p>
<p>
<b>Qué se escribe en Dynamics:</b> las visitas salen con lugar «Oficina del cliente»; otros participantes se agregan en el CRM.
Con «Con GV», la actividad lleva a Gerencia Comercial como participante y la oportunidad queda con «Participación de GV» (que suma a su puntuación); en las visitas, además, Marco recibe la invitación en su calendario de Outlook.
Al «Deshacer» la tanda se cancelan las actividades abiertas y la oportunidad vuelve a su valor anterior.
</p>
</div>
</details>
{candidatos.length === 0 && creadas.length === 0 ? (
<p className="agd-vacio">{ownerName} no tiene oportunidades abiertas con fecha de cierre estimada.</p>
) : (
<>
<div className="agd-paso">
<h4>1 · ¿Desde qué día agendas?</h4>
<div className="agd-fecha">
<input id="agd-fecha-i" type="date" value={fecha} min={hoy} max={maxFecha} onChange={(e) => cambiarFecha(e.target.value)} disabled={pendiente} aria-label="Agendar a partir del" />
<span className="hint">Se reparte de <b>{dias.length ? `${diaCorto(dias[0])} a ${diaCorto(dias[dias.length - 1])}` : "—"}</b> · puedes elegir hasta el {fechaLarga(maxFecha)}</span>
</div>
<div className="agd-capg">
{dias.map((d) => {
const c = val.porDia[d] || { Llamada: 0, Cita: 0, Tarea: 0, ...(existentes[d] || {}) };
return (
<div key={d} className="agd-capd" title="Lo que ya tiene agendado ese día más lo que marcaste">
<b className="agd-capd-t">{diaCorto(d)}</b>
{TIPOS_AGENDADOR.map((t) => {
const tope = AGENDADOR.topes[t];
const n = c[t] || 0;
return (
<div key={t} className={`agd-cap${n >= tope ? " lleno" : ""}`}>
<span className="agd-cap-k">{t === "Cita" ? "Visitas" : `${t}s`}</span>
<span className="agd-cap-b"><i style={{ width: `${Math.min(100, Math.round((n / tope) * 100))}%` }} /></span>
<span className="agd-cap-v">{n}/{tope}</span>
</div>
);
})}
</div>
);
})}
</div>
</div>
<div className="agd-paso">
<h4>2 · ¿Qué oportunidades?</h4>
<div className="agd-franja">
<input
type="search"
className="agd-busca"
value={busqueda}
onChange={(e) => setBusqueda(e.target.value)}
placeholder="🔍 Buscar cliente u oportunidad…"
aria-label="Buscar cliente u oportunidad"
/>
{FILTROS.filter((f) => f.visible).map(menuFiltro)}
<label className="agd-check">
<input type="checkbox" checked={ocultarConAct} onChange={(e) => setOcultarConAct(e.target.checked)} /> Ocultar las que ya tienen actividad
</label>
<button type="button" className="agd-mas" aria-expanded={masFiltros} onClick={() => setMasFiltros((v) => !v)}>
{masFiltros ? "- Menos filtros" : "+ Más filtros"}{!masFiltros && nExtra ? ` (${nExtra})` : ""}
</button>
</div>
{masFiltros && <div className="agd-franja agd-franja-mas">{FILTROS.filter((f) => !f.visible).map(menuFiltro)}</div>}
{hayFiltros && (
<div className="agd-chips">
{FILTROS.flatMap((f) => filtros[f.k].map((v) => (
<button key={f.k + v} type="button" className="agd-chip" title={`Quitar «${v}»`} onClick={() => setFiltros((p) => ({ ...p, [f.k]: p[f.k].filter((x) => x !== v) }))}>
{v} ✕
</button>
)))}
<button type="button" className="agd-btn-sec" onClick={() => setFiltros(SIN_FILTROS)}>Limpiar filtros</button>
</div>
)}
</div>
<div className="agd-paso">
<h4>3 · Marca y ajusta</h4>
{coinciden.length === 0 && filas.length === 0 && creadas.length === 0 ? (
<p className="agd-mal agd-grande">
Ninguna oportunidad coincide con la búsqueda y los filtros.{" "}
<button type="button" className="agd-btn-sec" onClick={quitarTodo}>Quitar filtros y búsqueda</button>
</p>
) : (
<>
<div className="agd-acc">
<button type="button" className="agd-btn-sec" onClick={() => marcarTodas(true)} disabled={pendiente || !filas.length}>Marcar todas ({filas.filter((f) => f.dia && !f.conActividad).length})</button>
<button type="button" className="agd-btn-sec" onClick={() => marcarTodas(false)} disabled={pendiente || !marcadas.length}>Desmarcar</button>
<button type="button" className="agd-btn-sec" onClick={restablecer} disabled={pendiente} title="Deshace tus cambios manuales en las filas no marcadas">Restablecer propuesta</button>
<button type="button" className="agd-btn-sec" onClick={marcarGV} disabled={pendiente || !marcadas.some((m) => m.tipo !== "Tarea")} title="Pone «Con GV» en las llamadas y visitas marcadas">👥 Marcar GV en las seleccionadas</button>
<label className="agd-tipo-todas">
<span className="hint">Tipo para las no tocadas:</span>
<select id="agd-tipo" value={tipoTodas} onChange={(e) => setTipoTodas(e.target.value)} disabled={pendiente} title="Aplica a las filas que no has tocado a mano">
{TIPOS_AGENDADOR.map((t) => <option key={t} value={t}>{t}</option>)}
</select>
</label>
<span className="hint agd-acc-r">
Mostrando {coinciden.length} de {disponibles.length} abiertas
{(hayFiltros || q || ocultarConAct) && <> · <button type="button" className="agd-btn-sec" onClick={quitarTodo}>Quitar filtros y búsqueda</button></>}
{fueraDeFiltro > 0 && ` · ${fueraDeFiltro} marcada${fueraDeFiltro === 1 ? "" : "s"} fuera del filtro (se conservan)`}
{sinCupo > 0 && ` · ${sinCupo} sin cupo`}
</span>
</div>
<div className="agd-t7-w">
<table className="agd-t7">
<colgroup>
<col style={{ width: "4%" }} />
<col style={{ width: "28%" }} />
<col style={{ width: "9%" }} />
<col style={{ width: "14%" }} />
<col style={{ width: "8%" }} />
<col style={{ width: "25%" }} />
<col style={{ width: "12%" }} />
</colgroup>
<thead>
<tr>
<th></th>
<th><button type="button" className="agd-th-b" onClick={() => ordenarPor("cliente")}>Cliente / oportunidad{flecha("cliente")}</button></th>
<th><button type="button" className="agd-th-b" onClick={() => ordenarPor("prio")} title="Ordenar por prioridad sugerida">Prioridad{flecha("prio")}</button></th>
<th>
<button type="button" className="agd-th-b" onClick={() => ordenarPor("cierre")}>Cierre{flecha("cierre")}</button>
{" · "}
<button type="button" className="agd-th-b" onClick={() => ordenarPor("forecast")} title="Ordenar por categoría de previsión">Previsión{flecha("forecast")}</button>
</th>
<th className="num"><button type="button" className="agd-th-b" onClick={() => ordenarPor("valor")}>Valor{flecha("valor")}</button></th>
<th>Propuesta</th>
<th>Objetivo</th>
</tr>
</thead>
<tbody>
{filasTabla.map((it) => {
const hecha = !!it.creada;
const bloqueada = !!it.conActividad;
const probs = hecha ? [] : val.porItem[it.key] || [];
const horas = horasDe(it.tipo).map(minAHora);
const vencida = it.cierre && it.cierre < hoy;
const av = avisoDe(it, probs);
const apagada = hecha || bloqueada || pendiente;
return (
<Fragment key={it.key}>
<tr className={`agd-f${hecha ? " agd-hecha" : it.incluir ? " agd-marcada" : bloqueada ? " agd-con-act" : ""}${av ? " agd-tiene-aviso" : ""}`}>
<td>
<input type="checkbox" checked={!!it.incluir && !hecha} disabled={apagada || (!it.dia && !it.incluir)} onChange={(e) => marcar(it, e.target.checked)} aria-label="Agendar esta oportunidad" title={bloqueada ? "Ya tiene una actividad agendada en esos días" : !it.dia && !it.incluir ? "Elige primero un día" : undefined} />
</td>
<td>
<strong>{it.cliente || it.nombre}</strong>
{it.cliente && <div className="agd-sub">{it.nombre}</div>}
<div className="agd-sub">{it.tipoOpp || "—"} · {it.plan || "Sin plan de cierre"}</div>
</td>
<td>
{it.prioNivel && (
<span className={`agd-prio p-${NIVELES_PRIO.indexOf(it.prioNivel)}`} title={(it.prioMotivos || []).join(" · ") || undefined}>{it.prioNivel}</span>
)}
</td>
<td className={vencida ? "agd-venc" : undefined}>
{it.cierre ? fechaCorta(it.cierre) : "—"}
{vencida && " · vencida"}
<div className="agd-sub">{it.forecast || "Sin previsión"}</div>
</td>
<td className="num">{money(it.valor)}</td>
<td>
<div className="agd-prop">
<select className="agd-s-tipo" aria-label="Tipo de actividad" value={it.tipo} disabled={apagada} onChange={(e) => cambiarTipo(it, e.target.value)}>
{TIPOS_AGENDADOR.map((t) => <option key={t} value={t}>{t}</option>)}
</select>
<select className="agd-s-dia" aria-label="Día" value={it.dia || ""} disabled={apagada} onChange={(e) => cambiarDia(it, e.target.value)}>
<option value="">— día —</option>
{dias.map((d) => <option key={d} value={d}>{diaCorto(d)}</option>)}
</select>
{it.tipo === "Tarea" ? (
<span className="agd-vence" title={`Las tareas vencen a las ${minAHora(AGENDADOR.horaTarea)}`}>vence {minAHora(AGENDADOR.horaTarea)}</span>
) : (
<select className="agd-s-hora" aria-label="Hora" value={it.hora || ""} disabled={apagada || !it.dia} onChange={(e) => editar(it, { hora: e.target.value })}>
<option value="">—</option>
{horas.map((h) => <option key={h} value={h}>{h}</option>)}
</select>
)}
</div>
{it.tipo !== "Tarea" && !hecha && !bloqueada && (
<label className="agd-gv" title="Gerencia Comercial (Marco) participa en esta actividad">
<input type="checkbox" checked={!!it.gv} disabled={pendiente} onChange={(e) => editar(it, { gv: e.target.checked })} /> 👥 Con GV
</label>
)}
</td>
<td>
<select aria-label="Objetivo" value={it.objetivo} disabled={apagada} onChange={(e) => editar(it, { objetivo: e.target.value })}>
<option value="">— elegir —</option>
{OBJETIVOS_AGENDADOR.map((o) => <option key={o} value={o}>{o}</option>)}
</select>
</td>
</tr>
{av && (
<tr className={`agd-aviso${av.mal ? " mal" : av.info ? " info" : " ok"}`}>
<td colSpan={7}>{av.mal || av.info || av}</td>
</tr>
)}
</Fragment>
);
})}
</tbody>
</table>
</div>
{hayCitas && <p className="hint">Las visitas se crean con lugar «Oficina del cliente»; otros participantes e invitados se agregan en el CRM.</p>}
<div className="agd-pie-fijo">
<span className="agd-pie-r">
<b>{marcadas.length} actividad{marcadas.length === 1 ? "" : "es"}</b> · {nGV} con GV
{marcadas.length > 0 && <> · {nTipo("Llamada")} llamada{nTipo("Llamada") === 1 ? "" : "s"} · {nTipo("Cita")} visita{nTipo("Cita") === 1 ? "" : "s"} · {nTipo("Tarea")} tarea{nTipo("Tarea") === 1 ? "" : "s"}</>}
</span>
{nMalos > 0 && <span className="agd-pie-mal">{nMalos} aviso{nMalos === 1 ? "" : "s"} por corregir</span>}
{marcadas.length === 0 && <span className="agd-pie-sub">Marca al menos una oportunidad para poder crear.</span>}
<button type="button" className="agd-pie-btn" disabled={pendiente || !marcadas.length || !val.ok} onClick={crear}>
{pendiente ? "Trabajando…" : `Crear ${marcadas.length} actividad${marcadas.length === 1 ? "" : "es"} en Dynamics`}
</button>
</div>
</>
)}
</div>
</>
)}
{aviso && <p className={aviso.mal ? "agd-mal" : "agd-ok"} role="status">{aviso.texto}</p>}
{resultado && (
<div className="agd-res">
<strong>Tanda #{resultado.loteId}:</strong> {resultado.creadas} creada(s){resultado.conGV ? ` (${resultado.conGV} con GV)` : ""}{resultado.errores ? `, ${resultado.errores} con error` : ""}{resultado.omitidas ? `, ${resultado.omitidas} omitida(s)` : ""}.
{resultado.resultados.filter((x) => x.estado !== "creada").map((x) => (
<div key={x.oppId} className="agd-mal">{x.nombre || x.oppId}: {x.error}</div>
))}
{resultado.resultados.filter((x) => x.estado === "creada" && x.avisoOpp).map((x) => (
<div key={x.oppId} className="agd-mal">{x.nombre || x.oppId}: {x.avisoOpp}</div>
))}
</div>
)}
{lotes.length > 0 && (
<details className="agd-lotes">
<summary>Tandas recientes ({lotes.length})</summary>
<ul>
{lotes.map((l) => (
<li key={l.id}>
#{l.id} · {fechaHora(l.creado_en)} · {l.creado_por} · {l.items.filter((x) => x.estado === "creada").length} actividad(es){l.items.some((x) => x.gv && x.estado === "creada") ? ` (${l.items.filter((x) => x.gv && x.estado === "creada").length} con GV)` : ""} · {fechaCorta(l.desde)} – {fechaCorta(l.hasta)}
{l.deshecho_en ? <span> — deshecha {fechaHora(l.deshecho_en)}</span> : (
<button type="button" className="agd-btn-sec" disabled={pendiente} onClick={() => deshacer(l.id)} style={{ marginLeft: 8 }}>Deshacer</button>
)}
</li>
))}
</ul>
</details>
)}
</section>
);
}