import streamlit as st
from networkx.drawing.nx_agraph import read_dot, write_dot
import pandas as pd
import plotly.graph_objects as go
import networkx as nx
import logging
import re
import tempfile

# Configuration Gitea
from config import DOT_FILE, INSTRUCTIONS

from utils.gitea import (
    charger_instructions_depuis_gitea,
    charger_schema_depuis_gitea
)

from utils.graph_utils import (
    extraire_chemins_depuis,
    extraire_chemins_vers,
    lancer_personnalisation
)

from utils.visualisation import (
    lancer_visualisation_ihh_criticite,
    lancer_visualisation_ihh_ivc
)

from components.sidebar import (
    afficher_menu,
    afficher_impact
)

from components.header import afficher_entete

from components.footer import afficher_pied_de_page

from components.fiches import afficher_fiches

st.set_page_config(
    page_title="Fabnum – Analyse de chaîne",
    page_icon="assets/weakness.png", # ajout
    layout="centered",
    initial_sidebar_state="expanded"
)

session_id = st.context.headers.get("x-session-id")

niveau_labels = {
    0: "Produit final",
    1: "Composant",
    2: "Minerai",
    10: "Opération",
    11: "Pays d'opération",
    12: "Acteur d'opération",
    99: "Pays géographique"
}
inverse_niveau_labels = {v: k for k, v in niveau_labels.items()}

# Une seule lecture du fichier, mais injection à chaque run
if "base_css_content" not in st.session_state:
    with open("assets/styles/base.css") as f:
        st.session_state["base_css_content"] = f.read()

st.markdown(f"<style>{st.session_state['base_css_content']}</style>", unsafe_allow_html=True)

# Chargement initial des thèmes (variables CSS uniquement)
if "theme_css_content_clair" not in st.session_state:
    with open("assets/styles/theme-light.css") as f:
        st.session_state["theme_css_content_clair"] = f.read()

if "theme_css_content_sombre" not in st.session_state:
    with open("assets/styles/theme-dark.css") as f:
        st.session_state["theme_css_content_sombre"] = f.read()

# Thème en cours
current_theme = st.session_state.get("theme_mode", "Clair").lower()
theme_css = st.session_state[f"theme_css_content_{current_theme}"]

# Injection des variables du thème
st.markdown(f"<style>{theme_css}</style>", unsafe_allow_html=True)

# Chargement unique du CSS principal (base.css)
if "base_css_content" not in st.session_state:
    with open("assets/styles/base.css") as f:
        st.session_state["base_css_content"] = f.read()

# Injection du style principal basé sur les variables
st.markdown(f"<style>{st.session_state['base_css_content']}</style>", unsafe_allow_html=True)


def get_total_bytes_for_session(session_id):
    total_bytes = 0
    try:
        with open("/var/log/nginx/fabnum-dev.access.log", "r") as f:
            for line in f:
                if session_id in line:
                    match = re.search(r'"GET.*?" \d+ (\d+)', line)
                    if match:
                        bytes_sent = int(match.group(1))
                        total_bytes += bytes_sent
    except Exception as e:
        st.error(f"Erreur lecture log: {e}")
    return total_bytes

# Intégration du fichier CSS externe
# with open("assets/styles.css") as f:
#    st.markdown(f"<style>{f.read()}</style>", unsafe_allow_html=True)


afficher_entete()

afficher_menu()

st.markdown("""
<main role="main">
""", unsafe_allow_html=True)


def couleur_noeud(n, niveaux, G):
    niveau = niveaux.get(n, 99)
    attrs = G.nodes[n]

    # Niveau 99 : pays géographique avec isg
    if niveau == 99:
        isg = int(attrs.get("isg", -1))
        return (
            "darkred" if isg >= 60 else
            "orange" if isg >= 31 else
            "darkgreen" if isg >= 0 else
            "gray"
        )

    # Niveau 11 ou 12 connecté à un pays géographique
    if niveau in (11, 12, 1011, 1012):
        for succ in G.successors(n):
            if niveaux.get(succ) == 99:
                isg = int(G.nodes[succ].get("isg", -1))
                return (
                    "darkred" if isg >= 60 else
                    "orange" if isg >= 31 else
                    "darkgreen" if isg >= 0 else
                    "gray"
                )

    # Logique existante pour IHH / IVC
    if niveau in (10, 1010) and attrs.get("ihh_pays"):
        ihh = int(attrs["ihh_pays"])
        return (
            "darkgreen" if ihh <= 15 else
            "orange" if ihh <= 25 else
            "darkred"
        )
    elif niveau == 2 and attrs.get("ivc"):
        ivc = int(attrs["ivc"])
        return (
            "darkgreen" if ivc <= 15 else
            "orange" if ivc <= 30 else
            "darkred"
        )

    return "lightblue"


