// Gestor de Flujos central · Configuración · ADR-0034.
// Administración demostrativa con persistencia local; ejecución a cargo de cada módulo.
const { useState: _flw_useState } = React;

const BLOQUES_M13 = [
  { n: 1, nombre: 'Inicio y formulario' },
  { n: 2, nombre: 'Revisión y validación' },
  { n: 3, nombre: 'Aprobación' },
  { n: 4, nombre: 'Recolección o actualización de datos' },
  { n: 5, nombre: 'Tarea operativa' },
  { n: 6, nombre: 'Decisión condicional' },
  { n: 7, nombre: 'Notificación interna' },
  { n: 8, nombre: 'Acción interna del sistema' },
  { n: 9, nombre: 'Generación de solicitudes relacionadas' },
  { n: 10, nombre: 'Cierre y resultado' },
  { n: 11, nombre: 'Firma de documento' },
];
const bloqueNombre = (n) => (BLOQUES_M13.find(b => b.n === n) || {}).nombre || `Bloque ${n}`;

// Procesos consumidores confirmados en V1 (Dotación queda pendiente de
// confirmación — no se le asigna plantilla).
const PLANTILLAS_FLUJO_SEED = [
  {
    id: 'WFT-001', proceso: 'Solicitudes de personal', nombre: 'Reemplazo por vacante', version: 'v4', estado: 'activa', usos: 186,
    secuencia: [1, 2, 3, 9, 10],
    historico: [{ version: 'v3', fecha: '02/03/2026', autor: 'Carolina Restrepo' }, { version: 'v2', fecha: '18/09/2025', autor: 'Carolina Restrepo' }],
  },
  {
    id: 'WFT-002', proceso: 'Solicitudes de personal', nombre: 'Ampliación de nómina · cargo existente', version: 'v2', estado: 'activa', usos: 42,
    secuencia: [1, 2, 3, 3, 3, 3, 9, 2, 4, 8, 7, 10],
    historico: [{ version: 'v1', fecha: '20/01/2026', autor: 'Carolina Restrepo' }],
  },
  {
    id: 'WFT-003', proceso: 'Formación y capacitación', nombre: 'Capacitación externa presencial', version: 'v1', estado: 'activa', usos: 58,
    secuencia: [1, 2, 10],
    historico: [],
  },
  {
    id: 'WFT-004', proceso: 'Ausencias', nombre: 'Solicitud de vacaciones', version: 'v3', estado: 'activa', usos: 421,
    secuencia: [1, 3, 8, 10],
    historico: [{ version: 'v2', fecha: '11/11/2025', autor: 'Carolina Restrepo' }, { version: 'v1', fecha: '01/06/2025', autor: 'Carolina Restrepo' }],
  },
  {
    id: 'WFT-005', proceso: 'Bienestar', nombre: 'Solicitud de evento de bienestar', version: 'v1', estado: 'activa', usos: 9,
    secuencia: [1, 3, 7, 10],
    historico: [],
  },
  {
    id: 'WFT-006', proceso: 'Onboarding', nombre: 'Confirmación de entrega de equipos (Sistemas)', version: 'v2', estado: 'activa', usos: 64,
    secuencia: [1, 5, 8, 10],
    historico: [{ version: 'v1', fecha: '04/08/2026', autor: 'Carolina Restrepo' }],
  },
];

const PROCESOS_FLUJO = ['Solicitudes de personal', 'Formación y capacitación', 'Ausencias', 'Bienestar', 'Onboarding'];

const FLOW_STORAGE_KEY = 'atica-workflow-templates-v1';
const flowModel = window.FlowTemplateData;
const allFlowSeeds = [
  ...flowModel.personnelTemplates,
  ...PLANTILLAS_FLUJO_SEED.filter(t => t.proceso !== 'Solicitudes de personal').map((t, i) => ({ ...t, requestTypes: [flowModel.requestTypes.filter(type => type.module !== 'Solicitudes de personal')[i].id] })),
];
const loadFlowTemplates = () => {
  let saved = [];
  try {
    const parsed = JSON.parse(localStorage.getItem(FLOW_STORAGE_KEY));
    if (Array.isArray(parsed)) saved = parsed.filter(p => p.id && PROCESOS_FLUJO.includes(p.proceso) && Array.isArray(p.secuencia) && Array.isArray(p.historico));
  } catch (_) { /* Se puede trabajar sin almacenamiento local. */ }
  return flowModel.mergeSaved(saved.map(window.FlowBuilderModel.normalize), JSON.parse(JSON.stringify(allFlowSeeds)).map(window.FlowBuilderModel.normalize));
};
const flowTypeName = id => (flowModel.requestTypes.find(t => t.id === id) || {}).name || id;

