// Administrador de formación: modelo exclusivo del prototipo, sin servicios externos.
window.TrainingAdminModel = (() => {
  const TODAY = '2026-11-05';
  const clone = value => JSON.parse(JSON.stringify(value));
  const businessDate = value => {
    if (!value) return '';
    if (/^\d{4}-\d{2}-\d{2}$/.test(value)) return value;
    const parts = new Intl.DateTimeFormat('en-CA', { timeZone: 'America/Bogota', year: 'numeric', month: '2-digit', day: '2-digit' }).formatToParts(new Date(value));
    const part = type => parts.find(p => p.type === type).value;
    return `${part('year')}-${part('month')}-${part('day')}`;
  };
  const anniversary = (date, year) => {
    const [, month, day] = date.split('-').map(Number);
    const lastDay = new Date(Date.UTC(year, month, 0)).getUTCDate();
    return `${year}-${String(month).padStart(2, '0')}-${String(Math.min(day, lastDay)).padStart(2, '0')}`;
  };
  const seedCourses = () => [
    ['gh', 'Gestión humana', 'Conoce nuestra cultura, los canales de atención y los beneficios de pertenecer a Atica.', 45, 'IconUsers'],
    ['sst', 'SST', 'Identifica riesgos, medidas de prevención y rutas de atención en tu lugar de trabajo.', 60, 'IconShield'],
    ['environment', 'Ambiental', 'Aplica las prácticas de separación, aprovechamiento y manejo responsable de residuos.', 45, 'IconLeaf'],
    ['quality', 'Calidad', 'Conoce el sistema de gestión y tu aporte a la mejora continua de nuestros procesos.', 40, 'IconCheck'],
    ['compliance', 'SAGRILAFT, SARLAFT y PTEE', 'Reconoce señales de alerta y los canales para reportar riesgos de cumplimiento.', 60, 'IconShield'],
    ['conflict', 'Conflicto de interés', 'Identifica y declara situaciones que pueden afectar la imparcialidad de tus decisiones.', 30, 'IconUsers'],
    ['conduct', 'Código de conducta', 'Conoce los principios de integridad, respeto y conducta que compartimos en Atica.', 40, 'IconBook'],
  ].map(([id, name, description, minutes, icon]) => ({
    id, name, description, minutes, icon, image: '', status: 'published', minScore: 80, version: 1,
    induction: true, reinduction: true,
    materials: [{ id: `${id}-guide`, type: 'Diapositivas', title: `Guía de ${name}`, url: '', demo: true }],
    questions: [
      { text: `¿Qué debes hacer si tienes una duda sobre ${name}?`, options: ['Consultar el procedimiento y al responsable del proceso', 'Actuar sin consultar', 'Ignorar la situación'], correct: 0 },
      { text: '¿Cómo debes reportar una situación que requiere atención?', options: ['Esperar a que alguien más la reporte', 'Usar los canales de atención definidos por Atica', 'Compartir información confidencial públicamente'], correct: 1 },
      { text: '¿Qué conducta contribuye a la mejora continua?', options: ['Cumplir los procedimientos y comunicar oportunidades de mejora', 'Omitir los controles', 'No registrar las novedades'], correct: 0 },
    ],
    survey: ['¿Qué tan claro fue el contenido?', '¿Qué tan útil es este curso para tu trabajo?'],
    inductionSurvey: ['¿Qué tan claro fue el contenido del curso?', '¿Qué tan útil es lo aprendido para tu trabajo?'],
  }));
  const roster = () => {
    const formation = window.FORMATION_EMPLOYEES || [];
    const all = new Map();
    const normalizeDoc = doc => String(doc || '').replace(/\D/g, '');
    formation.forEach(e => all.set(e.id, { id: e.id, name: e.name, doc: e.doc, role: e.cargo, site: e.planta, company: e.sociedad, hire: e.fechaIngreso, active: e.estadoLaboral === 'Activo', isNew: e.fechaIngreso >= '2026-10-01' }));
    (window.EMPLOYEES || []).forEach(e => {
      const prior = [...all.values()].find(p => p.id === e.id || (normalizeDoc(p.doc) === normalizeDoc(e.doc) && p.name === e.name));
      if (prior) all.delete(prior.id);
      const parts = (e.hire || '').includes('/') ? e.hire.split('/') : (e.hire || '').split('-').reverse();
      all.set(e.id, { ...prior, id: e.id, name: e.name, doc: e.doc, role: e.role, site: e.site, company: prior ? prior.company : 'Atica', hire: `${parts[2]}-${parts[1]}-${parts[0]}`, active: ['activo', 'onboarding'].includes(e.status), isNew: `${parts[2]}-${parts[1]}-${parts[0]}` >= '2026-10-01' });
    });
    // Dos ingresos posteriores al corte ilustran la experiencia pendiente, sin cambiar Empleados.
    ['Salomé Vargas Ríos', 'Mateo Esteban Caicedo'].forEach((name, index) => all.set(`demo-${index}`, { id: `FA-NEW-${index}`, name, doc: `1.114.208.00${index}`, role: index ? 'Auxiliar de Aprovechamiento' : 'Operaria de Clasificación', site: 'Cali', company: 'ASEI', hire: index ? '2026-10-22' : '2026-10-19', active: true, isNew: true }));
    all.set('learning-demo', { id: 'FA-LEARN-0', name: 'Laura Sofía Castaño Vélez', doc: '1.114.208.090', role: 'Auxiliar administrativa', site: 'Cali', company: 'ASEI', hire: TODAY, active: true, isNew: true });
    const active = [...all.values()].filter(e => e.active);
    return active.map(e => ({ ...e, identityWarning: active.some(other => other.id !== e.id && normalizeDoc(other.doc) === normalizeDoc(e.doc)) })).sort((a, b) => b.hire.localeCompare(a.hire));
  };
  const snapshot = (courses, type) => clone(courses.filter(c => c.status === 'published' && c[type]).map(c => ({ ...c, questionCount: c.questions.length, surveyRequired: type !== 'induction' && c.survey.length > 0, score: null, completedAt: '', survey: false, surveyQuestions: clone(c.inductionSurvey?.length ? c.inductionSurvey : c.survey || []), diploma: '', attempts: [] })));
  const adminDefaults = () => ({ status: 'Pendiente por revisar', supports: 'Pendiente', history: [] });
  const inductionRecord = (e, courses) => ({ type: 'induction', historical: !e.isNew, completedAt: '', inductionDate: e.isNew ? '' : e.hire, referenceDate: !e.isNew, unlockDate: e.hire, assignedAt: new Date().toISOString(), employeeIdentity: { name: e.name || '', doc: e.doc || '' }, startedAt: '', certificate: null, administration: adminDefaults(), courses: snapshot(courses, 'induction') });
  const initialState = employees => {
    const courses = seedCourses();
    return seedCompletedInductionExample({ schema: 2, people: [], courses, records: Object.fromEntries(employees.map(e => [`${e.id}:induction`, inductionRecord(e, courses)])), settings: { owner: 'Gestión Humana', noticeDays: 30 } }, employees);
  };
  const reconcile = (state, employees) => {
    const records = { ...state.records };
    employees.forEach(e => { if (!records[`${e.id}:induction`]) records[`${e.id}:induction`] = inductionRecord(e, state.courses); });
    return { ...state, records };
  };
  const ensureYear = (state, employees, year) => {
    const next = { ...state, records: { ...state.records } };
    employees.forEach(e => {
      const induction = next.records[`${e.id}:induction`];
      const date = induction && induction.inductionDate;
      if (!date || (!induction.historical && summary(induction).label !== 'Completada') || year <= Number(date.slice(0, 4)) || next.records[`${e.id}:${year}`]) return;
      next.records[`${e.id}:${year}`] = { type: 'reinduction', year, historical: false, unlockDate: anniversary(date, year), courses: snapshot(state.courses, 'reinduction') };
    });
    return next;
  };
  const reinductionHistory = (state, employeeId) => Object.entries(state.records)
    .filter(([key,r]) => key.startsWith(`${employeeId}:`) && r.type === 'reinduction' && r.certificate && (r.finalizedAt || r.completedAt))
    .map(([key,record]) => ({ key, record }))
    .sort((a,b) => (b.record.finalizedAt || b.record.completedAt).localeCompare(a.record.finalizedAt || a.record.completedAt));
  const nextReinduction = (state, employeeId) => {
    const induction = state.records[`${employeeId}:induction`];
    const completed = induction && !induction.historical && (induction.finalizedAt || induction.completedAt);
    if (!completed || !induction.certificate) return null;
    const latest = reinductionHistory(state, employeeId)[0]?.record;
    const date = businessDate(latest ? latest.finalizedAt || latest.completedAt : completed);
    const year = Number(date.slice(0, 4)) + 1, key = `${employeeId}:${year}`;
    return { key, year, unlockDate: anniversary(date, year), record: state.records[key], basedOn: latest ? `Reinducción ${latest.year}` : 'Inducción', baseDate: date };
  };
  const assertProgramAccess = (state, employeeId, key, now) => {
    if (key === `${employeeId}:induction`) return;
    const cycle = nextReinduction(state, employeeId);
    if (!cycle || cycle.key !== key || businessDate(now) < cycle.unlockDate) throw new Error('La reinducción se habilita un año después de finalizar la inducción o la última reinducción.');
  };
  const startReinduction = (state, employeeId, now = new Date().toISOString()) => {
    const cycle = nextReinduction(state, employeeId);
    if (!cycle) throw new Error('Primero finaliza tu inducción.');
    assertProgramAccess(state, employeeId, cycle.key, now);
    if (cycle.record?.startedAt) return state;
    const courses = snapshot(state.courses, 'reinduction').map(c => ({ ...c, surveyQuestions: clone(state.courses.find(source => source.id === c.id)?.survey?.length ? state.courses.find(source => source.id === c.id).survey : ['¿Qué tan claro fue el contenido del curso?']), learningSeconds: 0 }));
    if (!courses.length) throw new Error('Gestión Humana debe publicar los cursos de reinducción.');
    return { ...state, records: { ...state.records, [cycle.key]: { ...cycle.record, type: 'reinduction', year: cycle.year, unlockDate: cycle.unlockDate, journeyVersion: 2, startedAt: now, courses, certificate: null, finalizedAt: '' } } };
  };
  const trainingForRole = (role, catalog = window.FORMATION_CAPACITOGRAMA || []) => {
    const normalize = value => String(value || '').normalize('NFD').replace(/[\u0300-\u036f]/g, '').toLowerCase().trim();
    const aliases = { 'auxiliar administrativa': 'aux. administrativo', 'auxiliar de aprovechamiento': 'op. aprovechamiento', 'operaria de clasificacion': 'operario de clasificacion' };
    const normalized = normalize(role), canonical = aliases[normalized] || normalized;
    const administrative = /administrativ|contab|nomina|gestion humana|talento humano/.test(canonical);
    const operational = /operari|op\.|conductor|mantenimiento|aprovechamiento|planta/.test(canonical);
    return catalog.filter(c => c.activo && ['Interno', 'Externo'].includes(c.tipo) && c.cargosAplicables.some(target => {
      const name = normalize(target);
      return name === canonical || name === normalized || name === 'todos los cargos' || name === 'todos los cargos administrativos' && administrative || name === 'todos los cargos operativos' && operational;
    }));
  };
  const passed = c => c.score !== null && c.score >= c.minScore && !!c.completedAt;
  const summary = (record, today = TODAY) => {
    if (!record || record.blocked) return { label: 'Sin inducción completada', tone: 'navy', done: 0, percent: 0 };
    if (record.historical) return { label: 'Realizada · histórica', tone: 'green', done: record.courses.length, percent: 100 };
    const done = record.courses.filter(c => record.journeyVersion === 2 ? courseComplete(c) : passed(c) && (record.type === 'induction' || !c.surveyRequired || c.survey)).length;
    const percent = record.courses.length ? Math.round(done / record.courses.length * 100) : 0;
    if (record.type !== 'induction' && today < record.unlockDate) return { label: 'No habilitada', tone: 'navy', done, percent };
    if (!record.courses.length) return { label: 'Sin cursos asignados', tone: 'amber', done, percent };
    if (done === record.courses.length && record.journeyVersion === 2 && !record.finalizedAt) return { label: 'Lista para finalizar', tone: 'green', done, percent };
    if (done === record.courses.length) return { label: 'Completada', tone: 'green', done, percent };
    return { label: record.startedAt || record.courses.some(c => c.score !== null) ? 'En curso' : 'Pendiente', tone: 'amber', done, percent };
  };
  const recordResult = (state, employeeId, key, course) => {
    const original = state.records[key];
    const record = { ...original, courses: original.courses.map(c => c.id === course.id ? course : c) };
    const records = { ...state.records, [key]: record };
    if (record.type === 'induction') {
      const complete = summary(record).label === 'Completada';
      record.inductionDate = complete ? record.courses.reduce((max, c) => c.completedAt > max ? c.completedAt : max, '') : '';
      record.referenceDate = false;
      Object.keys(records).forEach(cycleKey => {
        if (!cycleKey.startsWith(`${employeeId}:`) || records[cycleKey].type !== 'reinduction') return;
        const cycle = records[cycleKey];
        records[cycleKey] = { ...cycle, blocked: !complete || cycle.year <= Number(record.inductionDate.slice(0, 4)), unlockDate: complete ? anniversary(record.inductionDate, cycle.year) : cycle.unlockDate };
      });
    }
    return { ...state, records };
  };
  const correctIndices = q => Array.isArray(q.correct) ? q.correct : [q.correct];
  const grade = (answers, questions) => questions.length ? questions.reduce((total, q, i) => {
    const raw = answers[i];
    const selected = raw == null ? [] : Array.isArray(raw) ? raw : [raw];
    const expected = correctIndices(q);
    return total + (selected.length === expected.length && expected.every(n => selected.includes(n)) && new Set(selected).size === selected.length ? 1 : 0);
  }, 0) / questions.length * 100 : 0;
  const validateCourse = c => {
    if (!c.name.trim()) return 'Escribe el nombre del curso.';
    if (!Number.isInteger(Number(c.minutes)) || Number(c.minutes) <= 0) return 'La duración debe ser un número entero de minutos mayor que cero.';
    if (!Number.isFinite(Number(c.minScore)) || Number(c.minScore) < 1 || Number(c.minScore) > 100) return 'El porcentaje mínimo debe estar entre 1 y 100.';
    if (c.status === 'published') {
      if (!c.materials.length || c.materials.some(m => !m.title.trim() || (!m.url && !m.demo))) return 'Agrega contenido con título y archivo o enlace antes de publicar.';
      if (!c.questions.length || c.questions.some(q => !q.text.trim() || q.options.length < 2 || q.options.some(o => !o.trim()) || !correctIndices(q).length || correctIndices(q).some(n => !Number.isInteger(n) || !q.options[n]))) return 'Completa la evaluación y selecciona la respuesta correcta de cada pregunta.';
      if (c.induction && Array.isArray(c.inductionSurvey) && (!c.inductionSurvey.length || c.inductionSurvey.some(q => !q.trim()))) return 'Completa al menos una pregunta de la encuesta de inducción.';
      if (c.reinduction && (!c.survey?.length || c.survey.some(q => !q.trim()))) return 'Completa la encuesta de reinducción o desmarca Reinducción. No se requiere encuesta para inducción.';
    }
    return '';
  };
  const programCourses = state => snapshot(state.courses, 'induction');
  const updateCourse = (state, course) => {
    const issue = validateCourse(course);
    if (issue) throw new Error(issue);
    const exists = state.courses.find(c => c.id === course.id);
    const nextCourse = { ...clone(course), version: exists ? exists.version + 1 : 1 };
    delete nextCourse.isNew;
    const courses = exists ? state.courses.map(c => c.id === course.id ? nextCourse : c) : [...state.courses, nextCourse];
    if (!courses.some(c => c.status === 'published' && c.induction)) throw new Error('Debe quedar al menos un curso publicado de inducción. No puedes retirar o inactivar el último.');
    const records = Object.fromEntries(Object.entries(state.records).map(([key, r]) => [key, r.type === 'induction' && !r.historical && !r.startedAt ? { ...r, courses: snapshot(courses, 'induction') } : r]));
    return { ...state, courses, records };
  };
  const assignEmployee = (state, employee) => {
    const key = `${employee.id}:induction`;
    if (state.records[key]) {
      const identity = state.records[key].employeeIdentity || (state.people || []).find(e => e.id === employee.id) || state.records[key].employeeSnapshot;
      if (identity && (String(identity.doc || '').replace(/\D/g, '') !== String(employee.doc || '').replace(/\D/g, '') || identity.name !== employee.name)) throw new Error('Este identificador pertenece a otra persona. Se conserva su historial y debe generarse una identidad nueva.');
      return state;
    }
    if (!programCourses(state).length) throw new Error('Configura al menos un curso publicado de inducción antes de crear empleados.');
    return { ...state, people: [...(state.people || []).filter(e => e.id !== employee.id), clone(employee)], records: { ...state.records, [key]: inductionRecord({ ...employee, isNew: true }, state.courses) } };
  };
  const startInduction = (state, employeeId, now = new Date().toISOString()) => {
    const key = `${employeeId}:induction`, r = state.records[key];
    if (!r) throw new Error('No hay inducción asignada para esta persona.');
    if (r.historical || r.startedAt) return state;
    const courses = programCourses(state);
    if (!courses.length) throw new Error('No hay cursos publicados de inducción. Contacta a Gestión Humana.');
    return { ...state, records: { ...state.records, [key]: { ...r, courses, startedAt: now, employeeSnapshot: clone((state.people || []).find(e => e.id === employeeId) || roster().find(e => e.id === employeeId) || { id: employeeId }) } } };
  };
  const submitAttempt = (state, employee, courseId, answers, now = new Date().toISOString(), key = `${employee.id}:induction`) => {
    assertProgramAccess(state, employee.id, key, now);
    const r = state.records[key];
    if (!r || !r.startedAt || r.historical) throw new Error('Inicia tu inducción antes de presentar la evaluación.');
    const c = r.courses.find(item => item.id === courseId);
    if (!c || !c.questions || !c.questions.length) throw new Error('La evaluación no está disponible.');
    if (passed(c)) throw new Error('Este curso ya está aprobado. Se conserva tu resultado.');
    const score = grade(answers, c.questions), attempts = c.attempts || [];
    const attempt = { number: attempts.length + 1, retry: attempts.length, at: now, answers: clone(answers), score, passed: score >= c.minScore };
    const courses = r.courses.map(item => item.id === c.id ? { ...item, score, completedAt: attempt.passed ? businessDate(now) : '', attempts: [...attempts, attempt] } : item);
    const complete = courses.every(passed);
    const certificate = complete && r.journeyVersion !== 2 ? { id: `IND-${employee.id}-${businessDate(now)}`, issuedAt: now, employee: clone(employee), minutes: courses.reduce((sum, item) => sum + Number(item.minutes || 0), 0), courses: courses.map(item => ({ id: item.id, name: item.name, version: item.version, minutes: item.minutes })), startedAt: r.startedAt } : null;
    return { ...state, records: { ...state.records, [key]: { ...r, courses, completedAt: complete && r.journeyVersion !== 2 ? now : '', inductionDate: complete && r.journeyVersion !== 2 ? businessDate(now) : '', referenceDate: false, certificate } } };
  };
  const courseComplete = course => passed(course) && !!course.surveyCompletedAt;
  const startLearning = (state, employeeId, now = new Date().toISOString()) => {
    const original = state.records[`${employeeId}:induction`];
    if (original?.historical) throw new Error('Este registro histórico conserva su reconocimiento; no necesita una nueva ejecución.');
    if (original?.certificate || original?.journeyVersion === 2) return state;
    const next = startInduction(state, employeeId, now), key = `${employeeId}:induction`, record = next.records[key];
    const courses = record.courses.map(c => ({ ...c, surveyQuestions: clone(c.surveyQuestions?.length ? c.surveyQuestions : c.inductionSurvey?.length ? c.inductionSurvey : ['¿Qué tan claro fue el contenido del curso?', '¿Qué tan útil es lo aprendido para tu trabajo?']), surveyAnswers: c.surveyAnswers || [], surveyCompletedAt: c.surveyCompletedAt || '', learningSeconds: c.learningSeconds || 0 }));
    return { ...next, records: { ...next.records, [key]: { ...record, journeyVersion: 2, finalizedAt: '', courses } } };
  };
  const saveInductionSurvey = (state, employeeId, courseId, answers, now = new Date().toISOString(), key = `${employeeId}:induction`) => {
    assertProgramAccess(state, employeeId, key, now);
    const r = state.records[key], c = r?.courses.find(item => item.id === courseId);
    if (!c || r.journeyVersion !== 2 || !passed(c)) throw new Error('Aprueba la evaluación antes de responder la encuesta.');
    if (r.finalizedAt) throw new Error('La inducción ya finalizó y conserva su encuesta.');
    if (!Array.isArray(answers) || answers.length !== c.surveyQuestions.length || Array.from(answers).some(n => !Number.isInteger(Number(n)) || Number(n) < 1 || Number(n) > 5)) throw new Error('Responde todas las preguntas de la encuesta de 1 a 5.');
    return { ...state, records: { ...state.records, [key]: { ...r, courses: r.courses.map(item => item.id === courseId ? { ...item, survey: true, surveyAnswers: answers.map(Number), surveyCompletedAt: c.surveyCompletedAt || now } : item) } } };
  };
  const recordLearningTime = (state, employeeId, courseId, seconds, key = `${employeeId}:induction`) => {
    assertProgramAccess(state, employeeId, key, new Date().toISOString());
    const r = state.records[key];
    if (!Number.isFinite(seconds) || seconds < 0) throw new Error('El tiempo dedicado debe ser igual o mayor que cero.');
    if (!r?.startedAt || r.finalizedAt || r.certificate) return state;
    return { ...state, records: { ...state.records, [key]: { ...r, courses: r.courses.map(c => c.id === courseId ? { ...c, learningSeconds: (c.learningSeconds || 0) + Math.floor(seconds) } : c) } } };
  };
  const finishInduction = (state, employee, now = new Date().toISOString(), key = `${employee.id}:induction`) => {
    const r = state.records[key];
    if (r?.certificate) return state;
    assertProgramAccess(state, employee.id, key, now);
    if (!r?.courses.length || r.journeyVersion !== 2 || !r.courses.every(courseComplete)) throw new Error('Completa todos los cursos, evaluaciones y encuestas antes de finalizar la inducción.');
    const certificate = { id: `${r.type === 'reinduction' ? 'REIND' : 'IND'}-${employee.id}-${businessDate(now)}`, type: r.type, year: r.year, issuedAt: now, employee: clone(r.employeeSnapshot?.name ? r.employeeSnapshot : employee), minutes: r.courses.reduce((sum,c) => sum + Number(c.minutes || 0), 0), courses: r.courses.map(c => ({ id: c.id, name: c.name, version: c.version, minutes: c.minutes, score: c.score, learningSeconds: c.learningSeconds || 0 })), startedAt: r.startedAt };
    const next = { ...state, records: { ...state.records, [key]: { ...r, finalizedAt: now, completedAt: now, inductionDate: businessDate(now), referenceDate: false, certificate } } };
    const cycle = nextReinduction(next, employee.id);
    if (cycle && !next.records[cycle.key]) next.records[cycle.key] = { type: 'reinduction', year: cycle.year, historical: false, unlockDate: cycle.unlockDate, courses: snapshot(next.courses, 'reinduction') };
    return next;
  };
  // Caso de demostración reproducible en cualquier navegador; no sustituye resultados existentes.
  const seedCompletedInductionExample = (state, employees) => {
    const employee = employees.find(e => e.id === 'FA-NEW-1' && e.name === 'Mateo Esteban Caicedo');
    const record = state.records['FA-NEW-1:induction'];
    if (!employee || !record || state.demoFixtures?.mateoCompletedInduction || record.certificate || record.historical || record.courses.some(c => c.attempts?.length || c.score != null || c.surveyCompletedAt)) return state;
    const startedAt = '2026-11-05T13:00:00.000Z', finishedAt = '2026-11-05T18:20:00.000Z';
    const courses = programCourses(state).map(c => ({ ...c,
      score: 100, completedAt: '2026-11-05', survey: true,
      surveyQuestions: clone(c.inductionSurvey?.length ? c.inductionSurvey : ['¿Qué tan claro fue el contenido del curso?']),
      surveyCompletedAt: finishedAt, learningSeconds: Number(c.minutes || 0) * 60,
      attempts: [{ number: 1, retry: 0, at: finishedAt, answers: c.questions.map(q => correctIndices(q)), score: 100, passed: true }],
    }));
    if (!courses.length) return state;
    courses.forEach(c => { c.surveyAnswers = c.surveyQuestions.map(() => 5); });
    const next = { ...state, demoFixtures: { ...state.demoFixtures, mateoCompletedInduction: true }, records: { ...state.records,
      'FA-NEW-1:induction': { ...record, courses, startedAt, journeyVersion: 2, employeeSnapshot: clone(employee), demoExample: true }
    } };
    return finishInduction(next, employee, finishedAt);
  };
  const ADMIN_STATUSES = ['Pendiente por revisar', 'Ejecutada', 'Desistió del proceso', 'Cambio de fecha de ingreso'];
  const SUPPORT_STATUSES = ['Sí', 'No', 'Pendiente'];
  const updateAdministration = (state, employeeId, values, actor, now = new Date().toISOString()) => {
    if (!ADMIN_STATUSES.includes(values.status) || !SUPPORT_STATUSES.includes(values.supports)) throw new Error('Selecciona un estado y una opción de soportes válidos.');
    const key = `${employeeId}:induction`, r = state.records[key];
    if (!r) throw new Error('No existe el registro de inducción.');
    const previous = r.administration || adminDefaults();
    const entry = { at: now, actor, status: values.status, supports: values.supports };
    return { ...state, records: { ...state.records, [key]: { ...r, administration: { ...values, updatedAt: now, actor, history: [...previous.history, entry] } } } };
  };
  const migrate = (saved, employees) => {
    if (!saved || ![1,2].includes(saved.schema) || !Array.isArray(saved.courses) || !saved.records || !saved.settings) return initialState(employees);
    const state = clone(saved);
    state.schema = 2; state.people = state.people || [];
    // Never discard an existing catalogue. Repair only a previously empty induction configuration.
    if (!state.courses.some(c => c.status === 'published' && c.induction)) {
      const fallback = seedCourses()[0]; fallback.id = 'induction-welcome'; fallback.name = 'Bienvenida a Atica';
      state.courses.push(fallback); state.configurationRecovered = true;
    }
    Object.entries(state.records).forEach(([key, record]) => {
      if (record.type !== 'induction') return;
      const hadResults = record.courses.some(c => c.score !== null && c.score !== undefined);
      record.startedAt = record.startedAt || (hadResults ? (record.courses.find(c => c.completedAt)?.completedAt || TODAY) + 'T12:00:00.000Z' : '');
      record.assignedAt = record.assignedAt || '';
      record.administration = record.administration || adminDefaults();
      record.certificate = record.certificate || null;
      record.courses = !record.historical && !record.startedAt ? programCourses(state) : record.courses.map(c => {
        const source = state.courses.find(item => item.id === c.id);
        return { ...(source ? clone(source) : { materials: [], questions: [], minutes: 0 }), ...c, attempts: c.attempts || [], surveyRequired: false };
      });
    });
    return seedCompletedInductionExample(reconcile(state, employees), employees);
  };
  return { TODAY, clone, anniversary, seedCourses, roster, initialState, reconcile, ensureYear, recordResult, passed, summary, grade, validateCourse, businessDate, correctIndices, programCourses, updateCourse, assignEmployee, startInduction, submitAttempt, updateAdministration, migrate, startLearning, saveInductionSurvey, recordLearningTime, finishInduction, reinductionHistory, nextReinduction, startReinduction, trainingForRole, seedCompletedInductionExample, courseComplete, ADMIN_STATUSES, SUPPORT_STATUSES };
})();

