"""
reproducibility/src/agent_runner.py
-----------------------------------
ReAct Agent execution runner for NORA agent-memory experiments.
Powers live LLM inference with google/gemini-2.5-flash-lite via OpenAI-compatible APIs (OpenRouter).

Conditions supported:
  - M0: Parametric baseline (no external memory access; zero context)
  - M1: Chunked unstructured memory (BM25 over 500-char chunks)
  - M2: Full-Node intact memory (BM25 over complete text nodes)
  - M3u: Structured uniform memory (BM25F with equal weights)
  - M3t: Structured tuned memory (BM25F with domain-fitted weights)
"""

import json
import os
import sys
import time
from pathlib import Path
from typing import Dict, Any, List, Optional
from openai import OpenAI

from .memory_backends import build_backend

sys.stdout.reconfigure(encoding='utf-8')

OPENROUTER_BASE_URL = os.getenv("OPENROUTER_BASE_URL", "https://openrouter.ai/api/v1")
MODEL = os.getenv("NORA_AGENT_MODEL", "google/gemini-2.5-flash-lite")

# Prompt instructions
SYSTEM_PROMPT = """\
তুমি একজন বিশেষজ্ঞ যিনি বাংলায় প্রশ্নের উত্তর দেন। তোমার কাছে একটি বাহ্যিক মেমোরি সিস্টেম আছে।

নিয়মাবলী:
১. উত্তর দেওয়ার আগে অবশ্যই retrieve_memory tool ব্যবহার করো।
২. সর্বোচ্চ ২ বার tool ব্যবহার করা যাবে।
৩. শুধুমাত্র retrieved তথ্যের উপর ভিত্তি করে উত্তর দাও।
৪. প্রতিটি তথ্যের পরে সংশ্লিষ্ট Node ID উল্লেখ করো — যেমন [Node: node_id]।
৫. যদি মেমোরিতে পর্যাপ্ত তথ্য না থাকে, লেখো: "স্মৃতিতে পর্যাপ্ত তথ্য পাওয়া যায়নি।"
"""

SYSTEM_PROMPT_M0 = """\
তুমি একজন বিশেষজ্ঞ যিনি বাংলায় প্রশ্নের উত্তর দেন।
নিজের জ্ঞান থেকে সংক্ষিপ্ত ও সরাসরি উত্তর দাও।
"""

TOOLS = [
    {
        "type": "function",
        "function": {
            "name": "retrieve_memory",
            "description": "বাংলায় প্রশ্ন বা কীওয়ার্ড দিয়ে মেমোরি সিস্টেম থেকে প্রাসঙ্গিক তথ্য অনুসন্ধান করে。",
            "parameters": {
                "type": "object",
                "properties": {
                    "query": {
                        "type": "string",
                        "description": "অনুসন্ধানের জন্য বাংলা প্রশ্ন বা মূল কীওয়ার্ড"
                    }
                },
                "required": ["query"]
            }
        }
    }
]


def get_client(api_key: Optional[str] = None) -> OpenAI:
    key = api_key or os.getenv("OPENROUTER_API_KEY")
    if not key:
        raise ValueError(
            "OPENROUTER_API_KEY environment variable is not set. "
            "Please export OPENROUTER_API_KEY before executing live agent calls."
        )
    return OpenAI(base_url=OPENROUTER_BASE_URL, api_key=key, timeout=60.0)


def execute_tool_call(tool_call, backend, top_k: int = 5) -> str:
    fn_name = tool_call.function.name
    if fn_name != "retrieve_memory":
        return f"Unknown tool: {fn_name}"

    try:
        args = json.loads(tool_call.function.arguments)
        q = args.get("query", "")
    except Exception as e:
        return f"Error parsing arguments: {e}"

    if not q or not backend:
        return "কোনো তথ্য পাওয়া যায়নি।"

    results = backend.search(q, top_k=top_k)
    if not results:
        return "মেমোরিতে কোনো প্রাসঙ্গিক তথ্য পাওয়া যায়নি।"

    output_lines = []
    for r in results:
        output_lines.append(f"[Node: {r['node_id']}] (Score: {r['score']:.2f})\n{r['text']}")
    return "\n\n".join(output_lines)


def run_agent_query(
    query_obj: Dict[str, Any],
    backend,
    condition: str,
    client: Optional[OpenAI] = None,
    top_k: int = 5,
    max_tool_calls: int = 2
) -> Dict[str, Any]:
    """Runs a single agent query under a specific memory condition."""
    if client is None:
        client = get_client()

    query_text = query_obj.get("query_bn", query_obj.get("query", ""))
    gold_node_ids = set()
    for s in query_obj.get("source_nodes", []):
        if isinstance(s, dict):
            gold_node_ids.add(s["node_id"])
        else:
            gold_node_ids.add(s)

    sys_prompt = SYSTEM_PROMPT_M0 if condition == "M0" else SYSTEM_PROMPT
    tools = None if condition == "M0" else TOOLS

    messages = [
        {"role": "system", "content": sys_prompt},
        {"role": "user", "content": query_text}
    ]

    all_retrieved_nodes = []
    all_context_text = ""
    tool_call_count = 0
    t0 = time.time()

    try:
        response = client.chat.completions.create(
            model=MODEL,
            messages=messages,
            tools=tools,
            tool_choice="auto" if tools else None,
            temperature=0.0
        )
        msg = response.choices[0].message

        # ReAct loop
        while msg.tool_calls and tool_call_count < max_tool_calls:
            messages.append(msg)
            for tc in msg.tool_calls:
                tool_call_count += 1
                try:
                    args = json.loads(tc.function.arguments)
                    q = args.get("query", "")
                    if backend:
                        res = backend.search(q, top_k=top_k)
                        for r in res:
                            all_retrieved_nodes.append(r["node_id"])
                            all_context_text += r.get("text", "") + " "
                except Exception:
                    pass

                content = execute_tool_call(tc, backend, top_k=top_k)
                messages.append({
                    "role": "tool",
                    "tool_call_id": tc.id,
                    "content": content
                })

            response = client.chat.completions.create(
                model=MODEL,
                messages=messages,
                tools=tools,
                temperature=0.0
            )
            msg = response.choices[0].message

        final_text = msg.content or ""
        elapsed = time.time() - t0

        # Evaluate gold recall and citation
        retrieved_set = set(all_retrieved_nodes)
        gold_hits = gold_node_ids & retrieved_set
        gold_retrieved = len(gold_hits) > 0

        # Rank of first gold hit
        first_gold_rank = None
        for r_idx, nid in enumerate(all_retrieved_nodes):
            if nid in gold_node_ids:
                first_gold_rank = r_idx + 1
                break

        # Check citation rate
        cited = any(f"[Node: {gid}]" in final_text or gid in final_text for gid in gold_node_ids)

        return {
            "query_id": query_obj.get("query_id"),
            "domain": query_obj.get("domain"),
            "condition": condition,
            "query": query_text,
            "gold_node_ids": list(gold_node_ids),
            "all_retrieved_node_ids": all_retrieved_nodes,
            "gold_retrieved": gold_retrieved,
            "gold_rank": first_gold_rank,
            "cited_gold": cited,
            "tool_calls": tool_call_count,
            "context_tokens": len(all_context_text.split()),
            "elapsed_seconds": elapsed,
            "answer": final_text
        }
    except Exception as e:
        return {
            "query_id": query_obj.get("query_id"),
            "domain": query_obj.get("domain"),
            "condition": condition,
            "error": str(e)
        }