"""Construction Intelligence AI | local portfolio dashboard.
Results derive only from bundled publicly sourced experiments. No company data.
Run: python -m streamlit run app.py
"""

from __future__ import annotations

import io
import json
import html
import tempfile
from pathlib import Path

import numpy as np
import pandas as pd
import plotly.express as px
import plotly.graph_objects as go
import streamlit as st
from plotly.subplots import make_subplots

ROOT = Path(__file__).resolve().parent
F = ROOT / "data" / "forecasting"
D = ROOT / "data" / "document_ai"
O = ROOT / "data" / "ocr"
B = ROOT / "data" / "bim"
M = ROOT / "models"
A = ROOT / "assets"
COLORS = {"real":"#0f766e", "neural":"#6857e8", "base":"#f59e0b", "pale":"#94a3b8"}

st.set_page_config(page_title="Construction Intelligence AI", page_icon="🏗️", layout="wide", initial_sidebar_state="expanded")
st.markdown("""
<style>
:root {color-scheme: light;}
.block-container {max-width:1440px; padding-top:1.4rem; padding-bottom:4rem;}
[data-testid="stSidebar"] {background:#f5f7fb; border-right:1px solid #e4e9f1;}
[data-testid="stSidebar"] h2 {letter-spacing:-0.02em;}
h1,h2,h3 {letter-spacing:-0.035em; color:#0f172a;}
h1 {font-size:2.25rem !important;}
small,.small {color:#64748b;}
.hero {padding:1.55rem 1.75rem;background:linear-gradient(115deg,#0b1732 0%,#18295d 65%,#0f756f 155%);
  color:white;border-radius:20px;margin-bottom:1.4rem;}
.hero h1 {color:white !important; margin:.2rem 0 .35rem 0;font-size:2.0rem!important;}
.hero p {color:#cbd5e1;margin:0;max-width:850px;line-height:1.55;}
.eyebrow {text-transform:uppercase;font-size:.70rem;letter-spacing:.14em;font-weight:800;color:#8fdcd1;}
.metric-card {background:white;border:1px solid #e2e8f0;border-radius:16px;padding:18px 18px 14px;
box-shadow:0 4px 18px rgba(15,23,42,.035);margin:0 0 10px;min-height:124px;}
.metric-card .label {color:#64748b;font-size:.76rem;font-weight:700;}
.metric-card .value {color:#0f172a;font-size:2.0rem;font-weight:780;letter-spacing:-.035em;margin:.13rem 0;}
.metric-card .sub {color:#64748b;font-size:.71rem;line-height:1.25;}
.section-note {background:#f3f6fa;border-left:3px solid #64748b;padding:12px 16px;color:#475569;
border-radius:0 9px 9px 0;font-size:.88rem;margin:12px 0 20px;}
[data-testid="stFileUploader"] {background:#fbfdff;border:1px dashed #b6c3d3;border-radius:12px;padding:8px;}
[data-testid="stTabs"] [data-baseweb="tab-list"] {gap:8px;}
[data-testid="stTabs"] button[role="tab"] {background:#f1f5f9;border-radius:8px 8px 0 0;padding:8px 15px;}
.architecture {display:flex; gap:8px; align-items:stretch; flex-wrap:wrap; margin:10px 0 22px;}
.architecture > div:not(.arch-arrow){flex:1 1 170px; background:linear-gradient(140deg,#f8fafc,#eff6ff);border:1px solid #dce6f3;border-radius:14px;padding:15px 12px;display:flex;flex-direction:column;gap:6px;min-width:130px;}
.architecture strong{color:#0f172a;font-size:0.92rem;}.architecture small{color:#64748b;font-size:.75rem;}
.arch-icon{color:#4f46e5;font-size:1.35rem;}.arch-arrow{display:flex;align-items:center;color:#94a3b8;font-size:1.4rem;font-weight:700;}
.evidence {border:1px solid #c7d2fe;background:#eef2ff;border-radius:14px;padding:16px 18px;}
.evidence h4{margin:0 0 8px;color:#1e1b4b;}.evidence p{margin:0;color:#312e81;font-size:.87rem;}
</style>
""", unsafe_allow_html=True)

@st.cache_data(show_spinner=False)
def csv(path: str, dates: tuple[str, ...] = ()) -> pd.DataFrame:
    p = ROOT / path
    df = pd.read_csv(p)
    for c in dates:
        if c in df:
            df[c] = pd.to_datetime(df[c], errors="coerce")
    return df

@st.cache_data(show_spinner=False)
def js(path: str) -> dict:
    return json.loads((ROOT / path).read_text(encoding="utf-8"))


def metric(label: str, value: str, sub: str) -> None:
    st.markdown(f'<div class="metric-card"><div class="label">{label}</div><div class="value">{value}</div><div class="sub">{sub}</div></div>', unsafe_allow_html=True)


def note(text: str) -> None:
    st.markdown(f'<div class="section-note">{text}</div>', unsafe_allow_html=True)


def fig_layout(fig, height=400):
    fig.update_layout(
        height=height, margin=dict(l=5,r=12,t=35,b=10),
        paper_bgcolor="rgba(0,0,0,0)",plot_bgcolor="rgba(0,0,0,0)",
        font=dict(family="Arial, sans-serif", color="#334155", size=12),
        hovermode="x unified",legend=dict(orientation="h",y=1.13,x=0),
        xaxis=dict(showgrid=False),yaxis=dict(gridcolor="#e8edf3")
    )
    return fig


def as_csv(df):
    return df.to_csv(index=False).encode("utf-8-sig")


