// js/vista/carga-progresiva.js
const observador = new IntersectionObserver((entradas, obs) => {
  for (const entrada of entradas) {
    if (!entrada.isIntersecting) continue;         // solo nos interesan las que ENTRAN

    const tarjeta = entrada.target;
    cargarDetalleDeTarea(tarjeta.dataset.id);      // pedir lo caro solo ahora
    obs.unobserve(tarjeta);                        // ← ya no hace falta vigilarla
  }
}, {
  root: null,          // null = el viewport; también puede ser un contenedor con scroll
  rootMargin: '200px', // empieza a cargar 200 px ANTES de que se vea: se percibe instantáneo
  threshold: 0.1       // basta con que se vea el 10 % del elemento
});

document.querySelectorAll('.tarea[data-id]').forEach((t) => observador.observe(t));

entrada.isIntersecting     // true si está visible según el threshold
entrada.intersectionRatio  // 0 a 1: qué proporción se ve
entrada.target             // el elemento observado
entrada.boundingClientRect // su geometría, sin forzar recálculo
entrada.time               // marca de tiempo

// A · Scroll infinito: cargar la página siguiente al llegar al centinela
const centinela = document.querySelector('#fin-de-lista');
new IntersectionObserver(([e]) => { if (e.isIntersecting) cargarSiguientePagina(); })
  .observe(centinela);

// B · Animar al aparecer (respetando la preferencia del usuario, apartado 8)
new IntersectionObserver((entradas) => {
  for (const e of entradas) e.target.classList.toggle('visible', e.isIntersecting);
}, { threshold: 0.25 }).observe(seccion);

// C · Cabecera que se pega al hacer scroll, sin escuchar 'scroll'
new IntersectionObserver(([e]) => cabecera.classList.toggle('fijada', !e.isIntersecting))
  .observe(document.querySelector('#sentinela-superior'));

const vigilante = new MutationObserver((mutaciones) => {
  for (const mutacion of mutaciones) {
    if (mutacion.type === 'childList') {
      console.log(`+${mutacion.addedNodes.length} −${mutacion.removedNodes.length} tarjetas`);
    }
    if (mutacion.type === 'attributes' && mutacion.attributeName === 'data-estado') {
      console.log('La tarjeta cambió de columna:', mutacion.target.dataset.id);
    }
  }
});

vigilante.observe(document.querySelector('#lista-tareas'), {
  childList: true, subtree: true, attributes: true, attributeFilter: ['data-estado']
});

const observadorTamano = new ResizeObserver((entradas) => {
  for (const entrada of entradas) {
    const ancho = entrada.contentRect.width;
    // Columnas compactas cuando el tablero es estrecho, sin depender del ancho de la ventana
    entrada.target.classList.toggle('columna--compacta', ancho < 320);
  }
});

document.querySelectorAll('.columna').forEach((c) => observadorTamano.observe(c));

// Consultar sin pedir nada (no todas las APIs lo soportan)
const estado = await navigator.permissions.query({ name: 'geolocation' });
console.log(estado.state);          // 'granted' | 'denied' | 'prompt'

estado.addEventListener('change', () => console.log('Cambió a', estado.state));

/** Patrón correcto: explicar, pedir en un gesto, y aceptar el no. */
async function activarAvisos() {
  if (Notification.permission === 'denied') {
    mostrarAyuda('Has bloqueado las notificaciones. Puedes reactivarlas desde el candado de la barra de direcciones.');
    return false;
  }
  if (Notification.permission === 'granted') return true;

  const acepta = await mostrarDialogoPropio({
    titulo: 'Avisos de vencimiento',
    texto: 'Te avisaremos cuando una tarea del taller esté a punto de vencer. Nada más.'
  });
  if (!acepta) return false;                       // ni siquiera llegamos a pedirlo al navegador

  return (await Notification.requestPermission()) === 'granted';
}

// 1 · Estado actual, sin pedir nada
console.log(Notification.permission);      // 'default' | 'granted' | 'denied'

// 2 · Pedir permiso (solo dentro de un gesto del usuario)
const resultado = await Notification.requestPermission();

