import streamlit as st
import streamlit.components.v1 as components
import pandas as pd
import ifcopenshell
import ifcopenshell.util.element as Element
import tempfile
import plotly.express as px
import plotly.graph_objects as go
import plotly.io as pio
import os
import json
import re
import matplotlib.pyplot as plt
import base64
import pdfkit

##-hola-

st.set_page_config(page_title="Revisor de Modelos IFC", page_icon="📈")

st.title("Revisor de Modelos IFC")

###---- HIDE STREAMLIT STYLE ----
hide_st_style = """
            <style>
            #MainMenu {visibility: hidden;}
            footer {visibility: hidden;}
            header {visibility: hidden;}
            </style>
            """
st.markdown(hide_st_style, unsafe_allow_html=True)
base="light"

def cargar_datos_desde_json(tipo_modelo, nivel_avance):
    # Genera la ruta completa del archivo JSON basado en la selección del usuario
    nombre_archivo = f"{tipo_modelo}_{nivel_avance}.json"
    ruta_archivo = os.path.join(nombre_archivo)
    
    try:
        # Intenta abrir y cargar el archivo JSON correspondiente
        with open(ruta_archivo, 'r') as file:
            data = json.load(file)
        return data
    except FileNotFoundError:
        st.error(f"No existe EAIM para este tipo de modelo.")
        return None
    except Exception as e:
        st.error(f"Error datos")
        return None


def obtener_informacion(data, tipo_modelo, nivel_avance):
    if data and tipo_modelo in data and nivel_avance in data[tipo_modelo]:
        info_seleccionada = data[tipo_modelo][nivel_avance]
        rows = []
        for entidad, ndi_info in info_seleccionada.items():
            for ndi, ndi_data in ndi_info.items():
                atributos = ndi_data.get('Atributos', None)
                Propiedades = ndi_data.get('Propiedades', None)

                # Utiliza apply con una función lambda para formatear la columna 'Atributos'
                atributos_str = ', '.join(atributos) if atributos else ''

                rows.append([entidad, ndi, atributos_str, Propiedades])

        df = pd.DataFrame(rows, columns=['Entidad', 'NDI', 'Atributos', 'Propiedades'])
        return df
    else:
        return pd.DataFrame({'Mensaje': ['No se encontró información para la selección']})


# Crear la aplicación de Streamlit con el tamaño de título personalizado
#st.markdown("<h1 style='text-left: center; font-size: 35px;'>Revisor de Modelos IFC</h1>", unsafe_allow_html=True)

# Definir las listas de tipos de modelo y niveles de avance
tipos_modelo = ["Sitio", "Volumetrico", "Arquitectura","Estructura",
               "MEP", "Coordinacion", "Construccion", "As-Built", "Operacion"]

nivel_avance = ["DC", "DA", "DB", "DD", "CC", "CM","AB","PM","GM"]

# Etiqueta para el tipo de modelo
st.write("Seleccione el tipo de modelo:")
tipo_modelo = st.selectbox("Tipo de Modelo:", tipos_modelo)

# Etiqueta para el nivel de avance
st.write("Seleccione el EAIM:")
nivel_avance = st.selectbox("EAIM:", nivel_avance)

data = cargar_datos_desde_json(tipo_modelo, nivel_avance)   
 
# Agrega un botón de "Aceptar"
if st.button("Aceptar"):
    st.write("Entidades, atributos y propiedades minimas de EBPP")
    # Código que se ejecutará cuando se presione el botón
    resultado_df = obtener_informacion(data, tipo_modelo, nivel_avance)
    #st.write(resultado_df)  # Muestra el resultado en la aplicación

resultado_df = obtener_informacion(data, tipo_modelo, nivel_avance)

    
# Crear la aplicación de Streamlit con el tamaño de título personalizado
st.markdown("<h1 style='text-left: center; font-size: 20px;'>Cargar Modelo IFC</h1>", unsafe_allow_html=True)
#st.write("Seleccione y cargue el modelo ifc que desea validar:")

