import json
import sys
import re
import pandas as pd
import numpy as np


def parse_jsonl(file_name):
    with open(file_name, 'r', encoding='utf-8') as f:
        lines = f.readlines()
    return [json.loads(line) for line in lines]


def unwrap_answer(data):
    if isinstance(data, dict) and "answer" in data:
        return data["answer"]
    return data


def extract_json_content(text):
    if not text:
        return None
    
    text = text.strip()
    start = text.find('{')
    end = text.rfind('}') + 1
    if start == -1 or end <= start:
        return None

    try:
        return json.loads(text[start:end])
    except json.JSONDecodeError:
        return None


def normalize_val(val):
    if val is None:
        return ""
    s = re.sub(r"[<>]", "", str(val)).strip()
    if not s:
        return ""
    num_candidate = s.replace(",", "")
    try:
        num = float(num_candidate)
    except ValueError:
        return s
    return str(int(num)) if num.is_integer() else str(num)


def flatten_json(data, prefix=""):
    items = set()
    if isinstance(data, dict):
        for k, v in data.items():
            items.update(flatten_json(v, f"{prefix}.{k}" if prefix else k))
    elif isinstance(data, list):
        for v in data:
            if isinstance(v, list):
                row_tuple = tuple(normalize_val(sub_item) for sub_item in v)
                items.add((prefix, row_tuple))
            else:
                items.update(flatten_json(v, prefix))
    else:
        s = normalize_val(data)
        parts = re.split(r'[，,]', s)
        for part in parts:
            part = part.strip()
            if part:
                items.add((prefix, part))
    return items


def calculate_metrics(pred_json, gt_json, doc_id=None):
    def filter_present_categories(obj):
        return {"present_categories": obj.get("present_categories", [])} if isinstance(obj, dict) else {}

    if doc_id and doc_id.startswith("DTR_003"):
        pred_json = filter_present_categories(pred_json)
        gt_json = filter_present_categories(gt_json)

    if doc_id and (doc_id.startswith("NC_001") or doc_id.startswith("NC_002")):
        if pred_json is None:
            return None
        try:
            return 1.0 if abs(float(pred_json) - float(gt_json)) <= 2 else 0.0
        except Exception:
            return 0.0

    pred_set = flatten_json(pred_json) if pred_json is not None else set()
    gt_set = flatten_json(gt_json)

    if not gt_set:
        return 1.0 if not pred_set else 0.0

    tp = len(pred_set & gt_set)
    fp = len(pred_set) - tp
    fn = len(gt_set) - tp

    precision = tp / (tp + fp) if (tp + fp) else 0.0
    recall = tp / (tp + fn) if (tp + fn) else 0.0
    f1 = (2 * precision * recall) / (precision + recall) if (precision + recall) else 0.0
    return f1


def evaluate_samples(pred_file, gt_file):
    predictions = parse_jsonl(pred_file)
    gts = parse_jsonl(gt_file)
    gt_map = {gt['id']: gt for gt in gts}
    raw_scores = []
    for pred_data in predictions:
        doc_id = pred_data['id']
        # task NC_005 is currently under construction
        if doc_id.startswith('NC_005'): 
            continue
        pred_json = extract_json_content(pred_data['response'])
        gt_json = json.loads(gt_map[doc_id]['response'])
        pred_json = unwrap_answer(pred_json)
        gt_json = unwrap_answer(gt_json)
        
        f1 = calculate_metrics(pred_json, gt_json, doc_id)
        raw_score = {
            "id": doc_id,
            "task": gt_map[doc_id]['task'],
            "subtask": gt_map[doc_id]['subtask'],
            "robustness": gt_map[doc_id]['robustness'],
            "f1": f1
        }
        raw_scores.append(raw_score)
    return raw_scores