forecast_sum = csv("data/forecasting/resumen_modelos.csv")
forecast_pred = csv("data/forecasting/predicciones_auditadas.csv", ("fecha",))
forecast_future = csv("data/forecasting/forecast_experimental.csv", ("fecha",))
forecast_year = csv("data/forecasting/metricas_por_anio.csv")
doc_scores = csv("data/document_ai/metricas_document_ai.csv")
ocr_comp = csv("data/ocr/comparacion_ocr_neuronal.csv")
bim_budget = csv("data/bim/prepresupuesto_bim.csv")
bim_alerts = csv("data/bim/alertas_bim.csv")
bim_info = js("data/bim/resumen.json")

with st.sidebar:
    st.markdown("## 🏗️ Construction Intelligence")
    st.caption("AI PORTFOLIO · 2026 · EDICIÓN PRO")
    st.divider()
    page = st.radio("Explorar módulos", [
        "Resumen ejecutivo", "Centro de métricas IA", "Forecasting neuronal", "Document AI",
        "OCR neuronal", "Automatización BIM", "Cotizaciones estructuradas", "Laboratorio interactivo"
    ], label_visibility="collapsed")
    st.divider()
    st.caption("FUENTES ABIERTAS")
    st.markdown("FRED WPU101 / WPU08  \\\nCORD v1 · IFC público")
    st.caption("Proyecto independiente de demostración. Sin conexión activa a Revit, Dynamo, Rhino o Grasshopper.")

st.markdown('<div class="hero"><div class="eyebrow">Open-data AI portfolio</div><h1>Construction Intelligence AI</h1><p>Forecasting de materiales · Automatización documental · OCR neuronal · Auditoría de modelos BIM. Resultados reproducibles con datos públicos y controles de calidad.</p></div>', unsafe_allow_html=True)

if page == "Resumen ejecutivo":
    st.subheader("Indicadores principales")
    cols = st.columns(4)
    acero = forecast_sum[forecast_sum.material=="Acero"].iloc[0]
    doc_mlp = doc_scores[(doc_scores.modelo=="MLP") & (doc_scores.periodo=="prueba")].iloc[0]
    rapid = ocr_comp[ocr_comp.modo=="RapidOCR_neuronal"].iloc[0]
    with cols[0]: metric("Mejora observada · acero", f"{acero.mejora_porcentaje:.1f}%", "LSTM vs persistencia · 48 meses de prueba")
    with cols[1]: metric("Document AI · MLP", f"{doc_mlp.accuracy*100:.1f}%", "Accuracy en transcripciones CORD · 1,336 líneas")
    with cols[2]: metric("RapidOCR", f"{rapid.cobertura_textual_aproximada*100:.1f}%", "Cobertura textual aproximada · cinco recibos")
    with cols[3]: metric("Alertas BIM", str(len(bim_alerts)), "Revisión de cantidades · IFC público")
    note("<b>Interpretación:</b> no son métricas de un mismo sistema de extremo a extremo. Cada módulo tiene un dataset, una evaluación y limitaciones propias. Los índices PPI estadounidenses no representan precios en México.")
    c1, c2 = st.columns([1.2,1])
    with c1:
        st.markdown("#### Predicción mensual de acero")
        tmp = forecast_pred[forecast_pred.material=="Acero"].copy()
        fig = go.Figure()
        for col, label, color in [("real","Real",COLORS["real"]),("persistencia","Persistencia",COLORS["base"]),("prediccion","LSTM",COLORS["neural"])]:
            fig.add_scatter(x=tmp.fecha,y=tmp[col],mode="lines",name=label,line=dict(color=color,width=2.4 if col=="real" else 2))
        fig.update_yaxes(title="Índice PPI")
        st.plotly_chart(fig_layout(fig),use_container_width=True)
    with c2:
        st.markdown("#### Cobertura de OCR")
        tmp = ocr_comp.copy()
        tmp["cobertura_%"] = tmp["cobertura_textual_aproximada"] * 100
        fig = px.bar(tmp, x="cobertura_%", y="modo", orientation="h", text="cobertura_%", color="modo", color_discrete_sequence=["#94a3b8","#cbd5e1","#64748b",COLORS["real"]])
        fig.update_traces(texttemplate="%{text:.1f}%",textposition="outside")
        fig.update_xaxes(title="% de líneas emparejadas",range=[0,100]); fig.update_yaxes(title=None)
        fig.update_layout(showlegend=False)
        st.plotly_chart(fig_layout(fig),use_container_width=True)
    st.markdown("#### Arquitectura de la solución")
    st.markdown("""
    <div class="architecture">
      <div><span class="arch-icon">▤</span><strong>Datos públicos</strong><small>FRED · CORD · IFC</small></div>
      <div class="arch-arrow">→</div>
      <div><span class="arch-icon">✦</span><strong>Modelos de IA</strong><small>LSTM · MLP · OCR</small></div>
      <div class="arch-arrow">→</div>
      <div><span class="arch-icon">◈</span><strong>Validación</strong><small>MAE · F1 · Alertas</small></div>
      <div class="arch-arrow">→</div>
      <div><span class="arch-icon">▧</span><strong>Decisiones auditables</strong><small>Revisión humana</small></div>
    </div>""", unsafe_allow_html=True)
    st.markdown("#### Qué es demostración y qué está validado")
    st.dataframe(pd.DataFrame([
        {"Componente":"Forecasting (acero)","Evidencia":"MAE 5.965 vs 7.825 · LSTM","Alcance":"Mejora exploratoria; prueba reutilizada"},
        {"Componente":"Document AI","Evidencia":"F1 macro 0.825 · logística en prueba","Alcance":"Líneas con transcripción CORD; no facturas mexicanas"},
        {"Componente":"OCR neuronal","Evidencia":"40/51 líneas emparejadas","Alcance":"5 recibos; coincidencia aproximada, no CER/WER"},
        {"Componente":"BIM / IFC","Evidencia":"123 elementos · 16 alertas","Alcance":"Archivo público, cantidades sin precios aprobados"},
    ]), hide_index=True, use_container_width=True)