def get_objects_data_by_class(entity):
    psets = Element.get_psets(entity)
    attribute_names = [attribute for attribute in dir(entity) if not attribute.startswith("_")]
    
    # Initialize a dictionary to store properties grouped by Pset name
    propiedades_dict = {}

    for pset_name, properties in psets.items():
        propiedades = []
        for property_name, property_value in properties.items():
            if isinstance(property_value, ifcopenshell.entity_instance):
                property_value = property_value.Name
            propiedades.append(property_name)
        propiedades_dict[pset_name] = propiedades

    object_data = {
        'Entidad': entity.is_a(),
        'Atributos': ', '.join(attribute_names),
        'Propiedades': propiedades_dict,
    }

    return object_data

class_type = "IfcProduct"  # Change this to the desired class

def main():
    df_Ifc = None
    tmp_filename = None
    
    archivo_subido = st.file_uploader("Seleccione y cargue el modelo ifc que desea validar:", type=["ifc"])

    if archivo_subido is not None:
        with tempfile.NamedTemporaryFile(delete=False) as tmp_file:
            tmp_file.write(archivo_subido.read())
            tmp_filename = tmp_file.name

        modelo = ifcopenshell.open(tmp_filename)
        entity_list = modelo.by_type(class_type)  # Use 'class_type' here
        entity_data_list = [get_objects_data_by_class(entidad) for entidad in entity_list]

        df = pd.DataFrame(entity_data_list)
        df_Ifc = df.drop_duplicates(subset=["Entidad", "Atributos"])

        # Eliminar el archivo temporal
        #os.unlink(tmp_filename)

    # Return the DataFrame df_Ifc
    return df_Ifc

df_Ifc  = main()



# Cargar el primer DataFrame
df1 = resultado_df
#st.write(df1)
# Cargar el segundo DataFrame
df2 = df_Ifc
#st.write(df2)

st.markdown("<h1 style='text-left: center; font-size: 20px;'>Iniciar validación</h1>", unsafe_allow_html=True)
st.write("Haga click en Validar IFC para obtener estadísticas de cumplimiento de su modelo")  

# Inicializar un nuevo DataFrame para resumir los resultados
resumen = pd.DataFrame(columns=['Entidad', 'Entidad_existe_si/no', 'Atributos', 'Atributos_existe_si/no'])

#color del boton validar
def ChangeButtonColour(widget_label, font_color, background_color='transparent'):
    htmlstr = f"""
        <script>
            var elements = window.parent.document.querySelectorAll('button');
            for (var i = 0; i < elements.length; ++i) {{ 
                if (elements[i].innerText == '{widget_label}') {{ 
                    elements[i].style.color ='{font_color}';
                    elements[i].style.background = '{background_color}'
                }}
            }}
        </script>
        """
    components.html(f"{htmlstr}", height=0, width=0)
    
ChangeButtonColour("Validar IFC", "#ffffff", "#ff9317") # button txt to find, colour to assign   


