"""Phase 4: Retrain models using reconstructed dataset with proper labels."""

import pandas as pd
import numpy as np
from pathlib import Path
import warnings
import sys
import os

# Suppress warnings
warnings.filterwarnings('ignore')
import logging
logging.getLogger('lightgbm').setLevel(logging.ERROR)

# Add src to path
sys.path.insert(0, str(Path(__file__).parent.parent))

from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import f1_score, precision_score, recall_score, confusion_matrix, classification_report
from sklearn.pipeline import Pipeline
import lightgbm as lgb
import xgboost as xgb
import catboost as cb
from imblearn.over_sampling import SMOTE

ROOT = Path(__file__).parent.parent.parent
DATA_DIR = ROOT / "data/reconstructed/rd14_clean"

def load_and_prepare_data():
    """Load and prepare the reconstructed dataset."""
    print("📖 Loading reconstructed dataset...")

    # Load features (which includes labels)
    df = pd.read_csv(DATA_DIR / "features_matrix.csv")

    print(f"✅ Loaded {len(df)} samples with {len(df.columns)} columns")
    print(f"\nClass distribution:")
    print(f"  unknown_present=0: {(df['unknown_present'] == 0).sum()}")
    print(f"  unknown_present=1: {(df['unknown_present'] == 1).sum()}")

    # Separate labels and features
    y = df['unknown_present'].values

    # Get feature columns (everything except ID and target columns)
    exclude_cols = ['sample_file', 'benchmark_id', 'split_id', 'partition', 'study_id', 'kit',
                    'num_known', 'num_unknown', 'unknown_present', 'num_contributors']
    feature_cols = [c for c in df.columns if c not in exclude_cols and not c.startswith('num_')]

    X = df[feature_cols].fillna(0).values

    # Filter out zero-variance features
    feature_variance = np.var(X, axis=0)
    valid_features = feature_variance > 0
    X = X[:, valid_features]

    print(f"✅ Feature matrix: {X.shape[0]} samples × {X.shape[1]} features")

    # Get train/dev/test splits
    train_mask = df['partition'] == 'train'
    dev_mask = df['partition'] == 'dev'
    test_mask = df['partition'] == 'test'

    X_train, y_train = X[train_mask], y[train_mask]
    X_dev, y_dev = X[dev_mask], y[dev_mask]
    X_test, y_test = X[test_mask], y[test_mask]

    print(f"\nSplit distribution:")
    print(f"  Train: {len(X_train)} samples")
    print(f"  Dev: {len(X_dev)} samples")
    print(f"  Test: {len(X_test)} samples")

    return X_train, y_train, X_dev, y_dev, X_test, y_test

