Porcentaje de áreas protegidas con planes de manejo en proceso de elaboración o aprobados y/o en implementación

# ------------------------------------------------------------
# Helper: descarga robusta + lectura (Excel o CSV desde URL)
# ------------------------------------------------------------
def fetch_bytes(url: str, timeout: int = 120, retries: int = 3, sleep_s: float = 2.0) -> bytes:
    headers = {
        # User-Agent ayuda con algunos servidores que bloquean requests "vacíos"
        "User-Agent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120 Safari/537.36"
    }
    last_err = None
    for i in range(retries):
        try:
            r = requests.get(url, headers=headers, timeout=timeout, allow_redirects=True)
            r.raise_for_status()
            return r.content
        except Exception as e:
            last_err = e
            if i < retries - 1:
                time.sleep(sleep_s)
    raise RuntimeError(f"No se pudo descargar {url} tras {retries} intentos. Último error: {last_err}")

def read_table_from_url(url: str):
    data = fetch_bytes(url)
    # Intentar Excel primero (el endpoint se llama GetExcelExtendido)
    try:
        xls = pd.ExcelFile(io.BytesIO(data))
        sheets = xls.sheet_names
        if len(sheets) == 1:
            return pd.read_excel(xls, sheet_name=sheets[0])
        return {name: pd.read_excel(xls, sheet_name=name) for name in sheets}
    except Exception:
        # Fallback: intentar como CSV con separador inferido y encoding típico
        for enc in ("utf-8", "latin-1"):
            try:
                return pd.read_csv(io.BytesIO(data), sep=None, engine="python", encoding=enc)
            except UnicodeDecodeError:
                continue
        return pd.read_csv(io.BytesIO(data), encoding="latin-1")

def pick_sheet(dfs: dict, include: str):
    """Selecciona una hoja por substring (case-insensitive)."""
    include = include.lower()
    for k in dfs.keys():
        if include in k.lower():
            return dfs[k], k
    # fallback: primera hoja
    first = next(iter(dfs.items()))
    return first[1], first[0]

# ============================================================
# 1) Validación y estandarización del KEY
# ============================================================

def normalize_key(series: pd.Series) -> pd.Series:
    # convierte a string, strip, y normaliza espacios raros
    s = series.astype(str).str.strip()
    s = s.str.replace(r"\s+", " ", regex=True)
    # si hay cosas tipo 'nan' como texto, pásalas a NaN real
    s = s.replace({"nan": np.nan, "None": np.nan, "": np.nan})
    return s

for df, name in [(df_general, "general"), (df_manejo, "manejo")]:
    if KEY not in df.columns:
        raise KeyError(f"No encontré la columna '{KEY}' en {name}. Columnas: {df.columns.tolist()}")
    df[KEY] = normalize_key(df[KEY])

# Duplicados por KEY (importante: manejo podría traer 1:N; lo veremos)
dup_gen = df_general[df_general.duplicated(KEY, keep=False)].sort_values(KEY)
dup_man = df_manejo[df_manejo.duplicated(KEY, keep=False)].sort_values(KEY)

print("Duplicados en general:", len(dup_gen))
print("Duplicados en manejo :", len(dup_man))

# Si quieres inspeccionar duplicados:
# display(dup_gen.head(20))
# display(dup_man.head(20))

# ============================================================
# Filtrar df_manejo: solo Plan de Manejo o No Tiene
# ============================================================

# Normalizamos la columna Tipo por seguridad
df_manejo["Tipo"] = (
    df_manejo["Tipo"]
    .astype(str)
    .str.strip()
)

valores_validos = ["Plan de manejo", "No Tiene"]

df_manejo_filtrado = df_manejo[df_manejo["Tipo"].isin(valores_validos)].copy()

#print("Registros manejo (original):", len(df_manejo))
#print("Registros manejo (filtrado):", len(df_manejo_filtrado))

# Revisión rápida
#df_manejo_filtrado["Tipo"].value_counts()

tabla_resumen = (
    df_manejo_filtrado
    .groupby("Tipo", as_index=False)
    .size()
    .rename(columns={"size": "n"})
)

# Calcular porcentaje
total = tabla_resumen["n"].sum()
tabla_resumen["porcentaje"] = (tabla_resumen["n"] / total * 100).round(1)

