"""
Train a trajectory quality predictor.

Input: intermediate measurement record
Output: P(final measurement correct)

This learns the optimal weighting function from data.
"""

import json
import numpy as np
from pathlib import Path
from sklearn.model_selection import train_test_split, cross_val_score
from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score, roc_auc_score, brier_score_loss
from sklearn.calibration import calibration_curve
import warnings
warnings.filterwarnings('ignore')


def parse_trajectory(bitstring, n_meas, expect='0'):
    """
    Parse a Zeno trajectory bitstring.

    Qiskit convention: rightmost = first measured
    bits[0] = final measurement
    bits[1:n_meas+1] = intermediate measurements
    """
    if len(bitstring) < n_meas + 1:
        return None

    final = bitstring[0]
    intermediate = bitstring[1:n_meas+1]

    n_flips = intermediate.count('1')
    flip_positions = [i for i, b in enumerate(intermediate) if b == '1']

    correct = 1 if final == expect else 0

    return {
        'n_flips': n_flips,
        'n_meas': n_meas,
        'flip_positions': flip_positions,
        'correct': correct,
        'final': final,
        'intermediate': intermediate,
    }


def build_features(traj, max_positions=16):
    """
    Build feature vector from parsed trajectory.

    Features:
    - n_flips: total flip count
    - n_meas: number of intermediate measurements
    - flip_rate: n_flips / n_meas
    - position indicators: which positions had flips
    - early_flips: flips in first half
    - late_flips: flips in second half
    """
    n_flips = traj['n_flips']
    n_meas = traj['n_meas']

    features = [
        n_flips,
        n_meas,
        n_flips / n_meas if n_meas > 0 else 0,
    ]

    pos_vec = [0] * max_positions
    for p in traj['flip_positions']:
        if p < max_positions:
            pos_vec[p] = 1
    features.extend(pos_vec)

    mid = n_meas // 2
    early_flips = sum(1 for p in traj['flip_positions'] if p < mid)
    late_flips = sum(1 for p in traj['flip_positions'] if p >= mid)
    features.extend([early_flips, late_flips])

    return features


def load_trajectory_data():
    """Load all trajectory data from results."""
    X = []
    y = []
    meta = []

    results_dir = Path('D:/qiskit-zenodragging/results')

    traj_file = results_dir / 'trajectory_estimation' / 'trajectory_estimation.json'
    if traj_file.exists():
        with open(traj_file) as f:
            data = json.load(f)

        for circuit_name, circuit_data in data['data'].items():
            n_meas = circuit_data['n_meas']
            expect = circuit_data.get('expect', '0')

            if 'freeze' in circuit_name or 'x_freeze' in circuit_name:
                expect = '0'
            elif 'drag' in circuit_name:
                expect = '1'

            for bs in circuit_data['bitstrings']:
                traj = parse_trajectory(bs, n_meas, expect)
                if traj:
                    X.append(build_features(traj))
                    y.append(traj['correct'])
                    meta.append({
                        'circuit': circuit_name,
                        'n_meas': n_meas,
                        'n_flips': traj['n_flips'],
                    })

    vqe_file = results_dir / 'vqe_trajectory_validation' / 'vqe_trajectory_validation.json'
    if vqe_file.exists():
        with open(vqe_file) as f:
            data = json.load(f)

        for result_name, result_data in data.get('results', {}).items():
            if 'bitstrings' not in result_data:
                continue
            if result_data.get('type') != 'zeno':
                continue

            n_meas = 8
            true_z = result_data.get('true_z', 0)
            expect = '0' if true_z >= 0 else '1'

            for bs in result_data['bitstrings']:
                traj = parse_trajectory(bs, n_meas, expect)
                if traj:
                    X.append(build_features(traj))
                    y.append(traj['correct'])
                    meta.append({
                        'circuit': result_name,
                        'n_meas': n_meas,
                        'n_flips': traj['n_flips'],
                    })

    return np.array(X), np.array(y), meta


def exponential_weight(n_flips, decay=1.0):
    """Baseline exponential weighting."""
    return np.exp(-decay * n_flips)


def evaluate_weighting(y_true, y_pred_proba, meta):
    """
    Evaluate a weighting scheme.

    Returns effective yield = weighted_fidelity * utilization
    """
    weights = y_pred_proba

    weighted_correct = np.sum(weights * y_true)
    total_weight = np.sum(weights)

    weighted_fidelity = weighted_correct / total_weight if total_weight > 0 else 0
    utilization = total_weight / len(y_true)
    effective_yield = weighted_fidelity * utilization

    return {
        'weighted_fidelity': weighted_fidelity,
        'utilization': utilization,
        'effective_yield': effective_yield,
    }


def bootstrap_ci(metric_fn, y_true, y_pred, n_bootstrap=1000, ci=0.95):
    """Compute bootstrap confidence interval for a metric."""
    n = len(y_true)
    scores = []

    for _ in range(n_bootstrap):
        idx = np.random.choice(n, n, replace=True)
        score = metric_fn(y_true[idx], y_pred[idx])
        scores.append(score)

    alpha = (1 - ci) / 2
    lower = np.percentile(scores, alpha * 100)
    upper = np.percentile(scores, (1 - alpha) * 100)
    mean = np.mean(scores)

    return mean, lower, upper


