import os
import json
import asyncio
from typing import Dict, Any, List, Optional, Tuple
from openai import AsyncOpenAI
from pydantic import BaseModel
from tqdm import tqdm

INICIAL_INSTRUCTION = "Você é um avaliador da qualidade de queries de usuários sobre leis da ANEEL. Avalie a conversa com base em sua clareza, especificidade e coerência. Também considere as seguintes regras:"
# INICIAL_INSTRUCTION = "Você é um avaliador da qualidade de queries de usuários. Avalie APENAS a primeira query do usuário com base em sua clareza, especificidade e coerência."

GUIDELINES = """
Regras para considerar na avaliação:
- Se o assistant em algum momento fala "de acordo com o contexto", "com base no texto fornecido" ou algo do tipo, a qualidade da conversa é muito ruim
- Se o user começa a repetir textos do assistente sem progredir a conversa ou fazer uma nova pergunta para o assistente, a qualidade da conversa é muito ruim.
- Não necessariamente uma pergunta e resposta pequena é ruim. Não tem problema dado que está respondendo a pergunta
"""

VLLM_BASE_URL = os.getenv("VLLM_BASE_URL", "http://10.100.0.111:8020/v1")
VLLM_API_KEY  = os.getenv("VLLM_API_KEY", "no-key-needed")
TEMPERATURE = float(os.getenv("TEMPERATURE", "0.0"))
TOP_P = float(os.getenv("TOP_P", "1.0"))
MAX_TOKENS = int(os.getenv("MAX_TOKENS", "1024"))
BATCH_SIZE = int(os.getenv("BATCH_SIZE", "4"))
NUM_TURNS = int(os.getenv("NUM_TURNS", "3"))

client = AsyncOpenAI(base_url=VLLM_BASE_URL, api_key=VLLM_API_KEY)

class EvalSchema(BaseModel):
    explicacao: str
    qualidade: str

OUTPUT_SCHEMA = EvalSchema.model_json_schema()

SYSTEM_PROMPT = f"""
{INICIAL_INSTRUCTION}

{GUIDELINES}

Escala de avaliação:
- muito ruim: A query é obscura, vaga ou incoerente. Faltam informações e contexto essenciais.
- ruim: A query é um tanto obscura ou carece de detalhes importantes. Requer esclarecimentos significativos.
- média: A query é moderadamente clara e específica. Pode exigir algumas informações adicionais para uma compreensão completa.
- boa: A query é clara, específica e, na maior parte, bem formulada. Fornece contexto suficiente para entender a intenção do usuário.
- excelente: A query é muito clara, específica e bem articulada. Contém todas as informações e contexto necessários para fornecer uma resposta abrangente.

Formato de saída OBRIGATÓRIO (JSON estrito, sem texto extra, sem crases):
{{
  "explicacao": "<string>",
  "qualidade": "muito ruim" | "ruim" | "média" | "boa" | "excelente"
}}
""".strip()

USER_PROMPT = "Query do Usuário (primeiros {n} turns):\n{input}"

async def get_model_id() -> str:
    models = await client.models.list()
    if not models.data:
        raise RuntimeError("Nenhum modelo disponível no endpoint vLLM.")
    return models.data[0].id

def _normalize_role(role: Any) -> Optional[str]:
    if isinstance(role, str):
        r = role.lower()
        if r in {"user", "assistant"}:
            return r
    return None

def _to_str(x: Any) -> str:
    if isinstance(x, str):
        return x
    return json.dumps(x, ensure_ascii=False) if x is not None else ""

def build_eval_input(conversation: List[Dict[str, Any]], num_turns: int) -> Optional[str]:
    if not conversation or num_turns <= 0:
        return None

    # primeiro turno do user
    start_idx = next(
        (i for i, t in enumerate(conversation) if _normalize_role(t.get("role")) == "user"),
        None,
    )
    if start_idx is None:
        return None

    lines: List[str] = []
    collected = 0
    for turn in conversation[start_idx:]:
        role = _normalize_role(turn.get("role"))
        if not role:
            continue
        lines.append(f"{role}: { _to_str(turn.get('content', '')) }")
        collected += 1
        if collected >= num_turns:
            break

    return "\n".join(lines) if lines else None