// 3 · Mostrar
if (resultado === 'granted') {
  const aviso = new Notification('Nómada Tareas', {
    body: '«Presupuesto de la carpintería» vence hoy.',
    icon: '/iconos/icono-192.png',
    badge: '/iconos/badge.png',
    tag: 'vence-6',                        // ← mismo tag = reemplaza, no acumula
    requireInteraction: false,
    silent: false
  });

  aviso.addEventListener('click', () => {
    window.focus();
    document.querySelector('[data-id="6"]')?.scrollIntoView({ behavior: 'smooth' });
    aviso.close();
  });
}

// js/vista/avisos.js
export function avisarDeVencimientos(tablero, hoy) {
  if (Notification.permission !== 'granted') return;      // sin permiso, silencio absoluto

  const criticas = tablero.filtrar((t) => t.abierta && t.diasRestantes <= 0);
  if (criticas.length === 0) return;

  const aviso = new Notification('Nómada Tareas', {
    body: criticas.length === 1
      ? `«${criticas[0].titulo}» ha vencido.`
      : `${criticas.length} tareas han vencido.`,
    icon: '/iconos/icono-192.png',
    tag: 'vencimientos'                                   // siempre la misma: nunca se acumulan
  });
  aviso.addEventListener('click', () => { window.focus(); aviso.close(); });
}

if ('geolocation' in navigator) {
  navigator.geolocation.getCurrentPosition(
    (posicion) => {
      const { latitude, longitude, accuracy } = posicion.coords;
      console.log(`Estás a ${accuracy} m de ${latitude}, ${longitude}`);
    },
    (error) => {
      const motivos = {
        1: 'Permiso denegado',
        2: 'Posición no disponible',
        3: 'Se agotó el tiempo de espera'
      };
      console.warn(motivos[error.code] ?? error.message);
    },
    { enableHighAccuracy: false, timeout: 8000, maximumAge: 300000 }
  );
}

const posicionActual = (opciones) => new Promise((resolver, rechazar) =>
  navigator.geolocation.getCurrentPosition(resolver, rechazar, opciones)
);

try {
  const { coords } = await posicionActual({ timeout: 8000 });
} catch (error) {
  if (error.code === 1) mostrar('Necesitamos tu ubicación para fichar la entrada al taller.');
}

// js/vista/portapapeles.js
export async function copiarResumen(tablero, hoy) {
  const r = tablero.resumen(hoy);
  const texto = [
    `Taller Nómada — resumen del ${hoy}`,
    `Tareas: ${r.total} (${r.abiertas} abiertas)`,
    `Horas: ${r.horasTotales} totales, ${r.horasAbiertas} abiertas`,
    `Vencidas: ${r.vencidas}`,
    `Esfuerzo ponderado: ${r.esfuerzo}`
  ].join('\n');

  try {
    await navigator.clipboard.writeText(texto);
    return true;
  } catch (error) {
    console.warn('[nomada] No se pudo copiar:', error);
    return false;
  }
}

// Debe llamarse desde un GESTO del usuario, no desde un temporizador
$('#copiar-resumen').addEventListener('click', async () => {
  const copiado = await copiarResumen(tablero, HOY);
  $('#aviso-copia').textContent = copiado
    ? 'Resumen copiado al portapapeles.'
    : 'No se pudo copiar. Selecciona el texto y usa Ctrl+C.';
  $('#aviso-copia').hidden = false;              // con role="status" para que se anuncie
});

// js/vista/enrutador.js
import { EVENTOS, emitir } from './eventos.js';

/** Lee el estado de la vista desde la URL actual. */
export function leerEstadoDeUrl() {
  const p = new URLSearchParams(location.search);
  return {
    responsable: p.get('responsable'),                    // null si no está
    texto: p.get('q') ?? '',
    orden: p.get('orden') ?? 'prioridad',
    estado: p.get('estado')
  };
}