def main():
    print("=" * 70)
    print("TRAJECTORY QUALITY MODEL TRAINING")
    print("=" * 70)

    print("\n[1/5] Loading data...")
    X, y, meta = load_trajectory_data()
    print(f"  Samples: {len(X)}")
    print(f"  Features: {X.shape[1]}")
    print(f"  Label balance: {y.mean():.1%} correct")

    print("\n[2/5] Train/test split...")
    X_train, X_test, y_train, y_test, meta_train, meta_test = train_test_split(
        X, y, meta, test_size=0.2, random_state=42, stratify=y
    )
    print(f"  Train: {len(X_train)}, Test: {len(X_test)}")

    print("\n[3/5] Training models...")

    models = {
        'LogisticRegression': LogisticRegression(max_iter=1000),
        'RandomForest': RandomForestClassifier(n_estimators=100, max_depth=10, random_state=42),
        'GradientBoosting': GradientBoostingClassifier(n_estimators=100, max_depth=5, random_state=42),
    }

    results = {}

    for name, model in models.items():
        print(f"\n  Training {name}...")
        model.fit(X_train, y_train)

        y_pred = model.predict(X_test)
        y_proba = model.predict_proba(X_test)[:, 1]

        acc = accuracy_score(y_test, y_pred)
        auc = roc_auc_score(y_test, y_proba)
        brier = brier_score_loss(y_test, y_proba)

        acc_mean, acc_lo, acc_hi = bootstrap_ci(
            lambda yt, yp: accuracy_score(yt, (yp > 0.5).astype(int)),
            y_test, y_proba, n_bootstrap=500
        )

        auc_mean, auc_lo, auc_hi = bootstrap_ci(
            roc_auc_score, y_test, y_proba, n_bootstrap=500
        )

        results[name] = {
            'model': model,
            'accuracy': acc,
            'accuracy_ci': (acc_lo, acc_hi),
            'auc': auc,
            'auc_ci': (auc_lo, auc_hi),
            'brier': brier,
            'y_proba': y_proba,
        }

        print(f"    Accuracy: {acc:.3f} [{acc_lo:.3f}, {acc_hi:.3f}]")
        print(f"    AUC:      {auc:.3f} [{auc_lo:.3f}, {auc_hi:.3f}]")
        print(f"    Brier:    {brier:.4f}")

    print("\n[4/5] Comparing weighting strategies...")

    n_flips_test = np.array([m['n_flips'] for m in meta_test])

    strategies = {
        'Hard (k=0)': (n_flips_test == 0).astype(float),
        'Soft (k<=1)': (n_flips_test <= 1).astype(float),
        'Soft (k<=2)': (n_flips_test <= 2).astype(float),
        'Exp(-n)': exponential_weight(n_flips_test, decay=1.0),
        'Exp(-0.5n)': exponential_weight(n_flips_test, decay=0.5),
    }

    for name, model_result in results.items():
        strategies[f'Model: {name}'] = model_result['y_proba']

    print("\n{:<25} | {:>10} | {:>10} | {:>12}".format(
        "Strategy", "Fidelity", "Util.", "Eff. Yield"))
    print("-" * 65)

    strategy_results = {}
    for strat_name, weights in strategies.items():
        eval_result = evaluate_weighting(y_test, weights, meta_test)
        strategy_results[strat_name] = eval_result

        print("{:<25} | {:>9.1%} | {:>9.1%} | {:>11.1%}".format(
            strat_name,
            eval_result['weighted_fidelity'],
            eval_result['utilization'],
            eval_result['effective_yield'],
        ))

    print("\n[5/5] Feature importance (best model)...")

    best_model_name = max(results.keys(), key=lambda k: results[k]['auc'])
    best_model = results[best_model_name]['model']

    feature_names = ['n_flips', 'n_meas', 'flip_rate'] + \
                    [f'pos_{i}' for i in range(16)] + \
                    ['early_flips', 'late_flips']

    if hasattr(best_model, 'feature_importances_'):
        importances = best_model.feature_importances_
        sorted_idx = np.argsort(importances)[::-1]

        print(f"\n  Top features ({best_model_name}):")
        for i in sorted_idx[:10]:
            print(f"    {feature_names[i]}: {importances[i]:.4f}")

    print("\n" + "=" * 70)
    print("SUMMARY")
    print("=" * 70)

    best_strat = max(strategy_results.keys(),
                     key=lambda k: strategy_results[k]['effective_yield'])

    print(f"\nBest weighting strategy: {best_strat}")
    print(f"  Effective yield: {strategy_results[best_strat]['effective_yield']:.1%}")

    exp_yield = strategy_results['Exp(-n)']['effective_yield']
    best_yield = strategy_results[best_strat]['effective_yield']

    if best_strat.startswith('Model'):
        improvement = (best_yield - exp_yield) / exp_yield * 100
        print(f"\n  Model improves over Exp(-n) by: {improvement:+.1f}%")
    else:
        print(f"\n  Exp(-n) remains competitive (learned model not better)")

    output = {
        'dataset_size': len(X),
        'train_size': len(X_train),
        'test_size': len(X_test),
        'models': {
            name: {
                'accuracy': r['accuracy'],
                'accuracy_ci': r['accuracy_ci'],
                'auc': r['auc'],
                'auc_ci': r['auc_ci'],
                'brier': r['brier'],
            }
            for name, r in results.items()
        },
        'weighting_strategies': {
            name: {
                'fidelity': r['weighted_fidelity'],
                'utilization': r['utilization'],
                'effective_yield': r['effective_yield'],
            }
            for name, r in strategy_results.items()
        },
        'best_strategy': best_strat,
    }

    out_file = Path('D:/kishka/data/trajectory_model_results.json')
    out_file.parent.mkdir(exist_ok=True)
    with open(out_file, 'w') as f:
        json.dump(output, f, indent=2)

    print(f"\nSaved: {out_file}")

    return output


if __name__ == "__main__":
    main()