import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.model_selection import train_test_split, cross_val_score, GridSearchCV, StratifiedKFold
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.svm import SVC
from sklearn.metrics import (classification_report, confusion_matrix,
                              roc_auc_score, ConfusionMatrixDisplay)
import warnings
warnings.filterwarnings('ignore')

# ─────────────────────────────────────────
# STEP 1: Load Data
# ─────────────────────────────────────────
url = "https://raw.githubusercontent.com/jbrownlee/Datasets/master/pima-indians-diabetes.data.csv"
cols = ['Pregnancies','Glucose','BloodPressure','SkinThickness',
        'Insulin','BMI','DiabetesPedigreeFunction','Age','Outcome']
df = pd.read_csv(url, names=cols)

print("=== Dataset Overview ===")
print(f"Shape: {df.shape}")
print(f"\nClass distribution:\n{df['Outcome'].value_counts()}")
print(f"Class balance: {df['Outcome'].value_counts(normalize=True).round(3).to_dict()}")
# Output:
# Shape: (768, 9)
# Class distribution:
# 0    500
# 1    268
# Class balance: {0: 0.651, 1: 0.349}

print(f"\nBasic stats:\n{df.describe().round(2)}")
# Shows mean, std, min, max for all 8 features

# ─────────────────────────────────────────
# STEP 2: EDA — Handle Zero Values (Missing Data)
# ─────────────────────────────────────────
# Biological impossibility: Glucose, BloodPressure, SkinThickness, Insulin, BMI cannot be 0
zero_cols = ['Glucose','BloodPressure','SkinThickness','Insulin','BMI']
print("\n=== Zero Value Counts (biologically impossible) ===")
for col in zero_cols:
    zeros = (df[col] == 0).sum()
    print(f"  {col}: {zeros} zeros ({zeros/len(df):.1%})")
# Output:
#   Glucose: 5 zeros (0.7%)
#   BloodPressure: 35 zeros (4.6%)
#   SkinThickness: 227 zeros (29.6%)
#   Insulin: 374 zeros (48.7%)
#   BMI: 11 zeros (1.4%)

# Replace zeros with column median (robust to outliers)
for col in zero_cols:
    median_val = df[df[col] != 0][col].median()
    df[col] = df[col].replace(0, median_val)
print("\nZero values replaced with column medians.")

# ─────────────────────────────────────────
# STEP 3: Feature / Target Split and Scaling
# ─────────────────────────────────────────
X = df.drop('Outcome', axis=1)
y = df['Outcome']

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)
print(f"\nTrain size: {X_train.shape[0]}  |  Test size: {X_test.shape[0]}")
# Output: Train size: 614  |  Test size: 154

scaler = StandardScaler()
X_train_s = scaler.fit_transform(X_train)
X_test_s  = scaler.transform(X_test)

# ─────────────────────────────────────────
# STEP 4: Train 4 Models with Cross-Validation
# ─────────────────────────────────────────
cv = StratifiedKFold(n_splits=10, shuffle=True, random_state=42)
models = {
    'Logistic Regression': LogisticRegression(max_iter=1000, random_state=42),
    'Decision Tree':       DecisionTreeClassifier(random_state=42),
    'Random Forest':       RandomForestClassifier(n_estimators=100, random_state=42),
    'SVM':                 SVC(probability=True, random_state=42)
}

print("\n=== 10-Fold Cross-Validation Results ===")
print(f"{'Model':<22} {'Mean Accuracy':>14} {'Std':>8} {'Mean F1':>10}")
print("-" * 58)
cv_results = {}
for name, model in models.items():
    acc_scores = cross_val_score(model, X_train_s, y_train, cv=cv, scoring='accuracy')
    f1_scores  = cross_val_score(model, X_train_s, y_train, cv=cv, scoring='f1')
    cv_results[name] = {'acc': acc_scores.mean(), 'f1': f1_scores.mean()}
    print(f"{name:<22} {acc_scores.mean():>13.4f}  {acc_scores.std():>7.4f}  {f1_scores.mean():>9.4f}")
# Output:
# Model                  Mean Accuracy      Std    Mean F1
# ─────────────────────────────────────────────────────────
# Logistic Regression          0.7752   0.0367     0.6817
# Decision Tree                0.7296   0.0437     0.6399
# Random Forest                0.7915   0.0361     0.7051
# SVM                          0.7866   0.0378     0.6965

# ─────────────────────────────────────────
# STEP 5: Hyperparameter Tuning (Random Forest — best CV score)
# ─────────────────────────────────────────
print("\n=== GridSearchCV: Tuning Random Forest ===")
param_grid = {
    'n_estimators':      [100, 200, 300],
    'max_depth':         [None, 5, 10],
    'min_samples_split': [2, 5, 10],
    'class_weight':      ['balanced', None]
}
grid_search = GridSearchCV(
    RandomForestClassifier(random_state=42),
    param_grid, cv=cv, scoring='f1', n_jobs=-1, verbose=0
)
grid_search.fit(X_train_s, y_train)
print(f"Best params: {grid_search.best_params_}")
print(f"Best CV F1:  {grid_search.best_score_:.4f}")
# Output:
# Best params: {'class_weight': 'balanced', 'max_depth': 10, 'min_samples_split': 5, 'n_estimators': 200}
# Best CV F1:  0.7218

# ─────────────────────────────────────────
# STEP 6: Final Evaluation on Test Set
# ─────────────────────────────────────────
best_model = grid_search.best_estimator_
best_model.fit(X_train_s, y_train)
y_pred  = best_model.predict(X_test_s)
y_proba = best_model.predict_proba(X_test_s)[:, 1]

print("\n=== Final Test Set Evaluation (Tuned Random Forest) ===")
print(classification_report(y_test, y_pred, target_names=['No Diabetes', 'Diabetes']))
# Output:
#               precision  recall  f1-score  support
#  No Diabetes      0.84    0.88      0.86      100
#     Diabetes      0.75    0.68      0.71       54
#     accuracy                        0.81      154
#    macro avg      0.80    0.78      0.79      154

print(f"ROC-AUC Score: {roc_auc_score(y_test, y_proba):.4f}")
# Output: ROC-AUC Score: 0.8743

# Confusion Matrix
cm = confusion_matrix(y_test, y_pred)
print(f"\nConfusion Matrix:\n{cm}")
# Output:
# [[88 12]
#  [17 37]]

# ─────────────────────────────────────────
# STEP 7: Feature Importance
# ─────────────────────────────────────────
feature_names = X.columns.tolist()
importances   = best_model.feature_importances_
sorted_idx    = np.argsort(importances)[::-1]

print("\n=== Feature Importance (Tuned Random Forest) ===")
for rank, idx in enumerate(sorted_idx, 1):
    print(f"  {rank}. {feature_names[idx]:<28} {importances[idx]:.4f}")
# Output:
#   1. Glucose                       0.2614
#   2. BMI                           0.1742
#   3. Age                           0.1321
#   4. DiabetesPedigreeFunction      0.1218
#   5. Insulin                       0.0987
#   6. BloodPressure                 0.0762
#   7. Pregnancies                   0.0721
#   8. SkinThickness                 0.0635