import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import importlib


from st_on_hover_tabs import on_hover_tabs

import streamlit as st

import streamlit_presentation
import streamlit_presentation.analyse
importlib.reload(streamlit_presentation.analyse)
from streamlit_presentation.analyse import repartition_par_categorie
from streamlit_presentation.analyse import repartition_longueur_categorie


import streamlit_presentation.preprocessing
importlib.reload(streamlit_presentation.preprocessing)
from streamlit_presentation.preprocessing import detection_langage_et_traduction

import streamlit_presentation.modele
importlib.reload(streamlit_presentation.modele)
from streamlit_presentation.modele import presentation_modele
from sklearn.metrics import f1_score


import streamlit_presentation.plusloin
importlib.reload(streamlit_presentation.plusloin)
from streamlit_presentation.plusloin import plusloin

plt.rcParams['font.size'] = 12
plt.rcParams['axes.labelsize'] = 10
plt.rcParams['axes.titlesize'] = 12
plt.rcParams['xtick.labelsize'] = 8
plt.rcParams['ytick.labelsize'] = 8
plt.rcParams['legend.fontsize'] = 8
plt.rcParams['lines.linewidth'] = 1

#on charge les donnees utilisees
data = pd.read_csv( 'data.csv')
extract_data = pd.read_csv( 'data_tr_extract.csv')
sum_data = pd.read_csv( 'data_sum_extract.csv')
test_data = pd.read_pickle( 'data_test.pkl')

from tensorflow.keras.models import load_model
autoencoder = load_model('autoencoder_model.h5')

from keras.models import load_model
import tensorflow as tf
from tensorflow.keras import backend as K
import ast


def f1_weighted(true, pred):  

    # Classes
    classes = K.arange(0, 27) 
    true = K.one_hot(K.cast(true, 'int32'), 27)
    
    # Calcule les TP, FP, FN pour chaque classe
    tp = K.dot(K.transpose(true), K.round(pred))
    fp = K.dot(K.transpose(1-true), K.round(pred))
    fn = K.dot(K.transpose(true), 1-K.round(pred))

    # Calcule le score F1 pour chaque classe
    p = tp / (tp + fp + K.epsilon())
    r = tp / (tp + fn + K.epsilon())
    f1 = 2*p*r / (p+r+K.epsilon())

    
    weighted_f1 = K.sum(f1 * K.sum(true, axis=0) / K.sum(true))
    return weighted_f1

model = load_model("final_model_kfold.h5", custom_objects={'f1_weighted': f1_weighted})





from sklearn.preprocessing import LabelEncoder
encoder =  LabelEncoder()
y_test = encoder.fit_transform(test_data["prdtypecode"])
class_labels = encoder.classes_
label_size = 27



####### Page principale
st.set_page_config(layout="wide",page_title="Rakuten Challenge")
hide_default_format = """
       <style>
       #MainMenu {visibility: hidden; }
       footer {visibility: hidden;}
       </style>
       """
st.markdown(hide_default_format, unsafe_allow_html=True)

st.markdown('<style>' + open('./style.css').read() + '</style>', unsafe_allow_html=True)

st.title("Rakuten Challenge")

with st.sidebar:
    tabs = on_hover_tabs(tabName=['Introduction', "Analyse", "Preprocessing", "Modèle", "Pistes exploratoires"], 
                         iconName=['apps', 'bar_chart', "sync", "memory", "topic"], 
                         styles = {'navtab': {'background-color':'RGB(55,71,79)',
                                                  'color': 'RGB(180,180,180)',
                                                  'font-size': '18px',
                                                  'transition': '.3s',
                                                  'white-space': 'nowrap',
                                                  'text-transform': 'uppercase'},
                                       'tabOptionsStyle': {':hover :hover': {'color': 'RGB(235,197,82)',
                                                                      'cursor': 'pointer'}},
                                       'iconStyle':{'position':'fixed',
                                                    'left':'7.5px',
                                                    'text-align': 'left'},
                                       'tabStyle' : {'list-style-type': 'none',
                                                     'margin-bottom': '30px',
                                                     'padding-left': '30px'}},
                         default_choice=0)

st.markdown("""
<style>
    .rounded-border-parent {
        border-radius: 15px !important;
        border: 1px solid blue !important;
        background-color: lightgray !important;
    }
</style>
""", unsafe_allow_html=True)


if tabs == "Introduction":
    st.write("### Introduction")
    st.write("""
Le catalogue de l’ecommerce Rakuten comporte des centaines de milliers d’articles mis à jour régulièrement. Le besoin de l’entreprise est de les classer automatiquement dans leur catégorie.
 
L’objectif de notre projet est de de prédire le code type d’un produit à partir de données textes décrivant des produits ainsi que leurs images associées.

Notre étude doit déterminer la qualité et la pertinence des données, d’évaluer un prétraitement possible et proposer une solution de classification l’exploitation de ces dernières
""")

elif tabs == "Analyse":
    st.write("### Analyse")
    st.write("Extrait de la base de données fournie par Rakuten:")
    st.dataframe(data.head(30))
    st.write("")
    st.write("### Regard sur les données:")
    st.write("")
    st.write("")
    st.write("Une distribution des observations par code produit non balancée:")
    st.write("")
    repartition_par_categorie(st, data)
    st.write("")
    st.divider()
    st.write("")
    st.write("### Variabilité de la taille des champs textes:")
    st.write("")
    st.text("""
    Pourcentage de valeurs manquantes pour la description : 35.09%
    Pourcentage de valeurs manquantes pour la designation : 0.00%         
             """)
    
    st.write("")
    st.write("")
    repartition_longueur_categorie(st, data)
    st.write("")
    

elif tabs == "Preprocessing":
    detection_langage_et_traduction(st, extract_data, sum_data)

elif tabs == "Modèle":
    presentation_modele(st, test_data, model,class_labels,y_test,encoder)

elif tabs == "Pistes exploratoires":
    st.write("### Pistes exploratoires")
    plusloin(st,autoencoder)