/** Escribe el estado en la URL. `reemplazar` evita llenar el historial. */
export function escribirEstadoEnUrl(estado, { reemplazar = false } = {}) {
  const p = new URLSearchParams();
  if (estado.responsable) p.set('responsable', estado.responsable);
  if (estado.texto) p.set('q', estado.texto);
  if (estado.orden && estado.orden !== 'prioridad') p.set('orden', estado.orden);
  if (estado.estado) p.set('estado', estado.estado);

  const url = p.toString() ? `${location.pathname}?${p}` : location.pathname;
  const metodo = reemplazar ? 'replaceState' : 'pushState';

  history[metodo](estado, '', url);                       // ← el primer argumento se recupera en popstate
}

/** El usuario pulsó atrás o adelante. */
window.addEventListener('popstate', (evento) => {
  const estado = evento.state ?? leerEstadoDeUrl();       // ← ojo: state puede ser null
  emitir(document, EVENTOS.FILTRO_APLICADO, estado);
});

// js/app.js
// 1 · Al arrancar, la URL manda
vista.actualizar({ filtros: leerEstadoDeUrl() });

// 2 · Cada cambio de filtro se refleja en la URL
document.addEventListener(EVENTOS.FILTRO_APLICADO, (evento) => {
  vista.actualizar({ filtros: evento.detail });
  escribirEstadoEnUrl(evento.detail, { reemplazar: evento.detail.origen === 'teclado' });
});

const oscuro = window.matchMedia('(prefers-color-scheme: dark)');

console.log(oscuro.matches);                    // true si el sistema está en modo oscuro

oscuro.addEventListener('change', (evento) => { // ← reacciona si el usuario lo cambia sobre la marcha
  aplicarTema(evento.matches ? 'oscuro' : 'claro');
});

// js/vista/preferencias-sistema.js
export const PREFERENCIAS = {
  temaOscuro:      window.matchMedia('(prefers-color-scheme: dark)'),
  menosMovimiento: window.matchMedia('(prefers-reduced-motion: reduce)'),
  pantallaAncha:   window.matchMedia('(min-width: 900px)')
};

/** Aplica el tema: la preferencia guardada (07-01) gana sobre la del sistema. */
export function aplicarTema() {
  const guardado = leerPreferencias().tema;                    // 'claro' | 'oscuro' | 'sistema'
  const efectivo = guardado === 'sistema'
    ? (PREFERENCIAS.temaOscuro.matches ? 'oscuro' : 'claro')
    : guardado;

  document.documentElement.dataset.tema = efectivo;            // el CSS hace el resto
  document.querySelector('meta[name="theme-color"]')
    ?.setAttribute('content', efectivo === 'oscuro' ? '#1b1f1e' : '#2b6b5b');
}

/** Mover una tarjeta de columna: con animación, o sin ella si el usuario la evita. */
export function moverTarjeta(tarjeta, destino) {
  if (PREFERENCIAS.menosMovimiento.matches) {
    destino.append(tarjeta);                                   // instantáneo, sin transición
    return;
  }
  tarjeta.animate(
    [{ opacity: 0, transform: 'translateY(-8px)' }, { opacity: 1, transform: 'none' }],
    { duration: 180, easing: 'ease-out' }
  );
  destino.append(tarjeta);
}

// js/vista/compartir.js
export async function compartirTablero(tablero, hoy) {
  const datos = {
    title: 'Nómada Tareas',
    text: `Tablero del taller: ${tablero.resumen(hoy).abiertas} tareas abiertas.`,
    url: location.href                          // ← incluye los filtros, gracias al apartado 7
  };

  // 1 · Compartir nativo, si existe (móvil sobre todo)
  if (navigator.canShare?.(datos)) {
    try {
      await navigator.share(datos);
      return 'compartido';
    } catch (error) {
      if (error.name === 'AbortError') return 'cancelado';   // el usuario cerró el diálogo
      console.warn('[nomada] Fallo al compartir:', error);
    }
  }

  // 2 · Respaldo: copiar el enlace al portapapeles (apartado 6)
  await navigator.clipboard.writeText(location.href);
  return 'copiado';
}

