Número de especies clasificadas con categoría de conservación en el sistema nacional

# ver valores de 'FUENTE DE CATEGORÍA VIGENTE:\nCAZA  = Reglamento Ley de CAZA\nRCE = Reglamento de Clasificación Especies.'
print(df['FUENTE DE CATEGORÍA VIGENTE:\nCAZA  = Reglamento Ley de CAZA\nRCE = Reglamento de Clasificación Especies.'].value_counts())

#filtrar df por 'FUENTE DE CATEGORÍA VIGENTE:\nCAZA  = Reglamento Ley de CAZA\nRCE = Reglamento de Clasificación Especies.' == 'RCE'
df = df[df['FUENTE DE CATEGORÍA VIGENTE:\nCAZA  = Reglamento Ley de CAZA\nRCE = Reglamento de Clasificación Especies.'] == 'RCE']
#imprimir dimensiones del df
print(df.shape)

# Crear columna de año de resolución desde la referencia/decreto vigente
df["anio_resolucion"] = (
    df["REFERENCIA o DECRETO\nCategoría Vigente"]
    .astype(str)
    .str.extract(r"(\d{4})", expand=False)
    .astype("Int64")  # permite NA
)

# Verificación rápida
df[[
    "REFERENCIA o DECRETO\nCategoría Vigente",
    "anio_resolucion"
]].head(10)

import re
import numpy as np

col_fuente_anteprev = "Fuente Categoría  ANTE ANTERIOR a RCE actual  \n(NO VIGENTE)\n(Ver valores en columna adyacente)"

def extraer_anio_previo(texto):
    if pd.isna(texto):
        return np.nan
    
    t = str(texto)
    
    # 1️⃣ Buscar patrón RCE con decreto (ej: DS 51/2008)
    match = re.search(r"DS\s*\d+\/(\d{4})", t)
    if match:
        return int(match.group(1))
    
    # 2️⃣ Asignar año según fuente histórica
    t_upper = t.upper()
    
    if "BOL_47" in t_upper:
        return 1998
    
    if "CAZA" in t_upper:
        return 1998
    
    if "L_ROJO_FLORA" in t_upper:
        return 1989
    
    if "L_ROJO_VERT" in t_upper:
        return 1988
    
    if "NÚÑEZ ET AL. 1997" in t_upper or "NUNEZ ET AL. 1997" in t_upper:
        return 1997
    
    if "YÁÑEZ ET AL. 1997" in t_upper or "YANEZ ET AL. 1997" in t_upper:
        return 1997
    
    return np.nan

df["anio_clasificacion_previa"] = df[col_fuente_anteprev].apply(extraer_anio_previo)

# Verificación rápida
df[[
    col_fuente_anteprev,
    "anio_clasificacion_previa"
]].head(20)

# Conteo de número de especies por año de resolución
conteo_por_anio = (
    df
    .dropna(subset=["anio_resolucion", "NOMBRE CIENTÍFICO"])
    .groupby("anio_resolucion")["NOMBRE CIENTÍFICO"]
    .nunique()
    .reset_index(name="n_especies")
    .sort_values("anio_resolucion")
)

# Ver resultado
print(conteo_por_anio)

# Columnas relevantes
col_prev = "Categoría ANTERIOR a RCE actual\n(NO VIGENTE)\nBol_47 = Boletín 47 MNHN\nCAZA  = Reglamento Ley de CAZA\nL_Rojo_Flora = Libro Rojo de flora\nL_Rojo_Vert = Libro Rojo de vertebrados\nNúñez et al. 1997 = Reunión de herpetólogos\nYáñez et al. 1997 = Reunión especialistas mamíferos acuáticos\nRCE = Reglamento de Clasificación Especies."

col_anteprev = "Categoría ANTE ANTERIOR a RCE actual \n(NO VIGENTE)\nBol_47 = Boletín 47 MNHN\nCAZA  = Reglamento Ley de CAZA\nL_Rojo_Flora = Libro Rojo de flora\nL_Rojo_Vert = Libro Rojo de vertebrados\nNúñez et al. 1997 = Reunión de herpetólogos\nYáñez et al. 1997 = Reunión especialistas mamíferos acuáticos\nRCE = Reglamento de Clasificación Especies."

