#!/usr/bin/env python3
"""
Task 2: Radio Galaxy Morphology Classification (FRI vs FRII)

Classifies radio galaxy images using the Fanaroff-Riley classification scheme.
Supports MiraBest_F (FIRST survey) and MiraBest_N (NVSS survey) datasets.
"""

import argparse
import base64
import json
import os
import pathlib
import re
import time
from typing import Optional

from dotenv import load_dotenv
load_dotenv(override=True)

from openai import OpenAI


# =========================
# CONFIGURATION
# =========================

DATA_DIR = pathlib.Path(__file__).resolve().parent.parent.parent / "data" / "Task2_RadioMorph"


# =========================
# CLIENT
# =========================

def get_client(model: str) -> OpenAI:
    """Create OpenAI-compatible client based on model name.

    Requires environment variables:
      - OPENAI_API_KEY / OPENAI_BASE_URL for OpenAI/compatible models
      - CLAUDE_API_KEY for Claude models
      - GROK_API_KEY for Grok models
      - QWEN_API_KEY for Qwen models
      - INTERN_API_KEY for InternVL models
    """
    api_key = os.getenv("OPENAI_API_KEY")
    base_url = os.getenv("OPENAI_BASE_URL")

    if "intern" in model.lower():
        api_key = os.getenv("INTERN_API_KEY")
        base_url = os.getenv("INTERN_BASE_URL")
    elif "qwen" in model.lower():
        api_key = os.getenv("QWEN_API_KEY")
        base_url = os.getenv("QWEN_BASE_URL")
    elif "grok" in model.lower():
        api_key = os.getenv("GROK_API_KEY")
    elif "claude" in model.lower():
        api_key = os.getenv("CLAUDE_API_KEY")

    return OpenAI(api_key=api_key, base_url=base_url)


# =========================
# IMAGE UTILS
# =========================

def encode_image(path: pathlib.Path) -> str:
    with open(path, "rb") as f:
        return base64.b64encode(f.read()).decode("utf-8")


# =========================
# DATA LOADING
# =========================

def load_metadata(dataset: str, data_dir: pathlib.Path = DATA_DIR) -> list:
    metadata_path = data_dir / dataset / "metadata.jsonl"
    samples = []
    with open(metadata_path, 'r') as f:
        for line in f:
            data = json.loads(line.strip())
            samples.append(data)
    return samples


def get_survey_name(dataset: str) -> str:
    if dataset == "MiraBest_F":
        return "FIRST"
    elif dataset == "MiraBest_N":
        return "NVSS"
    return "radio"


# =========================
# PROMPTS
# =========================

def build_prompt_guided(survey: str) -> str:
    return f"""**Task:** Classify the radio galaxy image from {survey} survey according to the Fanaroff-Riley classification scheme (Class I or Class II).

**Instructions:**
- FRI (Fanaroff-Riley Type I): Edge-darkened sources where the radio emission is brightest near the core and fades toward the edges. The jets are typically less collimated and more turbulent.
- FRII (Fanaroff-Riley Type II): Edge-brightened sources with prominent hotspots at the outer edges of the radio lobes. The jets remain well-collimated until they reach the hotspots.

**Output requirements:**
- Respond with a JSON object in the following format: {{"answer": "", "reason": ""}}
- The "answer" field must be either: FRI or FRII
- The "reason" field should contain a brief explanation of your classification decision
- Do not include any text outside the JSON object
"""


def build_prompt_woguide(survey: str) -> str:
    return f"""Classify this radio galaxy image from {survey} survey as FRI or FRII.

Output requirements:
- Respond with a JSON object in the following format: {{"answer": "", "reason": ""}}
- The "answer" field must be either: FRI or FRII
- The "reason" field should contain a brief explanation of your classification decision
- Do not include any text outside the JSON object
"""


USER_TEXT = "Classify this radio galaxy image: FRI or FRII. Respond with JSON format."


# =========================
# MODEL CALL
# =========================

