# Data manipulation and analysis
import pandas as pd
import numpy as np

# Data visualization
import seaborn as sns
import matplotlib.pyplot as plt

# Machine learning models and algorithms
from sklearn.neighbors import KNeighborsClassifier
from sklearn.linear_model import Ridge, Lasso, LogisticRegression
from sklearn.tree import DecisionTreeClassifier
from sklearn.svm import LinearSVC, SVC, SVR
from sklearn.ensemble import (RandomForestClassifier,
                              GradientBoostingClassifier,
                              AdaBoostClassifier,
                              ExtraTreesClassifier,
                              VotingClassifier)
from sklearn.neural_network import MLPClassifier
from xgboost import XGBClassifier
from lightgbm import LGBMClassifier
from catboost import CatBoostClassifier

# Machine learning tools and utilities
from mltools import *
from bayes_opt import BayesianOptimization

# Data preprocessing and preparation
from sklearn.preprocessing import StandardScaler

# Ignore warnings
import warnings
warnings.filterwarnings("ignore")

# loading data
train_data = pd.read_csv('./train_features.csv', index_col='match_id_hash')
test_data = pd.read_csv('./test_features.csv', index_col='match_id_hash')
train_y = pd.read_csv('./train_targets.csv', index_col='match_id_hash')

colors = ['#d9534f', '#5cb85c']
# Compute the target value counts
target_counts = train_y['radiant_win'].value_counts()

# Create a plot using seaborn
plt.figure(figsize=(6, 4))
sns.set_style('whitegrid')
ax = sns.barplot(x=target_counts.index,
                 y=target_counts.values, palette=colors)
ax.set_title('Win/Lose Distribution')
ax.set_xlabel('Target')
ax.set_ylabel('Count')
ax.set_xticklabels(['Lose', 'Win'])

# Save the plot as a PNG file
plt.savefig("images/balance.png")

# Create an HTML img tag to display the image
img_tag = (f'<img src="images/balance.png" alt="balance"'
           f'style="display:block; margin-left:auto;'
           f'margin-right:auto; width:80%;">')

# display the HTML <img> tag
display(HTML(img_tag))
plt.close()

sns.pairplot(train_data.iloc[:,:4], hue='lobby_type')

num_rows = train_data.shape[0]
num_cols = train_data.shape[1]
html_table = train_data.head().to_html()
html_table_with_info = f"{html_table} \n <p>Number of Rows: {num_rows}<br>Number of Columns: {num_cols}</p>"

# Print the HTML table
print(html_table_with_info)

train_data.info()
train_data.describe()
train_data.isnull().sum()
train_data.drop_duplicates()

# Create a countplot with a custom color palette
sns.countplot(data=train_data, x='lobby_type', order=train_data['lobby_type'].value_counts().index, palette='Set2');

# Add a title to the plot
plt.title('Counts of games in lobby type');

# Show the plot
plt.show()

# Create a countplot with the 'Set2' color palette for game modes
sns.countplot(data=train_data, x='game_mode',
              order=train_data['game_mode'].value_counts().index, palette='Set2')

# Add a title to the plot
plt.title('Counts of games in different modes')

# Show the plot
plt.show()

# Filter the dataset to only include the most common game mode
most_common_game_mode = train_data['game_mode'].value_counts().idxmax()
filtered_train_data = train_data[train_data['game_mode'] == most_common_game_mode]

# remove lobby_type with lower counts
train_y['lobby_type'] = train_data['lobby_type']
train_data = train_data[train_data['lobby_type'] == 7]
test_data = test_data[test_data['lobby_type'] == 7]
train_y = train_y[train_y['lobby_type'] == 7]

# remove game_mode with lower counts
train_y['game_mode'] = train_data['game_mode']
train_data = train_data[train_data['game_mode'] == 22]
test_data = test_data[test_data['game_mode'] == 22]
train_y = train_y[train_y['game_mode'] == 22]
# drop lobby_type and game_mode for train_y
train_y = train_y.drop(columns=['lobby_type', 'game_mode'])
# mapping win and lose values
train_y = train_y['radiant_win'].map({True: 1, False:0})

# Get the unique values of 'radiant_win' column
unique_vals = train_y.reset_index()['radiant_win'].unique()

# Get the count of win for each unique value of 'radiant_win'
win_counts = train_y.reset_index()['radiant_win'].value_counts()

# Create a bar plot with the 'Set2' color palette for Dire and Radiant wins
sns.barplot(x=unique_vals, y=win_counts, palette='Set2')

# Set the x-axis tick labels to 'Dire Win' and 'Radiant Win'
plt.xticks([0, 1], labels=['Dire Win', 'Radiant Win'])

# Add labels to the x- and y-axes and a title to the plot
plt.xlabel('Dire & Radiant')
plt.ylabel('Win Counts')
plt.title('Dire vs Radiant Win Counts')

# Show the plot
plt.show()

# combing all individual character features into a team based features
feature_names = train_data.columns
num = []
for y in range(24):
    for i in [feature_names[feature_names.str.contains("r"+str(i)) == True] for i in range(1,6)]:
        num.append(i[y])
    col = num[0].split("_")[1]
    train_data['r_'+col] = train_data[num].sum(axis=1)
    test_data['r_'+col] = test_data[num].sum(axis=1)
    
    # dropping individual features
    train_data.drop(columns=num, inplace=True)
    test_data.drop(columns=num, inplace=True)
    num = []
    