def vacio(x):
    if pd.isna(x):
        return True
    s = str(x).strip().upper()
    return s in ["", "NAN", "NA", "N/A", "--"]

# Es nueva si NO tiene clasificación previa
df["es_nueva"] = (
    df[col_prev].apply(vacio) &
    df[col_anteprev].apply(vacio)
)

def tiene_clasificacion_previa(x):
    if pd.isna(x):
        return False
    s = str(x).strip().upper()
    return s not in ["", "NAN", "NA", "N/A", "--"]

df["tiene_previa"] = (
    df[col_prev].apply(tiene_clasificacion_previa) |
    df[col_anteprev].apply(tiene_clasificacion_previa)
)

df_2024 = df[df["anio_resolucion"] == 2024]

nuevas_2024 = df_2024[~df_2024["tiene_previa"]]
reclas_2024 = df_2024[df_2024["tiene_previa"]]

print("Nuevas 2024:", nuevas_2024["NOMBRE CIENTÍFICO"].nunique())
print("Reclasificaciones 2024:", reclas_2024["NOMBRE CIENTÍFICO"].nunique())

tabla_anio_reino = (
    df
    .dropna(subset=["anio_resolucion", "NOMBRE CIENTÍFICO", "REINO"])
    .groupby(["anio_resolucion", "REINO"])["NOMBRE CIENTÍFICO"]
    .nunique()
    .reset_index(name="n_especies")
    .sort_values(["anio_resolucion", "REINO"])
)

print(tabla_anio_reino)

tabla_anio_reino_wide = (
    tabla_anio_reino
    .pivot(index="anio_resolucion", columns="REINO", values="n_especies")
    .fillna(0)
    .astype(int)
)

print(tabla_anio_reino_wide)

import pandas as pd
import matplotlib.pyplot as plt

# Conteo anual por año y reino
anio_reino = (
    df
    .dropna(subset=["anio_resolucion", "NOMBRE CIENTÍFICO", "REINO"])
    .groupby(["anio_resolucion", "REINO"])["NOMBRE CIENTÍFICO"]
    .nunique()
    .reset_index(name="n_especies")
    .sort_values("anio_resolucion")
)

# Acumulado por reino
anio_reino["n_especies_acumuladas"] = (
    anio_reino
    .groupby("REINO")["n_especies"]
    .cumsum()
)


#vamos a crear una tabla del acumulado por año y reino
tabla_acumulado_reino = (
    anio_reino
    .pivot(index="anio_resolucion", columns="REINO", values="n_especies_acumuladas")
    .fillna(0)
    .astype(int)
)
print(tabla_acumulado_reino)

plt.figure(figsize=(8, 5))

for reino, df_reino in anio_reino.groupby("REINO"):
    plt.plot(
        df_reino["anio_resolucion"],
        df_reino["n_especies_acumuladas"],
        marker="o",
        label=reino
    )

plt.xlabel("Año de resolución")
plt.ylabel("Número acumulado de especies clasificadas")
plt.title("Evolución acumulada de especies clasificadas por reino en Chile")
plt.legend(title="Reino")
plt.grid(True)

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

import pandas as pd
import matplotlib.pyplot as plt

# Filtrar solo Plantae y Animalia
df_pa = (
    df
    .query("REINO in ['Plantae', 'Animalia']")
    .dropna(subset=["anio_resolucion", "NOMBRE CIENTÍFICO", "REINO", "CLASE"])
)

# Conteo anual por reino y clase
anio_reino_clase = (
    df_pa
    .groupby(["anio_resolucion", "REINO", "CLASE"])["NOMBRE CIENTÍFICO"]
    .nunique()
    .reset_index(name="n_especies")
    .sort_values("anio_resolucion")
)