// ✗ Con setTimeout: 60 fps "aproximados", desincronizados con el pintado
function animarMal(elemento) {
  let x = 0;
  const id = setInterval(() => {
    x += 2;
    elemento.style.transform = `translateX(${x}px)`;
    if (x >= 200) clearInterval(id);
  }, 16);
}

// ✓ Con requestAnimationFrame: el navegador decide el momento exacto antes de pintar
function animarBien(elemento) {
  let inicio = null;

  function paso(marca) {                        // marca = ms de alta precisión, lo da el navegador
    inicio ??= marca;
    const transcurrido = marca - inicio;
    const progreso = Math.min(transcurrido / 300, 1);       // 300 ms de duración

    elemento.style.transform = `translateX(${progreso * 200}px)`;

    if (progreso < 1) requestAnimationFrame(paso);
  }
  requestAnimationFrame(paso);
}

// ✗ El array de meses a mano: solo español, sin formatos alternativos, y a mantener
export function fechaLegible(iso) {
  const MESES = ['enero', 'febrero', 'marzo', /* … */];
  const [anio, mes, dia] = iso.split('-');
  return `${Number(dia)} de ${MESES[Number(mes) - 1]} de ${anio}`;
}

const fecha = new Date('2026-09-05T00:00:00');

new Intl.DateTimeFormat('es-ES', { dateStyle: 'long' }).format(fecha);
// '5 de septiembre de 2026'

new Intl.DateTimeFormat('es-ES', { dateStyle: 'short' }).format(fecha);
// '5/9/26'

new Intl.DateTimeFormat('es-ES', { weekday: 'long', day: 'numeric', month: 'long' }).format(fecha);
// 'sábado, 5 de septiembre'

new Intl.DateTimeFormat('es-ES', { dateStyle: 'medium', timeStyle: 'short' }).format(new Date());
// '20 sept 2026, 10:14'

new Intl.NumberFormat('es-ES').format(1234.5);                       // '1234,5'
new Intl.NumberFormat('es-ES', { minimumFractionDigits: 1 }).format(48);   // '48,0'

new Intl.NumberFormat('es-ES', { style: 'currency', currency: 'EUR' }).format(1250);
// '1250,00 €'

new Intl.NumberFormat('es-ES', { style: 'percent', maximumFractionDigits: 0 }).format(0.9375);
// '94 %'

new Intl.NumberFormat('es-ES', { style: 'unit', unit: 'hour', unitDisplay: 'long' }).format(12);
// '12 horas'

const relativo = new Intl.RelativeTimeFormat('es-ES', { numeric: 'auto' });

relativo.format(-15, 'day');   // 'hace 15 días'   ← la tarea 6, vencida
relativo.format(10, 'day');    // 'dentro de 10 días'
relativo.format(-1, 'day');    // 'ayer'           ← gracias a numeric: 'auto'
relativo.format(0, 'day');     // 'hoy'
relativo.format(1, 'day');     // 'mañana'
relativo.format(2, 'week');    // 'dentro de 2 semanas'

const nombres = ['Ávila', 'Zurbarán', 'ámbito', 'Barcelona', 'ñu', 'nube'];

console.log([...nombres].sort());
// ['Barcelona', 'Zurbarán', 'nube', 'ámbito', 'ñu', 'Ávila']   ← desastre

const comparador = new Intl.Collator('es-ES', { sensitivity: 'base', numeric: true });
console.log([...nombres].sort(comparador.compare));
// ['ámbito', 'Ávila', 'Barcelona', 'nube', 'ñu', 'Zurbarán']   ← correcto

new Intl.ListFormat('es-ES', { style: 'long', type: 'conjunction' })
  .format(['Marta', 'Iván', 'Lucía']);
// 'Marta, Iván y Lucía'   ← la 'y' final, gratis

const plural = new Intl.PluralRules('es-ES');
plural.select(1);    // 'one'
plural.select(0);    // 'other'
plural.select(5);    // 'other'

// ✗ Crea un formateador por tarjeta, en cada render
tareas.map((t) => new Intl.DateTimeFormat('es-ES', { dateStyle: 'long' }).format(t.fechaLimite));

