"""
Description of the interface content
"""
from os import path
import gradio as gr
import pandas as pd

from src.services.serviceLLM.doc import load_doc
from src.interface.handlers import handle_launch

csv_path = path.join(path.dirname(__file__), "../../assets/data/")


# Point d'entrée de l'application
with gr.Blocks(title="EcoMindAI",
               analytics_enabled=False) as io:
    title = gr.HTML("""<h1 class=\"logo\">EcoMindAI</h1>
        <p>Estimating the environmental impact of an language model project </p>""")

    with gr.Tabs() as tabs:

        # Onglet des paramètres d'entrée
        with gr.Tab("📝 Input parameters", id=0, elem_classes="page") as calculator:
            with gr.Row():
                with gr.Column(scale=2):
                    gr.Markdown("## 📝 Input parameters")
                launch_btn = gr.Button("⯈ Launch impact estimation",
                                       variant="primary", scale=1, interactive=True)

            # Choix du mode
            mode = gr.Radio(
                ["Project's impact"], label="Mode", value="Project's impact")

            # Mode "impact projet"
            with gr.Column(visible=True) as project_impact:
                gr.HTML("<hr>", padding=False)
                project_duration = gr.Number(value=5, label="Estimated project duration (in years)",
                                             minimum=1, maximum=50)

                gr.Markdown("### Algorithm")
                with gr.Row() as algorithm:
                    dataframe = pd.read_csv(
                        csv_path + "input_parameters_llm.csv")
                    model_details = gr.Dropdown(label="Model details",
                                                choices=list(dict.fromkeys(
                                                    dataframe["model"].tolist())),
                                                value="llama3")
                    model_details_df = dataframe[(
                        dataframe["model"] == "llama3")]
                    parameters_count = gr.Dropdown(label="Parameters",
                                                   choices=list(dict.fromkeys(
                                                       model_details_df["parameters"].tolist())),
                                                   value="13b")
                    model_parameters_df = model_details_df[
                        (model_details_df["parameters"] == "13b")]
                    framework = gr.Dropdown(label="Framework",
                                            choices=list(dict.fromkeys(
                                                model_parameters_df["framework"].tolist())),
                                            value="llamacpp")
                    model_parameters_framework_df = model_parameters_df[
                        (model_details_df["framework"] == "llamacpp")]
                    quantization = gr.Dropdown(label="Quantization",
                                               choices=list(dict.fromkeys(
                                                   model_parameters_framework_df["quantization"]
                                                   .tolist())),
                                               value="8bit0")

                def handle_model_details(selected_model):
                    """
                    Met à jour les listes déroulantes en fonction du modèle sélectionné par
                    l'utilisateur
                    """
                    filtered_df = dataframe[(
                        dataframe["model"] == selected_model)]
                    return (
                        gr.Dropdown(label="Parameters",
                                    choices=list(dict.fromkeys(
                                        filtered_df["parameters"].tolist())),
                                    value=filtered_df.iloc[0]["parameters"]),
                        gr.Dropdown(label="Framework",
                                    choices=list(dict.fromkeys(
                                        filtered_df["framework"].tolist())),
                                    value=filtered_df.iloc[0]["framework"]),
                        gr.Dropdown(label="Quantization", choices=list(
                            dict.fromkeys(filtered_df["quantization"].tolist())),
                            value=filtered_df.iloc[0]["quantization"]))

                model_details.change(handle_model_details, inputs=model_details,
                                     outputs=[parameters_count, framework, quantization])

                def handle_parameters_count(
                        selected_model, selected_parameters):
                    """
                    Met à jour les listes déroulantes en fonction du modèle et du nombre de
                    paramètres associé, sélectionnés par l'utilisateur
                    """
                    filtered_df = dataframe[(dataframe["model"] == selected_model) &
                                            (dataframe["parameters"] == selected_parameters)]
                    return (
                        gr.Dropdown(label="Framework", choices=list(dict.fromkeys(
                            filtered_df["framework"].tolist())),
                            value=filtered_df.iloc[0]["framework"]),
                        gr.Dropdown(label="Quantization", choices=list(dict.fromkeys(
                            filtered_df["quantization"].tolist())),
                            value=filtered_df.iloc[0]["quantization"]))

                parameters_count.change(handle_parameters_count,
                                        inputs=[model_details,
                                                parameters_count],
                                        outputs=[framework, quantization])

                def handle_framework(
                        selected_model, selected_parameters, selected_framework):
                    """
                    Met à jour les listes déroulantes en fonction du modèle, du nombre de
                    paramètres associé et du framework, sélectionnés par l'utilisateur
                    """
                    filtered_df = dataframe[(dataframe["model"] == selected_model) &
                                            (dataframe["parameters"] == selected_parameters) &
                                            (dataframe["framework"] == selected_framework)]
                    return (
                        gr.Dropdown(label="Quantization", choices=list(
                            dict.fromkeys(filtered_df["quantization"].tolist())),
                            value=filtered_df.iloc[0]["quantization"]))

                framework.change(handle_framework,
                                 inputs=[model_details,
                                         parameters_count, framework],
                                 outputs=quantization)

                # Affichage dynamique des étapes
                gr.Markdown("### Stages")
                # La phase d'inférence est cochée par défaut
                stages = gr.CheckboxGroup(
                    choices=["Inference", "Finetuning ⚠️"], show_label=False, value="Inference")

                with gr.Column(visible=True) as inference_stage:
                    gr.Markdown("#### Inference")
                    with gr.Column():
                        with gr.Row():
                            inference_users = gr.Number(
                                label="Number of users per year", minimum=1, maximum=1000000000,
                                value=10000, elem_classes="inference")
                            inference_requests = gr.Number(
                                label="Average number of requests per year", minimum=1,
                                maximum=1000000000, value=200, elem_classes="inference")
                            inference_tokens = gr.Number(
                                label="Average number of tokens generated per request",
                                minimum=1, maximum=1000000000, value=500, elem_classes="inference"
                            )
                            inference_total_tokens_str = gr.Text(
                                label="⤇ Total number of generated tokens", value="5.0G",
                                interactive=False, elem_classes="inference")
                with gr.Column(visible=False, elem_classes="wip") as finetuning_stage:
                    gr.Markdown(
                        """#### 🏗️ Finetuning WIP: it will not be taken into account in your \
                        estimation
                        We will need more data to factor it into the estimate""")
                    with gr.Row():
                        finetuning_type = gr.Radio(
                            ["supervised finetuning", "RLHF"],
                            label="Type of finetuning", interactive=False)
                        finetuning_data_size = gr.Number(
                            label="Size of the new dataset (in GB)", minimum=1, maximum=1000000000,
                            value=500, interactive=False)
                        finetuning_epochs_number = gr.Number(label="Number of epochs",
                                                             minimum=1, maximum=1000000000,
                                                             value=12, interactive=False)
                        finetuning_batch_size = gr.Number(label="Size of the batch",
                                                          minimum=1, maximum=1000000000,
                                                          value=10000, interactive=False)
                        finetuning_peft = gr.Dropdown(label="PEFT method used",
                                                      choices=["LoRA", "prefix tuning", "p-tuning",
                                                               "prompt tuning"])

                def show_stages(selected_stages):
                    """
                    Gère l'affichage des formulaires en fonction des étapes sélectionnées
                    """
                    return gr.update(visible="Inference" in selected_stages), gr.update(
                        visible="Finetuning ⚠️" in selected_stages)

                stages.change(show_stages, inputs=stages,
                              outputs=[inference_stage, finetuning_stage])

                gr.HTML("<hr>", padding=False)
                gr.Markdown("### Infrastructure")
                with gr.Row():
                    infra_type = gr.Dropdown(label="Type",
                                             choices=["Server", "Desktop", "Laptop",
                                                      "AI Cloud Service"])
                with gr.Column() as infra_dedicated:
                    with gr.Row():
                        infra_cpu_cores = gr.Number(
                            label="CPU cores", minimum=0, maximum=1024, value=30, interactive=False,
                            elem_classes="show-disabled")
                        infra_gpu_count = gr.Number(
                            label="GPU count", minimum=0, maximum=1024, value=2, interactive=False,
                            elem_classes="show-disabled")
                        infra_gpu_memory = gr.Number(
                            label="GPU memory (GB)", minimum=0, maximum=2048, value=32,
                            interactive=False, elem_classes="show-disabled")
                        infra_memory = gr.Number(
                            label="RAM size (GB)", minimum=1, maximum=2048, value=64,
                            interactive=False, elem_classes="show-disabled")
                    gr.Markdown("#### Power effectiveness")
                    with gr.Row():
                        infra_pue_datacenter = gr.Number(
                            label="Datacenter PUE", minimum=1, maximum=10, value=1.5, step=0.01,
                            info="To learn more about the Power Usage Effectiveness and how it \
                                is calculated, check this page related to \
                                [PUE](https://en.wikipedia.org/wiki/Power_usage_effectiveness).",
                            elem_classes="show-disabled")
                        infra_pue_machine = gr.Number(
                            label="Complementary PUE", minimum=1, maximum=10, value=1.3, step=0.01,
                            info="Power used for the operating of OS, virtualization, control plan,\
                                  idle... To learn more about it, visit our documentation page.",)
                with gr.Column(visible=False) as infra_service:
                    gr.HTML(
                        "<div class=\"not-implemented\">🏗️ Not implemented yet</div>")

                def handle_inference_total_tokens(
                        duration, nb_inference_users, nb_inference_requests, nb_inference_tokens):
                    """
                    Calcul du nombre total de tokens générés sur la durée du projet
                    """
                    total = duration * nb_inference_users * \
                        nb_inference_requests * nb_inference_tokens
                    if total > 1000000000:
                        total_str = str(round(total / 1000000000, 3)) + "G"
                    elif total > 1000000:
                        total_str = str(round(total / 1000000, 3)) + "M"
                    elif total > 1000:
                        total_str = str(round(total / 1000, 3)) + "k"
                    else:
                        total_str = str(total)
                    return gr.update(value=total_str)

                project_duration.change(
                    handle_inference_total_tokens,
                    inputs=[project_duration, inference_users, inference_requests,
                            inference_tokens],
                    outputs=inference_total_tokens_str)
                inference_users.change(
                    handle_inference_total_tokens,
                    inputs=[project_duration, inference_users, inference_requests,
                            inference_tokens],
                    outputs=inference_total_tokens_str)
                inference_requests.change(
                    handle_inference_total_tokens,
                    inputs=[project_duration, inference_users, inference_requests,
                            inference_tokens],
                    outputs=inference_total_tokens_str)
                inference_tokens.change(
                    handle_inference_total_tokens,
                    inputs=[project_duration, inference_users, inference_requests,
                            inference_tokens],
                    outputs=inference_total_tokens_str)

                def handle_infra_type(infra_type_name):
                    """
                    Gestion des champs en fonction du type d'infrastructure sélectionné
                    """
                    if infra_type_name == "AI Cloud Service":
                        return gr.update(visible=False), gr.update(
                            visible=True), None, None, None, None, None
                    if infra_type_name == "Desktop":
                        return gr.update(visible=True), gr.update(visible=False), gr.update(
                            value=1.0, interactive=False), gr.update(value=8), gr.update(
                            value=1), gr.update(value=12), gr.update(value=32)
                    if infra_type_name == "Laptop":
                        return gr.update(visible=True), gr.update(visible=False), gr.update(
                            value=1.0, interactive=False), gr.update(value=8), gr.update(
                            value=0), gr.update(value=0), gr.update(value=16)
                    # infratype = "Server"
                    return gr.update(visible=True), gr.update(visible=False), gr.update(
                        value=1.5, interactive=True), gr.update(value=30), gr.update(
                        value=2), gr.update(value=32), gr.update(value=64)

                infra_type.change(handle_infra_type, inputs=infra_type,
                                  outputs=[infra_dedicated, infra_service, infra_pue_datacenter,
                                           infra_cpu_cores, infra_gpu_count, infra_gpu_memory,
                                           infra_memory])

                def enable_launch_button(infra_type_value, mode_selected, selected_stages):
                    """
                    Permettre d'appuyer sur le bouton uniquement quand les champs nécessaires
                    sont remplis
                    """
                    if (infra_type_value != "AI Cloud Service" and
                        mode_selected == "Project's impact" and
                            "Inference" in selected_stages):
                        return gr.update(interactive=True)
                    return gr.update(interactive=False)

                infra_type.change(enable_launch_button, inputs=[infra_type, mode, stages],
                                  outputs=launch_btn)

                mode.change(enable_launch_button, inputs=[infra_type, mode, stages],
                            outputs=launch_btn)

                stages.change(enable_launch_button, inputs=[infra_type, mode, stages],
                              outputs=launch_btn)

                gr.HTML("<hr>", padding=False)
                gr.Markdown("### Energy efficiency")
                with gr.Row() as energy_efficiency:
                    location_df = pd.read_csv(csv_path + "mixelecs.csv")
                    location = gr.Dropdown(label="Location", choices=list(dict.fromkeys(
                        location_df["location"].tolist())),
                        value="Germany")

        # Onglet des résultats
        with gr.Tab("📊 Results", id=1, visible=False, elem_classes="page") as results:

            with gr.Row(elem_classes="duration"):
                results_title = gr.Markdown("## 📊 Results for X years")
                duration_slider = gr.Slider(
                    1, 5, value=3, step=1,
                    label='Choose the duration for which you want to visualize your impact',
                    elem_classes="slider")

            gr.Markdown("### Environmental impact "
                        "<small>(for both stages use and embodied)</small>")
            with gr.Row():
                energy_consumption = gr.Text(label="⚡ Energy consumption", value="X Wh",
                                             elem_classes="result")
                carbon_footprint = gr.Text(label="🌫️ Carbon footprint", value="X gCO2eq",
                                           elem_classes="result")
                abiotic_resource_usage = gr.Text(label="⛏️ Abiotic resource use", value="X gSbeq",
                                                 elem_classes="result")
                water_usage = gr.Text(
                    label="💧 Water usage *", value="X mL", elem_classes="result")
            with gr.Row():
                gr.Markdown("↕", elem_classes="equiv")
                gr.Markdown("↕", elem_classes="equiv")
                gr.Markdown("↕", elem_classes="equiv")
                gr.Markdown("↕", elem_classes="equiv")

            with gr.Row():
                eq_energy_consumption = gr.Text(label="Energy consumption", value="X hours",
                                                elem_classes="result")
                eq_carbon_footprint = gr.Text(label="Carbon footprint", value="X",
                                              elem_classes="result")
                eq_abiotic_resources = gr.Text(label="Abiotic resources", value="X",
                                               elem_classes="result")
                eq_water_usage = gr.Text(
                    label="Water usage", value="X", elem_classes="result")

            gr.Markdown(
                "\\* the water usage is calculated only for the scope 3 because of the lack \
                    of open data about the water usage related to energy consumption",
                elem_classes="asterisk")
            gr.Markdown(
                "### Visualize the proportion of use and embodied impacts")
            with gr.Row():
                carbon_footprint_chart = gr.Plot(
                    show_label=False, container=False)
                abiotic_resource_chart = gr.Plot(
                    show_label=False, container=False)
                water_usage_chart = gr.Plot(show_label=False, container=False)

            gr.HTML("<hr>", padding=False)
            gr.Markdown("## 🌳 How to do better?")

            gr.Markdown("### Recommendations")

            with gr.Column(elem_classes="grid-css"):

                gr.Markdown("### Type", elem_classes="reco")
                gr.Markdown("### Topic", elem_classes="reco")
                gr.Markdown("### Example", elem_classes="reco")
                gr.Markdown("### Expected reduction",
                            elem_classes="reco")

                gr.Markdown("Quantified", elem_classes="reco")
                gr.Markdown("⚡ Use the right quantization !",
                            elem_classes="reco")
                gr.Markdown(
                    """On llamacpp, using q4ks instead of no quantization can lead to a reduction \
                        of impact by""",
                    elem_classes="reco")
                gr.Markdown("## 33%", elem_classes="reco")

                gr.Markdown("Quantified", elem_classes="reco")
                gr.Markdown("⚡ Use the right framework !", elem_classes="reco")
                gr.Markdown(
                    """Using the framework vllm instead of llamacpp for some model can lead
                    to a reduction of impact by""", elem_classes="reco")
                gr.Markdown("## 18%", elem_classes="reco")

                gr.Markdown("Quantified", elem_classes="reco")
                gr.Markdown(
                    "⚡ Use the lightest possible model that meets your needs !",
                    elem_classes="reco")
                gr.Markdown(
                    """Using the model llama3-8b instead of 13b can lead to a reduction of impact\
                          by""",
                    elem_classes="reco")
                gr.Markdown("## 30%", elem_classes="reco")

                gr.Markdown("Quantified", elem_classes="reco")
                gr.Markdown(
                    """🌫️ Locate servers in a country where energy production has less impact""",
                    elem_classes="reco")
                gr.Markdown(
                    """Using a server located in Sweden instead of United-States can lead
                    to a reduction of impact by""", elem_classes="reco")
                gr.Markdown("## 93%", elem_classes="reco")

                gr.Markdown("Quantified", elem_classes="reco")
                gr.Markdown(
                    """🌫️⛏️💧 Use as few resources as possible
                    (i.e. the smallest possible machine/server) to suit the need""",
                    elem_classes="reco")
                gr.Markdown(
                    """Using a small gpu server instead of a big one can lead to a reduction of \
                    impact by""",
                    elem_classes="reco")
                gr.Markdown("## 41%", elem_classes="reco")

                gr.Markdown("Calculated", elem_classes="reco")
                gr.Markdown(
                    "⚡ Use the most frugal configuration", elem_classes="reco")
                more_frugal_conf = gr.Markdown(elem_classes="reco")
                percentage_reduction = gr.Markdown(elem_classes="reco")

            launch_btn.click(
                fn=handle_launch,
                inputs=[mode, project_duration, project_duration, model_details, parameters_count,
                        framework, quantization, stages, inference_users, inference_requests,
                        inference_tokens, finetuning_data_size, finetuning_epochs_number,
                        finetuning_batch_size, finetuning_peft, infra_type, infra_cpu_cores,
                        infra_gpu_count, infra_gpu_memory, infra_memory, infra_pue_datacenter,
                        infra_pue_machine, location],
                outputs=[tabs, results, results_title, energy_consumption, carbon_footprint,
                         abiotic_resource_usage, water_usage, eq_energy_consumption,
                         eq_carbon_footprint, eq_abiotic_resources, eq_water_usage,
                         carbon_footprint_chart, abiotic_resource_chart, water_usage_chart,
                         more_frugal_conf, percentage_reduction, duration_slider])
            duration_slider.change(
                fn=handle_launch,
                inputs=[mode, project_duration, duration_slider, model_details, parameters_count,
                        framework, quantization, stages, inference_users, inference_requests,
                        inference_tokens, finetuning_data_size, finetuning_epochs_number,
                        finetuning_batch_size, finetuning_peft, infra_type, infra_cpu_cores,
                        infra_gpu_count, infra_gpu_memory, infra_memory, infra_pue_datacenter,
                        infra_pue_machine, location],
                outputs=[tabs, results, results_title, energy_consumption, carbon_footprint,
                         abiotic_resource_usage, water_usage, eq_energy_consumption,
                         eq_carbon_footprint, eq_abiotic_resources, eq_water_usage,
                         carbon_footprint_chart, abiotic_resource_chart, water_usage_chart,
                         more_frugal_conf, percentage_reduction, duration_slider])

        # Onglet de la documentation
        with gr.Tab("📗 Documentation", id=2) as documentation:
            gr.Markdown(
                load_doc(path.join(path.dirname(__file__), "../../assets/docs/doc.md")))