import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler

data = pd.read_excel(
    r"C:\Users\lloyd\PycharmProjects\pythonProject\Telco_Customer_Churn.xlsx"
)

# get rid of unused columns
data.drop(columns=['CustomerID', 'Count', 'Country', 'State', 'City', 'Zip Code',
                   'Lat Long', 'Latitude', 'Longitude'], inplace=True)

# change to be numerical value
data['Total Charges'] = pd.to_numeric(data['Total Charges'], errors='coerce')

# drop the rows with missing values
data.dropna(inplace=True)

# encode categorical columns
categorical_columns = ['Gender', 'Senior Citizen', 'Partner', 'Dependents',
                       'Phone Service', 'Multiple Lines', 'Internet Service',
                       'Online Security', 'Online Backup', 'Device Protection',
                       'Tech Support', 'Streaming TV', 'Streaming Movies',
                       'Contract', 'Paperless Billing', 'Payment Method',
                       'Churn Reason']

data = pd.get_dummies(data, columns=categorical_columns, drop_first=True)

# Make 'Churn Label' numeric
data['Churn'] = data['Churn Label'].map({'Yes': 1, 'No': 0})
data.drop(columns=['Churn Label'], inplace=True)

# separate features and target
X = data.drop(columns=['Churn Score'])
y = data['Churn Score']

# split the data into training and testing sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# scale numerical features
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

from sklearn.metrics import classification_report
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, roc_auc_score

from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, roc_auc_score


def evaluate_model(y_true, y_pred, model, X_test):
    print(f"Accuracy: {accuracy_score(y_true, y_pred):.4f}")
    print(f"Precision (macro): {precision_score(y_true, y_pred, average='macro', zero_division=0.0):.4f}")
    print(f"Recall (macro): {recall_score(y_true, y_pred, average='macro'):.4f}")
    print(f"F1 Score (macro): {f1_score(y_true, y_pred, average='macro'):.4f}")

    # predicted probabilities for AUC
    if hasattr(model, "predict_proba"):
        y_prob = model.predict_proba(X_test)
    else:
        # for models that do not support predict_proba (like some versions of SVM)
        y_prob = model.decision_function(X_test)

    # for multiclass, handle AUC differently (ROC AUC requires predicted probabilities)
    try:
        print(f"AUC-ROC (macro): {roc_auc_score(y_true, y_prob, multi_class='ovr', average='macro'):.4f}")
    except ValueError:
        print("AUC-ROC: Cannot compute AUC for multiclass with this setup.")

# initialize and train the Logistic Regression model
lr_model = LogisticRegression()
lr_model.fit(X_train_scaled, y_train)

# predict and evaluate
y_pred_lr = lr_model.predict(X_test_scaled)
print("Logistic Regression Performance:")
print(classification_report(y_test, y_pred_lr))

from sklearn.svm import SVC

# initialize and train the SVM model
svm_model = SVC(probability=True)
svm_model.fit(X_train_scaled, y_train)

# predict and evaluate
y_pred_svm = svm_model.predict(X_test_scaled)
print("Support Vector Machine Performance:")
print(classification_report(y_test, y_pred_svm))

# split data
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, stratify=y)

# initialize models
lr_model = LogisticRegression()
svm_model = SVC(probability=True)

# train Logistic Regression
lr_model.fit(X_train, y_train)
y_pred_lr = lr_model.predict(X_test)

# train SVM
svm_model.fit(X_train, y_train)
y_pred_svm = svm_model.predict(X_test)

# check if the data is split correctly
print(X_train.shape)
print(y_train.shape)

# evaluate models
print("\nLogistic Regression - Performance Metrics:")
evaluate_model(y_test, y_pred_lr, lr_model, X_test)

print("\nSupport Vector Machine - Performance Metrics:")
evaluate_model(y_test, y_pred_svm, svm_model, X_test)

from sklearn.model_selection import GridSearchCV
from sklearn.linear_model import LogisticRegression
from sklearn.svm import SVC
from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, roc_auc_score

# logistic Regression hyperparameters
lr_param_grid = {
    'C': [0.01, 0.1, 1, 10, 100],  # Regularization strength
    'solver': ['liblinear', 'saga'],  # Optimization algorithm
    'max_iter': [100, 200, 300]  # Maximum number of iterations
}
# SVM hyperparameters
svm_param_grid = {
    'C': [0.01, 0.1, 1, 10, 100],  # Regularization strength
    'kernel': ['linear', 'rbf', 'poly'],  # Kernel type
    'gamma': ['scale', 'auto', 0.01, 0.1, 1],  # Kernel coefficient
    'degree': [3, 4, 5]  # Degree of the polynomial kernel
}

# initialize models
lr_model = LogisticRegression(max_iter=1000)
svm_model = SVC(probability=True)

# gridSearchCV for Logistic Regression
lr_grid_search = GridSearchCV(estimator=lr_model, param_grid=lr_param_grid, cv=5, scoring='accuracy', n_jobs=-1)
lr_grid_search.fit(X_train, y_train)
print("Best Logistic Regression parameters:", lr_grid_search.best_params_)

# gridSearchCV for SVM
svm_grid_search = GridSearchCV(estimator=svm_model, param_grid=svm_param_grid, cv=5, scoring='accuracy', n_jobs=-1)
svm_grid_search.fit(X_train, y_train)
print("Best SVM parameters:", svm_grid_search.best_params_)

# train Logistic Regression with the best parameters
best_lr_model = lr_grid_search.best_estimator_
y_pred_lr = best_lr_model.predict(X_test)

# train SVM with the best parameters
best_svm_model = svm_grid_search.best_estimator_
y_pred_svm = best_svm_model.predict(X_test)

# evaluate models
def evaluate_model(y_true, y_pred):
    print(f"Accuracy: {accuracy_score(y_true, y_pred):.4f}")
    print(f"Precision (macro): {precision_score(y_true, y_pred, average='macro', zero_division=0.0):.4f}")
    print(f"Recall (macro): {recall_score(y_true, y_pred, average='macro'):.4f}")
    print(f"F1 Score (macro): {f1_score(y_true, y_pred, average='macro'):.4f}")

    # get predicted probabilities for AUC calculation
    if hasattr(best_lr_model, "predict_proba"):
        y_prob = best_lr_model.predict_proba(X_test)
    else:
        y_prob = best_lr_model.decision_function(X_test)

    try:
        print(f"AUC-ROC (macro): {roc_auc_score(y_true, y_prob, multi_class='ovr', average='macro'):.4f}")
    except ValueError:
        print("AUC-ROC: Cannot compute AUC for multiclass with this setup.")


# evaluate Logistic Regression
print("\nLogistic Regression - Performance Metrics:")
evaluate_model(y_test, y_pred_lr)

# evaluate Support Vector Machine
print("\nSupport Vector Machine - Performance Metrics:")
evaluate_model(y_test, y_pred_svm)