// ✓ Uno solo, reutilizado
const FECHA_LARGA = new Intl.DateTimeFormat('es-ES', { dateStyle: 'long' });
tareas.map((t) => FECHA_LARGA.format(new Date(t.fechaLimite)));

// js/util/formato.js — reescrito con Intl
const LOCAL = 'es-ES';

// Formateadores creados UNA vez: crearlos es caro
const FECHA_LARGA  = new Intl.DateTimeFormat(LOCAL, { dateStyle: 'long' });
const FECHA_CORTA  = new Intl.DateTimeFormat(LOCAL, { day: 'numeric', month: 'short' });
const FECHA_HORA   = new Intl.DateTimeFormat(LOCAL, { dateStyle: 'medium', timeStyle: 'short' });
const RELATIVO     = new Intl.RelativeTimeFormat(LOCAL, { numeric: 'auto' });
const NUMERO       = new Intl.NumberFormat(LOCAL, { maximumFractionDigits: 1 });
const HORAS        = new Intl.NumberFormat(LOCAL, { style: 'unit', unit: 'hour', unitDisplay: 'long' });
const PORCENTAJE   = new Intl.NumberFormat(LOCAL, { style: 'percent', maximumFractionDigits: 0 });
const LISTA        = new Intl.ListFormat(LOCAL, { style: 'long', type: 'conjunction' });
const COMPARADOR   = new Intl.Collator(LOCAL, { sensitivity: 'base', numeric: true });

export const MARCAS = Object.freeze({ pendiente: '○', 'en-curso': '▸', hecha: '✓' });
export const PESOS  = Object.freeze({ alta: 3, media: 2, baja: 1 });

export function marcaDeEstado(estado) {
  return MARCAS[estado] ?? '?';
}

/** '2026-09-05' → '5 de septiembre de 2026' */
export function fechaLegible(iso) {
  return FECHA_LARGA.format(new Date(`${iso}T00:00:00`));
}

/** '2026-09-05' → '5 sept' — para las tarjetas, donde el espacio es escaso */
export function fechaBreve(iso) {
  return FECHA_CORTA.format(new Date(`${iso}T00:00:00`));
}

/** -15 → 'hace 15 días' · 0 → 'hoy' · 1 → 'mañana' */
export function diasLegibles(dias) {
  if (Math.abs(dias) >= 14) return RELATIVO.format(Math.round(dias / 7), 'week');
  return RELATIVO.format(dias, 'day');
}

/** 12 → '12 horas' · 1 → '1 hora' — sin el plural() escrito a mano */
export function horasLegibles(horas) {
  return HORAS.format(horas);
}

export function numero(valor) {
  return NUMERO.format(valor);
}

/** 0.9375 → '94 %' */
export function porcentaje(fraccion) {
  return PORCENTAJE.format(fraccion);
}

/** ['Marta','Iván','Lucía'] → 'Marta, Iván y Lucía' */
export function listar(elementos) {
  return LISTA.format(elementos);
}

/** Comparador para sort(): respeta tildes, ñ y números dentro del texto */
export const compararTextos = COMPARADOR.compare;

// js/vista/tarjeta.js (fragmento)
import { fechaBreve, diasLegibles, horasLegibles } from '../util/formato.js';

const pie = crearElemento('p', { class: 'tarea__pie' });
pie.textContent = `${fechaBreve(tarea.fechaLimite)} · ${diasLegibles(tarea.diasRestantes)} · ${horasLegibles(tarea.horasEstimadas)}`;
// '5 sept · hace 15 días · 5 horas'   ← la tarea 6, vencida (R10)

// js/vista/tablero-vista.js — ordenar por título, correctamente
import { compararTextos } from '../util/formato.js';

const ORDENES = {
  prioridad: (a, b) => PESOS[b.prioridad] - PESOS[a.prioridad],
  fecha:     (a, b) => a.fechaLimite.localeCompare(b.fechaLimite),
  titulo:    (a, b) => compararTextos(a.titulo, b.titulo)      // ← Intl.Collator
};