tabla_resumen

# Agregar a nivel Código AP
manejo_agg = (
    df_manejo_filtrado
    .groupby(KEY, as_index=False)
    .agg(
        tiene_plan=("Tipo", lambda x: (x == "Plan de manejo").any()),
        tipo_plan=("Tipo", lambda x: "Plan de manejo" if (x == "Plan de manejo").any() else "No Tiene")
    )
)

manejo_agg.head()

manejo_agg = (
    df_manejo_filtrado
    .groupby(KEY, as_index=False)
    .agg(
        tiene_plan=("Tipo", lambda x: (x == "Plan de manejo").any()),
        tipo_plan=("Tipo", lambda x: "Plan de manejo" if (x == "Plan de manejo").any() else "No Tiene"),
        anio_ultimo=("Año", "max"),
        anio_primero=("Año", "min")
    )
)

manejo_agg.head()

df = (
    df_general
    .merge(manejo_agg, on=KEY, how="left")
    .merge(df_ambiente, on=KEY, how="left")
)

# Si no aparece en manejo → No Tiene
df["tiene_plan"] = df["tiene_plan"].fillna(False)
df["tipo_plan"]  = df["tipo_plan"].fillna("No Tiene")

df.head()

df["Presencia"].value_counts(dropna=False)

# Área total de Chile continental (ha) extraído desde indicaddor A.1
AREA_CHILE_CONTINENTAL = 75688051.58421065

# Asegurar tipos
df["tiene_plan"] = df["tiene_plan"].astype(bool)
df["Superficie oficial"] = pd.to_numeric(
    df["Superficie oficial"], errors="coerce"
)

# Valores de Presencia a considerar
PRESENCIAS_VALIDAS = ["Terrestre", "Acuático"]

# 1) Suma de superficie oficial con plan y presencia válida
superficie_con_plan = (
    df
    .loc[
        (df["tiene_plan"]) &
        (df["Presencia"].isin(PRESENCIAS_VALIDAS)),
        "Superficie oficial"
    ]
    .sum(skipna=True)
)

# 2) Porcentaje respecto al área continental
porcentaje_chile = (superficie_con_plan / AREA_CHILE_CONTINENTAL) * 100

#superficie_con_plan, porcentaje_chile

# ============================================================
# Tabla de resultados: superficie con plan de manejo
# ============================================================

tabla_resultados = pd.DataFrame({
    "Indicador": [
        "Superficie de AP con plan de manejo (Terrestre + Acuático)",
        "Área continental de Chile"
    ],
    "Superficie (ha)": [
        superficie_con_plan,
        AREA_CHILE_CONTINENTAL
    ]
})

# Calcular porcentaje solo para la primera fila
tabla_resultados["Porcentaje del área continental (%)"] = [
    round(porcentaje_chile, 2),
    100.0
]

tabla_resultados

# Buscar columna de categoría/designación
[c for c in df.columns if "categor" in c.lower() or "design" in c.lower()]

# ============================================================
# Normalizar categorías: Reserva Nacional (antiguo) → Reserva Nacional
# ============================================================
CAT_COL = "Categoría o designación"

df[CAT_COL] = (
    df[CAT_COL]
    .astype(str)
    .str.strip()
    .replace({
        "Reserva Nacional (antiguo)": "Reserva Nacional"
    })
)

# Verificación rápida
df[CAT_COL].value_counts().loc[
    lambda s: s.index.str.contains("Reserva Nacional", case=False)
]

tabla_conteo = (
    df
    .groupby([CAT_COL, "tipo_plan"], dropna=False)
    .size()
    .reset_index(name="n")
)

totales = (
    tabla_conteo
    .groupby(CAT_COL, as_index=False)["n"]
    .sum()
    .rename(columns={"n": "total_categoria"})
)

tabla_pct = (
    tabla_conteo
    .merge(totales, on=CAT_COL, how="left")
    .assign(porcentaje=lambda d: 100 * d["n"] / d["total_categoria"])
    .sort_values([CAT_COL, "tipo_plan"])
)

tabla_pct

import matplotlib.pyplot as plt
from matplotlib.gridspec import GridSpec


# ============================================================
# Tabla base: conteos por categoría y tipo de plan
# ============================================================

