#!/usr/bin/env python3
"""
Task 3: SED Classification (Type-1 AGN, Type-2 AGN, or Galaxy)

Classifies astronomical sources from SED plots or text-based magnitude data.
Supports both image-based and text-based modalities, with/without redshift.
"""

import argparse
import base64
import csv
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" / "Task3_SED"

# Magnitude columns: (band name, mag column, err column, wavelength in microns)
MAG_COLUMNS = [
    ("HSC-g",      "HSC_G_MAG",      "HSC_G_MAG_ERR",      0.48),
    ("HSC-r",      "HSC_R_MAG",      "HSC_R_MAG_ERR",      0.62),
    ("HSC-i",      "HSC_I_MAG",      "HSC_I_MAG_ERR",      0.77),
    ("HSC-z",      "HSC_Z_MAG",      "HSC_Z_MAG_ERR",      0.91),
    ("HSC-Y",      "HSC_Y_MAG",      "HSC_Y_MAG_ERR",      1.00),
    ("Euclid-Y",   "EUCLID_Y_MAG",   "EUCLID_Y_MAG_ERR",   1.08),
    ("Euclid-J",   "EUCLID_J_MAG",   "EUCLID_J_MAG_ERR",   1.25),
    ("Euclid-H",   "EUCLID_H_MAG",   "EUCLID_H_MAG_ERR",   1.65),
    ("AKARI-N2",   "AKARI_N2_MAG",   "AKARI_N2_MAG_ERR",   2.4),
    ("AKARI-N3",   "AKARI_N3_MAG",   "AKARI_N3_MAG_ERR",   3.2),
    ("AKARI-N4",   "AKARI_N4_MAG",   "AKARI_N4_MAG_ERR",   4.1),
    ("AKARI-S7",   "AKARI_S7_MAG",   "AKARI_S7_MAG_ERR",   7.0),
    ("AKARI-S9W",  "AKARI_S9W_MAG",  "AKARI_S9W_MAG_ERR",  9.0),
    ("AKARI-S11",  "AKARI_S11_MAG",  "AKARI_S11_MAG_ERR",  11.0),
    ("AKARI-L15",  "AKARI_L15_MAG",  "AKARI_L15_MAG_ERR",  15.0),
    ("AKARI-L18",  "AKARI_L18_MAG",  "AKARI_L18_MAG_ERR",  18.0),
    ("AKARI-L24",  "AKARI_L24_MAG",  "AKARI_L24_MAG_ERR",  24.0),
    ("WISE-W1",    "WISE_W1_MAG",    "WISE_W1_MAG_ERR",    3.4),
    ("WISE-W2",    "WISE_W2_MAG",    "WISE_W2_MAG_ERR",    4.6),
    ("WISE-W3",    "WISE_W3_MAG",    "WISE_W3_MAG_ERR",    12.0),
    ("WISE-W4",    "WISE_W4_MAG",    "WISE_W4_MAG_ERR",    22.0),
]


# =========================
# 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")


def get_image_media_type(path: pathlib.Path) -> str:
    suffix = path.suffix.lower()
    if suffix in [".jpg", ".jpeg"]:
        return "image/jpeg"
    elif suffix == ".png":
        return "image/png"
    return "image/png"


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

SYSTEM_PROMPT_IMAGE = """**Task:** Classify the astronomical source shown in the attached SED plot as a 'Type-1 AGN', 'Type-2 AGN', or 'Galaxy'.

**Context:**
- The plot shows nu_fnu (y-axis, log scale) vs. Wavelength (x-axis, log scale).
- The upper x-axis shows rest-frame wavelength and the lower x-axis shows observed wavelength.
- The HSC g, r, i, z, y bands, the Euclid Y, J, H bands, the AKARI N2, N3, N4, S7, S9W, S11, L15, L18, L24 bands, and the WISE W1, W2, W3, W4 bands are marked on the plot (if available).
- {REDSHIFT_BLOCK}

**Instructions:**
Normal galaxies are entirely driven by stellar processes, peaking with starlight in the optical/NIR and star-heated cold dust in the MIR. Type 1 AGNs outshine their host galaxies across the board, dominated by the naked accretion disk in the UV/optical and the intensely heated inner dust torus in the MIR. Type 2 AGNs have their central engines hidden behind thick dust, leaving their UV/optical to appear as normal star-dominated host galaxies, while their MIR reveals the hidden monster via the glowing, re-radiating dust torus.
{REDSHIFT_INSTRUCTION}

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

SYSTEM_PROMPT_WOGUIDE = """Classify the astronomical source shown in the attached SED plot as a 'Type-1 AGN', 'Type-2 AGN', or 'Galaxy'.

- {REDSHIFT_BLOCK}
{REDSHIFT_INSTRUCTION}

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


def format_photometry(row: dict) -> str:
    lines = []
    for band_name, mag_col, err_col, wavelength in MAG_COLUMNS:
        mag = row.get(mag_col, "")
        err = row.get(err_col, "")
        if mag and mag.strip() and mag.strip() not in ["", "nan", "NaN"]:
            try:
                mag_val = float(mag)
                if err and err.strip() and err.strip() not in ["", "nan", "NaN"]:
                    err_val = float(err)
                    lines.append(f"  {band_name} ({wavelength:.2f} um): {mag_val:.3f} +/- {err_val:.3f} mag")
                else:
                    lines.append(f"  {band_name} ({wavelength:.2f} um): {mag_val:.3f} mag")
            except ValueError:
                pass
    return "\n".join(lines) if lines else "  No photometric data available."


