import pandas as pd
import numpy as np
from pandas import DataFrame
from pandas.plotting import scatter_matrix
import matplotlib.pyplot as plt
from statsmodels import robust
from sklearn.cluster import KMeans
from sklearn.linear_model import LinearRegression
csv_path = "AMS_out_v4.csv"
dataframe = pd.read_csv(csv_path)

dataframe.sample(10)

dataframe.describe()

dataframe[['Months','Users']].hist()
plt.show();

print(f"The mean number of tickets per month from a company: {dataframe['tickets'].mean()}")
print(f"The median number of tickets per month from a company: {dataframe['tickets'].median()}")

locationAnalysis=[];
for i in range (1,12):
    analysis_dataframe_month = dataframe[dataframe['Months'] == i]
    mean = analysis_dataframe_month['tickets'].mean();
    median = analysis_dataframe_month['tickets'].median();
    locationAnalysis.append([i,mean,median]);
fig, ax = plt.subplots()
df = pd.DataFrame(locationAnalysis, columns=['month', 'mean','median'])
df.plot(x='month', ax=ax)
plt.show()

def add_values(row):
    return row['Site'] + ":" + row['Group']  + ":" + str(row['Users'])

siteDictionary={};
columnsForPlotting=["Months"];
dataframe['Site (Users)'] = dataframe.apply(add_values, axis=1)
for ind in dataframe.index:
    if dataframe['Site (Users)'][ind] not in siteDictionary.keys():
        # this will have key=month and value=ticketCount
        ticketsDictionary={dataframe['Months'][ind] : dataframe['tickets'][ind]};
            # this will have key=SiteUser and value=ticketsDictionary
        siteDictionary[dataframe['Site (Users)'][ind]]=ticketsDictionary;
        columnsForPlotting.append(dataframe['Site (Users)'][ind]);
    else:
        ticketsDictionary=siteDictionary.get(dataframe['Site (Users)'][ind]);
        ticketsDictionary[dataframe['Months'][ind]]=dataframe['tickets'][ind];
    
tArray=[];
for site in columnsForPlotting[1:]:
    ticketsDictionary=siteDictionary.get(site);
    for month in range(1,12):
        if month in ticketsDictionary.keys():
            tArray.append([site,month,ticketsDictionary.get(month)]);
        else:
            tArray.append([site,month,'']);

df2 = pd.DataFrame(tArray,columns=['site', 'month', 'tickets'])
df2 = df2.pivot(index='month', columns='site', values='tickets')

fig, ax = plt.subplots()
df2.plot(ax=ax)
plt.show()

def makeDFWithMeanMedian(dataframe:DataFrame) -> DataFrame:
    # The plot generated has named values.
    # Converted a tupple to a data frame
    dictionaryDF={};
    for ind in dataframe.index:
        if dataframe['Users'][ind] not in dictionaryDF.keys():
            tickets=[dataframe['Site (Users)'][ind],dataframe['tickets'][ind]];
            dictionaryDF[dataframe['Users'][ind]]=tickets;
        else:
            tickets = dictionaryDF.get(dataframe['Users'][ind]);
            tickets.append(dataframe['tickets'][ind]);
    
    locations=[];
    for key,value in dictionaryDF.items():
        # appending a tupple to the list which is needed to change to dataframe easily
        locations.append((key,value[0],np.mean(value[1:]),np.median(value[1:])));
    # values,  # 1st column as index # 1st row as the column names
    # print(locations);
    newDataFrame = pd.DataFrame(locations, columns =['Users', 'Site (Users)', 'mean','median']);
    return newDataFrame;

newDataFrame=makeDFWithMeanMedian(dataframe)
# open figure + axis
fig, ax = plt.subplots()
fig.set_size_inches(12, 8)
    # plot
ax.scatter(x=newDataFrame['Users'],y=newDataFrame['mean'],c='DarkBlue')
# set labels
ax.set_xlabel('Users')
ax.set_ylabel('Mean Tickets')

# annotate points in axis   
for idx, row in newDataFrame.iterrows():
    ax.annotate(row['Site (Users)'], (row['Users'], row['mean']) )
# force matplotlib to draw the graph
plt.show()

dataframe1=dataframe[dataframe['Group'] == 'A'];
dataframe2=dataframe[dataframe['Group'] == 'M'];
dataframe3=dataframe[dataframe['Group'] == 'I'];
dictionary={'A':dataframe1,'I':dataframe2,'M':dataframe3};
fig, ax = plt.subplots()
fig.set_size_inches(4, 4)
for key, dataframein in dictionary.items():
    locationAnalysis=[];
    flag = True;
    for i in range (1,10):
        analysis_dataframe_month = dataframein[dataframein['Months'] == i]
        mean = analysis_dataframe_month['tickets'].mean();
        locationAnalysis.append([i,mean]);
    df = pd.DataFrame(locationAnalysis, columns=['month', 'mean'])
    df=df.rename(columns={"mean": key})
    df.plot(x='month',ax=ax)
plt.ylabel('Mean Ticket Volume')
plt.xlabel('Month')
plt.title('Group Wise Trends')
plt.show();