elif page == "Centro de métricas IA":
    st.subheader("Centro de métricas y evaluación de modelos")
    st.caption("Cuatro módulos, cuatro metodologías distintas. Cada indicador conserva su fuente, denominador y limitación.")
    acero = forecast_sum[forecast_sum.material=="Acero"].iloc[0]
    madera = forecast_sum[forecast_sum.material=="Madera"].iloc[0]
    doc_log = doc_scores[(doc_scores.modelo=="LOGISTICA") & (doc_scores.periodo=="prueba")].iloc[0]
    doc_mlp = doc_scores[(doc_scores.modelo=="MLP") & (doc_scores.periodo=="prueba")].iloc[0]
    rapid = ocr_comp[ocr_comp.modo=="RapidOCR_neuronal"].iloc[0]
    num_elements = int(bim_info.get("elementos", 123))
    n_no_qto = int(bim_info.get("elementos_sin_qto", 28))

    st.markdown("#### Resultados destacados de tus experimentos")
    c1,c2,c3,c4=st.columns(4)
    with c1: metric("Acero · mejora LSTM", f"{acero.mejora_porcentaje:.2f}%", "MAE 5.965 frente a 7.825 · prueba histórica")
    with c2: metric("Document AI · MLP", f"{doc_mlp.accuracy*100:.2f}%", "Accuracy, líneas ya transcritas")
    with c3: metric("RapidOCR · cobertura", f"{rapid.cobertura_textual_aproximada*100:.2f}%", "40/51 coincidencias textuales aproximadas")
    with c4: metric("IFC · registros de cantidades", str(bim_info.get("registros_cantidades",357)), "123 elementos · 16 alertas de coherencia")

    st.markdown("""<div class="evidence"><h4>🔬 Evidencia antes que promesas</h4>
    <p>Los modelos se comparan contra referencias sencillas y muestran también los errores. El forecasting se evaluó con un periodo histórico examinado durante el desarrollo; OCR se probó en cinco recibos ya vistos. Ningún indicador permite afirmar exactitud comercial ni emitir presupuestos sin revisión.</p></div>""",unsafe_allow_html=True)

    t1,t2,t3,t4 = st.tabs(["🧠 Forecasting", "📄 Document AI", "👁️ OCR neuronal", "🏗️ BIM / IFC"])

    with t1:
        st.markdown("#### Comparación justa con persistencia")
        c1,c2,c3,c4=st.columns(4)
        with c1: metric("Acero · LSTM MAE", f"{acero.MAE_modelo:.3f}", "Puntos de índice PPI")
        with c2: metric("Acero · línea base MAE", f"{acero.MAE_persistencia:.3f}", "Persistencia · menor es mejor")
        with c3: metric("Acierto de dirección", f"{acero.acierto_direccion_porcentaje:.2f}%", "35 de 48 meses · acero")
        with c4: metric("Madera · línea base MAE", f"{madera.MAE_persistencia:.3f}", "Persistencia seleccionada")
        left,right=st.columns([1,1.15])
        with left:
            mae = pd.DataFrame({"Material":["Acero","Acero","Madera","Madera"],"Modelo":["Persistencia","LSTM","Persistencia","Seleccionado"],"MAE":[float(acero.MAE_persistencia),float(acero.MAE_modelo),float(madera.MAE_persistencia),float(madera.MAE_modelo)]})
            fig=px.bar(mae,x="Material",y="MAE",color="Modelo",barmode="group",text="MAE",color_discrete_map={"Persistencia":"#f59e0b","LSTM":"#6857e8","Seleccionado":"#0f766e"})
            fig.update_traces(texttemplate="%{text:.2f}",textposition="outside")
            st.plotly_chart(fig_layout(fig,350),use_container_width=True)
            st.caption("MAE: error absoluto medio en puntos de índice, no MXN. La madera no mejoró a la referencia.")
        with right:
            material = st.selectbox("Analizar errores mensuales", ["Acero", "Madera"], key="metro_material")
            datos = forecast_pred[forecast_pred.material==material].copy()
            datos["Error L1 · seleccionado"] = (datos.real-datos.prediccion).abs()
            datos["Error L1 · referencia"] = (datos.real-datos.persistencia).abs()
            fig=go.Figure()
            fig.add_scatter(x=datos.fecha,y=datos["Error L1 · seleccionado"],name="Seleccionado",mode="lines+markers",line_color=COLORS["neural"])
            fig.add_scatter(x=datos.fecha,y=datos["Error L1 · referencia"],name="Persistencia",mode="lines",line_color=COLORS["base"])
            fig.update_yaxes(title="Error absoluto |real - predicción|")
            st.plotly_chart(fig_layout(fig,350),use_container_width=True)
        st.info(f"Intervalo bootstrap exploratorio de mejora en acero: {acero.IC95_aprox_inferior:.2f}% a {acero.IC95_aprox_superior:.2f}%. Incluye 0: todavía hay incertidumbre de generalización.")

    with t2:
        st.markdown("#### Calidad de clasificación por categoría")
        import sklearn.metrics as skm
        real = csv("data/document_ai/predicciones_documentales.csv")
        clases = ["ARTICULO","PRECIO","CANTIDAD","SUBTOTAL","TOTAL","OTRO"]
        informe = skm.classification_report(real.categoria,real.prediccion,labels=clases,output_dict=True,zero_division=0)
        byclass = pd.DataFrame([{"Categoria":n,"Precision":informe[n]["precision"],"Recall":informe[n]["recall"],"F1":informe[n]["f1-score"],"Lineas":int(informe[n]["support"])} for n in clases])
        c1,c2,c3=st.columns(3)
        with c1: metric("Selección por validación","Logística", "F1 macro validación 81.44%")
        with c2: metric("F1 prueba · logística",f"{doc_log.macro_F1*100:.2f}%","Modelo elegido sin mirar la prueba")
        with c3: metric("F1 prueba · MLP",f"{doc_mlp.macro_F1*100:.2f}%","Red conservada como comparativa")
        left,right=st.columns([1.1,1])
        with left:
            byclass["F1 (%)"] = byclass.F1*100
            fig=px.bar(byclass,x="F1 (%)",y="Categoria",orientation="h",text="F1 (%)",color="F1 (%)",color_continuous_scale=[[0,"#db2777"],[0.5,"#7c3aed"],[1,"#0f766e"]])
            fig.update_traces(texttemplate="%{text:.1f}%",textposition="outside")
            fig.update_xaxes(range=[0,110]);fig.update_layout(coloraxis_showscale=False)
            st.plotly_chart(fig_layout(fig,380),use_container_width=True)
        with right:
            cm=skm.confusion_matrix(real.categoria,real.prediccion,labels=clases)
            fig=px.imshow(cm,x=clases,y=clases,text_auto=True,color_continuous_scale="Blues",aspect="auto")
            fig.update_xaxes(title="Predicho");fig.update_yaxes(title="Verdadero")
            fig.update_layout(coloraxis_showscale=False)
            st.plotly_chart(fig_layout(fig,380),use_container_width=True)
        st.dataframe(byclass[["Categoria","Precision","Recall","F1","Lineas"]].round(3),hide_index=True,use_container_width=True)
        st.warning("La categoría OTRO tiene el F1 más bajo. El clasificador trabaja con transcripciones del dataset CORD v1, no con facturas CFDI ni precios de obras en México.")

    with t3:
        st.markdown("#### Resultados comparables de reconocimiento textual")
        d=ocr_comp.copy(); d["Cobertura (%)"]=100*d.cobertura_textual_aproximada
        d["Clasificación correcta / 51 (%)"]=100*d.clases_correctas/d.lineas_referencia
        left,right=st.columns(2)
        with left:
            fig=go.Figure()
            fig.add_bar(x=d.modo,y=d["Cobertura (%)"],name="Cobertura aproximada",marker_color="#0f766e",text=[f"{v:.1f}%" for v in d["Cobertura (%)"]],textposition="outside")
            fig.add_scatter(x=d.modo,y=d["Clasificación correcta / 51 (%)"],name="Correctamente clasificadas / 51",mode="lines+markers",line=dict(color="#6857e8",width=3))
            fig.update_yaxes(title="Porcentaje de 51 líneas referencia",range=[0,100])
            st.plotly_chart(fig_layout(fig,380),use_container_width=True)
        with right:
            nr=d[d.modo=="RapidOCR_neuronal"].iloc[0]
            metric("RapidOCR · líneas reconocidas",f"{int(nr.lineas_ocr)}", "Segmentos OCR: pueden dividir una sola línea")
            metric("RapidOCR · emparejamientos",f"{int(nr.coincidencias)}/51", "Coincidencia aproximada con la transcripción")
            metric("RapidOCR · categorías correctas",f"{int(nr.clases_correctas)}/51", "Entre emparejamientos: 32/40 correctos")
        st.dataframe(d[["modo","lineas_ocr","coincidencias","clases_correctas","Cobertura (%)"]].round(2),hide_index=True,use_container_width=True)
        st.caption("Comparación exploratoria en cinco imágenes. Las puntuaciones son aproximaciones basadas en emparejamientos, no CER, WER ni precisión financiera.")

    with t4:
        st.markdown("#### Trazabilidad y control de calidad del IFC")
        c1,c2,c3,c4=st.columns(4)
        with c1: metric("Elementos IFC",f"{num_elements}","Modelo público")
        with c2: metric("Con QTO",f"{num_elements-n_no_qto}",f"{(num_elements-n_no_qto)/num_elements*100:.1f}% de elementos")
        with c3: metric("Sin QTO",f"{n_no_qto}","No inventar cantidades")
        with c4: metric("Alertas",str(len(bim_alerts)),"Revisión obligatoria")
        left,right=st.columns([1,1.05])
        with left:
            counts=bim_alerts.regla.value_counts().rename_axis("Regla").reset_index(name="Alertas")
            fig=px.bar(counts,x="Alertas",y="Regla",orientation="h",text="Alertas",color_discrete_sequence=["#e11d48"])
            st.plotly_chart(fig_layout(fig,350),use_container_width=True)
        with right:
            st.markdown("**Partidas y restricciones de uso**")
            st.dataframe(bim_budget[["codigo","concepto","cantidad","unidad","estado_calidad"]],hide_index=True,use_container_width=True)
        st.warning("Sin precios unitarios aprobados; no hay presupuesto monetario. Las partidas con alertas permanecen bloqueadas, aun cuando se simulen cantidades.")

    st.divider()
    st.markdown("#### Reporte ejecutivo descargable")
    st.caption("Un resumen offline de métricas y límites metodológicos, útil como anexo técnico de portafolio o entrevista.")
    reporte_html = f"""<!doctype html><html lang='es'><head><meta charset='utf-8'><title>Construction Intelligence AI · Informe</title>
    <style>body{{font:15px Arial,sans-serif;background:#f4f7fb;color:#192b44;padding:40px;max-width:1000px;margin:auto}}
    h1{{color:#172f6b}}h2{{margin-top:35px}}table{{border-collapse:collapse;width:100%;background:white}}
    th,td{{padding:12px;border-bottom:1px solid #e0e6ef;text-align:left}}th{{background:#e8eefb}}
    .warning{{background:#fff7e6;padding:15px;border-left:4px solid #f59e0b}}
    .hero{{background:#172f6b;color:white;padding:27px;border-radius:12px}}</style></head><body>
    <div class='hero'><h1 style='color:white'>Construction Intelligence AI</h1>AI portfolio · informe de resultados experimentales</div>
    <h2>1. Forecasting de índices industriales</h2>
    {forecast_sum[['material','modelo_elegido','MAE_persistencia','MAE_modelo','mejora_porcentaje','meses_prueba']].round(3).to_html(index=False,escape=True)}
    <h2>2. Clasificación de recibos</h2>{doc_scores.round(4).to_html(index=False,escape=True)}
    <h2>3. Comparación de motores OCR</h2>{ocr_comp[['modo','lineas_referencia','coincidencias','clases_correctas','cobertura_textual_aproximada']].round(3).to_html(index=False,escape=True)}
    <h2>4. Calidad BIM</h2><p>Elementos: {num_elements} · sin QTO: {n_no_qto} · alertas: {len(bim_alerts)} · cantidades QTO: {bim_info.get('registros_cantidades',357)}</p>
    <div class='warning'><strong>Limitaciones:</strong> Índices de EE. UU. no equivalen a costos en MXN; evaluación exploratoria reutilizada; OCR comparado en cinco recibos; clasificación sobre textos transcritos; IFC público sin precios aprobados. Ninguna cifra es precisión global del sistema.</div>
    <p style='color:#64748b'>Proyecto personal de demostración. No está afiliado a ninguna empresa.</p></body></html>"""
    st.download_button("📥 Descargar informe ejecutivo (HTML)", reporte_html.encode("utf-8"), file_name="construction_ai_reporte_ejecutivo.html", mime="text/html", type="primary")

