import gradio as gr
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestRegressor
from sklearn.preprocessing import LabelEncoder
import seaborn as sns

def load_data():
    data = {}
    years = range(2015, 2023)
    for year in years:
        batting_file = f"./Datasets/{year} data/{year}_league_batting.csv"
        pitching_file = f"./Datasets/{year} data/{year}_league_pitching.csv"
        
        batting_data = pd.read_csv(batting_file)
        pitching_data = pd.read_csv(pitching_file)
        
        data[f"{year}_batting"] = batting_data
        data[f"{year}_pitching"] = pitching_data
    return data

data = load_data()
all_teams = sorted(data['2015_pitching']['Finals'].tolist())

def train_win_probability_model(data):
    df_list = []
    for year in range(2015, 2023):
        df = data[f"{year}_pitching"].copy()
        df["Win_Percentage"] = df["W"] / (df["W"] + df["L"])  # Create win probability column
        df_list.append(df)
    
    full_data = pd.concat(df_list, axis=0)
    features = ["ERA", "SO", "WHIP"]  # Key indicators of team performance
    
    X = full_data[features]
    y = (full_data["Win_Percentage"] > 0.5).astype(int)  # Convert to binary target (Win=1, Lose=0)
    
    model = LogisticRegression()
    model.fit(X, y)
    return model

win_probability_model = train_win_probability_model(data)

def calculate_win_probability(pitching_data, team_a, team_b):
    team_a_stats = pitching_data[pitching_data["Finals"] == team_a][["ERA", "SO", "WHIP"]]
    team_b_stats = pitching_data[pitching_data["Finals"] == team_b][["ERA", "SO", "WHIP"]]

    # Predict probability of winning
    prob_a = win_probability_model.predict_proba(team_a_stats)[0][1]  # Probability of team A winning
    prob_b = win_probability_model.predict_proba(team_b_stats)[0][1]  # Probability of team B winning
    
    return round(prob_a * 100, 2), round(prob_b * 100, 2)  # Convert to percentage

def train_predictive_model(data):
    df_list = []
    for year in range(2015, 2023):
        df = data[f"{year}_pitching"].copy()
        df["Year"] = year
        df_list.append(df)
    
    full_data = pd.concat(df_list, axis=0)
    features = ["W", "L", "ERA", "SO", "WHIP"]  
    
    X = full_data[features]
    y = full_data[features]
    
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
    model = RandomForestRegressor(n_estimators=100, random_state=42)
    model.fit(X_train, y_train)
    return model

predictive_model = train_predictive_model(data)




def predict_match_performance(team_a, team_b):
    last_known_data_a = data["2022_pitching"][data["2022_pitching"]["Finals"] == team_a]
    last_known_data_b = data["2022_pitching"][data["2022_pitching"]["Finals"] == team_b]
    
    if last_known_data_a.empty or last_known_data_b.empty:
        return "Team data not available for predictions."
    
    features = ["W", "L", "ERA", "SO", "WHIP"]
    
    X_a = last_known_data_a[features]
    X_b = last_known_data_b[features]
    
    prediction_a = predictive_model.predict(X_a)[0]
    prediction_b = predictive_model.predict(X_b)[0]
    
    predicted_values_a = {feature: round(value, 2) for feature, value in zip(features, prediction_a)}
    predicted_values_b = {feature: round(value, 2) for feature, value in zip(features, prediction_b)}
    
    # Convert to DataFrame for better presentation
    df_results = pd.DataFrame([predicted_values_a, predicted_values_b], index=[team_a, team_b])
    
    # Determine the winner based on W/L ratio
    win_ratio_a = predicted_values_a["W"] / (predicted_values_a["W"] + predicted_values_a["L"])
    win_ratio_b = predicted_values_b["W"] / (predicted_values_b["W"] + predicted_values_b["L"])
    
    winner = team_a if win_ratio_a > win_ratio_b else team_b
    win_probability = round((max(win_ratio_a, win_ratio_b) / (win_ratio_a + win_ratio_b)) * 100, 2)
    winner_text = f"Predicted Winner: {winner} with {win_probability}% probability"
    
    # Historical Performance Visualization
    fig, ax = plt.subplots(figsize=(12, 6))
    try:
        team_history = pd.concat(
        [data[f"{year}_pitching"][data[f"{year}_pitching"]["Finals"] == team_a].assign(Year=year) for year in range(2015, 2023)]
        )
        team_history_b = pd.concat(
        [data[f"{year}_pitching"][data[f"{year}_pitching"]["Finals"] == team_b].assign(Year=year) for year in range(2015, 2023)]
        )
        
        if "Year" in team_history.columns and "Year" in team_history_b.columns:
            sns.lineplot(data=team_history, x="Year", y="W", label=team_a, ax=ax)
            sns.lineplot(data=team_history_b, x="Year", y="W", label=team_b, ax=ax)
            ax.set_title(f"Historical Wins: {team_a} vs {team_b}")
            ax.set_ylabel("Wins")
            ax.legend()
        else:
            ax.text(0.5, 0.5, "Year column missing in dataset", fontsize=12, ha='center')
    except Exception as e:
        ax.text(0.5, 0.5, f"Error generating chart: {str(e)}", fontsize=12, ha='center')
    
    return df_results, fig, winner_text


demo = gr.Interface(
    fn=predict_match_performance,
    inputs=[gr.Dropdown(choices=all_teams, label="Your Team"),
            gr.Dropdown(choices=all_teams, label="Opponent Team")],
    outputs=[gr.Dataframe(label="Predicted Performance Comparison"),
             gr.Plot(label="Historical Wins Over the Years"),
             gr.Textbox(label="Predicted Winner and Probability")],
    title="KBO Match Performance Prediction",
    theme="dark"
)

demo.launch()