for y in range(24):
    for i in [feature_names[feature_names.str.contains("d"+str(i)) == True] for i in range(1,6)]:
        num.append(i[y])
    col = num[0].split("_")[1]
    train_data['d_'+col] = train_data[num].sum(axis=1)
    test_data['d_'+col] = test_data[num].sum(axis=1)
    
    # dropping individual features
    train_data.drop(columns=num, inplace=True)
    test_data.drop(columns=num, inplace=True)
    num = []

# what features to be used
to_load = (['r_kills', 'r_deaths', 'r_assists', 'r_denies', 'r_lh', 'r_gold',
            'd_kills', 'd_deaths', 'd_assists', 'd_denies', 'd_lh', 'd_gold'])
train_X = train_data[to_load]
test_X = test_data[to_load]

# reduced the datapoints for the interest of runtime and
# to show the significance of the models
feature_names = train_X.columns
train_sample = int(train_X.shape[0]/2)
test_sample = int(test_X.shape[0]/2)

# getting sample size
train_X = train_X.sample(train_sample, random_state=3)
train_y = train_y.sample(train_sample, random_state=3)
test_X = test_X.sample(test_sample, random_state=3)
train_X

# Scaling
scaler = StandardScaler()
train_X_scaled = scaler.fit_transform(train_X)
test_X_scaled = scaler.fit_transform(test_X)

# scaled data
train_X_scaled # for train value
test_X_scaled # for test value

# original data
train_X # for train value
test_X # for test value

# output to csv
train_X.to_csv('train_X.csv')
test_X.to_csv('test_X.csv')
train_y.to_csv('train_y.csv')

# Select methods
methods = ['kNN', 'Logistic (L1)', 'Logistic (L2)', 'Decision Tree',
           'RF Classifier', 'GB Classifier', 'XGB Classifier',
           'AdaBoost DT', 'LightGBM Classifier', 'CatBoost Classifier']

# Perform training and testing
ml_models = MLModels.run_classifier(
    train_X_scaled, train_y, feature_names, task='C',
    use_methods=methods, n_trials=2, tree_rs=3, test_size=0.20,
    n_neighbors=list(range(1, 3)),
    C=[1e-1, 1],
    max_depth=[5, 10])
res = MLModels.summarize(ml_models, feature_names,
                         show_plot=True, show_top=True)

for model_name in methods[3:]:
    try:
        ax = ml_models[model_name].plot_feature_importance(feature_names)
        ax.set_title(model_name, fontsize=16, weight="bold")
    except Exception as e:
        print(model_name, e)

# reduced params range based from previous multiple trials
tune_model(train_X_scaled, train_y, 'Classification', 'LightGBM Classifier',
           params={'max_depth': [25, 50],
                   'n_estimators': [150, 200],
                   'learning_rate': [0.1, 0.2]},
           n_trials=2, tree_rs=3)

def lgb_cv(num_leaves, max_depth, min_data_in_leaf):
    params = {
        "num_leaves": int(num_leaves),
        "max_depth": int(max_depth),
        "learning_rate": 0.5,
        'min_data_in_leaf': int(min_data_in_leaf),
        "force_col_wise": True,
        'verbose': -1,
        "metric" : "auc",
        "objective" : "binary",
    }
    
    lgtrain = lightgbm.Dataset(train_X_scaled, train_y)
    cv_result = lightgbm.cv(params,
                       lgtrain,
                       200,
                       early_stopping_rounds=200,
                       stratified=True,
                       nfold=5)
    return cv_result['auc-mean'][-1]

def bayesian_optimizer(init_points, num_iter, **args):
    lgb_BO = BayesianOptimization(lgb_cv, {'num_leaves': (100, 200),
                                           'max_depth': (25, 50),
                                           'min_data_in_leaf': (50, 200)
                                           })
    lgb_BO.maximize(init_points=init_points, n_iter=num_iter, **args)
    return lgb_BO

results = bayesian_optimizer(10,10)

def lgb_train(num_leaves, max_depth,  min_data_in_leaf):
    params = {
        "num_leaves": int(num_leaves),
        "max_depth": int(max_depth),
        "learning_rate": 0.5,
        'min_data_in_leaf': int(min_data_in_leaf),
        "force_col_wise": True,
        'verbose': -1,
        "metric": "auc",
        "objective": "binary",
    }

    x_train, x_val, y_train, y_val = train_test_split(
        train_X_scaled, train_y, test_size=0.2, random_state=3)
    lgtrain = lightgbm.Dataset(x_train, y_train)
    lgvalid = lightgbm.Dataset(x_val, y_val)
    model = (lightgbm.train(params, lgtrain, 200, valid_sets=[lgvalid],
                            early_stopping_rounds=200, verbose_eval=False))
    prediction_val = model.predict(
        test_X_scaled, num_iteration=model.best_iteration)
    return prediction_val, model

# 5 runs of the prediction model and get mean values.
optimized_params = results.max['params']
prediction_val1, _ = lgb_train(**optimized_params)
prediction_val2, _ = lgb_train(**optimized_params)
prediction_val3, _ = lgb_train(**optimized_params)
prediction_val4, _ = lgb_train(**optimized_params)
prediction_val5, model = lgb_train(**optimized_params)
y_pred = ((prediction_val1 + prediction_val2 +b
           prediction_val3 + prediction_val4 +
           prediction_val5)/5)
df_result = pd.DataFrame(
    {'Radiant_Win_Probability': y_pred})
df_result.sort_values(by='Radiant_Win_Probability', ascending=False).head()

feature_importance = (pd.DataFrame({'feature': train_X.columns,
                                   'importance': model.feature_importance()})
                      .sort_values('importance', ascending=False))
plt.figure(figsize=(8, 5))
sns.barplot(x=feature_importance.importance,
            y=feature_importance.feature, palette=("Blues_d"))
plt.show()