def afficher_sankey(
    G,
    niveau_depart, niveau_arrivee,
    noeuds_depart=None, noeuds_arrivee=None,
    minerais=None,
    filtrer_ics=False, filtrer_ivc=False,
    filtrer_ihh=False, filtrer_isg=False,
    logique_filtrage="OU"):

    niveaux = {}

    for node, attrs in G.nodes(data=True):
        niveau_str = attrs.get("niveau")
        try:
            if niveau_str:
                niveaux[node] = int(str(niveau_str).strip('"'))
        except ValueError:
            logging.warning(f"Niveau non entier pour le noeud {node}: {niveau_str}")

    chemins = []
    if noeuds_depart and noeuds_arrivee:
        for nd in noeuds_depart:
            for na in noeuds_arrivee:
                tous_chemins = extraire_chemins_depuis(G, nd)
                chemins.extend([chemin for chemin in tous_chemins if na in chemin])
    elif noeuds_depart:
        for nd in noeuds_depart:
            chemins.extend(extraire_chemins_depuis(G, nd))
    elif noeuds_arrivee:
        for na in noeuds_arrivee:
            chemins.extend(extraire_chemins_vers(G, na, niveau_depart))
    else:
        sources_depart = [n for n in G.nodes() if niveaux.get(n) == niveau_depart]
        for nd in sources_depart:
            chemins.extend(extraire_chemins_depuis(G, nd))

    if minerais:
        chemins = [chemin for chemin in chemins if any(n in minerais for n in chemin)]

    def extraire_criticite(u, v):
        data = G.get_edge_data(u, v)
        if not data:
            return 0
        if isinstance(data, dict) and all(isinstance(k, int) for k in data):
            return float(data[0].get("criticite", 0))
        return float(data.get("criticite", 0))

    liens_chemins = set()
    chemins_filtres = set()
    niveaux_speciaux = [1000, 1001, 1002, 1010, 1011, 1012]

    for chemin in chemins:
        has_ihh = has_ivc = has_criticite = has_isg_critique = False

        for i in range(len(chemin) - 1):
            u, v = chemin[i], chemin[i + 1]
            niveau_u = niveaux.get(u)
            niveau_v = niveaux.get(v)

            if (
                (niveau_depart <= niveau_u <= niveau_arrivee or niveau_u in niveaux_speciaux)
                and (niveau_depart <= niveau_v <= niveau_arrivee or niveau_v in niveaux_speciaux)
            ):
                liens_chemins.add((u, v))

                if filtrer_ihh and ihh_type:
                    ihh_field = "ihh_pays" if ihh_type == "Pays" else "ihh_acteurs"
                    if niveau_u in (10, 1010) and int(G.nodes[u].get(ihh_field, 0)) > 25:
                        has_ihh = True
                    if niveau_v in (10, 1010) and int(G.nodes[v].get(ihh_field, 0)) > 25:
                        has_ihh = True

                if filtrer_ivc and niveau_u in (2, 1002) and int(G.nodes[u].get("ivc", 0)) > 30:
                    has_ivc = True

                if filtrer_ics and ((niveau_u == 1 and niveau_v == 2) or (niveau_u == 1001 and niveau_v == 1002) or (niveau_u == 10 and niveau_v in (1000, 1001))) and extraire_criticite(u, v) > 0.66:
                    has_criticite = True

            for n in (u, v):
                if niveaux.get(n) == 99 and int(G.nodes[n].get("isg", 0)) >= 60:
                    has_isg_critique = True
                elif niveaux.get(n) in (11, 12, 1011, 1012):
                    for succ in G.successors(n):
                        if niveaux.get(succ) == 99 and int(G.nodes[succ].get("isg", 0)) >= 60:
                            has_isg_critique = True

        if logique_filtrage == "ET":
            keep = True
            if filtrer_ihh:
                keep = keep and has_ihh
            if filtrer_ivc:
                keep = keep and has_ivc
            if filtrer_ics:
                keep = keep and has_criticite
            if filtrer_isg:
                keep = keep and has_isg_critique
            if keep:
                chemins_filtres.add(tuple(chemin))
        elif logique_filtrage == "OU":
            if (filtrer_ihh and has_ihh) or (filtrer_ivc and has_ivc) or (filtrer_ics and has_criticite) or (filtrer_isg and has_isg_critique):
                chemins_filtres.add(tuple(chemin))

    if any([filtrer_ics, filtrer_ivc, filtrer_ihh, filtrer_isg]):
        chemins = list(chemins_filtres)
        liens_chemins = set()
        for chemin in chemins:
            for i in range(len(chemin) - 1):
                u, v = chemin[i], chemin[i + 1]
                niveau_u = niveaux.get(u, 999)
                niveau_v = niveaux.get(v, 999)
                if (
                    (niveau_depart <= niveau_u <= niveau_arrivee or niveau_u in niveaux_speciaux)
                    and (niveau_depart <= niveau_v <= niveau_arrivee or niveau_v in niveaux_speciaux)
                ):
                    liens_chemins.add((u, v))

    if not liens_chemins:
        st.warning("Aucun chemin ne correspond aux critères.")
        return

    df_liens = pd.DataFrame(list(liens_chemins), columns=["source", "target"])
    df_liens = df_liens.groupby(
        ["source", "target"]).size().reset_index(name="value")

    df_liens["criticite"] = df_liens.apply(
        lambda row: extraire_criticite(row["source"], row["target"]), axis=1)
    df_liens["value"] = 0.1

    # Ne garder que les nœuds effectivement connectés
    niveaux_speciaux = [1000, 1001, 1002, 1010, 1011, 1012]

    # Inclure les nœuds connectés + tous les nœuds 10xx traversés dans les chemins
    noeuds_utilises = set(df_liens["source"]) | set(df_liens["target"])
    for chemin in chemins:
        for n in chemin:
            if niveaux.get(n) in niveaux_speciaux:
                noeuds_utilises.add(n)

    sorted_nodes = [
        n for n in sorted(G.nodes(), key=lambda x: niveaux.get(x, 99), reverse=True)
        if n in noeuds_utilises
    ]

    def couleur_criticite(p):
        if p <= 0.33:
            return "darkgreen"
        elif p <= 0.66:
            return "orange"
        else:
            return "darkred"

    df_liens["color"] = df_liens.apply(
        lambda row: couleur_criticite(row["criticite"]) if row["criticite"] > 0 else "gray",
        axis=1
    )

    all_nodes = pd.unique(df_liens[["source", "target"]].values.ravel())
    sorted_nodes = sorted(
        all_nodes, key=lambda x: niveaux.get(x, 99), reverse=True)
    node_indices = {name: i for i, name in enumerate(sorted_nodes)}

    sources = df_liens["source"].map(node_indices).tolist()
    targets = df_liens["target"].map(node_indices).tolist()
    values = df_liens["value"].tolist()

    customdata = []
    for n in sorted_nodes:
        info = [f"{k}: {v}" for k, v in G.nodes[n].items()]
        niveau = niveaux.get(n, 99)

        # Ajout d’un ISG hérité si applicable
        if niveau in (11, 12, 1011, 1012):
            for succ in G.successors(n):
                if niveaux.get(succ) == 99 and "isg" in G.nodes[succ]:
                    isg_val = G.nodes[succ]["isg"]
                    info.append(f"isg (géographique): {isg_val}")
                    break

        customdata.append("<br>".join(info))

    def edge_info(u, v):
        data = G.get_edge_data(u, v)
        if not data:
            return f"Relation : {u} → {v}"
        if isinstance(data, dict) and all(isinstance(k, int) for k in data):
            data = data[0]
        base = [f"{k}: {v}" for k, v in data.items()]
        return f"Relation : {u} → {v}<br>" + "<br>".join(base)

    link_customdata = [
        edge_info(row["source"], row["target"]) for _, row in df_liens.iterrows()
    ]

    fig = go.Figure(go.Sankey(
        arrangement="snap",
        node=dict(
            pad=10,
            thickness=8,
            label=sorted_nodes,
            x=[niveaux.get(n, 99) / 100 for n in sorted_nodes],
            color=[couleur_noeud(n, niveaux, G) for n in sorted_nodes],
            customdata=customdata,
            hovertemplate="%{customdata}<extra></extra>"
        ),
        link=dict(
            source=sources,
            target=targets,
            value=values,
            color=df_liens["color"].tolist(),
            customdata=link_customdata,
            hovertemplate="%{customdata}<extra></extra>"
        )
    ))

    fig.update_layout(
        title_text="Hiérarchie filtrée par niveaux et noeuds",
        paper_bgcolor="white",
        plot_bgcolor="white"
    )
    st.plotly_chart(fig)

    if st.session_state.get("logged_in", False):
        if liens_chemins:
            G_export = nx.DiGraph()
            for u, v in liens_chemins:
                G_export.add_node(u, **G.nodes[u])
                G_export.add_node(v, **G.nodes[v])
                data = G.get_edge_data(u, v)
                if isinstance(data, dict) and all(isinstance(k, int) for k in data):
                    G_export.add_edge(u, v, **data[0])
                elif isinstance(data, dict):
                    G_export.add_edge(u, v, **data)
                else:
                    G_export.add_edge(u, v)

            with tempfile.NamedTemporaryFile(delete=False, suffix=".dot", mode="w", encoding="utf-8") as f:
                write_dot(G_export, f.name)
                dot_path = f.name

            with open(dot_path, encoding="utf-8") as f:
                st.download_button(
                    label="Télécharger le fichier DOT filtré",
                    data=f.read(),
                    file_name="graphe_filtré.dot",
                    mime="text/plain"
                )

