import streamlit as st
import openai
import random
import os

# Configurar la API key de OpenAI desde la variable de entorno
openai.api_key = os.environ.get("OPENAI_API_KEY")

# Verificar si la API key está configurada
if not openai.api_key:
    st.error("La API key de OpenAI no está configurada. Por favor, configúrala en las variables de entorno.")
    st.stop()

# El resto del código permanece igual
contexto = """
CONCEPTOS BÁSICOS UAS, RPAS, drone o aeromodelo:
Se usan diferentes términos para referirnos a las aeronaves no tripuladas, pero ¿qué diferencias hay entre ellos?
• Aeronave no tripulada o RPA (Remotely Piloted Aircraft): Cualquier aeronave que opere o esté diseñada para operar de forma autónoma o para ser pilotada a distancia sin un piloto a bordo. Este RPA, es también llamado DAOD por DINACIA (Dispositivo aéreo operado a distancia)
• Dron (drone en inglés): Palabra coloquialmente usada para referirse en general a todas las aeronaves no tripuladas, debido a su similitud con un zumbido de Abejorro es otra forma de nombrar a los RPA
• Aeromodelo: Aeronave de tamaño reducido pilotado a distancia usada principalmente para vuelos deportivos o experimentales. También puede ser un RPA
• RPAS «sistema de aeronave pilotada por control remoto»: Aeronave pilotada a distancia, su sistema de vuelo, su estación, los enlaces requeridos de mando y control y cualquier otro componente según lo indicado en el diseño de la aeronave.
• UAV « aeronave no tripulada»: Aeronave no tripulada, que tiene la capacidad de volar autónomamente y el equipo para controlarla de forma remota.
• UAS «Unmanned Aircraft System»: El término UAS engloba los RPAS y las aeronaves autónomas es un término más genérico que se refiere a cualquier sistema de aeronaves no tripuladas, incluidos RPAS y UAV. (el piloto a distancia no puede intervenir durante el vuelo).
"""

def generar_preguntas(num_preguntas=38):
    prompt = f"""Basándote en el siguiente contexto sobre drones y aeronaves no tripuladas, genera {num_preguntas} preguntas de opción múltiple. 
    Cada pregunta debe tener tres opciones de respuesta y solo una debe ser correcta. 
    Devuelve las preguntas en formato JSON como una lista de diccionarios, donde cada diccionario contenga las claves 'pregunta', 'opciones' (lista de 3 opciones), y 'respuesta_correcta' (índice de la opción correcta, 0, 1 o 2).

    Contexto:
    {contexto}
    """

    response = openai.ChatCompletion.create(
        model="gpt-4o-mini",  # Asegúrate de que este es el nombre correcto del modelo
        messages=[{"role": "system", "content": prompt}],
        temperature=0.7,
    )

    # Asumimos que la respuesta está en formato JSON y la parseamos
    import json
    preguntas = json.loads(response.choices[0].message.content)
    return preguntas

def evaluar_respuestas(preguntas, respuestas_usuario):
    correctas = 0
    resultados = []
    for i, (pregunta, respuesta_usuario) in enumerate(zip(preguntas, respuestas_usuario)):
        if respuesta_usuario == pregunta['respuesta_correcta']:
            correctas += 1
            resultados.append(f"Pregunta {i+1}: Correcta")
        else:
            resultados.append(f"Pregunta {i+1}: Incorrecta. La respuesta correcta era: {pregunta['opciones'][pregunta['respuesta_correcta']]}")
    return correctas, resultados

# Aplicación Streamlit
st.title("Cuestionario de Drones")

# Inicializar o cargar preguntas
if 'preguntas' not in st.session_state:
    st.session_state.preguntas = generar_preguntas()

# Botón para generar nuevas preguntas
if st.button("Generar nuevas preguntas"):
    st.session_state.preguntas = generar_preguntas()
    st.session_state.respuestas_enviadas = False

# Formulario para las preguntas
with st.form("quiz_form"):
    respuestas_usuario = []
    for i, pregunta in enumerate(st.session_state.preguntas):
        st.write(f"**Pregunta {i+1}:** {pregunta['pregunta']}")
        respuesta = st.radio(f"Selecciona una opción para la pregunta {i+1}:", 
                             pregunta['opciones'], 
                             key=f"pregunta_{i}")
        respuestas_usuario.append(pregunta['opciones'].index(respuesta))

    submitted = st.form_submit_button("Enviar respuestas")

# Evaluar respuestas cuando se envía el formulario
if submitted:
    st.session_state.respuestas_enviadas = True
    st.session_state.correctas, st.session_state.resultados = evaluar_respuestas(st.session_state.preguntas, respuestas_usuario)

# Mostrar resultados
if st.session_state.get('respuestas_enviadas', False):
    st.write(f"Has acertado {st.session_state.correctas} de {len(st.session_state.preguntas)} preguntas.")
    for resultado in st.session_state.resultados:
        st.write(resultado)