def evaluate_tasks(raw_scores):
    df = pd.DataFrame(raw_scores)
    subtask_mean = (
    df.groupby(["task", "subtask"], as_index=False)
        .agg(subtask_f1_mean=("f1", "mean"))
    )
    task_mean = (
        subtask_mean.groupby("task", as_index=False)
                    .agg(task_f1=("subtask_f1_mean", "mean"))
    )
    order = ["DTR", "KIE", "IQE", "CC", "VC", "NC", "RR"] 
    task_mean_sorted = (
        task_mean.assign(task=pd.Categorical(task_mean["task"], categories=order, ordered=True))
                .sort_values("task")
                .reset_index(drop=True)
    )
    print("Performance by Task:\n", task_mean_sorted)


def evaluate_robustness(raw_scores):
    df = pd.DataFrame(raw_scores)
    subtask_mean = (
        df.loc[df["task"].ne("IQE")]
        .groupby(["robustness", "task", "subtask"], as_index=False)
        .agg(subtask_f1_mean=("f1", "mean"))
    )
    normal_sub_mean = (
        subtask_mean[subtask_mean["robustness"].eq("Normal Captures")]
    )
    normal_task_mean = (
        normal_sub_mean.groupby("task", as_index=False)
                .agg(task_f1=("subtask_f1_mean", "mean"))
    )
    normal_overall_mean = normal_task_mean["task_f1"].mean()

    sec_keys = (
        subtask_mean.loc[subtask_mean["robustness"].eq("Secondary Captures"), ["task", "subtask"]]
                .drop_duplicates()
    )
    sec_normal_sub_mean = (
        subtask_mean[subtask_mean["robustness"].eq("Normal Captures")]
        .merge(sec_keys, on=["task", "subtask"], how="inner")
    )
    sec_normal_task_mean = (
        sec_normal_sub_mean.groupby("task", as_index=False)
                    .agg(task_f1=("subtask_f1_mean", "mean"))
    )
    sec_normal_overall_mean = sec_normal_task_mean["task_f1"].mean()
    
    multi_subtask_mean = (
        df.loc[df["subtask"].isin([
            "DTR_001_001", 
            "DTR_003_001",
            "KIE_002_001",
            ])]  
        .groupby(["robustness", "task", "subtask"], as_index=False)
        .agg(subtask_f1_mean=("f1", "mean"))
    )

    multi_normal_sub_mean = (
        multi_subtask_mean[multi_subtask_mean["robustness"].eq("Normal Captures")]
    )
    multi_normal_task_mean = (
        multi_normal_sub_mean.groupby("task", as_index=False)
                    .agg(task_f1=("subtask_f1_mean", "mean"))
    )
    multi_normal_overall_mean = multi_normal_task_mean["task_f1"].mean()

    task_mean = (
        subtask_mean.groupby(["robustness", "task"], as_index=False)
                    .agg(task_f1=("subtask_f1_mean", "mean"))
    )
    robustness_scores = (
        task_mean.groupby("robustness", as_index=False)
                 .agg(robustness_macro_f1=("task_f1", "mean"))
                 .sort_values("robustness_macro_f1", ascending=False)
                 .reset_index(drop=True)
    )
    use_special_denoms = {
        "Secondary Captures": sec_normal_overall_mean,
        "Cluttered Background": sec_normal_overall_mean,
        "Multi-doc Images": multi_normal_overall_mean}  
    robustness_scores = robustness_scores.copy()
    robustness_scores["normal_denom"] = robustness_scores["robustness"].apply(
        lambda r: use_special_denoms.get(r, normal_overall_mean)
    )
    robustness_scores["relative_to_normal"] = (
        robustness_scores["robustness_macro_f1"] / robustness_scores["normal_denom"].replace(0, np.nan)
    )
    robustness_scores = robustness_scores.drop(columns=["normal_denom", "robustness_macro_f1"])
    robustness_scores = robustness_scores.sort_values('relative_to_normal', ascending=False)
    print("Performance by Robustness:\n", robustness_scores)


if __name__ == "__main__":
    p_file = sys.argv[1]
    g_file = sys.argv[2]
    raw_scores = evaluate_samples(p_file, g_file)
    evaluate_tasks(raw_scores)
    evaluate_robustness(raw_scores)