from core.controllers.pages_controller import Page
from core.controllers.main_process import Generador


class Home(Page):
    variables_globales = {
        "img_bytes": None,
        "img_src": None,
        "settings": {
            "model": str("google/vit-base-patch16-224"),
            "tokenizer": str("google/vit-base-patch16-224"),
        },
        "img_output": None,
        "predicciones": None,
    }
    archivos_css = ["main",
                    "home"]

    def __init__(self, title=str("Bienvenido"), icon=str("🖼️"), init_page=False):
        super().__init__()
        if init_page:
            self.new_page(title=title,
                          icon=icon)
        self.init_globals(globals=self.variables_globales)
        for archivo in self.archivos_css:
            self.cargar_css(archivo_css=archivo)

    def obtener_bytes(self, archivo):
        self.set_global(key='img_src',
                        value=archivo)

    def actualizar_modelo_tokenizer(self, modelo, tokenizer):
        self.set_global(key='settings',
                        value={'model': modelo,
                               'tokenizer': tokenizer})

    def procesar_imagen(self):
        proceso = Generador(configuraciones=self.get_global('settings'))
        proceso.generar_prediccion(imagen_bytes=self.imgg.open(
            self.get_global('img_src')).convert("RGB"))
        self.set_global(key='predicciones', value=proceso.prediccion)

    def expander_instrucciones(self, placeholder):
        instrucciones = placeholder.expander(expanded=False,
                                             label="Instrucciones")
        instrucciones.markdown(unsafe_allow_html=False,
                               help=None,
                               body="""
                               1.   **Cargue su Imagen Base**:

                               Elija cualquiera de las dos opciones para cargar su imagen:

                               *    **Desde su Galería**: cargue la imagen desde la galería de su teléfono o computadora.

                               *    **Desde su Cámara**: cargue la imagen directamente desde la cámara de su teléfono o computadora.


                               2.   **Clasificar / Predecir**:

                               Realice la **clasificación de su imagen** con base a las predicciones realizadas por el **modelo** pre-entrenado seleccionado.

                               A partir del dataset con el que fue pre-entrenado el modelo, tratará de predecir cuales son los objetos en la imagen cargada.


                               *    **Configuraciones Avanzadas**:

                               *Elija un modelo y procesador de la lista disponible, o elija uno directamente de la base de modelos disponible en HuggingFace.*
                               """)

    def expander_imagen_base(self, placeholder):
        imagen_base = placeholder.container()
        imagen_base.markdown(unsafe_allow_html=False,
                             help=None,
                             body="""
                             **Cargue su Imagen Base**:
                             """)
        archivo_expander = imagen_base.expander(expanded=False,
                                                label="Desde su Galería")
        _archivo = archivo_expander.file_uploader(label="Galería",
                                                  on_change=None,
                                                  accept_multiple_files=False,
                                                  label_visibility="visible")
        if (archivo_expander.button(label="Cargar Archivo", type="secondary", use_container_width=True,
                                    help="Suba un archivo.") and _archivo is not None):
            self.obtener_bytes(_archivo)

        camara_expander = imagen_base.expander(expanded=False, 
                                               label="Desde su Cámara")
        _captura = camara_expander.camera_input(label="Cámara",
                                                on_change=None,
                                                label_visibility="visible")
        if (camara_expander.button(label="Cargar Captura", type="secondary", use_container_width=True,
                                   help="Tome una fotografía.") and _captura is not None):
            self.obtener_bytes(_captura)

    def expander_configuraciones(self, placeholder):
        configuraciones = placeholder.expander(
            expanded=False, label="Configuraciones Avanzadas")
        modelo = configuraciones.text_input(
            label="MODELO", on_change=None, label_visibility="visible",
            value=self.get_global('settings').get('model'))
        tokenizer = configuraciones.text_input(
            label="TOKENIZER", on_change=None, label_visibility="visible",
            value=self.get_global('settings').get('tokenizer'))

        if configuraciones.button(label="Configurar", type="secondary", use_container_width=True,
                                  help="Actualice configuraciones"):
            self.actualizar_modelo_tokenizer(modelo, tokenizer)

    def resultados(self, placeholder):
        resultados = placeholder.container()

        if self.get_global('img_src', None) is not None:
            resultados.image(
                image=self.get_global('img_src').getvalue(),
                caption="Su resultado",
                use_column_width="auto",
                channels="RGB",
                output_format="auto"
            )
            if self.get_global('predicciones', None) is not None:
                resultados.success(body=self.get_global(
                    'predicciones'), icon=None)

    def agregar_card_base(self, columna):
        card_principal = columna.container()

        columna_inputs, columna_outputs = card_principal.columns(
            [0.3, 0.7], gap="small")

        self.expander_instrucciones(columna_inputs)
        self.expander_imagen_base(columna_inputs)
        self.expander_configuraciones(columna_inputs)
        if columna_inputs.button(label="Clasificar / Predecir", help="Realizar Predicciones",
                                 type="secondary", use_container_width=True):
            self.procesar_imagen()
        self.resultados(columna_outputs)

    def build(self):
        
        columna_principal = self.get_body().columns(1, gap="small")[0]
        self.agregar_card_base(columna_principal)


if __name__ == "__main__":
    Home(init_page=True).build()