// ✓ Comprobar la característica
if ('share' in navigator)              { /* … */ }
if ('IntersectionObserver' in window)  { /* … */ }
if ('clipboard' in navigator)          { /* … */ }
if ('serviceWorker' in navigator)      { /* … */ }
if (typeof Intl?.RelativeTimeFormat === 'function') { /* … */ }

// Encadenamiento opcional para métodos concretos
navigator.canShare?.(datos);
registro.sync?.register('enviar');

// ✗ Nunca detectes el navegador por su cadena de identificación
if (navigator.userAgent.includes('Chrome')) { /* … */ }   // frágil, mentiroso y obsoleto

export function copiarEnlace(url) {
  // Capa 1 · La mejor: la API moderna
  if (navigator.clipboard?.writeText) {
    return navigator.clipboard.writeText(url).then(() => 'copiado');
  }
  // Capa 2 · El respaldo antiguo
  const campo = Object.assign(document.createElement('textarea'), { value: url });
  document.body.append(campo);
  campo.select();
  const ok = document.execCommand?.('copy');            // obsoleto, pero aún funciona
  campo.remove();
  if (ok) return Promise.resolve('copiado');

  // Capa 3 · Que el usuario lo haga a mano
  return Promise.resolve('manual');
}

// js/vista/enrutador.js
import { EVENTOS, emitir } from './eventos.js';

const POR_DEFECTO = Object.freeze({ responsable: null, texto: '', orden: 'prioridad', estado: null });

export function leerEstadoDeUrl(url = location.href) {
  const p = new URL(url).searchParams;
  return {
    responsable: p.get('responsable'),
    texto: p.get('q') ?? '',
    orden: p.get('orden') ?? POR_DEFECTO.orden,
    estado: p.get('estado')
  };
}

export function escribirEstadoEnUrl(estado, { reemplazar = false } = {}) {
  const p = new URLSearchParams();
  // Solo lo que difiere del valor por defecto: URLs limpias
  if (estado.responsable) p.set('responsable', estado.responsable);
  if (estado.texto) p.set('q', estado.texto);
  if (estado.orden !== POR_DEFECTO.orden) p.set('orden', estado.orden);
  if (estado.estado) p.set('estado', estado.estado);

  const cadena = p.toString();
  const url = cadena ? `${location.pathname}?${cadena}` : location.pathname;

  if (url === location.pathname + location.search) return;      // nada que cambiar
  history[reemplazar ? 'replaceState' : 'pushState']({ ...estado }, '', url);
}

export function conectarEnrutador(vista, { signal } = {}) {
  vista.actualizar({ filtros: leerEstadoDeUrl() });              // 1 · la URL manda al arrancar

  document.addEventListener(EVENTOS.FILTRO_APLICADO, (evento) => {
    const { origen, ...filtros } = evento.detail;
    vista.actualizar({ filtros });
    escribirEstadoEnUrl(filtros, { reemplazar: origen === 'texto' });   // 2 · reflejar
  }, { signal });

  window.addEventListener('popstate', (evento) => {              // 3 · atrás / adelante
    const estado = evento.state ?? leerEstadoDeUrl();
    vista.actualizar({ filtros: estado });
  }, { signal });
}

document.querySelector('#copiar-enlace').addEventListener('click', async () => {
  const aviso = document.querySelector('#aviso-copia');         // role="status" aria-live="polite"
  try {
    await navigator.clipboard.writeText(location.href);
    aviso.textContent = 'Enlace de esta vista copiado.';
  } catch {
    aviso.textContent = 'No se pudo copiar. El enlace está en la barra de direcciones.';
  }
  aviso.hidden = false;
}, { signal });

// js/vista/tema.js
const CLAVE = 'nomada:tema';
const CONSULTA = window.matchMedia('(prefers-color-scheme: dark)');

const leerPreferencia  = () => localStorage.getItem(CLAVE) ?? 'sistema';
const temaEfectivo = (pref) => (pref === 'sistema' ? (CONSULTA.matches ? 'oscuro' : 'claro') : pref);