# Acumulado por reino y clase
anio_reino_clase["n_especies_acumuladas"] = (
    anio_reino_clase
    .groupby(["REINO", "CLASE"])["n_especies"]
    .cumsum()
)

for reino in ["Plantae", "Animalia"]:
    plt.figure(figsize=(8, 5))

    df_reino = anio_reino_clase[anio_reino_clase["REINO"] == reino]

    for clase, df_clase in df_reino.groupby("CLASE"):
        plt.plot(
            df_clase["anio_resolucion"],
            df_clase["n_especies_acumuladas"],
            marker="o",
            label=clase
        )

    plt.xlabel("Año de resolución")
    plt.ylabel("Número acumulado de especies clasificadas")
    plt.title(f"Evolución acumulada de especies clasificadas por clase – {reino}")
    plt.legend(title="Clase", fontsize=8)
    plt.grid(True)

    plt.tight_layout()
    plt.savefig(f"especies_clasificadas_por_clase_{reino}.png", dpi=300, bbox_inches="tight")
    plt.show()

import pandas as pd
import plotly.graph_objects as go
import plotly.express as px
from plotly.subplots import make_subplots

# -----------------------------
# Preparación de datos
# -----------------------------
base = df.copy()

columnas_taxonomicas = [col for col in ["REINO", "FILO", "CLASE", "ORDEN", "FAMILIA"] if col in base.columns]

candidatas_especie = ["NOMBRE CIENTÍFICO", "scientificName", "especie", "species"]
col_especie = next((c for c in candidatas_especie if c in base.columns), None)
if col_especie is None:
    raise ValueError("No se encontró una columna de especie reconocible en el dataframe.")

base["anio_resolucion"] = pd.to_numeric(base["anio_resolucion"], errors="coerce")
base = base.dropna(subset=["anio_resolucion", col_especie]).copy()
base["anio_resolucion"] = base["anio_resolucion"].astype(int)

for col in columnas_taxonomicas:
    base[col] = (
        base[col]
        .fillna("Sin dato")
        .astype(str)
        .str.strip()
        .replace("", "Sin dato")
    )

cols_dedup = ["anio_resolucion", col_especie] + columnas_taxonomicas
base = base.drop_duplicates(subset=cols_dedup)

# -----------------------------
# Reinos
# -----------------------------
reinos = sorted(base["REINO"].dropna().unique().tolist()) if "REINO" in base.columns else []
lista_reinos = ["Todos"] + reinos

# -----------------------------
# Funciones auxiliares
# -----------------------------
def construir_serie(datos):
    if datos.empty:
        return pd.DataFrame(columns=["anio_resolucion", "n_especies", "n_especies_acumuladas"])

    serie = (
        datos.groupby("anio_resolucion")[col_especie]
        .nunique()
        .reset_index(name="n_especies")
        .sort_values("anio_resolucion")
    )
    serie["n_especies_acumuladas"] = serie["n_especies"].cumsum()
    return serie


def construir_treemap_tabla(datos, profundidad="CLASE"):
    columnas_disponibles = [c for c in ["REINO", "FILO", "CLASE", "ORDEN", "FAMILIA"] if c in datos.columns]

    if profundidad not in columnas_disponibles:
        profundidad = columnas_disponibles[-1]

    path = columnas_disponibles[:columnas_disponibles.index(profundidad) + 1]

    tabla = (
        datos.groupby(path)[col_especie]
        .nunique()
        .reset_index(name="n_especies")
    )
    return tabla, path


# -----------------------------
# Precalcular por reino
# -----------------------------
series_por_reino = {}
treemap_por_reino = {}
profundidad_treemap = "CLASE" if "CLASE" in columnas_taxonomicas else columnas_taxonomicas[-1]

for reino in lista_reinos:
    datos = base if reino == "Todos" else base[base["REINO"] == reino].copy()
    series_por_reino[reino] = construir_serie(datos)
    treemap_por_reino[reino] = construir_treemap_tabla(datos, profundidad=profundidad_treemap)