tabla_n = (
    df
    .groupby([CAT_COL, "tipo_plan"])
    .size()
    .reset_index(name="n")
)

tabla_n

# ============================================================
# Función para gráfico de torta
# ============================================================

def pie_por_categoria(tabla, categoria, cat_col=CAT_COL):
    data = tabla[tabla[cat_col] == categoria]

    if data.empty:
        return

    labels = data["tipo_plan"]
    sizes  = data["n"]
    total  = sizes.sum()

    def autopct_fmt(pct):
        n = int(round(pct * total / 100))
        return f"{pct:.1f}%\n(n={n})"

    plt.figure(figsize=(5, 5))
    plt.pie(
        sizes,
        labels=labels,
        autopct=autopct_fmt,
        startangle=90,
        counterclock=False
    )
    plt.title(f"{categoria}")
    plt.tight_layout()
    plt.show()

# Paleta fija por tipo de plan
COLOR_MAP = {
    "Plan de manejo": "#F28E2B",  # naranjo
    "No Tiene": "#4E79A7"         # azul
}

def pie_ax(ax, data, titulo):
    if data.empty:
        ax.axis("off")
        ax.set_title(f"{titulo}\n(sin datos)")
        return

    data = data.copy()
    data["color"] = data["tipo_plan"].map(COLOR_MAP)

    total = data["n"].sum()

    def autopct_fmt(pct):
        n = int(round(pct * total / 100))
        return f"{pct:.1f}%\n(n={n})"

    ax.pie(
        data["n"],
        labels=data["tipo_plan"],
        colors=data["color"],
        autopct=autopct_fmt,
        startangle=90,
        counterclock=False
    )
    ax.set_title(titulo)


# ============================================================
# Figura y layout
# ============================================================

fig = plt.figure(figsize=(10, 16))
gs = GridSpec(nrows=4, ncols=2, figure=fig)

# Parque Nacional: columna 0, filas 0–1
ax_parque = fig.add_subplot(gs[0:2, 0])
data_parque = tabla_n[tabla_n[CAT_COL] == "Parque Nacional"]
pie_ax(ax_parque, data_parque, "Parque Nacional")

# Otras categorías
cat_others = {
    (2, 0): "Reserva Nacional",
    (3, 0): "Monumento Natural",
    (0, 1): "Área de Conservación de Múltiples Usos",
    (1, 1): "Santuario de la Naturaleza",
    (2, 1): "Reserva Forestal",
    (3, 1): "Reserva Marina"
}

for (row, col), categoria in cat_others.items():
    ax = fig.add_subplot(gs[row, col])
    data = tabla_n[tabla_n[CAT_COL] == categoria]

    if not data.empty:
        pie_ax(ax, data, categoria)
    else:
        ax.axis("off")
        ax.set_title(f"{categoria}\n(sin datos)")

plt.tight_layout()
fig.savefig("figura_categorias.png", dpi=300, bbox_inches="tight")
plt.show()

import matplotlib.pyplot as plt
import pandas as pd
from datetime import datetime

# Asegurar que el año sea numérico
df["anio_ultimo"] = pd.to_numeric(df["anio_ultimo"], errors="coerce")

# Filtrar solo áreas que tienen plan válido
df_plot = df.loc[
    (df["tiene_plan"] == True) & 
    (df["anio_ultimo"] > 0)
].copy()

plt.figure()
plt.hist(df_plot["anio_ultimo"], bins=10)
plt.xlabel("Año de publicación del último plan de manejo")
plt.ylabel("Número de Áreas Protegidas")
plt.savefig("histograma_anio_ultimo_plan.png", dpi=300, bbox_inches="tight")
plt.show()

df_plot["decada"] = (df_plot["anio_ultimo"] // 10) * 10

conteo_decadas = df_plot["decada"].value_counts().sort_index()

plt.figure()
plt.bar(conteo_decadas.index.astype(str), conteo_decadas.values)
plt.xlabel("Década")
plt.ylabel("Número de Áreas Protegidas")
plt.title("Planes de manejo por década")
plt.show()

anio_actual = datetime.now().year
df_plot["antiguedad"] = anio_actual - df_plot["anio_ultimo"]

df_plot["antiguedad"].describe()