const COLORES = Object.freeze({ claro: '#2b6b5b', oscuro: '#1b1f1e' });

export function aplicarTema(preferencia = leerPreferencia()) {
  const efectivo = temaEfectivo(preferencia);
  document.documentElement.dataset.tema = efectivo;
  document.querySelector('meta[name="theme-color"]')?.setAttribute('content', COLORES[efectivo]);
  return efectivo;
}

export function conectarSelectorDeTema(selector, { signal } = {}) {
  selector.value = leerPreferencia();

  selector.addEventListener('change', () => {
    const elegido = selector.value;
    try { localStorage.setItem(CLAVE, elegido); } catch { /* modo privado: no persiste */ }
    aplicarTema(elegido);
  }, { signal });

  // Solo cuando la preferencia es 'sistema' importa lo que haga el sistema
  CONSULTA.addEventListener('change', () => {
    if (leerPreferencia() === 'sistema') aplicarTema('sistema');
  }, { signal });

  aplicarTema();
}

<!-- En <head>, ANTES del CSS: evita el destello de tema equivocado -->
<script>
  (function () {
    var pref = localStorage.getItem('nomada:tema') || 'sistema';
    var oscuro = pref === 'oscuro' ||
      (pref === 'sistema' && matchMedia('(prefers-color-scheme: dark)').matches);
    document.documentElement.dataset.tema = oscuro ? 'oscuro' : 'claro';
  })();
</script>

// js/vista/resumen.js
import { fechaLegible, diasLegibles, numero, porcentaje, listar, compararTextos, horasLegibles }
  from '../util/formato.js';

export function resumenLegible(tablero, hoy) {
  const r = tablero.resumen(hoy);
  const completadas = r.total === 0 ? 0 : (r.total - r.abiertas) / r.total;

  // Horas abiertas por responsable, ordenadas por nombre con el Collator
  const porResponsable = new Map();
  for (const tarea of tablero.filtrar((t) => t.abierta)) {
    const quien = tarea.responsable ?? 'Sin asignar';
    porResponsable.set(quien, (porResponsable.get(quien) ?? 0) + tarea.horasEstimadas);
  }
  const reparto = [...porResponsable.entries()]
    .sort((a, b) => compararTextos(a[0], b[0]))
    .map(([quien, horas]) => `  · ${quien}: ${horasLegibles(horas)}`);

  const equipo = listar([...porResponsable.keys()].sort(compararTextos));

  const vencidas = tablero
    .filtrar((t) => t.abierta && t.diasRestantes < 0)
    .map((t) => `  ! ${t.titulo} — venció ${diasLegibles(t.diasRestantes)}`);

  return [
    `Taller Nómada — ${fechaLegible(hoy)}`,
    '',
    `Tareas: ${numero(r.total)} (${numero(r.abiertas)} abiertas, ${porcentaje(completadas)} completado)`,
    `Horas: ${horasLegibles(r.horasTotales)} totales · ${horasLegibles(r.horasAbiertas)} abiertas`,
    `Esfuerzo ponderado: ${numero(r.esfuerzo)}`,
    '',
    `Equipo: ${equipo}`,
    ...reparto,
    ...(vencidas.length ? ['', `Vencidas (${vencidas.length}):`, ...vencidas] : [])
  ].join('\n');
}

export async function copiarResumen(tablero, hoy, aviso) {
  try {
    await navigator.clipboard.writeText(resumenLegible(tablero, hoy));
    aviso.textContent = 'Resumen copiado al portapapeles.';
  } catch {
    aviso.textContent = 'No se pudo copiar. Selecciona el texto y usa Ctrl+C.';
  }
  aviso.hidden = false;
}

Taller Nómada — 20 de septiembre de 2026

Tareas: 6 (5 abiertas, 17 % completado)
Horas: 48 horas totales · 45 horas abiertas
Esfuerzo ponderado: 124

Equipo: Iván, Lucía y Marta
  · Iván: 25 horas
  · Lucía: 14 horas
  · Marta: 6 horas

Vencidas (1):
  ! Presupuesto de la carpintería — venció hace 15 días