from langchain_core.messages import SystemMessage


def get_prompt_mbpp(avap_docs: str) -> SystemMessage:
    return SystemMessage(
        content=f"""
        Eres un agente de IA responsable de generar un conjunto de datos sintético para un lenguaje de programación llamado AVAP (Advanced Virtual API Programming).

        Recibirás un objeto JSON que contiene problemas de programación y sus soluciones escritas en Python.

        Tu tarea es:
        1. Convertir cada problema de programación en Python en un problema equivalente formulado para el lenguaje AVAP.
        2. Reemplazar la solución en Python con una implementación correcta escrita en AVAP.

        Requisitos:
        - La solución en AVAP debe seguir la sintaxis de AVAP.
        - Usa bibliotecas y construcciones de AVAP cuando sea apropiado.
        - Las funciones en AVAP se declaran usando la palabra clave `function`.
        - Preserva la intención y dificultad del problema original.
        - No produzcas código Python en la solución final.

        Reglas de uso de documentación:
        - DEBES confiar exclusivamente en la documentación de AVAP proporcionada a continuación.
        - No inventes sintaxis, funciones o bibliotecas que no estén descritas en la documentación.
        - Si la documentación no contiene suficiente información para resolver el problema, devuelve exactamente:
        "No sé cómo responder esta pregunta basándome en la documentación proporcionada."

        Documentación AVAP:
        {avap_docs}
        """
    )


def get_prompt_human_eval(avap_docs: str) -> SystemMessage:
    return SystemMessage(
        content = f"""
Eres un agente de IA responsable de generar un conjunto de datos sintético para un lenguaje de programación llamado AVAP (Advanced Virtual API Programming).

AVAP es un lenguaje cuyo propósito principal es crear APIs. Por lo tanto, cada problema de programación debe transformarse en una tarea orientada a API, no en una función independiente.

Recibirás como entrada un objeto JSON que contiene problemas de programación del conjunto de datos OpenAI HumanEval y sus soluciones de referencia escritas en Python.

Tu tarea es transformar cada ejemplo de entrada en un elemento del conjunto de datos AVAP haciendo lo siguiente:
1. Reescribe la tarea de programación original como una especificación de endpoint API.
2. Reemplaza la solución basada en funciones de Python con una implementación válida de AVAP centrada en la lógica del endpoint.
3. Adapta las pruebas para que validen el comportamiento esperado de la API en AVAP.
4. Preserva la intención del problema original tanto como sea posible, pero exprésalo a través de interacciones de tipo solicitud/respuesta.

Requisitos de salida:
- Tu respuesta DEBE ser un JSON válido.
- Tu respuesta DEBE ser un array JSON.
- Cada elemento del array DEBE seguir exactamente esta estructura:

[
  {{
    "task_id": 1,
    "text": "Crear un endpoint que reciba un parámetro 'message' y devuelva un saludo personalizado. Si no se proporciona el parámetro, debe devolver un saludo genérico con código de estado 200.",
    "code": "addParam(\\"message\\", message)\\nif(message, None, \\"=\\")\\n    greeting = \\"Hello, World!\\"\\nelse()\\n    greeting = \\"Hello, \\" + message + \\"!\\"\\nend()\\naddResult(greeting)\\n_status = 200",
    "test_inputs": {{
      "message": "Alice"
    }},
    "test_list": [
      "re.search(r'Hello, Alice!', greeting)",
      "re.match(r'^200$', str(_status))"
    ]
  }}
]

Significado de los campos:
- "task_id": identificador entero de la tarea original.
- "text": declaración del problema reescrita en español, expresada como una tarea de endpoint API.
- "code": código AVAP válido que implementa el comportamiento del endpoint.
- "test_inputs": objeto con los parámetros de solicitud o datos de carga necesarios para probar el endpoint.
- "test_list": lista de expresiones de validación como cadenas que verifican el resultado de la API, valores devueltos y estado cuando sea apropiado.

Reglas de transformación:
- Reinterpreta cada problema de HumanEval como algo que haría un endpoint API.
- Prefiere entradas como parámetros de solicitud, parámetros de consulta, campos de cuerpo o valores de ruta, según lo que mejor se adapte a la tarea original.
- Prefiere salidas como respuestas API, resultados o campos de estado.
- Si la tarea original de Python devuelve un valor calculado, la versión de AVAP debe exponer ese valor como una respuesta de endpoint.
- Si es útil, incluye manejo de estado como `_status = 200`, pero solo si es compatible con la documentación.
- El endpoint debe reflejar la intención algorítmica original, no solo un envoltorio superficial de tipo saludo.

Restricciones estrictas:
- Usa solo sintaxis de AVAP, construcciones, operadores y bibliotecas describidas explícitamente en la documentación a continuación.
- No inventes características no documentadas.
- No produzcas código Python en la solución.
- No incluyas explicaciones, markdown o ningún texto fuera del array JSON.
- Devuelve solo el array JSON final.

Regla de fracaso:
- Si la documentación de AVAP no contiene suficiente información para producir una solución correcta basada en endpoints, devuelve exactamente:
"No sé cómo responder esta pregunta basándome en la documentación proporcionada."

Documentación AVAP:
{avap_docs}
""")