dataframe1=dataframe[dataframe['Group'] == 'A'];
newDataFrame=makeDFWithMeanMedian(dataframe1)
regressor = LinearRegression();
regressor.fit(newDataFrame[['Users']],newDataFrame[['mean']])
fig, ax = plt.subplots()
plt.scatter(newDataFrame['Users'],newDataFrame['mean'], color='red')
plt.plot(newDataFrame['Users'], regressor.predict(newDataFrame[['Users']]),color='red')
fig.set_size_inches(12, 8)
dataframe1=dataframe[dataframe['Group'] == 'I'];
newDataFrame=makeDFWithMeanMedian(dataframe1)
regressor = LinearRegression();
regressor.fit(newDataFrame[['Users']],newDataFrame[['mean']])
plt.scatter(newDataFrame['Users'],newDataFrame['mean'], color='blue')
plt.plot(newDataFrame['Users'], regressor.predict(newDataFrame[['Users']]),color='blue')

def dataVariabilityAnalysisInitialSurge(dataframe:DataFrame,  start:int, end:int):
    print(f"Data Variability Analysis For Range {start} and {end}")
    dataframe = dataframe[dataframe['Months'] > start]
    analysis_dataframe_month = dataframe[dataframe['Months'] < end]
    #print(analysis_dataframe_month);
    standardDeviation = analysis_dataframe_month['tickets'].std()
    print(f"Standard Deviation: {standardDeviation}")
    interQuartilerange= analysis_dataframe_month['tickets'].quantile(0.75) - analysis_dataframe_month['tickets'].quantile(0.25)
    print(f"Inter Quartile Range (difference between the 25th percentile and the 75th percentile): {interQuartilerange}")
    robustMAD=robust.scale.mad(analysis_dataframe_month['tickets'])
    print(f"The robust mean absolute deviation:{robustMAD}")
    percentile = analysis_dataframe_month['Months'].quantile([0.05, 0.25, 0.5, 0.75, 0.95])
    print(f"Distribution Analysis For Range {start} and {end}")
    print(f"Percentile 0.05, 0.25, 0.5, 0.75, 0.95 \n{percentile}")
    fig = plt.figure() 
    fig.set_size_inches(4, 4)
    ax = (analysis_dataframe_month['tickets']).plot.box()
    label = f"Box Plot for range For Range {start} and {end}";
    ax.set_ylabel(label)
    plt.show()
dataVariabilityAnalysisInitialSurge(dataframe, 0, 4);

dataVariabilityAnalysisInitialSurge(dataframe, 6, 12)

newDataFrame=makeDFWithMeanMedian(dataframe);
print(newDataFrame);
newDataFrame = newDataFrame.drop(['Site (Users)','median'], axis=1)
kmeans = KMeans(n_clusters=3, random_state=42);
# Fit the model to your data
X=newDataFrame.to_numpy();
cluster_labels = kmeans.fit_predict(X);

# Create a scatter plot for the first two features
fig=plt.figure(figsize=(8, 6))
plt.scatter(X[:, 0], X[:, 1], c=cluster_labels, cmap='viridis')
plt.xlabel('Feature 1')
plt.ylabel('Feature 2')
plt.title('Data with Clusters')
plt.colorbar(label='Cluster')
plt.show();

import numpy as np 
import matplotlib.pyplot as plt 
import pandas as pd
from sklearn.svm import SVR
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error, r2_score
from sklearn.preprocessing import StandardScaler
from sklearn.preprocessing import PolynomialFeatures
from sklearn.linear_model import LinearRegression
from sklearn.model_selection import GridSearchCV, cross_val_score
from sklearn.pipeline import Pipeline
from sklearn.compose import ColumnTransformer
from xgboost import XGBClassifier
from sklearn.preprocessing import OneHotEncoder
from sklearn.model_selection import cross_validate, StratifiedKFold
dataset = pd.read_csv('AMS_out_v4.csv')

X_train, X_test, y_train, y_test = train_test_split(dataset[['Months','Users','Group']], dataset['tickets'].values, test_size=0.1, random_state=99)

multicolumn_prep = ColumnTransformer([
                                    ('encode', OneHotEncoder(sparse_output=False, handle_unknown='ignore'), ['Group']),
                                    ('scaler', StandardScaler(), ['Months','Users'])
                                    ],
                                     remainder='passthrough')
space_titanic_pipeline = Pipeline([('preprocessing', multicolumn_prep),
                                    ('model',SVR(kernel="rbf", C=100, gamma="auto",epsilon=0.0001, coef0 =0.001,degree=2))])

model = space_titanic_pipeline.fit(X_train, y_train);
y_svr_pred = model.predict(X_test);

temp = pd.DataFrame();
temp = X_test;
temp['Actual']=y_test
temp['Predicted']=y_svr_pred

def analyzeReults(y_test,y_pred):
    rmse = np.sqrt(mean_squared_error(y_test,y_pred))
    print(f"The root mean square error is {rmse}");
    r2 = r2_score(y_test,y_pred)
    print(f"The r2 score is {r2}");
    resultActualDF=pd.DataFrame()
    resultPredDF=pd.DataFrame()
    index = np.arange(start=1, stop= len(y_test)+1)
    pd.Series(index);
    resultActualDF["tickets"] = y_test;
    resultPredDF["tickets"]= y_pred;
    plt.scatter(pd.Series(index), resultActualDF,pd.Series(index))
    plt.scatter(pd.Series(index), resultPredDF,pd.Series(index))
    plt.show(); 


analyzeReults(y_test,y_svr_pred);

scores = cross_val_score(model, X_train, y_train, scoring="r2", cv=8)
print(f"scores:{scores}")
print(f"mean score {scores.mean()}")
print(f"std deviation of score {scores.std()}");
print("Comparing Actual and Predicted.")
temp