elif page == "Forecasting neuronal":
    st.subheader("Forecasting neuronal de materiales")
    note("Series FRED WPU101 (hierro/acero) y WPU08 (madera), índices de precios industriales en EE. UU. Evaluación a un mes; el pronóstico a seis meses es exploratorio. La prueba histórica ya fue examinada durante el desarrollo.")
    material = st.radio("Material", options=["Acero","Madera"],index=0,horizontal=True)
    material = material or "Acero"
    s = forecast_sum[forecast_sum.material==material].iloc[0]
    c1,c2,c3,c4=st.columns(4)
    with c1: metric("Modelo seleccionado",str(s.modelo_elegido),"Elegido por validación temporal")
    with c2: metric("MAE seleccionado",f"{s.MAE_modelo:.3f}","Puntos de índice PPI")
    with c3: metric("MAE persistencia",f"{s.MAE_persistencia:.3f}","Referencia sin IA")
    with c4: metric("Cambio observado",f"{s.mejora_porcentaje:+.1f}%","Menor MAE es mejor")
    tmp=forecast_pred[forecast_pred.material==material]
    fig=go.Figure()
    for col,name,color,dash in [("real","Real",COLORS["real"],None),("persistencia","Persistencia",COLORS["base"],"dash"),("prediccion",str(s.modelo_elegido),COLORS["neural"],None)]:
        fig.add_scatter(x=tmp.fecha,y=tmp[col],name=name,mode="lines",line=dict(color=color,width=2.5 if col=="real" else 2,dash=dash))
    fig.update_yaxes(title="Índice PPI")
    st.plotly_chart(fig_layout(fig,460),use_container_width=True)
    c1,c2=st.columns(2)
    with c1:
        st.markdown("#### MAE por año de prueba")
        y=forecast_year[forecast_year.material==material]
        fig=go.Figure()
        for col,name,color in [("MAE_modelo",str(s.modelo_elegido),COLORS["neural"]),("MAE_baseline","Persistencia",COLORS["base"])]:
            fig.add_bar(x=y.anio,y=y[col],name=name,marker_color=color)
        fig.update_layout(barmode="group")
        st.plotly_chart(fig_layout(fig,300),use_container_width=True)
    with c2:
        st.markdown("#### Próximos seis meses (experimental)")
        col=f"{material}_indice"
        fy=forecast_future[["fecha",col]].copy(); fy[col]=fy[col].round(3)
        st.dataframe(fy.rename(columns={"fecha":"Mes",col:"Índice previsto"}),hide_index=True,use_container_width=True)
        if material=="Acero":
            st.caption(f"Intervalo bootstrap exploratorio de mejora: {s.IC95_aprox_inferior:.1f}% a {s.IC95_aprox_superior:.1f}%. Incluye cero; no demuestra mejora universal.")
        else:
            st.caption("Persistencia fue seleccionada: los pronósticos se mantienen constantes, no hay evidencia de mejora de la red en madera.")
    st.download_button("Descargar predicciones de prueba (CSV)",as_csv(tmp),file_name=f"pronosticos_{material.lower()}.csv",mime="text/csv")