const FlujosSection = () => {
  const [activeModule, setActiveModule] = _flw_useState(PROCESOS_FLUJO[0]);
  const [templates, setTemplates] = _flw_useState(loadFlowTemplates);
  const [viewing, setViewing] = _flw_useState(null);
  const [editing, setEditing] = _flw_useState(null);
  const [deactivating, setDeactivating] = _flw_useState(null);
  const [message, setMessage] = _flw_useState('');
  const [pendingAssignments, setPendingAssignments] = _flw_useState({});
  const saveAssignment = (typeId) => {
    try {
      const next = flowModel.reassignType(templates, typeId, pendingAssignments[typeId]);
      persist(next);
      setPendingAssignments(current => { const copy = { ...current }; delete copy[typeId]; return copy; });
      setMessage(`Asignación de ${flowTypeName(typeId)} guardada. Las solicitudes existentes conservan su versión.`);
    } catch (error) { setMessage(error.message); }
  };
  const persist = (next) => {
    try { localStorage.setItem(FLOW_STORAGE_KEY, JSON.stringify(next)); }
    catch (_) { setMessage('Los cambios se conservarán durante esta sesión. El navegador no permite guardarlos para la próxima visita.'); }
    setTemplates(next);
  };
  const save = (draft) => {
    const previous = templates.find(t => t.id === draft.id);
    const historySnapshot = previous ? { ...JSON.parse(JSON.stringify(previous)), historico: [] } : null;
    const version = previous ? `v${Number(previous.version.slice(1)) + 1}` : 'v1';
    const next = { ...draft, id: previous ? previous.id : `WFT-${Date.now()}`, version, estado: previous ? previous.estado : 'activa', usos: previous ? previous.usos : 0,
      historico: previous ? [{ ...historySnapshot, fecha: new Date().toLocaleDateString('es-CO'), autor: 'Gestión Humana' }, ...previous.historico] : [] };
    setMessage(`${next.nombre}: versión ${version} guardada.`);
    persist(previous ? templates.map(t => t.id === next.id ? { ...next, requestTypes: previous.requestTypes || [] } : t) : [...templates, { ...next, requestTypes: [] }]);
    setEditing(null);
  };
  const filtered = templates.filter(p => p.proceso === activeModule);
  return <>
    <div className="cf-section-head">
      <div><h2 className="cf-section-title">Gestor de Flujos</h2><p className="cf-section-sub">Administra las plantillas de cada módulo. Crea flujos, ajusta sus etapas y conserva el historial de versiones.</p></div>
      <button className="btn primary" onClick={() => setEditing(window.FlowBuilderModel.create(activeModule === 'Solicitudes de personal' ? 'coverage' : 'module_request', activeModule))}>+ Crear flujo</button>
    </div>
    <div className="flw-module-tabs" role="tablist" aria-label="Módulos del Gestor de Flujos">
      {PROCESOS_FLUJO.map((module, index) => <button key={module} id={`flw-tab-${index}`} role="tab" aria-selected={activeModule === module} aria-controls="flw-module-panel" className={`sst-chip ${activeModule === module ? 'active' : ''}`} onClick={() => { setActiveModule(module); setMessage(''); }}>{module} <span className="sst-chip-count">{templates.filter(t => t.proceso === module).length}</span></button>)}
    </div>
    {message && <div className="ne-callout" role="status" style={{ marginTop: 14 }}><IconInfo size={16} /><div>{message}</div></div>}
    <div id="flw-module-panel" role="tabpanel" aria-labelledby={`flw-tab-${PROCESOS_FLUJO.indexOf(activeModule)}`} className="doc-list-card flw-table-wrap" style={{ marginTop: 14 }}>
      <table className="doc-table"><thead><tr><th>Flujo</th><th>Tipos de solicitud asignados</th><th>Versión vigente</th><th>Etapas</th><th>Solicitudes iniciadas</th><th>Estado</th><th>Acciones</th></tr></thead><tbody>
        {filtered.map(p => <tr key={p.id}>
          <td style={{ fontWeight: 600 }}>{p.nombre}<div className="muted" style={{ fontSize: 11 }}>{window.FlowBuilderModel.process(p.processId).name}</div><div className="muted mono" style={{ fontSize: 10 }}>{p.id}</div></td>
          <td><div className="flw-type-tags">{(p.requestTypes || []).length ? p.requestTypes.map(id => <span key={id} className="pill navy">{flowTypeName(id)}</span>) : <span className="muted">Sin asignación</span>}</div></td><td><span className="pill navy mono">{p.version}</span></td><td>{p.secuencia.length}</td><td>{p.usos.toLocaleString('es-CO')}</td>
          <td><EstadoPill activo={p.estado === 'activa'} labelOn="Activa" labelOff="Inactiva" /></td>
          <td><div className="flw-row-actions"><button className="btn" onClick={() => setViewing(p)}>Ver</button><button className="btn" onClick={() => setEditing(JSON.parse(JSON.stringify(p)))}>Modificar</button><button className="btn" disabled={p.estado !== 'activa'} onClick={() => { if (!flowModel.canDeactivate(p)) { setMessage('Reasigna los tipos de solicitud a otra plantilla antes de inactivar este flujo.'); return; } setDeactivating(p); }}>Inactivar</button></div></td>
        </tr>)}
        {!filtered.length && <tr><td colSpan="7" className="muted">Este módulo aún no tiene flujos. Usa Crear flujo para agregar el primero.</td></tr>}
      </tbody></table>
    </div>
    <div className="ne-callout" style={{ marginTop: 14 }}><IconInfo size={16} /><div>Las solicitudes mantienen su versión al iniciar. En cada módulo los usuarios ven el progreso y sus tareas; la configuración de los flujos se administra aquí.</div></div>
    <section className="flw-assignment-summary" aria-label="Asignación por tipo de solicitud">
      <h3>Asignación por tipo de solicitud</h3>
      <p className="muted">Cada tipo utiliza una sola plantilla activa compatible con su proceso. Elige otra y guarda para sustituir la asignación vigente. Las solicitudes que ya iniciaron conservan su versión.</p>
      <table className="doc-table"><thead><tr><th>Tipo de solicitud</th><th>Plantilla asignada</th><th>Acción</th></tr></thead><tbody>
        {flowModel.requestTypes.filter(t => t.module === activeModule).map(type => {
          const owner = templates.find(t => t.estado === 'activa' && (t.requestTypes || []).includes(type.id));
          const options = templates.filter(t => t.estado === 'activa' && t.proceso === type.module && window.FlowBuilderModel.isCompatible(t, type.id));
          const selected = pendingAssignments[type.id] || (owner ? owner.id : '');
          const changed = selected && (!owner || selected !== owner.id);
          return <tr key={type.id}><td>{type.name}</td><td>
            <select className="form-input" aria-label={`Plantilla para ${type.name}`} value={selected} onChange={e => setPendingAssignments(current => ({ ...current, [type.id]: e.target.value }))}>
              {!owner && !pendingAssignments[type.id] && <option value="" disabled>Selecciona una plantilla</option>}
              {options.map(t => <option key={t.id} value={t.id}>{t.nombre} · {t.version}</option>)}
            </select>
            {!owner && <div className="flw-error">Este tipo requiere una plantilla para habilitar solicitudes.</div>}
          </td><td><button className="btn" disabled={!changed} onClick={() => saveAssignment(type.id)}>Guardar asignación</button></td></tr>;
        })}
      </tbody></table>
    </section>
    {viewing && <FlowDemoEditor template={viewing} readOnly onClose={() => setViewing(null)} />}
    {editing && <FlowDemoEditor template={editing} onClose={() => setEditing(null)} onSave={save} />}
    {deactivating && <Modal open onClose={() => setDeactivating(null)} title="Inactivar flujo" subtitle={deactivating.nombre} width={520} footer={<><button className="btn" onClick={() => setDeactivating(null)}>Cancelar</button><button className="btn primary" onClick={() => { setMessage(`${deactivating.nombre}: flujo inactivo.`); persist(templates.map(t => t.id === deactivating.id ? { ...t, estado: 'inactiva' } : t)); setDeactivating(null); }}>Confirmar inactivación</button></>}><p>El flujo dejará de estar disponible para nuevas asignaciones. Las solicitudes que ya lo utilizan conservan su versión y su historial.</p></Modal>}
  </>;
};

window.FlujosSection = FlujosSection;