// One shared store for the catalogue, GH tracking, employee portal and immediate employee creation.
window.TrainingInductionStore = (() => {
  const M = window.TrainingAdminModel, key = 'atica-formation-admin-v1';
  let current = null, loadIssue = '';
  const listeners = new Set();
  const notify = () => listeners.forEach(fn => fn());
  const get = () => {
    if (!current) {
      let saved = null;
      try { saved = JSON.parse(window.localStorage?.getItem(key) || 'null'); }
      catch (_) { loadIssue = 'No se pudo leer el guardado local. Revisa el almacenamiento del navegador antes de continuar.'; }
      current = M.ensureYear(M.migrate(saved, M.roster()), M.roster(), 2026);
    }
    return current;
  };
  const employees = () => {
    const base = M.roster(), people = get().people || [];
    return [...base, ...people.filter(e => !base.some(item => item.id === e.id))];
  };
  const write = next => {
    if (!window.localStorage) throw new Error('No está disponible el almacenamiento local. No se guardaron los cambios.');
    try { window.localStorage.setItem(key, JSON.stringify(next)); }
    catch (_) { throw new Error('No se pudieron guardar los cambios. Libera espacio en el navegador y vuelve a intentarlo.'); }
    current = next; loadIssue = ''; notify(); return next;
  };
  const update = fn => write(fn(get()));
  const assign = employee => {
    const normalized = { id: employee.id, name: employee.name, doc: employee.doc, role: employee.role, site: employee.site, company: employee.empleadorLegal || 'Atica', hire: employee.hire?.includes('/') ? employee.hire.split('/').reverse().join('-') : employee.hire, active: true, isNew: true };
    return update(state => M.assignEmployee(state, normalized));
  };
  if (window.addEventListener) window.addEventListener('storage', event => { if (event.key === key || event.key === null) { current = null; notify(); } });
  return { get, employees, write, update, assign, subscribe: fn => { listeners.add(fn); return () => listeners.delete(fn); }, getWarning: () => loadIssue, key };
})();