dot_file_path = None

if st.session_state.onglet == "Instructions":
    markdown_content = charger_instructions_depuis_gitea(INSTRUCTIONS)
    if markdown_content:
        st.markdown(markdown_content)

elif st.session_state.onglet == "Fiches":
    st.markdown("# Affichage des fiches")
    st.markdown("Sélectionner d'abord l'opération que vous souhaitez examiner et ensuite choisisez la fiche à lire.")
    st.markdown("---")
    afficher_fiches()

else:
    # Charger le graphe une seule fois
    if "G_temp" not in st.session_state:
            try:
                if charger_schema_depuis_gitea(DOT_FILE):
                    st.session_state["G_temp"] = read_dot(DOT_FILE)
                    st.session_state["G_temp_ivc"] = st.session_state["G_temp"].copy()
                    dot_file_path = True
                else:
                    dot_file_path = False
            except Exception as e:
                st.error(f"Erreur de lecture du fichier DOT : {e}")
                dot_file_path = False
    else:
        dot_file_path = True

    if dot_file_path:
        G_temp = st.session_state["G_temp"]
        G_temp_ivc = st.session_state["G_temp_ivc"]
    else:
        st.error("Impossible de charger le graphe pour cet onglet.")

if dot_file_path and st.session_state.onglet == "Analyse":
    try:
        niveaux_temp = {
            node: int(str(attrs.get("niveau")).strip('"'))
            for node, attrs in G_temp.nodes(data=True)
            if attrs.get("niveau") and str(attrs.get("niveau")).strip('"').isdigit()
        }
        G_temp.remove_nodes_from([n for n in G_temp.nodes() if n not in niveaux_temp])
        G_temp.remove_nodes_from(
            [n for n in G_temp.nodes() if niveaux_temp.get(n) == 10 and 'Reserves' in n])

        st.markdown("# Analyse")
        st.markdown("## Sélection des nœuds de départ et d'arrivée")
        valeur_defaut = "-- Sélectionner un niveau --"
        niveau_choix = [valeur_defaut] + list(niveau_labels.values())

        niveau_depart = st.selectbox("Niveau de départ", niveau_choix, key="analyse_niveau_depart")

        if niveau_depart != "-- Sélectionner un niveau --":
            niveau_depart = inverse_niveau_labels[niveau_depart]
            niveaux_arrivee_possibles = [v for k, v in niveau_labels.items() if k > niveau_depart]

            niveaux_arrivee_choix = [valeur_defaut] + niveaux_arrivee_possibles

            analyse_niveau_arrivee = st.selectbox("Niveau d'arrivée", niveau_choix, key="analyse_niveau_arrivee")

            if analyse_niveau_arrivee != "-- Sélectionner un niveau --":
                niveau_arrivee = inverse_niveau_labels[analyse_niveau_arrivee]

                minerais_selection = None
                if niveau_depart < 2 < niveau_arrivee:
                    st.markdown("### Sélectionner un ou plusieurs minerais")
                    # Tous les nœuds de niveau 2 (minerai)
                    minerais_nodes = sorted([
                        n for n, d in G_temp.nodes(data=True)
                        if d.get("niveau") and int(str(d.get("niveau")).strip('"')) == 2
                    ])

                    minerais_selection = st.multiselect(
                        "Filtrer par minerais (optionnel)",
                        minerais_nodes,
                        key="analyse_minerais"
                    )

                st.markdown("---")

                depart_nodes = [n for n in G_temp.nodes() if niveaux_temp.get(n) == niveau_depart]
                arrivee_nodes = [n for n in G_temp.nodes() if niveaux_temp.get(n) == niveau_arrivee]

                st.markdown("## Sélection fine des items")

                noeuds_depart = st.multiselect("Filtrer par noeuds de départ (optionnel)", sorted(depart_nodes), key="analyse_noeuds_depart")

                noeuds_arrivee = st.multiselect("Filtrer par noeuds d'arrivée (optionnel)", sorted(arrivee_nodes), key="analyse_noeuds_arrivee")

                st.markdown("---")

                noeuds_depart = noeuds_depart if noeuds_depart else None
                noeuds_arrivee = noeuds_arrivee if noeuds_arrivee else None

                st.markdown("## Sélection des filtres pour identifier les vulnérabilités")

                filtrer_ics = st.checkbox("Filtrer les chemins contenant au moins minerai critique pour un composant (ICS > 66 %)", key="analyse_filtrer_ics")
                filtrer_ivc = st.checkbox("Filtrer les chemins contenant au moins un minerai critique par rapport à la concurrence sectorielle (IVC > 30)", key="analyse_filtrer_ivc")
                filtrer_ihh = st.checkbox("Filtrer les chemins contenant au moins une opération critique par rapport à la concentration géographique ou industrielle (IHH pays ou acteurs > 25)", key="analyse_filtrer_ihh")

                ihh_type = None
                if filtrer_ihh:
                    ihh_type = st.radio("Appliquer le filtre IHH sur :", ["Pays", "Acteurs"], horizontal=True, key="analyse_ihh_type")

                filtrer_isg = st.checkbox("Filtrer les chemins contenant un pays instable (ISG ≥ 60)", key="analyse_filtrer_isg")
                logique_filtrage = st.radio("Logique de filtrage", ["OU", "ET"], horizontal=True, key="analyse_logique_filtrage")

                st.markdown("---")

                if st.button("Lancer l’analyse", type="primary", key="analyse_lancer"):
                    afficher_sankey(
                        G_temp,
                        niveau_depart=niveau_depart,
                        niveau_arrivee=niveau_arrivee,
                        noeuds_depart=noeuds_depart,
                        noeuds_arrivee=noeuds_arrivee,
                        minerais=minerais_selection,
                        filtrer_ics=filtrer_ics,
                        filtrer_ivc=filtrer_ivc,
                        filtrer_ihh=filtrer_ihh,
                        filtrer_isg=filtrer_isg,
                        logique_filtrage=logique_filtrage
                )

    except Exception as e:
        st.error(f"Erreur de prévisualisation du graphe : {e}")