async def evaluate_query(query_block: str, model_id: str) -> Dict[str, Any]:
    messages = [
        {"role": "system", "content": SYSTEM_PROMPT},
        {"role": "user", "content": USER_PROMPT.format(n=NUM_TURNS, input=query_block)},
    ]
    resp = await client.chat.completions.create(
        model=model_id,
        messages=messages,
        temperature=TEMPERATURE,
        top_p=TOP_P,
        max_tokens=MAX_TOKENS,
    )
    raw = (resp.choices[0].message.content or "").strip()
    if not raw:
        return {"explicacao": "Resposta vazia do modelo", "qualidade": "muito ruim"}

    try:
        return json.loads(raw)
    except json.JSONDecodeError:
        start, end = raw.find("{"), raw.rfind("}")
        if start != -1 and end != -1 and end > start:
            try:
                return json.loads(raw[start:end+1])
            except json.JSONDecodeError:
                pass
        return {"explicacao": raw, "qualidade": "invalida"}

async def evaluate_conversation_quality(block: Optional[str], model_id: str) -> Dict[str, Any]:
    if not block:
        return {"explicacao_qualidade": "Nenhuma query de usuário encontrada", "qualidade": "muito ruim"}
    result = await evaluate_query(block, model_id)
    return {
        "explicacao_qualidade": result.get("explicacao", ""),
        "qualidade": result.get("qualidade", "invalida"),
    }

def _load_processed_ids(output_file: str) -> set:
    ids = set()
    if os.path.exists(output_file):
        with open(output_file, "r", encoding="utf-8") as f:
            for line in f:
                try:
                    rec = json.loads(line)
                    seq = rec.get("seq_id")
                    if seq is not None:
                        ids.add(seq)
                except json.JSONDecodeError:
                    continue
    return ids

async def process_jsonl_file(input_file: str, output_file: Optional[str] = None):
    """Adiciona avaliações às conversas do arquivo JSONL, com checkpoint por seq_id."""
    if output_file is None:
        output_file = input_file

    processed_ids = _load_processed_ids(output_file)

    with open(input_file, "r", encoding="utf-8") as f:
        lines = [ln.strip() for ln in f if ln.strip()]

    model_id = await get_model_id()

    print(f"Starting process (NUM_TURNS={NUM_TURNS})")
    total_batches = (len(lines) + BATCH_SIZE - 1) // BATCH_SIZE
    pbar = tqdm(total=total_batches, desc="Processing conversations")

    for i in range(0, len(lines), BATCH_SIZE):
        batch_lines = lines[i : i + BATCH_SIZE]
        # prepara dados brutos ignorando já processados
        batch_data: List[Tuple[int, Dict[str, Any]]] = []
        for j, line in enumerate(batch_lines):
            try:
                data = json.loads(line)
            except json.JSONDecodeError as e:
                tqdm.write(f"Error parsing line {i+j+1}: {e}")
                continue
            seq_id = data.get("seq_id")
            if seq_id in processed_ids:
                continue
            batch_data.append((i + j, data))

        if not batch_data:
            pbar.update(1)
            continue

        processed_lines: List[str] = []
        sem = asyncio.Semaphore(BATCH_SIZE)

        async def worker(line_idx: int, data: Dict[str, Any]):
            async with sem:
                try:
                    block = build_eval_input(data.get("conversation", []), NUM_TURNS)
                    result = await evaluate_conversation_quality(block, model_id)
                    data["explicacao_qualidade"] = result["explicacao_qualidade"]
                    data["qualidade"] = result["qualidade"]
                    processed_lines.append(json.dumps(data, ensure_ascii=False))
                    seq = data.get("seq_id")
                    if seq is not None:
                        processed_ids.add(seq)
                except Exception as e:
                    tqdm.write(f"Error processing line {line_idx+1}: {e}")
                    data["explicacao_qualidade"] = "Erro na avaliação"
                    data["qualidade"] = "muito ruim"
                    processed_lines.append(json.dumps(data, ensure_ascii=False))

        await asyncio.gather(*(worker(idx, d) for idx, d in batch_data))

        # checkpoint do batch
        with open(output_file, "a", encoding="utf-8") as f:
            for line in processed_lines:
                f.write(line + "\n")

        pbar.update(1)

    pbar.close()
    print(f"Processing complete. Updated file: {output_file}")

async def main():
    await process_jsonl_file(
        "./magpie_conversations_cemig_cleaned.jsonl",
        "./magpie_conversations_cemig_cleaned_evaled.jsonl",
    )

if __name__ == "__main__":
    asyncio.run(main())