import gradio as gr
import json
from llama_cpp import Llama
import spacy

class ProcesadorAutodiagnostico:
    def __init__(self):
        # Initialize Llama model
        self.llm = Llama(
            model_path="./models/llama-2-7b-chat.gguf",  # We'll need to specify the correct path
            n_ctx=2048,  # Context window
            n_threads=4  # Adjust based on available resources
        )
        self.nlp = spacy.load("es_core_news_sm")
        
    def generar_prompt(self, texto: str) -> str:
        return f"""Analiza el siguiente texto y extrae información estructurada para un autodiagnóstico.
El texto describe un reto o proyecto relacionado con tecnologías cognitivas.

Texto: {texto}

Genera un JSON con la siguiente estructura, manteniendo solo la información relevante encontrada en el texto:
{{
    "datos_generales": {{
        "sector": "",
        "ubicacion": ""
    }},
    "reto": {{
        "descripcion": "",
        "contexto": "",
        "alcance": ""
    }},
    "conocimientos_cogtech": {{
        "terminos_desconocidos": [],
        "conceptos_dudosos": [],
        "areas_desconfianza": []
    }},
    "dominio_actual": {{
        "aspectos_dominados": [],
        "experiencia_previa": [],
        "recursos_disponibles": []
    }},
    "entrampes": {{
        "tecnicos": [],
        "implementacion": [],
        "organizacionales": []
    }},
    "objetivos": {{
        "corto_plazo": [],
        "esperados_microtaller": []
    }}
}}

Asegúrate de:
1. Identificar términos técnicos que generan dudas
2. Detectar preocupaciones y áreas de desconfianza
3. Identificar objetivos explícitos e implícitos
4. Clasificar correctamente los entrampes
5. Mantener el contexto del sector y ubicación

JSON:"""

    def procesar_texto(self, texto: str) -> dict:
        # Generate prompt
        prompt = self.generar_prompt(texto)
        
        # Get completion from LLaMa
        response = self.llm(
            prompt,
            max_tokens=2048,
            temperature=0.1,  # Low temperature for more consistent results
            top_p=0.9,
            stop=["```"]  # Stop at code blocks if any
        )
        
        try:
            # Parse the response as JSON
            resultado = json.loads(response['choices'][0]['text'])
            
            # Post-process with spaCy if needed
            doc = self.nlp(texto)
            # Add any additional processing here
            
            return resultado
        except json.JSONDecodeError:
            # Fallback in case of invalid JSON
            return {
                "error": "No se pudo procesar el texto correctamente",
                "texto_original": texto
            }

def procesar_con_gradio(texto_input: str) -> str:
    """Wrapper function for Gradio interface"""
    procesador = ProcesadorAutodiagnostico()
    try:
        resultado = procesador.procesar_texto(texto_input)
        return json.dumps(resultado, indent=2, ensure_ascii=False)
    except Exception as e:
        return json.dumps({
            "error": f"Error en el procesamiento: {str(e)}",
            "texto_original": texto_input
        }, indent=2, ensure_ascii=False)

# Create the Gradio interface
with gr.Blocks() as app:
    gr.Markdown("# Autodiagnóstico CogTech")
    gr.Markdown("""
    ## Instrucciones
    Describe tu situación considerando:
    - Tu reto o necesidad principal
    - Qué conoces y qué dudas tienes sobre tecnologías cognitivas
    - Qué obstáculos o dificultades enfrentas
    - Qué esperas lograr
    """)
    
    with gr.Row():
        texto_input = gr.Textbox(
            label="Tu descripción",
            placeholder="Describe tu situación...",
            lines=10
        )
        json_output = gr.JSON(label="Autodiagnóstico Estructurado")
    
    analizar_btn = gr.Button("Generar Autodiagnóstico")
    analizar_btn.click(
        fn=procesar_con_gradio,
        inputs=texto_input,
        outputs=json_output
    )

if __name__ == "__main__":
    app.launch(share=True)