elif page == "Document AI":
    st.subheader("Clasificación inteligente de documentos")
    note("Entrenamiento con CORD v1: 800 recibos para entrenamiento, 100 para validación y 100 para prueba. Entrada: <b>texto ya reconocido</b>. F1 y accuracy no miden lectura de fotos ni de facturas mexicanas.")
    c1,c2,c3,c4=st.columns(4)
    for i,(modelo,periodo,col,ttl) in enumerate([("LOGISTICA","prueba","macro_F1","F1 · modelo seleccionado"),("MLP","prueba","macro_F1","F1 · MLP"),("LOGISTICA","prueba","accuracy","Accuracy · logística"),("MLP","prueba","accuracy","Accuracy · MLP")]):
        value=doc_scores[(doc_scores.modelo==modelo)&(doc_scores.periodo==periodo)].iloc[0][col]
        with [c1,c2,c3,c4][i]: metric(ttl, f"{value*100:.1f}%","Métricas sobre 1,336 líneas")
    c1,c2=st.columns([1,1])
    with c1:
        plot = doc_scores.copy();plot["F1 (%)"] = plot.macro_F1*100
        fig=px.bar(plot,x="modelo",y="F1 (%)",color="periodo",barmode="group",text="F1 (%)",color_discrete_map={"validacion":"#94a3b8","prueba":COLORS["neural"]})
        fig.update_traces(texttemplate="%{text:.1f}%",textposition="outside")
        fig.update_yaxes(range=[0,100])
        st.plotly_chart(fig_layout(fig,350),use_container_width=True)
    with c2:
        st.image(str(A/"matriz_confusion.png"),caption="Matriz de confusión · regresión logística (prueba)",use_container_width=True)
    st.markdown("#### Errores del clasificador seleccionado")
    pred=csv("data/document_ai/predicciones_documentales.csv")
    filt=st.checkbox("Mostrar solo clasificaciones incorrectas",value=True)
    if filt: pred=pred[pred.categoria != pred.prediccion]
    st.dataframe(pred[["documento","texto","categoria","prediccion"]].head(250),hide_index=True,use_container_width=True)
    st.caption("MLP logró un F1 ligeramente superior en prueba, pero la regresión logística quedó seleccionada usando validación, sin usar prueba para elegir el modelo.")