elif dot_file_path and st.session_state.onglet == "Visualisations":
    st.markdown("# Visualisations")
    st.markdown("""## Indice de Herfindahl-Hirschmann - IHH vs Criticité

Entre 0 et 15%, concentration faible, entre 15 et 25%, modérée, au-delà, forte.

Taille des points = criticité substituabilité du minerai
""")
    if st.button("Lancer", key="btn_ihh_criticite"):
        try:
            lancer_visualisation_ihh_criticite(G_temp)
        except Exception as e:
            st.error(f"Erreur dans la visualisation IHH vs Criticité : {e}")

    st.markdown("""## Indice de Herfindahl-Hirschmann - IHH vs IVC

Entre 0 et 15%, concentration faible, entre 15 et 25%, modérée, au-delà, forte.

Taille des points = criticité concurrentielle du minerai
""")

    if st.button("Lancer", key="btn_ihh_ivc"):
        try:
            lancer_visualisation_ihh_ivc(G_temp_ivc)
        except Exception as e:
            st.error(f"Erreur dans la visualisation IHH vs IVC : {e}")

elif dot_file_path and st.session_state.onglet == "Personnalisation":
    G_temp = lancer_personnalisation(G_temp)

st.markdown("</div>", unsafe_allow_html=True)

st.markdown("""</section>""", unsafe_allow_html=True)

st.markdown("</main>", unsafe_allow_html=True)

total_bytes = get_total_bytes_for_session(session_id)

afficher_pied_de_page()

afficher_impact(total_bytes)