import time

import pandas as pd
import streamlit as st
from sklearn.ensemble import RandomForestRegressor
from sklearn.feature_extraction.text import CountVectorizer
from sklearn.naive_bayes import MultinomialNB
from sklearn.preprocessing import LabelEncoder


def New():
    progress_text = "Operación en progreso... :sunglasses: Por favor " \
                    "espere... " \
                    ":bomb:"
    my_bar = st.progress(0, text=progress_text)

    for percent_complete in range(100):
        time.sleep(0.05)
        my_bar.progress(percent_complete + 1, text=progress_text)

    st.markdown("""
            <h1>¡Descubre los proyectos más innovadores en fase Beta y 
            <strong>sé el primero</strong> en experimentar con ellos!</h1>
            <hr>
            <code>
            !Te presentamos un adelanto exclusivo de lo que viene 
            próximamente en nuestros proyectos más innovadores!
            </code>
        """, unsafe_allow_html=True)

    # Leer los datos y seleccionar las columnas necesarias
    df = pd.read_csv('./ML/ds_salaries.csv')
    df = df[['company_location', 'salary_in_usd']]

    # Codificar las ubicaciones de las empresas
    le = LabelEncoder()
    df['company_location'] = le.fit_transform(df['company_location'])

    # Decodificar las ubicaciones de las empresas
    decoded_locations = le.inverse_transform(df['company_location'].unique())

    # Separar los datos de entrada y salida
    X = df.iloc[:, :-1].values
    y = df.iloc[:, -1].values

    # Entrenar el modelo
    model = RandomForestRegressor(n_estimators=100, random_state=42)
    model.fit(X, y)

    # Obtener las ubicaciones de las empresas y sus salarios predichos
    locations = df['company_location'].unique()
    predicted_salaries = model.predict(locations.reshape(-1, 1))
    results_df = pd.DataFrame(
        {'company_location': locations, 'predicted_salary': predicted_salaries})

    # Decodificar las ubicaciones de las empresas
    results_df['company_location'] = le.inverse_transform(
        results_df['company_location'])

    # Ordenar los resultados por salario predicho
    results_df = results_df.sort_values('predicted_salary',
                                        ascending=False).reset_index(drop=True)

    # Mostrar el título y el top 5 de países mejor pagados
    st.markdown("""
            <h2>Atrae a los mejores talentos con nuestra lista precisa de los 
            países mejor pagados.</h2>
            <hr>
            """, unsafe_allow_html=True)

    # Descripción
    st.markdown("""
            <p>Como reclutador, sabes que la remuneración es un factor clave 
            para atraer a los mejores talentos. Con nuestro algoritmo 
            <strong>RandomForest</strong>, obtenemos un promedio preciso de los 
            países 
            mejor pagados en todo el mundo, lo que te permite atraer a los candidatos más talentosos. Nuestra lista está menos sesgada por outliers gracias a nuestra selección aleatoria de empresas en cada país. Únete a nuestra comunidad y toma decisiones informadas para un futuro próspero. ¡Atrae a los mejores talentos y lleva tu empresa al siguiente nivel con nuestra lista precisa de los países mejor pagados!""", unsafe_allow_html=True)

    for i in range(5):
        location = results_df.loc[i, 'company_location']
        salary = results_df.loc[i, 'predicted_salary']
        st.markdown(f'### **{location}**: ${salary:,.2f}',
                    unsafe_allow_html=True)

    # Mostrar el menú desplegable para seleccionar un país
    st.markdown("""
        <h2>Seleccionar un país</h2>
        <hr>
        """, unsafe_allow_html=True)
    selected_location = st.selectbox('Ubicación de la empresa',
                                     decoded_locations)

    # Mostrar el salario predicho para el país seleccionado
    predicted_salary = results_df.loc[results_df[
                                          'company_location'] == selected_location, 'predicted_salary'].iloc[
        0]
    st.markdown(f'### **{selected_location}**: ${predicted_salary:,.2f}',
                unsafe_allow_html=True)

    #####

    # Cargar los datos
    df = pd.read_csv('./assets/dataset_modelo_1.csv')

    # Crear una lista con todas las skills disponibles
    all_skills = set()
    for skills in df.skills:
        all_skills.update(skills.split(", "))

    # Crear un diccionario que relaciona cada skill con su índice en el vector
    skill_indices = {skill: i for i, skill in enumerate(all_skills)}

    # Crear una matriz de características con la frecuencia de cada skill en cada fila
    vectorizer = CountVectorizer(vocabulary=skill_indices.keys(),
                                 lowercase=False)
    X = vectorizer.fit_transform(df.skills)

    # Entrenar el modelo
    clf = MultinomialNB()
    clf.fit(X, df.Aptitude)

    # Crear la interfaz de usuario con Streamlit
    st.markdown("""
        <h2>Encuentra el talento perfecto con nuestro modelo de Naive Bayes para identificar las habilidades más importantes.</h2>
        <hr>
        """, unsafe_allow_html=True)
    st.markdown(
        """
        <p>Como reclutador, sabes que encontrar al talento perfecto es un 
        desafío constante. Con nuestro modelo de <strong>Naive Bayes</strong>, 
        podemos 
        identificar las habilidades más importantes para cualquier trabajo en particular. Al ingresar el título de trabajo, nuestro algoritmo genera una lista precisa de habilidades necesarias para tener éxito en esa posición específica. Esto te permite encontrar y atraer al candidato perfecto para el trabajo. Únete a nuestra comunidad y comienza a impulsar tu carrera hoy mismo!</p>""", unsafe_allow_html=True)

    title = st.text_input("Título del trabajo")

    # Crear una función que encuentra las habilidades más importantes para un título dado
    def get_top_skills(title, limit):
        # Filtrar el dataframe por el título dado
        filtered_df = df[df.job_title.str.contains(title, case=False)]

        # Crear una matriz de características con la frecuencia de cada skill en el dataframe filtrado
        X_filtered = vectorizer.transform(filtered_df.skills)

        # Calcular la frecuencia de cada habilidad en el dataframe filtrado
        skill_frequencies = X_filtered.sum(axis=0).A1

        # Obtener los nombres de las habilidades
        skill_names = vectorizer.vocabulary_.keys()

        # Crear un diccionario que relaciona cada habilidad con su frecuencia
        skill_freq_dict = dict(zip(skill_names, skill_frequencies))

        # Ordenar las habilidades por frecuencia descendente y devolver las más importantes (según el límite dado)
        top_skills = sorted(skill_freq_dict, key=skill_freq_dict.get,
                            reverse=True)[:limit]
        return top_skills

    if title:
        limit = st.number_input("Cantidad de habilidades a mostrar", value=5,
                                min_value=1, max_value=len(all_skills))
        top_skills = get_top_skills(title, limit)
        st.write(
            f"Las {limit} habilidades más importantes para el trabajo de '{title}' son:")
        for skill in top_skills:
            st.write(f"- {skill}")

    #####