# Crear un botón de validación
if st.button("Validar IFC"):

    filtro_del_modelo = pd.DataFrame(columns=['Entidad', 'Entidad valida en EBPP'])
    # Revisar las entidades
    for entidad in df2['Entidad']:
        if entidad in df1['Entidad'].values:
            x = 'Si'
        else:
            x = 'Entidad no valida en EBPP'
        row = pd.DataFrame({'Entidad': [entidad], 'Entidad valida en EBPP': [x]})
        filtro_del_modelo = pd.concat([filtro_del_modelo, row], ignore_index=True)

    # Mostrar el resumen de propiedades en Streamlit
    st.write("Resultados de Validación entidades del modelo cargado:")
    st.dataframe(filtro_del_modelo, width=1000)
 
    # Revisar las entidades
    for entidad in df1['Entidad']:
        if entidad in df2['Entidad'].values:
            cumple_entidad = 'Si'
        else:
            cumple_entidad = 'La entidad no existe en el modelo'
        row = pd.DataFrame({'Entidad': [entidad], 'Entidad_existe_si/no': [cumple_entidad]})
        resumen = pd.concat([resumen, row], ignore_index=True)

    # Revisar los atributos
    for entidad, atributos in zip(df1['Entidad'], df1['Atributos']):
        if entidad in df2['Entidad'].values:
            # Dividir los atributos de df2 en una lista
            atributos_df2 = df2[df2['Entidad'] == entidad]['Atributos'].iloc[0].split(", ")
            
            # Verificar si alguno de los atributos en df1 coincide con los atributos en df2
            if any(atributo in atributos_df2 for atributo in atributos.split(', ')):
                cumple_atributo = 'Si'
                
            else:
                cumple_atributo = 'No'

        else:
            cumple_atributo = 'No'  # Si la entidad no existe en df2, los atributos tampoco pueden existir
      
        resumen.loc[resumen['Entidad'] == entidad, 'Atributos'] = atributos
        resumen.loc[resumen['Entidad'] == entidad, 'Atributos_existe_si/no'] = cumple_atributo

    # Rellenar los valores faltantes en el DataFrame de resumen2
    resumen.fillna('N/A', inplace=True)

    # Mostrar el resumen de propiedades en Streamlit
    st.write("Resultados de Validación de entidades y atributos validos:")
    st.write(resumen)
   
    # Datos del DataFrame 1
    data_df1 = {
        'Entidad': df1['Entidad'],
        #'Grupo de Propiedades': df1['Propiedades'].apply(lambda x: set(x.keys())),
        'Propiedades': df1['Propiedades'].apply(lambda x: ', '.join([f'{key}: {value}' for key, value in x.items()]))
    }
    df1_nuevo = pd.DataFrame(data_df1)

    # Datos del DataFrame 2
    data_df2 = {
        'Entidad': df2['Entidad'],
        #'Grupo de Propiedades': df2['Propiedades'].apply(lambda x: set(x.keys())),
        'Propiedades': df2['Propiedades'].apply(lambda x: ', '.join([f'{key}: {value}' for key, value in x.items()]))
    }
    df2_nuevo = pd.DataFrame(data_df2)
      
    #st.write(df1_nuevo)
    #st.write(df2_nuevo)
    
    # Encontrar grupos que coinciden y que no coinciden
    grupos_coinciden = df1_nuevo[df1_nuevo.apply(lambda x: x['Entidad'] in df2_nuevo['Entidad'].values, axis=1)]
    grupos_no_coinciden1 = df1_nuevo[~df1_nuevo['Entidad'].isin(df2_nuevo['Entidad'].values)]
    #grupos_no_coinciden2 = df2_nuevo[~df2_nuevo['Entidad'].isin(df1_nuevo['Entidad'].values)]
    #st.write(grupos_coinciden)
    st.write("Propiedades que falta agregar por entidad:")
    st.write(grupos_no_coinciden1)
    
    
    propiedades1= grupos_coinciden
    propiedades2 = df2_nuevo
    
    #st.write(propiedades1)
    #st.write(propiedades2)
    
    # Función para extraer grupos y propiedades de la cadena
    def extraer_grupos_propiedades(cadena):
        grupos_propiedades = re.findall(r"(\w+): \[(.*?)\]", cadena)
        resultado = {}
        for grupo, propiedades in grupos_propiedades:
            resultado[grupo] = propiedades.split(', ')
        return resultado
 
    # Crear una lista para almacenar los datos
    data = []

    # Iterar a través de las filas de propiedades1
    for index, row in propiedades1.iterrows():
        entidad = row['Entidad']
        propiedades_grupo1 = extraer_grupos_propiedades(row['Propiedades'])
        
        # Iterar sobre los grupos y propiedades en el grupo
        for grupo, propiedades in propiedades_grupo1.items():
            if entidad in propiedades2['Entidad'].values:
                propiedades_grupo2 = extraer_grupos_propiedades(propiedades2[propiedades2['Entidad'] == entidad]['Propiedades'].values[0])
                coincide_grupo = "Si" if grupo in propiedades_grupo2 else "No"
                
                propiedades_coinciden = []
                for propiedad in propiedades:
                    if propiedad in propiedades_grupo2.get(grupo, []):
                        coincide_propiedad = "Si"
                    else:
                        coincide_propiedad = "No"
                    propiedades_coinciden.append((propiedad, coincide_propiedad))
            else:
                coincide_grupo = "No"
                propiedades_coinciden = [(propiedad, "No") for propiedad in propiedades]

            data.extend([(entidad, grupo, coincide_grupo, prop, coincide_prop) for prop, coincide_prop in propiedades_coinciden])

    # Crear el DataFrame
    df = pd.DataFrame(data, columns=["Entidad", "Grupo", "Grupo_coincide_si/no_EBPP", "Propiedad", "Propiedad_coincide_si/no_EBPP"])
    
    st.write("Resultados de Validación: grupos de propiedades y propiedades:")
    # Imprimir el DataFrame
    st.write(df)
    
   
     
    # Definir los colores que deseas usar para cada sección
    colores = ['#1f77b4', '#ff7f0e']  # Puedes cambiar estos códigos de color según tus preferencias
    
    
    # Crear un DataFrame a partir de resultados_df
    resultados_df_dataframe = pd.DataFrame(resumen)
    
    # Realizar estadísticas simples sobre resultados_df_dataframe
    if not resultados_df_dataframe.empty:
        st.subheader("Estadísticas sobre los resultados")
        num_coincidencias = len(resultados_df_dataframe[resultados_df_dataframe['Entidad_existe_si/no'] == "Si"])
        num_diferencias = len(resultados_df_dataframe[resultados_df_dataframe['Entidad_existe_si/no'] == "La entidad no existe en el modelo"])
        # Crear un gráfico de anillo con Plotly para las estadísticas globales
        anillo = px.pie(
            names=["La entidad existe en el modelo", "La entidad no existe en el modelo"],
            values=[num_coincidencias, num_diferencias],
            hole=0.4,  # Controla el tamaño del agujero en el centro del gráfico (0.4 significa un donut)
            color_discrete_sequence=colores,  # Especifica los colores personalizados aquí
            labels={"names": "Estadisitcas del modelo"}
        )
            # Personalizar el diseño del gráfico
        anillo.update_layout(
            title='Cumplimiento del modelo según EBPP '
            )
        # Mostrar el gráfico de anillo en Streamlit
        st.plotly_chart(anillo)

    
    # Calcular el recuento de cada tipo en 'Entidad_existe_si/no'
    counts = resultados_df_dataframe['Entidad_existe_si/no'].value_counts()
    # Definir los colores que deseas usar para cada sección
    colores = ['#1f77b4', '#ff7f0e']  # Puedes cambiar estos códigos de color según tus preferencias
    # Filtrar el DataFrame para obtener los nombres de entidades donde 'Entidad_existe_si/no' es igual a 'Si'
    nombres_entidades = resumen[resumen['Entidad_existe_si/no'] == 'Si']['Entidad']
    nombres_entidades2 = resumen[resumen['Entidad_existe_si/no'] == 'La entidad no existe en el modelo']['Entidad']
    serie_de_nombres = pd.Series(nombres_entidades)
    serie_de_nombres2 = pd.Series(nombres_entidades2)
    # Concatena los elementos de la serie en un solo texto
    texto_concatenado = serie_de_nombres.str.cat(sep=',')
    texto_concatenado1 = serie_de_nombres2.str.cat(sep=',')   

    # Crear el gráfico de barras personalizado con los valores numéricos encima de las barras y colores personalizados
    fig = go.Figure()
    
    for index, row in counts.items():
        color_barra = colores.pop(0)  # Obtener el próximo color de la lista
        entidad_name = nombres_entidades if index == 'Si' else nombres_entidades2
        entidad_name = ', '.join(entidad_name)  # Convierte la lista en una cadena separada por comas
        fig.add_trace(go.Bar(
            x=[index],
            y=[row],
            text=[row],  # Agregar el valor numérico encima de la barra
            textposition=['outside'],  # Posicionar el valor fuera de la barra
            name=str(index),  # Usar el valor como etiqueta
            marker_color=color_barra  # Establecer el color de la barra
        ))

    # Personalizar el diseño del gráfico
    fig.update_layout(
        xaxis_title='Cumplimiento',
        yaxis_title='N° de Clases',   #[f"{index} ({entidad_name})"]
        title='Cumplimiento por Entidades',
        yaxis_title_text="N° de Clases"
    )
    
    st.write("Entidades que cumplen: "+texto_concatenado) 
    st.write("Entidades que no cumplen: "+texto_concatenado1) 
    # Mostrar el gráfico de barras en Streamlit
    #st.plotly_chart(fig)
    
       
    # Crear un DataFrame a partir de resultados_df
    df = pd.DataFrame(df)

    # Realizar estadísticas y crear un gráfico de barras apilado con Plotly
    fig1 = go.Figure()

    # Agrupar los datos y crear un gráfico de barras apilado
    grouped = df.groupby(['Entidad', 'Grupo_coincide_si/no_EBPP']).size().reset_index(name='Cantidad')
    fig1 = px.bar(grouped, x='Entidad', y='Cantidad', color='Grupo_coincide_si/no_EBPP',color_discrete_sequence=['#1f77b4', 'lightblue'])

    # Personalizar el diseño del gráfico
    fig1.update_layout(
        xaxis_title='Entidad',
        yaxis_title='Cumplimiento',
        title='Cumplimiento de grupos de propiedades por entidades existentes en el modelo',
    )
    
    fig1.update_traces(texttemplate='%{y}', textposition='outside')

    # Mostrar el gráfico con st.plotly_chart en Streamlit
    st.plotly_chart(fig1)
    
    # Crear un DataFrame a partir de resultados_df
    df = pd.DataFrame(df)

    # Realizar estadísticas y crear un gráfico de barras apilado con Plotly
    barra_propiedades = go.Figure()

    # Agrupar los datos y crear un gráfico de barras apilado
    grouped = df.groupby(['Grupo', 'Propiedad_coincide_si/no_EBPP']).size().reset_index(name='Cantidad')
    barra_propiedades = px.bar(grouped, x='Grupo', y='Cantidad', color='Propiedad_coincide_si/no_EBPP',color_discrete_sequence=['#1f77b4', 'lightblue'])

    # Personalizar el diseño del gráfico
    barra_propiedades.update_layout(
        xaxis_title='Entidad',
        yaxis_title='Cumplimiento',
        title='Cumplimiento propiedades por grupo de propiedades',
        margin=dict(l=50, r=50, b=250, t=50)  # Márgenes izquierdo, derecho, inferior y superior
    )

    # Agregar el valor numérico encima de cada barra
    barra_propiedades.update_traces(texttemplate='%{y}', textposition='inside')

    # Mostrar el gráfico con st.plotly_chart en Streamlit
    st.plotly_chart(barra_propiedades)
    
           
    nombre = f'resultados_validacion_{tipo_modelo}_{nivel_avance}.xlsx'     
    # Crear un escritor Excel para guardar los DataFrames en hojas diferentes
    with pd.ExcelWriter(nombre, engine='xlsxwriter') as writer:
        filtro_del_modelo.to_excel(writer, sheet_name='revisón de entidades')
        resumen.to_excel(writer, sheet_name='Resumen_entidades')
        df.to_excel(writer, sheet_name='Resumen_Propiedades')
        grupos_no_coinciden1.to_excel(writer, sheet_name='entidades_propiedades_faltantes')
    
    # Generar el enlace para descargar el archivo Excel
    if os.path.isfile(nombre):
        with open(nombre, 'rb') as f:
            excel_data = f.read()
        b64 = base64.b64encode(excel_data).decode()
        href = f'<a href="data:file/excel;base64,{b64}" download="{nombre}">Descargar Resultados de Validación (Excel)</a>'
        st.markdown(href, unsafe_allow_html=True)
    else:
        st.error(f"El archivo {nombre} no se encuentra en el directorio.")

    # Función para crear enlaces de descarga
    def get_binary_file_downloader_html(bin_file, file_label='Archivo', file_extension='xlsx'):
        if os.path.isfile(bin_file):
            with open(bin_file, 'rb') as f:
                data = f.read()
            bin_str = base64.b64encode(data).decode()
            href = f'<a href="data:file/{file_extension};base64,{bin_str}" download="{file_label}.{file_extension}">Descargar {file_label}</a>'
            return href
        else:
            return f"El archivo {bin_file} no se encuentra en el directorio."