import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from sklearn.linear_model import LogisticRegression
from sklearn.neighbors import KNeighborsClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
from sklearn.svm import SVC
from sklearn.naive_bayes import GaussianNB
from sklearn.model_selection import train_test_split, cross_val_score, StratifiedKFold
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import confusion_matrix

wine = pd.read_csv('wine.csv')
feature_cols = [c for c in wine.columns if c != 'target']
print(f'Real wines in this dataset: {len(wine)}')
print(f'Real chemical features: {len(feature_cols)}')

X = wine[feature_cols].values
y = wine['target'].values
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25, random_state=42, stratify=y)
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)
skf = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
print(f'Real training wines: {len(X_train)}')
print(f'Real test wines: {len(X_test)}')

models = {
    'Logistic Regression': (LogisticRegression(max_iter=1000), True),
    'KNN (k=5)': (KNeighborsClassifier(n_neighbors=5), True),
    'Decision Tree': (DecisionTreeClassifier(random_state=42), False),
    'Random Forest': (RandomForestClassifier(n_estimators=100, random_state=42), False),
    'Gradient Boosting': (GradientBoostingClassifier(random_state=42), False),
    'SVM (RBF)': (SVC(kernel='rbf', random_state=42), True),
    'Naive Bayes': (GaussianNB(), True),
}
print(f'Real algorithms entered into this comparison: {len(models)}')

results = {}
for name, (model, needs_scaling) in models.items():
    X_tr = X_train_scaled if needs_scaling else X_train
    X_te = X_test_scaled if needs_scaling else X_test
    cv_scores = cross_val_score(model, X_tr, y_train, cv=skf, scoring='accuracy')
    model.fit(X_tr, y_train)
    test_accuracy = model.score(X_te, y_test)
    results[name] = (cv_scores.mean(), cv_scores.std(), test_accuracy)
    print(f'{name}: real CV mean={cv_scores.mean():.4f}, real CV std={cv_scores.std():.4f}, real test acc={test_accuracy:.4f}')

names = list(results.keys())
means = [results[n][0] for n in names]
stds = [results[n][1] for n in names]
plt.figure(figsize=(11, 6))
plt.bar(names, means, yerr=stds, capsize=5, color='steelblue')
plt.title('Real Cross-Validated Accuracy by Algorithm')
plt.xlabel('Algorithm')
plt.ylabel('CV Accuracy')
plt.xticks(rotation=30, ha='right')
plt.ylim(0.8, 1.02)
plt.tight_layout()
plt.savefig('algorithm_comparison.png', dpi=150)
plt.show()

svm_folds = cross_val_score(SVC(kernel='rbf', random_state=42), X_train_scaled, y_train, cv=skf, scoring='accuracy')
rf_folds = cross_val_score(RandomForestClassifier(n_estimators=100, random_state=42), X_train, y_train, cv=skf, scoring='accuracy')
logreg_folds = cross_val_score(LogisticRegression(max_iter=1000), X_train_scaled, y_train, cv=skf, scoring='accuracy')
print(f'Real SVM per-fold scores: {[round(s, 4) for s in svm_folds]}')
print(f'Real Random Forest per-fold scores: {[round(s, 4) for s in rf_folds]}')
print(f'Real Logistic Regression per-fold scores: {[round(s, 4) for s in logreg_folds]}')

svm_final = SVC(kernel='rbf', random_state=42).fit(X_train_scaled, y_train)
svm_pred = svm_final.predict(X_test_scaled)
print('Real SVM test confusion matrix:')
print(confusion_matrix(y_test, svm_pred))
logreg_final = LogisticRegression(max_iter=1000).fit(X_train_scaled, y_train)
logreg_pred = logreg_final.predict(X_test_scaled)
print('Real logistic regression test confusion matrix:')
print(confusion_matrix(y_test, logreg_pred))

import joblib
joblib.dump(logreg_final, 'capstone_final_model.joblib')
reloaded_model = joblib.load('capstone_final_model.joblib')
print(f'Real original model test accuracy: {logreg_final.score(X_test_scaled, y_test):.4f}')
print(f'Real reloaded model test accuracy: {reloaded_model.score(X_test_scaled, y_test):.4f}')

results_df = pd.DataFrame([
    {'Algorithm': n, 'CV_Mean_Accuracy': round(v[0], 4), 'CV_Std': round(v[1], 4), 'Test_Accuracy': round(v[2], 4)}
    for n, v in results.items()
])
results_df.to_csv('algorithm_comparison_results.csv', index=False)
print('Real comparison table saved to algorithm_comparison_results.csv')
print(results_df)