# -----------------------------
# Una sola figura con 2 paneles
# -----------------------------
fig = make_subplots(
    rows=2,
    cols=1,
    specs=[[{"type": "xy"}], [{"type": "domain"}]],
    row_heights=[0.42, 0.58],
    vertical_spacing=0.12,
    subplot_titles=(
        "Número acumulado de especies clasificadas",
        "Composición taxonómica por número de especies únicas"
    )
)

# Guardaremos 2 trazas por reino:
#  - 1 línea acumulada
#  - 1 treemap
for i, reino in enumerate(lista_reinos):
    serie = series_por_reino[reino]
    tabla_tree, path_tree = treemap_por_reino[reino]

    # Línea
    fig.add_trace(
        go.Scatter(
            x=serie["anio_resolucion"],
            y=serie["n_especies_acumuladas"],
            mode="lines+markers",
            name=f"{reino} - acumulada",
            visible=(i == 0),
            hovertemplate="Año: %{x}<br>Especies acumuladas: %{y}<extra></extra>"
        ),
        row=1, col=1
    )

    # Treemap
    if tabla_tree.empty:
        fig.add_trace(
            go.Treemap(
                labels=["Sin datos"],
                parents=[""],
                values=[1],
                visible=(i == 0),
                textinfo="label"
            ),
            row=2, col=1
        )
    else:
        fig_tmp = px.treemap(
            tabla_tree,
            path=path_tree,
            values="n_especies"
        )
        trace = fig_tmp.data[0]
        trace.visible = (i == 0)
        fig.add_trace(trace, row=2, col=1)

# -----------------------------
# Botones únicos para ambos paneles
# -----------------------------
botones = []

for i, reino in enumerate(lista_reinos):
    visibles = [False] * len(fig.data)
    visibles[2 * i] = True       # línea
    visibles[2 * i + 1] = True   # treemap

    serie = series_por_reino[reino]
    total = int(serie["n_especies"].sum()) if not serie.empty else 0
    primer_anio = int(serie["anio_resolucion"].min()) if not serie.empty else "-"
    ultimo_anio = int(serie["anio_resolucion"].max()) if not serie.empty else "-"

    botones.append(
        dict(
            label=reino,
            method="update",
            args=[
                {"visible": visibles},
                {
                    "annotations": [
                        dict(
                            x=0,
                            y=1.16,
                            xref="paper",
                            yref="paper",
                            text=f"Total de especies únicas: {total} | Rango temporal: {primer_anio}–{ultimo_anio}",
                            showarrow=False,
                            xanchor="left",
                            align="left",
                            font=dict(size=11)
                        )
                    ]
                }
            ]
        )
    )

# -----------------------------
# Layout
# -----------------------------
serie0 = series_por_reino["Todos"]
total0 = int(serie0["n_especies"].sum()) if not serie0.empty else 0
primer0 = int(serie0["anio_resolucion"].min()) if not serie0.empty else "-"
ultimo0 = int(serie0["anio_resolucion"].max()) if not serie0.empty else "-"

fig.update_layout(
    template="plotly_white",
    autosize=True,
    height=760,
    margin=dict(l=30, r=20, t=110, b=30),
    hovermode="x unified",
    showlegend=False,
    xaxis=dict(title="Año de resolución", dtick=1),
    yaxis=dict(title="Especies acumuladas"),
    updatemenus=[
        dict(
            type="buttons",
            direction="right",
            x=0.5,
            y=1.23,
            xanchor="center",
            yanchor="top",
            pad={"r": 4, "t": 0},
            showactive=True,
            bgcolor="white",
            bordercolor="lightgray",
            borderwidth=1,
            font=dict(size=10),
            buttons=botones
        )
    ],
    annotations=[
        dict(
            x=0,
            y=1.16,
            xref="paper",
            yref="paper",
            text=f"Total de especies únicas: {total0} | Rango temporal: {primer0}–{ultimo0}",
            showarrow=False,
            xanchor="left",
            align="left",
            font=dict(size=11)
        )
    ]
)

fig.show(config={"responsive": True})