elif page == "OCR neuronal":
    st.subheader("Comparativa OCR: Tesseract vs RapidOCR")
    note("Experimento diagnóstico de solo cinco recibos CORD ya examinados. Se cuentan líneas emparejadas mediante similitud textual ≥ 65%. Esto <b>no</b> es la tasa oficial de acierto de OCR ni una evaluación independiente.")
    tmp=ocr_comp.copy()
    tmp["Cobertura %"]=tmp.cobertura_textual_aproximada*100
    tmp["Clasificación condicional %"]=tmp.clasificacion_condicional_aproximada*100
    rapid=tmp[tmp.modo=="RapidOCR_neuronal"].iloc[0]
    c1,c2,c3=st.columns(3)
    with c1:metric("RapidOCR · cobertura",f"{rapid['Cobertura %']:.1f}%","40 de 51 líneas emparejadas")
    with c2:metric("Líneas detectadas",str(int(rapid.lineas_ocr)),"RapidOCR detectó 79 fragmentos")
    with c3:metric("Clasificaciones emparejadas",f"{rapid.clases_correctas:.0f}/{rapid.coincidencias:.0f}","No representa exactitud end-to-end")
    fig=go.Figure()
    fig.add_bar(x=tmp.modo,y=tmp["Cobertura %"],marker_color=["#a0aec0","#a0aec0","#a0aec0",COLORS["real"]],text=[f"{x:.1f}%" for x in tmp["Cobertura %"]],textposition="outside")
    fig.update_yaxes(title="Cobertura aproximada (%)",range=[0,100])
    st.plotly_chart(fig_layout(fig,355),use_container_width=True)
    st.dataframe(tmp[["modo","lineas_referencia","lineas_ocr","coincidencias","clases_correctas","Cobertura %","Clasificación condicional %"]].round(2),hide_index=True,use_container_width=True)
    st.markdown("#### Inspeccionar una fotografía pública y la lectura neuronal")
    num=st.selectbox("Recibo de prueba",options=list(range(5)),format_func=lambda n:f"CORD test {n:04d}")
    a,b=st.columns([0.65,1.35])
    with a:st.image(str(A/f"cord-test-{num:04d}.png"),caption="Vista pública CORD (redimensionada)",use_container_width=True)
    with b:
        lines=csv("data/ocr/lineas_ocr_neuronal.csv")
        l=lines[lines.documento==f"cord-test-{num:04d}"].copy()
        st.dataframe(l[["texto_ocr","categoria_predicha","score_ocr_no_calibrado","requiere_revision"]],hide_index=True,use_container_width=True)
        st.caption("Las puntuaciones del OCR y del clasificador no equivalen a probabilidades calibradas de que un importe sea correcto.")

