import pandas as pd
import numpy as np
import os
import pickle as pkl

# standardising formula
def zscore(col):
    mean = col.mean()
    std = col.std()

    return (col - mean)  / std

df = pd.DataFrame() # will hold the final dataset at the end
player_db = pd.read_csv("player-db.csv") # need it for player ratings

for file in os.listdir("matches"):
    f = os.path.join("matches", file)
    match_df = pd.read_csv(f)
    match_df = match_df.fillna(0)

    # columns of all the match data needed

    ball_no = []
    striker = []
    bowler = []
    batsman_runs = []
    batsman_balls = []
    batsman_outcome_dists = { outcome : [] for outcome in [0,1,2,3,4,6]}
    bowler_economy = []
    wicket_taking = []
    bowler_consistency = []
    bowler_wickets = []
    bowler_runs = []
    bowler_balls = []
    bowler_outcome_dists = { outcome : [] for outcome in range(0, 7) }
    innings_score = []
    innings_wickets = []
    chasing =  []
    req_run_rate = []

    outcome = []

    batsmen = {}
    bowlers = {}
    score = 0
    wickets = 0
    chasing_score = 0

    prev_innings = 1

    for ball in match_df.iloc:

            batter = ball["striker"]
            _bowler = ball["bowler"]

            striker.append(batter)
            bowler.append(_bowler)

            runs = int(ball["runs_off_bat"])
            runs = min(runs, 6)
            runs = 4 if runs == 5 else runs
            wides = int(ball["wides"])
            wicket = 1 if ball["wicket_type"] else 0
            innings = int(ball["innings"])

            if innings != prev_innings:
                chasing_score = score
                score = 0
                wickets = 0

            prev_innings = innings


            if batter not in batsmen:
                # this will hold the number of balls faced for each outcome by a batsman
                batsmen[batter] = {
                    0: 0,
                    1: 0,
                    2: 0,
                    3: 0,
                    4: 0,
                    6: 0
                }

            if _bowler not in bowlers:
                # this will hold the number of balls bowled for each outcome by a bowler (5 means wicket)

                bowlers[_bowler] = {
                    0: 0,
                    1: 0,
                    2: 0,
                    3: 0,
                    4: 0,
                    5: 0,
                    6: 0
                }


            ## Batting Data ##

            batsman_balls_faced = np.sum([batsmen[batter][i] for i in batsmen[batter]])
            batsman_dist = { _outcome : 0 if batsman_balls_faced == 0 else batsmen[batter][_outcome] / batsman_balls_faced for _outcome in batsmen[batter]} # getting proportion of balls faced for each outcome
            batsman_runs_scored = np.sum([_outcome * batsmen[batter][_outcome] for _outcome in batsmen[batter]])

            for _outcome in batsman_outcome_dists:
                batsman_outcome_dists[_outcome].append(batsman_dist[_outcome])

            batsman_runs.append(batsman_runs_scored)
            batsman_balls.append(batsman_balls_faced)

            ## Bowling Data ##

            bowler_balls_bowled = np.sum([bowlers[_bowler][i] for i in bowlers[_bowler]])
            bowler_runs_given = np.sum([_outcome * bowlers[_bowler][_outcome] if _outcome != 5 else 0 for _outcome in bowlers[_bowler]])
            bowler_wickets_taken = bowlers[_bowler][5]
            bowler_dist = { _outcome : bowlers[_bowler][_outcome] / bowler_balls_bowled if bowler_balls_bowled != 0 else 0 for _outcome in bowlers[_bowler] } # getting proportion of balls bowled for each outcome

            for _outcome in bowler_outcome_dists:
                bowler_outcome_dists[_outcome].append(bowler_dist[_outcome])

            bowler_runs.append(bowler_runs_given)
            bowler_wickets.append(bowler_wickets_taken)
            bowler_balls.append(bowler_balls_bowled)

            ## Innings Data

            innings_score.append(score)
            innings_wickets.append(wickets)
            chasing.append(chasing_score)

            ball_outcome = runs if wicket == 0 else 5

            outcome.append(ball_outcome)

            discrete_ball_no = ball["ball"]
            discrete_ball_no = int(discrete_ball_no) * 6 + round(discrete_ball_no % 1) * 10
            ball_no.append(discrete_ball_no)

            rem_balls = 120 - (discrete_ball_no - 1) if discrete_ball_no <= 120 else int(discrete_ball_no - 120)
            _req_run_rate = max(0, (chasing_score - score) / rem_balls)

            req_run_rate.append(_req_run_rate)

            ## Update State ##

            batsmen[batter][runs] += 1
            bowlers[_bowler][runs] += 1
            bowlers[_bowler][5] += wicket
            score += runs
            wickets += wicket

    new_match_df = pd.DataFrame()
    new_match_df["striker"] = striker
    new_match_df["bowler"] = bowler
    new_match_df["batsman_runs"] = batsman_runs
    new_match_df["batsman_balls"] = batsman_balls

    for _outcome in batsman_outcome_dists:
        new_match_df[f"batsman_{_outcome}"] = batsman_outcome_dists[_outcome]

    new_match_df["bowler_runs"] = bowler_runs
    new_match_df["bowler_balls"] = bowler_balls
    new_match_df["bowler_wickets"] = bowler_wickets

    for _outcome in bowler_outcome_dists:
        new_match_df[f"bowler_{_outcome}"] = bowler_outcome_dists[_outcome]

    new_match_df["innings_score"] = innings_score
    new_match_df["innings_wickets"] = innings_wickets
    new_match_df["ball"] = ball_no
    new_match_df["chasing"] = chasing
    new_match_df["req_run_rate"] = req_run_rate
    new_match_df["outcome"] = outcome

    frames = [df, new_match_df]
    df = pd.concat(frames)


