import sys
import json
import pandas as pd
from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, confusion_matrix


def fail(message):
    print(message)
    sys.exit(1)


def safe_accuracy(frame):
    if len(frame) == 0:
        return None

    return round(accuracy_score(frame["label"], frame["prediction"]), 4)


def main():
    if len(sys.argv) != 3:
        fail("Usage: python scorer.py predictions.csv data/test.csv")

    pred_path = sys.argv[1]
    test_path = sys.argv[2]

    try:
        pred = pd.read_csv(pred_path)
        test = pd.read_csv(test_path)
    except Exception as exc:
        fail(f"Error reading CSV files: {exc}")

    required_pred_cols = {"scenario_id", "prediction"}
    required_test_cols = {"scenario_id", "label", "case_type"}

    if not required_pred_cols.issubset(pred.columns):
        fail("Error: predictions.csv must contain scenario_id and prediction columns.")

    if not required_test_cols.issubset(test.columns):
        fail("Error: test.csv must contain scenario_id, case_type, and label columns.")

    try:
        pred["prediction"] = pred["prediction"].astype(float).astype(int)
    except (ValueError, TypeError):
        fail("Error: prediction column must contain integers 0 or 1.")

    if not pred["prediction"].isin([0, 1]).all():
        fail("Error: prediction column must contain only 0 or 1.")

    if pred["scenario_id"].duplicated().any():
        fail("Error: predictions.csv contains duplicate scenario_id values.")

    merged = test.merge(pred, on="scenario_id", how="left")

    if merged["prediction"].isna().any():
        missing = merged.loc[merged["prediction"].isna(), "scenario_id"].tolist()
        fail(f"Error: missing predictions for scenario_id values: {missing}")

    merged["label"] = merged["label"].astype(int)
    merged["prediction"] = merged["prediction"].astype(int)

    y_true = merged["label"]
    y_pred = merged["prediction"]

    metrics = {
        "accuracy": round(accuracy_score(y_true, y_pred), 4),
        "precision": round(precision_score(y_true, y_pred, zero_division=0), 4),
        "recall": round(recall_score(y_true, y_pred, zero_division=0), 4),
        "f1": round(f1_score(y_true, y_pred, zero_division=0), 4),
        "confusion_matrix": confusion_matrix(y_true, y_pred).tolist(),
    }

    case_type_scores = []

    for case_type in sorted(merged["case_type"].unique()):
        subset = merged[merged["case_type"] == case_type]
        score = safe_accuracy(subset)

        metrics[f"accuracy_{case_type}"] = score
        metrics[f"count_{case_type}"] = len(subset)

        if score is not None:
            case_type_scores.append(score)

    metrics["case_type_accuracy_macro"] = round(
        sum(case_type_scores) / len(case_type_scores),
        4
    )

    print(json.dumps(metrics, indent=2))


if __name__ == "__main__":
    main()