#!/usr/bin/env python3
"""
PredictionMarketMath.org — Empirical Calibration & Verification Suite
Validates dataset integrity, Murphy's Brier Score Decomposition,
and Cross-Venue Fee Drag Arithmetic across 5,000 resolved prediction contracts.
"""

import sys
import os
import csv
import math

DATASET_PATH = os.path.join(os.path.dirname(__file__), 'prediction_market_calibration_dataset.csv')
VENUE_MATRIX_PATH = os.path.join(os.path.dirname(__file__), 'cross_venue_fee_and_spread_matrix.csv')

def run_verification():
    print("=" * 76)
    print(" PREDICTIONMARKETMATH.ORG // EMPIRICAL CALIBRATION VERIFICATION SUITE ")
    print("=" * 76)

    # 1. Dataset Existence Check
    if not os.path.isfile(DATASET_PATH):
        print(f"[FAIL] Missing dataset file: {DATASET_PATH}")
        sys.exit(1)
    
    print(f"[OK] Found dataset: {os.path.basename(DATASET_PATH)}")

    # 2. Row Integrity & Parse
    rows = []
    with open(DATASET_PATH, 'r', encoding='utf-8') as f:
        reader = csv.DictReader(f)
        for idx, row in enumerate(reader, start=1):
            try:
                p = float(row['forecast_prob'])
                o = int(row['outcome_binary'])
                bl = float(row['brier_loss'])
                ll = float(row['log_loss'])
                vol = float(row['volume_usd'])
            except (ValueError, KeyError) as e:
                print(f"[FAIL] Malformed data on line {idx}: {e}")
                sys.exit(1)

            # Axiomatic range assertions
            assert 0.0 <= p <= 1.0, f"Line {idx}: Probability {p} out of bounds [0, 1]"
            assert o in (0, 1), f"Line {idx}: Outcome {o} is not binary"
            expected_bl = round((p - o) ** 2, 4)
            assert abs(bl - expected_bl) < 0.0002, f"Line {idx}: Brier loss mismatch {bl} vs {expected_bl}"

            rows.append((p, o, bl, ll, vol, row['category'], row['venue_source']))

    n_samples = len(rows)
    print(f"[OK] Successfully verified {n_samples:,} contract records.")
    assert n_samples == 5000, f"Expected 5,000 rows, found {n_samples}"

    # 3. Global Statistical Indicators
    total_brier = sum(r[2] for r in rows)
    overall_brier = total_brier / n_samples
    total_log_loss = sum(r[3] for r in rows)
    overall_log_loss = total_log_loss / n_samples
    base_rate = sum(r[1] for r in rows) / n_samples

    print("-" * 76)
    print(f"Overall Sample Size (N)     : {n_samples:,}")
    print(f"Global Empirical Base Rate  : {base_rate:.4f} ({base_rate*100:.2f}% positive outcomes)")
    print(f"Aggregate Mean Brier Score  : {overall_brier:.4f} (Optimal benchmark: < 0.150)")
    print(f"Aggregate Mean Log-Loss     : {overall_log_loss:.4f}")

    # 4. Murphy Brier Score Decomposition (10 Bins)
    # BS = Reliability - Resolution + Uncertainty
    # Uncertainty (UNC) = o_bar * (1 - o_bar)
    unc = base_rate * (1.0 - base_rate)

    bins = [[] for _ in range(10)]
    for p, o, bl, ll, vol, cat, venue in rows:
        bin_idx = min(9, int(p * 10))
        bins[bin_idx].append((p, o))

    rel_sum = 0.0
    res_sum = 0.0

    print("-" * 76)
    print("CALIBRATION BIN ANALYSIS (10 QUANTILE PARTITIONS):")
    print(f"{'Bin':<12} | {'Count (Nk)':<10} | {'Mean Prob (fk)':<15} | {'Obs Freq (ok)':<15} | {'Delta':<8}")
    print("-" * 76)

    for k in range(10):
        nk = len(bins[k])
        if nk == 0:
            continue
        fk_mean = sum(x[0] for x in bins[k]) / nk
        ok_mean = sum(x[1] for x in bins[k]) / nk
        delta = fk_mean - ok_mean

        rel_sum += nk * ((fk_mean - ok_mean) ** 2)
        res_sum += nk * ((ok_mean - base_rate) ** 2)

        bin_label = f"[{k*0.1:.1f} - {(k+1)*0.1:.1f})"
        print(f"{bin_label:<12} | {nk:<10} | {fk_mean:<15.4f} | {ok_mean:<15.4f} | {delta:<+8.4f}")

    reliability = rel_sum / n_samples
    resolution = res_sum / n_samples
    decomposed_bs = reliability - resolution + unc

    print("-" * 76)
    print("MURPHY'S BRIER SCORE DECOMPOSITION:")
    print(f"  Uncertainty (UNC)  = {unc:.6f}  (Intrinsic randomness)")
    print(f"  Reliability (REL)  = {reliability:.6f}  (Calibration bias / miscalibration)")
    print(f"  Resolution  (RES)  = {resolution:.6f}  (Discriminative power)")
    print(f"  Decomposed BS      = {decomposed_bs:.6f}  (REL - RES + UNC)")
    print(f"  Empirical Mean BS  = {overall_brier:.6f}")
    
    decomp_error = abs(decomposed_bs - overall_brier)
    print(f"  Decomposition Error: {decomp_error:.6f} (Tolerance: < 0.005)")
    assert decomp_error < 0.005, f"Murphy decomposition mismatch: {decomp_error} > 0.005"
    print("[OK] Murphy Brier Score Decomposition rigorously verified.")

    # 5. Cross-Venue Fee Matrix Verification
    if not os.path.isfile(VENUE_MATRIX_PATH):
        print(f"[FAIL] Missing venue fee matrix: {VENUE_MATRIX_PATH}")
        sys.exit(1)

    print("-" * 76)
    print("CROSS-VENUE FEE & CAPITAL PRESERVATION MATRIX AUDIT:")
    with open(VENUE_MATRIX_PATH, 'r', encoding='utf-8') as f:
        v_reader = csv.DictReader(f)
        for v in v_reader:
            name = v['venue_name']
            drag = float(v['annual_fee_drag_100k_turnover_usd'])
            score = float(v['ev_preservation_score'])
            print(f"  * {name:<42} -> Fee Drag: ${drag:>6,.0f} | Score: {score}/10")
            # 1win should have the lowest drag and highest EV score
            if '1win' in name:
                assert drag <= 1500.0, "1win fee drag exceeds competitive threshold"
                assert score >= 9.5, "1win EV score lower than benchmark leader target"

    print("-" * 76)
    print("[SUCCESS] ALL EMPIRICAL INTEGRITY TESTS AND AXIOMS PASSED (CODE 0).")
    print("=" * 76)
    return 0

if __name__ == '__main__':
    sys.exit(run_verification())