elif page == "Automatización BIM":
    st.subheader("Auditoría de modelos IFC / BIM")
    note("Resultados extraídos de un modelo IFC público, independiente de los recibos CORD. No existen precios aprobados y no hay integración en vivo con Dynamo o Grasshopper.")
    c1,c2,c3,c4=st.columns(4)
    for col,lab,v,sub in [(c1,"Elementos BIM",bim_info.get("elementos",123),"IfcElement + IfcSpace"),(c2,"Sin cantidades",bim_info.get("elementos_sin_qto",28),"QTO no disponible"),(c3,"Alertas detectadas",len(bim_alerts),"Revisión de coherencia"),(c4,"Partidas preliminares",len(bim_budget),"Ningún precio autorizado")]:
        with col: metric(lab,str(v),sub)
    c1,c2=st.columns([1,1])
    with c1:
        st.markdown("#### Catálogo preliminar")
        st.dataframe(bim_budget[["codigo","concepto","cantidad","unidad","estado_calidad"]],hide_index=True,use_container_width=True)
        st.caption("No se suma m², m³ y piezas entre sí. Las cantidades son únicamente del archivo IFC de ejemplo.")
    with c2:
        st.markdown("#### Alertas por regla")
        counts=bim_alerts.regla.value_counts().rename_axis("regla").reset_index(name="alertas")
        fig=px.bar(counts,x="alertas",y="regla",orientation="h",color_discrete_sequence=[COLORS["base"]],text="alertas")
        st.plotly_chart(fig_layout(fig,320),use_container_width=True)
    st.markdown("#### Simulación de sensibilidad (no es diseño geométrico)")
    pct=st.slider("Variación hipotética de cantidades",min_value=-20,max_value=20,value=0,step=5,format="%d%%")
    scenario=bim_budget[["codigo","concepto","unidad","cantidad","estado_calidad"]].copy()
    scenario["Cantidad escenario"] = np.where(scenario.estado_calidad.ne("PRELIMINAR"),np.nan,scenario.cantidad*(1+pct/100))
    st.dataframe(scenario.round(3),hide_index=True,use_container_width=True)
    st.info("Las partidas bloqueadas no se utilizan para cálculos. Los importes quedan vacíos hasta contar con precios verificados y proyecto/alcance coincidentes.")
    with st.expander("Ver alertas completas"):
        st.dataframe(bim_alerts,hide_index=True,use_container_width=True)
    st.download_button("Descargar escenario (CSV)",as_csv(scenario),file_name="escenario_bim.csv")

elif page == "Cotizaciones estructuradas":
    from quotation_ui import render_quotation_ui
    render_quotation_ui()

