# Suppress warnings for a cleaner learning environment
import warnings; warnings.filterwarnings('ignore')
import numpy as np
np.random.seed(42)

# Data setup (Pima Indians Diabetes Dataset)
import pandas as pd
url = 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/pima-indians-diabetes.data.csv'
cols = ['Pregnancies','Glucose','BloodPressure','SkinThickness','Insulin','BMI','DiabetesPedigree','Age','Outcome']
df = pd.read_csv(url, names=cols)
print(df.shape)
print(df.head(3))

# Quick check for missing data or unusual values
print(df.isnull().sum())
print('Zeroes in columns:')
print((df == 0).sum())

# Replace zero values in specific columns with the median (except 'Pregnancies' and 'Outcome')
cols_with_zero_na = ['Glucose','BloodPressure','SkinThickness','Insulin','BMI']
for col in cols_with_zero_na:
    df[col] = df[col].replace(0, df[col].median())
print(df[cols_with_zero_na].head(3))

# Splitting data into input features and target label
X = df.drop('Outcome', axis=1)
y = df['Outcome']
print(X.shape, y.shape)

# Split data: 75% training, 25% testing
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25, random_state=42)
print(X_train.shape, X_test.shape)

# Standardize features for SVM
from sklearn.preprocessing import StandardScaler
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

# Train an SVM model
from sklearn.svm import SVC
svm_model = SVC(random_state=42)
svm_model.fit(X_train_scaled, y_train)

# Make predictions and evaluate accuracy
from sklearn.metrics import accuracy_score
y_pred = svm_model.predict(X_test_scaled)
acc = accuracy_score(y_test, y_pred)
print(f'SVM accuracy: {acc:.2%}')

# View confusion matrix for deeper insights
from sklearn.metrics import confusion_matrix
cm = confusion_matrix(y_test, y_pred)
print(cm)

# Try linear kernel SVM
svm_linear = SVC(kernel='linear', random_state=42)
svm_linear.fit(X_train_scaled, y_train)
y_pred_linear = svm_linear.predict(X_test_scaled)
print('Linear kernel accuracy:', accuracy_score(y_test, y_pred_linear))

# Tune the penalty parameter C to see its effect
svm_c_high = SVC(C=5.0, random_state=42)
svm_c_high.fit(X_train_scaled, y_train)
acc_high = accuracy_score(y_test, svm_c_high.predict(X_test_scaled))
svm_c_low = SVC(C=0.1, random_state=42)
svm_c_low.fit(X_train_scaled, y_train)
acc_low = accuracy_score(y_test, svm_c_low.predict(X_test_scaled))
print(f'High C accuracy: {acc_high:.2%}')
print(f'Low C accuracy: {acc_low:.2%}')

# Try a mini grid search for hyperparameter tuning
from sklearn.model_selection import GridSearchCV
params = {'C': [0.1, 1, 10], 'kernel': ['linear', 'rbf']}
grid = GridSearchCV(SVC(random_state=42), params, cv=3)
grid.fit(X_train_scaled, y_train)
print('Best params:', grid.best_params_)
print('Best cross-validation score:', grid.best_score_)

# ROC curve for SVM performance
from sklearn.metrics import roc_curve, auc
import matplotlib.pyplot as plt
y_scores = svm_model.decision_function(X_test_scaled)
fpr, tpr, thresholds = roc_curve(y_test, y_scores)
roc_auc = auc(fpr, tpr)
plt.plot(fpr, tpr, label=f'AUC = {roc_auc:.2f}')
plt.plot([0, 1], [0, 1], linestyle='--', color='gray')
plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate')
plt.title('SVM ROC Curve')
plt.legend()
plt.show()

# Simulate screening a new patient
user_input = [6, 140, 70, 28, 0, 35.0, 0.537, 41]
import numpy as np
user_input = np.array(user_input).reshape(1, -1)
user_input[:, 1:6] = np.where(user_input[:, 1:6]==0, [df[c].median() for c in cols_with_zero_na], user_input[:, 1:6])
user_input_scaled = scaler.transform(user_input)
pred = svm_model.predict(user_input_scaled)
print('Diabetes risk:' , 'Positive' if pred[0]==1 else 'Negative')

# Self-check: Try classifying your own row! Enter numbers and run live prediction.
input_row = input('Enter 8 numbers (comma-separated) for a new patient: ')
try:
    user_vals = [float(n.strip()) for n in input_row.split(',')]
    arr = np.array(user_vals).reshape(1, -1)
    arr[:, 1:6] = np.where(arr[:, 1:6]==0, [df[c].median() for c in cols_with_zero_na], arr[:, 1:6])
    arr_scaled = scaler.transform(arr)
    result = svm_model.predict(arr_scaled)
    print('This patient is', 'Diabetes Positive' if result[0]==1 else 'Diabetes Negative')
except:
    print('Could not parse your input. Please try again.')