def classify_image(client: OpenAI, image_path: pathlib.Path, system_prompt: str, model: str, max_completion_tokens: int):
    img_b64 = encode_image(image_path)

    messages = [
        {"role": "system", "content": system_prompt},
        {
            "role": "user",
            "content": [
                {"type": "text", "text": USER_TEXT},
                {
                    "type": "image_url",
                    "image_url": {
                        "url": f"data:image/png;base64,{img_b64}",
                        "detail": "high",
                    },
                },
            ],
        },
    ]

    extra = {"enable_thinking": False} if "qwen" in model.lower() else {}
    for attempt in range(5):
        try:
            response = client.chat.completions.create(
                model=model,
                messages=messages,
                temperature=0,
                max_completion_tokens=max_completion_tokens,
                extra_body=extra if extra else None,
            )
            return response
        except Exception as e:
            if attempt < 4:
                wait = 2 ** attempt * 5
                print(f"  Attempt {attempt+1} failed ({e}), retrying in {wait}s...")
                time.sleep(wait)
            else:
                raise


# =========================
# PARSE PREDICTION
# =========================

def parse_prediction(raw: str) -> dict:
    cleaned = re.sub(r"```json\s*", "", raw)
    cleaned = re.sub(r"```\s*", "", cleaned)
    cleaned = cleaned.strip()
    try:
        return json.loads(cleaned)
    except json.JSONDecodeError:
        return {"answer": raw, "reason": ""}


def canonicalize_label(value: str) -> str:
    val = (value or "").strip().upper()
    if "FRII" in val or "FR2" in val or "II" in val:
        return "FRII"
    if "FRI" in val or "FR1" in val:
        return "FRI"
    return "Unknown"


# =========================
# MAIN PIPELINE
# =========================

def run(
    dataset: str,
    model: str,
    limit: Optional[int],
    results_dir: pathlib.Path,
    prompt_type: str,
    max_completion_tokens: int,
    resume: bool,
    data_dir: pathlib.Path = DATA_DIR,
) -> pathlib.Path:

    client = get_client(model)
    samples = load_metadata(dataset, data_dir)
    results_dir.mkdir(parents=True, exist_ok=True)

    out_path = results_dir / f"predictions-{dataset}-{prompt_type}-{model}.json"

    results = []
    processed_images = set()
    if resume and out_path.exists():
        with out_path.open("r") as f:
            results = json.load(f)
            processed_images = {r["image"] for r in results}
        print(f"Resuming from {len(results)} existing predictions")

    correct = sum(r["correct"] for r in results)
    total = len(results)

    survey = get_survey_name(dataset)
    if prompt_type == "guided":
        system_prompt = build_prompt_guided(survey)
    else:
        system_prompt = build_prompt_woguide(survey)

    for i, sample in enumerate(samples):
        if limit is not None and i >= limit:
            break

        image_path = data_dir / dataset / sample["filename"]
        if str(image_path) in processed_images:
            continue

        label = sample["label"]

        response = classify_image(client, image_path, system_prompt, model, max_completion_tokens)
        content = response.choices[0].message.content
        pred = parse_prediction(content)
        answer = canonicalize_label(pred.get("answer", ""))
        is_correct = answer == label

        total += 1
        correct += int(is_correct)

        results.append({
            "image": str(image_path),
            "label": label,
            "prediction": pred,
            "correct": int(is_correct),
            "raw_response": response.model_dump(),
        })
        print(f"{sample['filename']}: pred={answer} label={label} {'✓' if is_correct else '✗'}")

        with out_path.open("w") as f:
            json.dump(results, f, indent=2)

    if total > 0:
        print(f"Accuracy on {total} checked: {correct}/{total} = {correct/total:.2%}")

    print(f"Saved predictions to {out_path}")
    return out_path


# =========================
# ARGPARSE
# =========================

def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser(description="Task2: Radio Galaxy Morphology Classification")
    parser.add_argument("--dataset", choices=["MiraBest_F", "MiraBest_N"], default="MiraBest_F")
    parser.add_argument("--model", default="gpt-4o")
    parser.add_argument("--prompt-type", choices=["guided", "woguide"], default="guided")
    parser.add_argument("--limit", type=int, default=None)
    parser.add_argument("--results-dir", type=pathlib.Path, default=pathlib.Path("./results"))
    parser.add_argument("--max-completion-tokens", type=int, default=16384)
    parser.add_argument("--resume", action="store_true")
    return parser.parse_args()


if __name__ == "__main__":
    args = parse_args()
    run(
        dataset=args.dataset,
        model=args.model,
        limit=args.limit,
        results_dir=args.results_dir,
        prompt_type=args.prompt_type,
        max_completion_tokens=args.max_completion_tokens,
        resume=args.resume,
    )