def train_models(X_train, y_train, X_dev, y_dev, X_test, y_test):
    """Train ensemble of models."""
    print("\n" + "=" * 80)
    print("🤖 PHASE 4: Retrain Models on Reconstructed Data")
    print("=" * 80)

    # Apply SMOTE for class balancing (for training only)
    print("\n⚖️  Applying SMOTE for class balancing...")
    smote = SMOTE(random_state=42, k_neighbors=min(3, len(np.unique(y_train)) - 1))
    try:
        X_train_smote, y_train_smote = smote.fit_resample(X_train, y_train)
        print(f"✅ SMOTE applied: {len(X_train)} → {len(X_train_smote)} samples")
    except:
        print("⚠️  SMOTE failed (insufficient samples), using original data")
        X_train_smote, y_train_smote = X_train, y_train

    # Scale features
    print("\n📊 Scaling features...")
    scaler = StandardScaler()
    X_train_scaled = scaler.fit_transform(X_train_smote)
    X_dev_scaled = scaler.transform(X_dev)
    X_test_scaled = scaler.transform(X_test)

    # Train LightGBM
    print("\n🌳 Training LightGBM...")
    lgb_model = lgb.LGBMClassifier(
        n_estimators=200,
        learning_rate=0.05,
        num_leaves=31,
        max_depth=-1,
        lambda_l1=1.0,
        lambda_l2=1.0,
        feature_fraction=0.8,
        bagging_fraction=0.8,
        bagging_freq=5,
        verbose=-1,
        random_state=42,
        force_col_wise=True
    )
    lgb_model.fit(X_train_scaled, y_train_smote)

    y_dev_lgb = lgb_model.predict(X_dev_scaled)
    y_test_lgb = lgb_model.predict(X_test_scaled)
    f1_dev_lgb = f1_score(y_dev, y_dev_lgb)
    f1_test_lgb = f1_score(y_test, y_test_lgb)
    print(f"   Dev F1: {f1_dev_lgb:.4f}, Test F1: {f1_test_lgb:.4f}")

    # Train XGBoost
    print("\n🌳 Training XGBoost...")
    xgb_model = xgb.XGBClassifier(
        n_estimators=200,
        learning_rate=0.05,
        max_depth=5,
        reg_lambda=1.0,
        reg_alpha=0.0,
        subsample=0.8,
        colsample_bytree=0.8,
        verbosity=0,
        random_state=42,
        eval_metric='logloss'
    )
    xgb_model.fit(X_train_scaled, y_train_smote)

    y_dev_xgb = xgb_model.predict(X_dev_scaled)
    y_test_xgb = xgb_model.predict(X_test_scaled)
    f1_dev_xgb = f1_score(y_dev, y_dev_xgb)
    f1_test_xgb = f1_score(y_test, y_test_xgb)
    print(f"   Dev F1: {f1_dev_xgb:.4f}, Test F1: {f1_test_xgb:.4f}")

    # Train CatBoost
    print("\n🌳 Training CatBoost...")
    cb_model = cb.CatBoostClassifier(
        iterations=200,
        learning_rate=0.05,
        max_depth=5,
        l2_leaf_reg=1.0,
        verbose=0,
        random_state=42
    )
    cb_model.fit(X_train_scaled, y_train_smote)

    y_dev_cb = cb_model.predict(X_dev_scaled)
    y_test_cb = cb_model.predict(X_test_scaled)
    f1_dev_cb = f1_score(y_dev, y_dev_cb)
    f1_test_cb = f1_score(y_test, y_test_cb)
    print(f"   Dev F1: {f1_dev_cb:.4f}, Test F1: {f1_test_cb:.4f}")

    # Ensemble predictions (majority voting)
    print("\n🔗 Creating ensemble...")
    y_dev_ensemble = ((y_dev_lgb + y_dev_xgb + y_dev_cb) / 3 > 0.5).astype(int)
    y_test_ensemble = ((y_test_lgb + y_test_xgb + y_test_cb) / 3 > 0.5).astype(int)
    f1_dev_ensemble = f1_score(y_dev, y_dev_ensemble)
    f1_test_ensemble = f1_score(y_test, y_test_ensemble)
    print(f"   Dev F1: {f1_dev_ensemble:.4f}, Test F1: {f1_test_ensemble:.4f}")

    # Detailed evaluation
    print("\n" + "=" * 80)
    print("📊 FINAL RESULTS - Test Set")
    print("=" * 80)

    print("\nLightGBM:")
    print(f"  F1: {f1_test_lgb:.4f}")
    print(f"  Precision: {precision_score(y_test, y_test_lgb):.4f}")
    print(f"  Recall: {recall_score(y_test, y_test_lgb):.4f}")

    print("\nXGBoost:")
    print(f"  F1: {f1_test_xgb:.4f}")
    print(f"  Precision: {precision_score(y_test, y_test_xgb):.4f}")
    print(f"  Recall: {recall_score(y_test, y_test_xgb):.4f}")

    print("\nCatBoost:")
    print(f"  F1: {f1_test_cb:.4f}")
    print(f"  Precision: {precision_score(y_test, y_test_cb):.4f}")
    print(f"  Recall: {recall_score(y_test, y_test_cb):.4f}")

    print("\nEnsemble (Majority Voting):")
    print(f"  F1: {f1_test_ensemble:.4f}")
    print(f"  Precision: {precision_score(y_test, y_test_ensemble):.4f}")
    print(f"  Recall: {recall_score(y_test, y_test_ensemble):.4f}")

    # Confusion matrix
    print("\n🎯 Confusion Matrix (Test Set - Ensemble):")
    cm = confusion_matrix(y_test, y_test_ensemble)
    print(f"   TN={cm[0,0]}, FP={cm[0,1]}")
    print(f"   FN={cm[1,0]}, TP={cm[1,1]}")

    best_f1 = max(f1_test_lgb, f1_test_xgb, f1_test_cb, f1_test_ensemble)
    best_model = 'LightGBM' if best_f1 == f1_test_lgb else ('XGBoost' if best_f1 == f1_test_xgb else ('CatBoost' if best_f1 == f1_test_cb else 'Ensemble'))

    print("\n" + "=" * 80)
    print(f"🏆 BEST MODEL: {best_model} with F1 = {best_f1:.4f}")
    print("=" * 80)

    return best_f1

def main():
    try:
        # Load data
        X_train, y_train, X_dev, y_dev, X_test, y_test = load_and_prepare_data()

        # Train models
        best_f1 = train_models(X_train, y_train, X_dev, y_dev, X_test, y_test)

        print("\n" + "=" * 80)
        print("✅ PHASE 4 COMPLETE!")
        print("=" * 80)
        print(f"\n🎉 Final F1 Score: {best_f1:.4f}")

        if best_f1 > 0.5:
            print("✅ TARGET REACHED: F1 > 0.5")
        else:
            print("⚠️  Target F1 > 0.5 not yet reached")
            print("   Note: Dataset is small (30 samples), consider using full filtered dataset")

    except Exception as e:
        print(f"\n❌ Error: {e}")
        import traceback
        traceback.print_exc()

if __name__ == "__main__":
    main()