Plot = require("@observablehq/plot@0.6")

encuestas = FileAttachment("datos/encuestas.csv").csv()

// Normalizar vacíos
esVacio = (v) => {
  if (v === null || v === undefined) return true
  const t = String(v).trim().toLowerCase()
  return t === "" || t === "nan" || t === "null" || t === "none" || t === "s/n"
}

// Campos evaluados para completitud de encuestas
campos = [
  "cobertura",
  "autor",
  "fecha_fin",
  "fecha_inicio",
  "margen",
  "muestra",
  "resultado",
  "publicacion",
  "nivel_confianza",
  "archivo",
  "casa_registrada",
  "ciudadanos_registrados",
  "censo_personas16",
  "item",
  "label",
  "coberturaLabel",
  "autorLabel"
]

totalCampos = campos.length

// Cálculo por encuesta
encuestasCompletitud = encuestas.map((e) => {
  const llenos = campos.filter((k) => !esVacio(e[k])).length
  const faltantes = totalCampos - llenos
  const completitud = llenos / totalCampos
  const camposFaltantes = campos.filter((k) => esVacio(e[k]))
  const coberturaNombre = e.coberturaLabel || e.cobertura || "(Sin dato)"
  const autorNombre = e.autorLabel || e.autor || "(Sin dato)"
  const puntajeImportancia = faltantes
  return {
    ...e,
    llenos,
    faltantes,
    camposFaltantes,
    coberturaNombre,
    autorNombre,
    puntajeImportancia,
    completitud,
    completitudPct: Math.round(completitud * 100)
  }
})

totalEncuestas = encuestasCompletitud.length
promedioCompletitud = totalEncuestas
  ? encuestasCompletitud.reduce((acc, d) => acc + d.completitud, 0) / totalEncuestas
  : 0

registrosCompletos = encuestasCompletitud.filter((d) => d.completitud === 1).length
sinArchivo = encuestasCompletitud.filter((d) => esVacio(d.archivo)).length

// Completitud por campo
completitudCampos = campos.map((campo) => {
  const llenos = encuestasCompletitud.filter((d) => !esVacio(d[campo])).length
  return {
    campo,
    llenos,
    total: totalEncuestas,
    pct: totalEncuestas ? (llenos / totalEncuestas) * 100 : 0
  }
})

// Promedio por autor
completitudAutor = Array.from(
  encuestasCompletitud.reduce((m, d) => {
    const k = d.autorNombre
    if (!m.has(k)) m.set(k, [])
    m.get(k).push(d.completitud)
    return m
  }, new Map()),
  ([autor, valores]) => ({
    autor,
    pct: (valores.reduce((a, b) => a + b, 0) / valores.length) * 100
  })
).sort((a, b) => b.pct - a.pct)

// Ranking con menor completitud
peorCompletitud = [...encuestasCompletitud]
  .sort((a, b) => b.puntajeImportancia - a.puntajeImportancia)
  .slice(0, 12)

coberturasDisponibles = ["(Todos)", ...new Set(encuestasCompletitud.map((d) => d.coberturaNombre))]
autoresDisponibles = ["(Todos)", ...new Set(encuestasCompletitud.map((d) => d.autorNombre))]