import csv
import json
import sys
from typing import Dict, List


DEFAULT_INPUT_PATH = "data/tester.csv"


def _safe_float(value, default: float = 0.0) -> float:
    try:
        return float(value)
    except (TypeError, ValueError):
        return default


def _read_csv(path: str) -> List[Dict[str, str]]:
    with open(path, "r", encoding="utf-8") as f:
        return list(csv.DictReader(f))


def _detect_id_column(fieldnames: List[str]) -> str:
    preferred = ["id", "row_id", "sample_id", "case_id", "record_id"]
    for col in preferred:
        if col in fieldnames:
            return col
    return ""


def heuristic_score(row: Dict[str, str]) -> float:
    counterfactual_divergence_score = _safe_float(row.get("counterfactual_divergence_score"))
    cascade_pressure_index = _safe_float(row.get("cascade_pressure_index"))
    systemic_coupling_score = _safe_float(row.get("systemic_coupling_score"))
    intervention_reversibility_index = _safe_float(row.get("intervention_reversibility_index"))
    drift_gradient = _safe_float(row.get("drift_gradient"))
    stabilization_window_score = _safe_float(row.get("stabilization_window_score"))
    latent_failure_load = _safe_float(row.get("latent_failure_load"))
    coordination_stability_score = _safe_float(row.get("coordination_stability_score"))

    score = 0.0
    score += counterfactual_divergence_score * 1.2
    score += cascade_pressure_index * 1.3
    score += systemic_coupling_score * 1.2
    score += max(0.0, 1.0 - intervention_reversibility_index) * 1.1
    score += max(0.0, drift_gradient) * 1.4
    score += max(0.0, 1.0 - stabilization_window_score) * 1.2
    score += latent_failure_load * 1.3
    score -= coordination_stability_score * 0.9

    if score < 0.0:
        return 0.0
    if score > 1.0:
        return 1.0
    return round(score, 6)


def generate_predictions(
    input_path: str = DEFAULT_INPUT_PATH,
    output_path: str = "predictions.csv",
    threshold: float = 0.5,
) -> Dict[str, object]:
    rows = _read_csv(input_path)
    if not rows:
        raise ValueError("Input file is empty.")

    fieldnames = list(rows[0].keys())
    id_col = _detect_id_column(fieldnames)

    output_rows = []
    positive_predictions = 0

    for idx, row in enumerate(rows):
        row_id = row[id_col] if id_col else str(idx)
        pred_score = heuristic_score(row)
        pred_label = 1 if pred_score >= threshold else 0
        positive_predictions += pred_label

        output_rows.append(
            {
                "id": row_id,
                "prediction_score": pred_score,
                "prediction": pred_label,
            }
        )

    with open(output_path, "w", encoding="utf-8", newline="") as f:
        writer = csv.DictWriter(f, fieldnames=["id", "prediction_score", "prediction"])
        writer.writeheader()
        writer.writerows(output_rows)

    return {
        "input_path": input_path,
        "output_path": output_path,
        "rows_processed": len(rows),
        "threshold_used": threshold,
        "predicted_positive_support": positive_predictions,
        "predicted_negative_support": len(rows) - positive_predictions,
        "note": "This is a dataset-specific baseline heuristic, not the canonical evaluation scorer.",
    }


if __name__ == "__main__":
    input_path = sys.argv[1] if len(sys.argv) > 1 else DEFAULT_INPUT_PATH
    output_path = sys.argv[2] if len(sys.argv) > 2 else "predictions.csv"
    threshold = float(sys.argv[3]) if len(sys.argv) > 3 else 0.5

    result = generate_predictions(
        input_path=input_path,
        output_path=output_path,
        threshold=threshold,
    )
    print(json.dumps(result, indent=2))