def build_text_prompt(photometry: str, redshift_mode: str, redshift: float, redshift_err: float) -> str:
    if redshift_mode == "with":
        if redshift_err and redshift_err > 0:
            redshift_block = f"Redshift (z) = {redshift:.4f} +/- {redshift_err:.4f}"
        else:
            redshift_block = f"Redshift (z) = {redshift:.4f}"
        redshift_instruction = "Use the redshift information to interpret rest-frame wavelengths where helpful."
    else:
        redshift_block = "Redshift: not provided."
        redshift_instruction = "Do not assume redshift; base your reasoning on the observer-frame SED only."

    return f"""**Task:** Classify the astronomical source based on the following photometric magnitude data as a 'Type-1 AGN', 'Type-2 AGN', or 'Galaxy'.

**Photometric Data (observed-frame magnitudes):**
{photometry}

**Context:**
- {redshift_block}
- Lower magnitude values indicate brighter flux at that wavelength.

**Instructions:**
Normal galaxies are entirely driven by stellar processes, peaking with starlight in the optical/NIR and star-heated cold dust in the MIR. Type 1 AGNs outshine their host galaxies across the board, dominated by the naked accretion disk in the UV/optical and the intensely heated inner dust torus in the MIR. Type 2 AGNs have their central engines hidden behind thick dust, leaving their UV/optical to appear as normal star-dominated host galaxies, while their MIR reveals the hidden monster via the glowing, re-radiating dust torus.
{redshift_instruction}

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


def build_image_prompt(redshift_mode: str, redshift: float, redshift_err: float, prompt_type: str = "guided") -> str:
    if redshift_mode == "with":
        if redshift_err and redshift_err > 0:
            redshift_block = f"Redshift (z) = {redshift:.4f} ± {redshift_err:.4f}"
        else:
            redshift_block = f"Redshift (z) = {redshift:.4f}"
        redshift_instruction = "\nUse the redshift information to interpret rest-frame wavelengths where helpful."
    else:
        redshift_block = "Redshift: not provided."
        redshift_instruction = "\nDo not assume redshift; base your reasoning on the observer-frame SED only."

    template = SYSTEM_PROMPT_IMAGE if prompt_type == "guided" else SYSTEM_PROMPT_WOGUIDE
    return template.format(
        REDSHIFT_BLOCK=redshift_block,
        REDSHIFT_INSTRUCTION=redshift_instruction,
    )


USER_TEXT = "Label this image: Type-1 AGN, Type-2 AGN, or Galaxy. 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)
    media_type = get_image_media_type(image_path)

    messages = [
        {"role": "system", "content": system_prompt},
        {
            "role": "user",
            "content": [
                {"type": "text", "text": USER_TEXT},
                {
                    "type": "image_url",
                    "image_url": {
                        "url": f"data:{media_type};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


def classify_text(client: OpenAI, system_prompt: str, model: str, max_completion_tokens: int):
    messages = [
        {"role": "system", "content": system_prompt},
        {"role": "user", "content": "Label this source: Type-1 AGN, Type-2 AGN, or Galaxy. Respond with JSON format."},
    ]

    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().lower()
    if "type-1" in val or "type 1" in val:
        return "Type-1 AGN"
    if "type-2" in val or "type 2" in val:
        return "Type-2 AGN"
    if "galaxy" in val or "sfg" in val or "star" in val:
        return "Galaxy"
    return "Unknown"


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

def run(
    catalog_path: pathlib.Path,
    images_dir: pathlib.Path,
    model: str,
    limit: Optional[int],
    results_dir: pathlib.Path,
    redshift_mode: str,
    modality: str,
    prompt_type: str,
    max_completion_tokens: int,
    resume: bool,
) -> pathlib.Path:

    client = get_client(model)

    rows = list(csv.DictReader(catalog_path.open()))
    results_dir.mkdir(parents=True, exist_ok=True)

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

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

    correct = sum(r.get("correct", False) for r in results)
    total = len(results)

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

        targetid = str(row.get("targetid", "")).strip()
        if not targetid:
            continue
        if targetid in processed_targets:
            continue

        label = (row.get("class") or "").strip()
        redshift = float(row.get("z", 0.0) or 0.0)
        redshift_err = float(row.get("zerr", 0.0) or 0.0)

        if modality == "image":
            matches = list(images_dir.glob(f"*_{targetid}.png"))
            if not matches:
                print(f"Warning: image not found for {targetid}")
                continue
            image_path = matches[0].resolve()
            system_prompt = build_image_prompt(redshift_mode, redshift, redshift_err, prompt_type)
            response = classify_image(client, image_path, system_prompt, model, max_completion_tokens)
        else:
            photometry = format_photometry(row)
            system_prompt = build_text_prompt(photometry, redshift_mode, redshift, redshift_err)
            response = classify_text(client, 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.lower() == label.lower()

        total += 1
        correct += int(is_correct)

        results.append({
            "targetid": targetid,
            "label": label,
            "prediction": pred,
            "correct": int(is_correct),
            "raw_response": response.model_dump(),
        })
        print(f"{targetid}: 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="Task3: SED Classification")
    parser.add_argument("--catalog", type=pathlib.Path, default=DATA_DIR / "nirsed_v2_catalog.csv")
    parser.add_argument("--images-dir", type=pathlib.Path, default=DATA_DIR / "images")
    parser.add_argument("--model", default="gpt-4o")
    parser.add_argument("--modality", choices=["image", "text"], default="image")
    parser.add_argument("--prompt-type", choices=["guided", "woguide"], default="guided")
    parser.add_argument("--redshift-mode", choices=["with", "without"], default="with")
    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(
        catalog_path=args.catalog,
        images_dir=args.images_dir,
        model=args.model,
        limit=args.limit,
        results_dir=args.results_dir,
        redshift_mode=args.redshift_mode,
        modality=args.modality,
        prompt_type=args.prompt_type,
        max_completion_tokens=args.max_completion_tokens,
        resume=args.resume,
    )