import io
import json
import unicodedata
import zipfile

import matplotlib.pyplot as plt
import pandas as pd
import seaborn as sns
import streamlit as st

from config.config import method_order, resource_order, resource_units
from optimization.optimization import run_optimization
from utils.ui_helpers import format_results_summary
from utils.data_utils import is_valid_scenario


def render_tab():
    st.header("Portfolio generation")
    st.caption("Tab 4 - Seaborn fallback for vertical histograms")

    st.info("""
    **Objective:**
    Run the optimization tool, explore results, and save scenarios for comparison or export.
    """)

    # Initialize necessary session state variables if they don't exist
    if "resource_caps" not in st.session_state:
        st.session_state.resource_caps = {}
    if "constraints" not in st.session_state:
        st.session_state.constraints = {}
    if "costs" not in st.session_state:
        st.session_state.costs = {}
    if "scenarios" not in st.session_state:
        st.session_state.scenarios = {}
    
    # Run optimization
    st.markdown("### Run optimization")
    col_run, col_load = st.columns(2)

    with col_run:
        st.markdown("**From current input values**")
        run_clicked = st.button("▶️ Run Optimization", use_container_width=False)

    with col_load:
        st.markdown("**From a saved JSON scenario**")
        uploaded_scenario = st.file_uploader("Upload a saved JSON scenario", type="json", key="scenario_loader")
        if uploaded_scenario is not None:
            try:
                data = json.load(uploaded_scenario)
                if is_valid_scenario(data):
                    if st.button("↩️ Reload this scenario into all tabs", use_container_width=True):
                        st.session_state.resource_caps = data["resource_caps"].copy()
                        st.session_state.constraints = data["method_constraints"].copy()
                        st.session_state.costs = data["method_costs"].copy()
                        keys_to_delete = [k for k in st.session_state if any(
                            k.startswith(prefix) for prefix in ["slider_", "manual_", "toggle_"]
                        )]
                        for k in keys_to_delete:
                            del st.session_state[k]
                        st.session_state.latest_result = data
                        st.success("Scenario loaded. All tabs have been updated.")
                        st.rerun()
                else:
                    st.error("Invalid scenario format.")
            except Exception as e:
                st.error(f"Error loading scenario: {e}")

    # Vérifications et exécution — uniquement si Run Optimization cliqué
    if run_clicked:
        if sum(st.session_state.resource_caps.values()) <= 0:
            st.warning("⚠️ All resources are currently set to 0. Please increase availability or load a saved scenario.")
        else:
            success, result = run_optimization(
                resource_caps=st.session_state.resource_caps,
                method_constraints=st.session_state.constraints,
                method_costs=st.session_state.costs,
            )
            if success:
                allocations = result["method_usage"]
                total_removed = result["total_removed"]
                if total_removed <= 0:
                    st.warning("❌ Optimization removed 0 tCO₂. Relax constraints or increase resources.")
                else:
                    total_cost = sum(
                        allocations[m] * sum(st.session_state.costs[m].values())
                        for m in allocations
                    )
                    st.session_state.latest_result = {
                        "summary": {"total_co2_removed": total_removed, "total_cost": total_cost},
                        "allocations": allocations,
                        "resource_caps": st.session_state.resource_caps.copy(),
                        "method_constraints": st.session_state.constraints,
                        "method_costs": st.session_state.costs,
                    }
                    st.success(f"✅ Optimization successful: {total_removed:,.0f} tCO₂ removed")
            else:
                st.error("❌ Optimization failed")
                if "message" in result:
                    st.error(result["message"])

    if "latest_result" not in st.session_state:
        return
    latest = st.session_state.latest_result
    allocations = latest["allocations"]
    resource_caps = latest["resource_caps"]
    method_costs = latest["method_costs"]

    if not allocations or sum(allocations.values()) == 0:
        return

    # Metrics
    col1, col2 = st.columns(2)
    col1.metric("Total CO₂ Removed", f"{latest['summary']['total_co2_removed']:,.0f} t")
    col2.metric("Methods Used", len(allocations))

    # Summary table
    st.subheader("Optimization Summary")
    df_result = pd.DataFrame.from_dict(allocations, orient="index", columns=["tCO₂ removed"])
    df_result["tCO₂ removed"] = pd.to_numeric(df_result["tCO₂ removed"], errors="coerce")
    total = df_result["tCO₂ removed"].sum()
    if total > 0:
        df_result["Share (%)"] = (df_result["tCO₂ removed"] / total * 100).round(2)
    df_result = df_result.sort_values(by="tCO₂ removed", ascending=False)
    st.table(format_results_summary(df_result))

    # Donut chart
    st.markdown("### Method allocation breakdown")
    labels = df_result.index.tolist()
    values = df_result["tCO₂ removed"].tolist()

    import plotly.graph_objects as go
    fig_donut = go.Figure(data=[go.Pie(
        labels=labels,
        values=values,
        hole=0.4,
        textinfo="label+percent",
        textposition="outside",
        marker=dict(line=dict(color="#000000", width=1)),
        showlegend=False
    )])
    fig_donut.update_layout(margin=dict(t=10, b=10))
    st.plotly_chart(fig_donut, use_container_width=True)

    # Heatmap
    st.markdown("### Resource usage heatmap (% of cap)")
    heatmap_matrix, heatmap_y = [], []
    available_resources = [r for r in resource_order if resource_caps.get(r, 0) > 0]

    for method in df_result.index:
        row = []
        for r in available_resources:
            usage = method_costs.get(method, {}).get(r, 0.0) * allocations.get(method, 0.0)
            row.append((usage / resource_caps[r]) * 100 if resource_caps[r] > 0 else 0)
        heatmap_matrix.append(row)
        heatmap_y.append(method)

    fig_heatmap = go.Figure(data=go.Heatmap(
        z=heatmap_matrix,
        x=available_resources,
        y=heatmap_y,
        colorscale="Blues",
        hovertemplate="Method: %{y}<br>Resource: %{x}<br>% Used: %{z:.2f}%<extra></extra>",
    ))
    fig_heatmap.update_layout(
        title="Resource Usage vs. Cap",
        xaxis_title="Resource",
        yaxis_title="Method",
        height=400,
    )
    st.plotly_chart(fig_heatmap, use_container_width=True)

    # Absolute usage (fallback with seaborn)
    st.markdown("### Absolute resource usage by unit (Seaborn)")
    df_abs = []
    for m, co2_removed in allocations.items():
        for unit, resources in resource_units.items():
            for r in resources:
                if r in method_costs.get(m, {}):
                    used = method_costs[m][r] * co2_removed
                    if used > 0:
                        df_abs.append({
                            "Method": m,
                            "Resource": r,
                            "Used": used,
                            "Unit": unit
                        })

    if df_abs:
        df_abs = pd.DataFrame(df_abs)
        for unit in df_abs["Unit"].unique():
            st.markdown(f"#### Resources in {unit}")
            df_unit = df_abs[df_abs["Unit"] == unit]

            fig, ax = plt.subplots(figsize=(8, 4 + 0.3 * df_unit["Resource"].nunique()))
            sns.barplot(data=df_unit, x="Resource", y="Used", hue="Method", ax=ax)
            ax.set_ylabel(f"Used ({unit})")
            ax.set_xlabel("Resource")
            ax.tick_params(axis='x', rotation=45)
            ax.legend(title="Method", bbox_to_anchor=(1.05, 1), loc='upper left')
            st.pyplot(fig)

    # Save scenario
    st.markdown("### Save scenario")
    st.text_input("Scenario name", key="scenario_name")

    if st.button("Save Scenario"):
        name = st.session_state.get("scenario_name", "").strip()
        if not name:
            st.warning("Please enter a name before saving.")
        elif name in st.session_state.scenarios:
            st.warning("Scenario name already exists.")
        else:
            st.session_state.scenarios[name] = latest
            st.success(f"Scenario '{name}' saved.")

    # Preview saved scenario
    current_name = st.session_state.get("scenario_name", "").strip()
    if current_name and current_name in st.session_state.scenarios:
        scenario = st.session_state.scenarios[current_name]
        st.markdown(f"#### Scenario: {current_name}")
        df_saved = pd.DataFrame.from_dict(
            scenario["allocations"], orient="index", columns=["tCO₂ removed"]
        )
        df_saved["tCO₂ removed"] = pd.to_numeric(df_saved["tCO₂ removed"], errors="coerce")
        total = df_saved["tCO₂ removed"].sum()
        if total > 0:
            df_saved["Share (%)"] = (df_saved["tCO₂ removed"] / total * 100).round(2)
        df_saved = df_saved.sort_values(by="tCO₂ removed", ascending=False)
        st.table(format_results_summary(df_saved))

        # Export buttons
        safe_name = unicodedata.normalize("NFKD", current_name).encode("ascii", "ignore").decode("ascii")

        st.download_button(
            label="Export JSON",
            data=json.dumps(scenario, indent=2),
            file_name=f"{safe_name}_scenario.json",
            mime="application/json"
        )

        inputs_df = pd.DataFrame.from_dict(scenario["resource_caps"], orient="index", columns=["Available"])
        constraints_df = pd.DataFrame.from_dict({m: v.get("resources", {}) for m, v in scenario["method_constraints"].items()}, orient="index").fillna(0)
        allocations_df = pd.DataFrame.from_dict(scenario["allocations"], orient="index", columns=["tCO₂ removed"])

        csv_buffer = io.BytesIO()
        with zipfile.ZipFile(csv_buffer, "w") as zipf:
            zipf.writestr("resource_caps.csv", inputs_df.to_csv())
            zipf.writestr("method_constraints.csv", constraints_df.to_csv())
            zipf.writestr("allocations.csv", allocations_df.to_csv())

        st.download_button(
            label="Export CSV",
            data=csv_buffer.getvalue(),
            file_name=f"{safe_name}_scenario.zip",
            mime="application/zip"
        )