# df now contains the relevant match data from every single ball in the dataset

batting_ratings = player_db[["player", "explosivity_rating", "consistency_rating", "finisher_rating", "quick_scorer_rating", "running_rating"]]
bowling_ratings = player_db[["player", "economy_rating", "wicket_taking_rating", "bowling_consistency_rating", "specialist_rating"]]

df = df.join(batting_ratings.set_index("player"), on="striker") # add batsmen's batting ratings to dataframe
df = df.join(bowling_ratings.set_index("player"), on="bowler") # add bowler's bowling ratings to dataframe

df = df.drop(["striker", "bowler"], axis=1) # remove the striker and bowler columns since they are not part of the features needed to predict the outcome of a ball

# get the means and standard deviations of each column

df_mean = df.drop(["outcome"], axis=1).mean()
df_std = df.drop(["outcome"], axis=1).std()

# save the mean and std of all the columns. this would be needed later for preprocessing when predicting new data.

with open("mean-std.bin","wb") as f:
    pkl.dump({
        "mean": df_mean,
        "std": df_std
    }, f)

# standardise all the columns except the ratings and outcome

for col in df.columns:
    if col != "outcome" and "rating" not in col:
        df[col] = zscore(df[col])

# shuffle

df = df.sample(frac=1)

# split into a training set and a testing set 
training_split = int(len(df) * 0.85) # take 85% to train

training_df = df[:training_split]
testing_df = df[training_split:]

# save the datasets

training_df.to_csv("balls-train.csv", index=False)
testing_df.to_csv("balls-test.csv", index=False)

import numpy as np
import pandas as pd
from sklearn.ensemble import RandomForestClassifier
import pickle as pkl
from random import choices

dataset = pd.read_csv("balls-train.csv")
x = dataset.drop(["outcome"], axis=1)
y = dataset["outcome"]

clf = RandomForestClassifier(max_depth=15, n_estimators=50)
clf.fit(x, y)

with open("clf.bin", "wb") as f:
    pkl.dump(clf, f)

test = pd.read_csv("balls-test.csv")
predicted = clf.predict(test.drop(["outcome"], axis=1))
print (np.sum(predicted == test["outcome"]) / len(test))

0.4430872720835546

test = pd.read_csv("balls-test.csv")
predicted = test.drop(["outcome"], axis=1)
preds = clf.predict(predicted)
predicted["outcome"] = preds

for outcome in range(0, 7):
    print ("Outcome ", outcome)

    # get rows which were labelled with this outcome in the test data
    test_slice = test[test["outcome"] == outcome]

    # get rows which were predicted with this outcome by the model
    predicted_slice = predicted[predicted["outcome"] == outcome]

    # a vector of the average values of the inputs that were labelled with the outcome in the test set
    test_slice_mean = test_slice.mean() 

    # a vector of the average values of the inputs that were predicted to have this outcome by the model
    predicted_slice_mean = predicted_slice.mean().fillna(0) 

    # calculates the euclidean distance between the two vectors
    dist = ((predicted_slice_mean - test_slice_mean) ** 2).sum() ** 0.5

    print ("Actual Count", len(test_slice), "Predicted Count", len(predicted_slice)) # compared how many times this outcome appeared in the test set and how many times it got predicted
    print ("Average Distance", dist)

Outcome  0
Actual Count 12041 Predicted Count 13324
Average Distance 1.1953108714619187
Outcome  1
Actual Count 12564 Predicted Count 20402
Average Distance 0.8442394082114827
Outcome  2
Actual Count 2055 Predicted Count 16
Average Distance 4.355749118524852
Outcome  3
Actual Count 112 Predicted Count 0
Average Distance 4.526265034977223
Outcome  4
Actual Count 3848 Predicted Count 74
Average Distance 2.6306944519746605
Outcome  5
Actual Count 1646 Predicted Count 20
Average Distance 3.586353351892623
Outcome  6
Actual Count 1628 Predicted Count 58
Average Distance 4.243057588990431

test = pd.read_csv("balls-test.csv")
predicted = clf.predict_proba(test.drop(["outcome"], axis=1))
preds = []

for weights in predicted:
    outcomes = [0,1,2,3,4,5,6]

    # weighted random selection
    p = choices(outcomes, weights=weights)

    preds.append(p[0])

predicted = test.drop(["outcome"], axis=1)
predicted["outcome"] = preds

for outcome in range(0, 7):
    print ("Outcome ", outcome)

    test_slice = test[test["outcome"] == outcome]
    predicted_slice = predicted[predicted["outcome"] == outcome]

    # a vector of the average values of the inputs that were labelled with the outcome in the test set
    test_slice_mean = test_slice.mean() 

    # a vector of the average values of the inputs that were predicted to have this outcome by the model
    predicted_slice_mean = predicted_slice.mean().fillna(0) 

    # calculates the euclidean distance between the two vectors
    dist = ((predicted_slice_mean - test_slice_mean) ** 2).sum() ** 0.5

    print ("Actual Count", len(test_slice), "Predicted Count", len(predicted_slice))
    print ("Average Distance", dist)

Outcome  0
Actual Count 12041 Predicted Count 12072
Average Distance 0.06285163994309419
Outcome  1
Actual Count 12564 Predicted Count 12507
Average Distance 0.047105551432281484
Outcome  2
Actual Count 2055 Predicted Count 2089
Average Distance 0.13890305459997243
Outcome  3
Actual Count 112 Predicted Count 94
Average Distance 0.779151006384056
Outcome  4
Actual Count 3848 Predicted Count 3858
Average Distance 0.09621869495553977
Outcome  5
Actual Count 1646 Predicted Count 1676
Average Distance 0.2084278773037825
Outcome  6
Actual Count 1628 Predicted Count 1598
Average Distance 0.29624599526308754