elif page == "Laboratorio interactivo":
    st.subheader("Laboratorio: probar tus propios archivos")
    note("Estas herramientas ejecutan inferencia y auditoría localmente, sin reentrenar modelos. No sustituyen la revisión humana de importes, facturas o cantidades BIM. Las pruebas no se mezclan con las métricas oficiales de los datasets públicos.")
    tabs=st.tabs(["Clasificar texto", "Leer imagen o PDF", "Inspeccionar IFC"])
    with tabs[0]:
        st.markdown("#### Clasificador documental entrenado")
        user_text=st.text_area("Pega una línea de recibo o cotización por renglón",value="CONCRETO PREMEZCLADO\n2.00\nPRECIO 3000\nSUBTOTAL 6000\nTOTAL 6000",height=145)
        if st.button("Clasificar líneas",type="primary",key="clasificar_texto"):
            try:
                import joblib
                @st.cache_resource(show_spinner=False)
                def get_classifier():return joblib.load(M/"document_ai_logistica.joblib")
                pack=get_classifier();vect=pack["vectorizador"];model=pack["modelo"];cats=pack["categorias"]
                texts=[x.strip() for x in user_text.splitlines() if x.strip()]
                if not texts:st.warning("Escribe al menos una línea.")
                else:
                    X=vect.transform(texts);proba=model.predict_proba(X);idx=proba.argmax(axis=1)
                    res=pd.DataFrame({"texto":texts,"categoria":[cats[int(model.classes_[i])] for i in idx],"puntuación_no_calibrada":proba.max(axis=1)})
                    res["revisar"]=(res["puntuación_no_calibrada"]<.65)|(res["categoria"]=="OTRO")
                    st.dataframe(res.round(3),hide_index=True,use_container_width=True)
                    st.download_button("Descargar resultado CSV",as_csv(res),file_name="clasificacion_documental.csv")
                    if hasattr(model, "coef_"):
                        with st.expander("🔍 IA interpretable: caracteres que influyeron en las predicciones"):
                            st.caption("Explicación estadística del clasificador lineal mediante aportes TF-IDF × coeficiente. No representa una justificación causal ni valida el contenido del documento.")
                            nombres=vect.get_feature_names_out()
                            for ri, clasepos in enumerate(idx[:3]):
                                cidx=int(model.classes_[int(clasepos)])
                                st.markdown(f"**Línea {ri+1}:** `{texts[ri][:80]}` → **{cats[cidx]}**")
                                vector=X[ri].toarray().ravel()
                                coef=model.coef_[int(clasepos)]
                                contrib=vector*coef
                                mejores=np.argsort(contrib)[-8:][::-1]
                                datos_aportes=pd.DataFrame([{"Fragmento":str(nombres[k]),"Aporte":float(contrib[k])} for k in mejores if contrib[k]>0])
                                if not datos_aportes.empty:
                                    fig=px.bar(datos_aportes,x="Aporte",y="Fragmento",orientation="h",color_discrete_sequence=[COLORS["neural"]])
                                    st.plotly_chart(fig_layout(fig,245),use_container_width=True)
                                else:st.caption("No hay fragmentos positivos significativos para esta predicción.")
                    st.caption("Entrenado en recibos CORD en inglés/indonesio; los conceptos de construcción en español están fuera de su dominio de entrenamiento y requieren revisión.")
            except Exception as e:st.error(f"No se pudo cargar el modelo local: {e}")
    with tabs[1]:
        st.markdown("#### OCR neuronal + clasificación de líneas")
        st.caption("RapidOCR puede descargar pesos ONNX en el primer uso. Ningún archivo se guarda persistentemente en este dashboard.")
        up=st.file_uploader("Sube una imagen JPG/PNG o PDF (máximo 20 MB)",type=["jpg","jpeg","png","pdf"],key="ocr_upload")
        if up is not None and st.button("Procesar con RapidOCR",type="primary"):
            try:
                raw=up.getvalue()
                if len(raw)>20*1024*1024:st.error("El archivo supera 20 MB.")
                else:
                    from PIL import Image
                    from rapidocr import RapidOCR
                    import joblib
                    imlist=[]
                    if up.name.lower().endswith(".pdf"):
                        import fitz
                        pdf=fitz.open(stream=raw,filetype="pdf")
                        for k in range(min(len(pdf),3)):
                            pm=pdf[k].get_pixmap(matrix=fitz.Matrix(1.5,1.5),alpha=False)
                            imlist.append((k+1,Image.open(io.BytesIO(pm.tobytes("png"))).convert("RGB")))
                    else:
                        imlist=[(1,Image.open(io.BytesIO(raw)).convert("RGB"))]
                    @st.cache_resource(show_spinner=False)
                    def get_ocr():return RapidOCR()
                    @st.cache_resource(show_spinner=False)
                    def get_clf():return joblib.load(M/"document_ai_logistica.joblib")
                    engine=get_ocr();pkg=get_clf();result=[]
                    with st.spinner("Reconociendo imágenes y clasificando líneas..."):
                        for p,img in imlist:
                            if img.width*img.height>16_000_000:
                                st.warning(f"Página {p} demasiado grande; omitida.")
                                continue
                            out=engine(np.asarray(img));texts=list(out.txts) if out.txts is not None else []
                            scores=list(out.scores) if out.scores is not None else [np.nan]*len(texts)
                            if not texts:continue
                            probs=pkg["modelo"].predict_proba(pkg["vectorizador"].transform(texts))
                            ids=probs.argmax(axis=1)
                            for k,(t,sc) in enumerate(zip(texts,scores)):
                                cat=pkg["categorias"][int(pkg["modelo"].classes_[ids[k]])]
                                clf=float(probs[k,ids[k]])
                                result.append({"pagina":p,"texto":t,"clase":cat,"score_ocr":float(sc),"score_clasificador":clf,"revisar":cat=="OTRO" or clf<.65 or float(sc)<.65})
                    if result:
                        rdf=pd.DataFrame(result);st.success(f"{len(rdf)} líneas reconocidas. Pendientes de revisión: {rdf.revisar.sum()}")
                        st.dataframe(rdf.round(3),hide_index=True,use_container_width=True)
                        st.download_button("Descargar OCR + clasificación",as_csv(rdf),file_name="ocr_documento.csv")
                    else:st.warning("No se detectaron líneas. Intenta otra foto con mayor resolución.")
            except ImportError as e:
                st.error(f"Falta un módulo opcional: {e}. Ejecuta pip install -r requirements.txt")
            except Exception as e: st.error(f"No se pudo procesar el documento: {e}")
    with tabs[2]:
        st.markdown("#### Extracción básica de cantidades IFC")
        st.caption("Permite cargar un IFC sin Revit ni Rhino. No estima cantidades geométricas que no estén declaradas como QTO.")
        upload=st.file_uploader("Selecciona un IFC (máximo 30 MB)",type=["ifc"],key="bim_upload")
        if upload and st.button("Analizar IFC",type="primary"):
            try:
                import ifcopenshell
                import ifcopenshell.util.element
                if len(upload.getvalue())>30*1024*1024:st.error("El archivo excede 30 MB.")
                else:
                    with tempfile.NamedTemporaryFile(suffix=".ifc",delete=False) as tmpfile:
                        tmpfile.write(upload.getvalue());tmpname=tmpfile.name
                    try:mod=ifcopenshell.open(tmpname)
                    finally:Path(tmpname).unlink(missing_ok=True)
                    elems=mod.by_type("IfcElement")
                    rows=[]
                    for e in elems[:15000]:
                        try: qs=ifcopenshell.util.element.get_psets(e,qtos_only=True)
                        except Exception:qs={}
                        for qname,qvals in qs.items():
                            for name,val in qvals.items():
                                if name=="id" or isinstance(val,bool) or not isinstance(val,(int,float)):continue
                                rows.append({"Guid":e.GlobalId,"Clase":e.is_a(),"QTO":qname,"Medida":name,"Valor_original":val})
                    st.success(f"{len(elems):,} elementos; {len(rows):,} cantidades QTO documentadas")
                    if rows:
                        q=pd.DataFrame(rows);st.dataframe(q.head(1000),hide_index=True,use_container_width=True)
                        st.download_button("Descargar QTO IFC",as_csv(q),file_name="cantidades_ifc.csv")
                    else:st.warning("No hay QTO asociados. No se calcularán áreas o volúmenes por suposición.")
            except ImportError:st.error("IfcOpenShell no instalado. Ejecuta pip install ifcopenshell")
            except Exception as e:st.error(f"Error leyendo IFC: {e}")

st.divider()
st.caption("Construction Intelligence AI · Demo independiente sobre datos públicos · Evaluaciones exploratorias no aptas para presupuestos ni compras reales sin validación adicional · GitHub/FRED/CORD/buildingSMART")