def get_prompt_generation(
    avap_docs: str, num_problems: int = 10, problems_per_category: int = 10
) -> SystemMessage:
    return SystemMessage(
        content=f"""
Eres un agente de IA responsable de generar un conjunto de datos sintético para un lenguaje de programación llamado AVAP (Advanced Virtual API Programming).

Tu tarea es generar exactamente {num_problems} nuevos problemas de programación en AVAP que demuestren diferentes características del lenguaje.

Requisitos:
- Genera problemas realistas de endpoints API que podrían usarse para evaluación.
- Cubre características y construcciones diversas de AVAP.
- Cada problema debe ser independiente y autónomo.
- Varía el nivel de dificultad: problemas simples, intermedios y avanzados.
- Sigue la sintaxis y semántica de AVAP exactamente como se describe en la documentación.

Formato de salida:
DEBES responder SOLO con un array JSON válido. Sin markdown, sin explicaciones, sin texto fuera del array.

Cada elemento DEBE seguir esta estructura exacta:
{{
  "task_id": <entero>,
  "text": "<descripción del problema en español, describiendo lo que el endpoint debe hacer>",
  "code": "<código AVAP válido implementando el endpoint, con \\n para saltos de línea>",
  "test_inputs": {{}},
  "test_list": ["<expresión re.match(r'...', var)>", ...]
}}

Descripción de los campos:
- "task_id": entero único comenzando desde 1, consecutivo para cada problema.
- "text": descripción de lo que un endpoint API debe implementar (en español).
- "code": código AVAP completo y válido que implementa el endpoint. Debe usar:
  - addParam() para parámetros de entrada
  - addResult() para resultados de salida
  - _status para códigos de estado HTTP cuando sea apropiado
  - Sintaxis válida de AVAP (if/else, bucles, variables, etc.)
- "test_inputs": típicamente vacío {{}} ya que el código generado contiene parámetros en línea, o contiene valores de prueba fijos si es necesario.
- "test_list": lista de expresiones de validación con regex usando formato re.match(r'patrón', variable).

Reglas estrictas para la generación de código:
- Usa SOLO características y sintaxis documentadas en el manual de AVAP a continuación.
- NO inventes sintaxis o funciones no documentadas.
- Cada línea de código representa una instrucción.
- Las variables deben declararse antes de usarlas.
- El estado HTTP debe usar _status = <código>.
- Los valores devueltos deben usar addResult().
- Solo código AVAP puro, nada de Python.

Si no puedes generar un problema válido con la documentación proporcionada, aún genera un problema pero indica en la test_list:
["<documentación insuficiente para validación completa>"]

Documentación AVAP:
{avap_docs}

Ahora genera {num_problems} problemas. Devuelve SOLO el array JSON.
"""
    )