app.py

import streamlit as st
import numpy as np
import pandas as pd
import gspread
import pymongo
import re

st.set_page_config(layout="wide")

@st.cache_resource
def init_conn():
        uri = st.secrets['mongo_uri']
        client = pymongo.MongoClient(uri, retryWrites=True, serverSelectionTimeoutMS=500000)
        db = client["MLB_Database"]

        return db
    
db = init_conn()

game_format = {'Win%': '{:.2%}','First Inning Lead Percentage': '{:.2%}', 'Top Score': '{:.2%}',
              'Fifth Inning Lead Percentage': '{:.2%}', '8+ Runs': '{:.2%}', 'LevX': '{:.2%}'}

player_roo_format = {'Top_finish': '{:.2%}','Top_5_finish': '{:.2%}', 'Top_10_finish': '{:.2%}', '20+%': '{:.2%}', '2x%': '{:.2%}', '3x%': '{:.2%}',
                   '4x%': '{:.2%}'}

dk_columns = ['SP1', 'SP2', 'C', '1B', '2B', '3B', 'SS', 'OF1', 'OF2', 'OF3', 'salary', 'proj', 'Team', 'Team_count', 'Secondary', 'Secondary_count', 'Own']
fd_columns = ['P', 'C_1B', '2B', '3B', 'SS', 'OF1', 'OF2', 'OF3', 'UTIL', 'salary', 'proj', 'Team', 'Team_count', 'Secondary', 'Secondary_count', 'Own']
dk_sd_columns = ['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'salary', 'proj', 'Team', 'Team_count', 'Secondary', 'Secondary_count', 'Own']
fd_sd_columns = ['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'salary', 'proj', 'Team', 'Team_count', 'Secondary', 'Secondary_count', 'Own']

@st.cache_resource(ttl = 61)
def init_baselines():

    collection = db["Hitter_Info"] 
    cursor = collection.find()
    Hitter_info = pd.DataFrame(cursor)
    LHP_Info = Hitter_info[Hitter_info['Set'] == 'LHP'].drop_duplicates(subset=['Player'])
    RHP_Info = Hitter_info[Hitter_info['Set'] == 'RHP'].drop_duplicates(subset=['Player'])

    collection = db["Pitcher_Info"] 
    cursor = collection.find()
    Pitcher_info = pd.DataFrame(cursor)
    Pitcher_info = Pitcher_info.rename(columns={'Names':'Player'})
    LHH_Info = Pitcher_info[Pitcher_info['Set'] == 'LHH'].drop_duplicates(subset=['Player'])
    RHH_Info = Pitcher_info[Pitcher_info['Set'] == 'RHH'].drop_duplicates(subset=['Player'])

    collection = db["Player_Range_Of_Outcomes"] 
    cursor = collection.find()
    player_frame = pd.DataFrame(cursor)

    roo_data = player_frame.drop(columns=['_id'])
    roo_data['Salary'] = roo_data['Salary'].astype(int)
    hold_frame = roo_data.copy()
    
    hold_frame['Order'] = np.where(hold_frame['pos_group'] == 'Hitters', hold_frame['Player'].map(RHP_Info.set_index('Player')['Order']), 0)
    hold_frame['Hand'] = np.where(hold_frame['pos_group'] == 'Hitters', hold_frame['Player'].map(RHP_Info.set_index('Player')['bats']), hold_frame['Player'].map(RHH_Info.set_index('Player')['Hand']))
    try:
        hold_frame['Opp'] = hold_frame['Team'].map(RHH_Info.drop_duplicates(subset='Team').set_index('Team')['Opp'])
    except:
        hold_frame['Opp'] = np.nan
    try:
        hold_frame['Team_Total'] = hold_frame['Team'].map(RHH_Info.drop_duplicates(subset='Team').set_index('Opp')['Opp_TT'])
    except:
        hold_frame['Team_Total'] = np.nan
    try:
        hold_frame['Opp_Total'] = hold_frame['Team'].map(RHH_Info.drop_duplicates(subset='Team').set_index('Team')['Opp_TT'])
    except:
        hold_frame['Opp_Total'] = np.nan
    
    roo_data.insert(3, 'Opp', hold_frame['Opp'])
    roo_data.insert(4, 'Hand', hold_frame['Hand'])
    try:
        roo_data.insert(5, 'Order', hold_frame['Order'].astype(int))
    except:
        roo_data.insert(5, 'Order', hold_frame['Order'])
    roo_data.insert(6, 'Team_Total', hold_frame['Team_Total'])
    roo_data.insert(7, 'Opp_Total', hold_frame['Opp_Total'])
    
    dk_roo = roo_data[roo_data['Site'] == 'Draftkings']
    dk_id_map = dict(zip(dk_roo['Player'], dk_roo['player_ID']))
    fd_roo = roo_data[roo_data['Site'] == 'Fanduel']
    fd_id_map = dict(zip(fd_roo['Player'], fd_roo['player_ID']))

    collection = db["Player_SD_Range_Of_Outcomes"] 
    cursor = collection.find()
    player_frame = pd.DataFrame(cursor)

    sd_roo_data = player_frame.drop(columns=['_id'])
    sd_roo_data['Salary'] = sd_roo_data['Salary'].astype(int)
    sd_roo_data = sd_roo_data.rename(columns={'Own': 'Own%', 'Small_Own': 'Small Field Own%', 'Large_Own': 'Large Field Own%', 'Cash_Own': 'Cash Own%'})
    sd_hold_frame = sd_roo_data.copy()
    
    sd_hold_frame['Order'] = np.where(sd_hold_frame['Position'] != 'SP', sd_hold_frame['Player'].map(RHP_Info.set_index('Player')['Order']), 0)
    sd_hold_frame['Hand'] = np.where(sd_hold_frame['Position'] != 'SP', sd_hold_frame['Player'].map(RHP_Info.set_index('Player')['bats']), sd_hold_frame['Player'].map(RHH_Info.set_index('Player')['Hand']))
    try:
        sd_hold_frame['Opp'] = sd_hold_frame['Team'].map(RHH_Info.drop_duplicates(subset='Team').set_index('Team')['Opp'])
    except:
        sd_hold_frame['Opp'] = np.nan
    try:
        sd_hold_frame['Team_Total'] = sd_hold_frame['Team'].map(RHH_Info.drop_duplicates(subset='Team').set_index('Opp')['Opp_TT'])
    except:
        sd_hold_frame['Team_Total'] = np.nan
    try:
        sd_hold_frame['Opp_Total'] = sd_hold_frame['Team'].map(RHH_Info.drop_duplicates(subset='Team').set_index('Team')['Opp_TT'])
    except:
        sd_hold_frame['Opp_Total'] = np.nan
    sd_roo_data.insert(3, 'Opp', sd_hold_frame['Opp'])
    sd_roo_data.insert(4, 'Hand', sd_hold_frame['Hand'])
    try:
        sd_roo_data.insert(5, 'Order', sd_hold_frame['Order'].astype(int))
    except:
        sd_roo_data.insert(5, 'Order', sd_hold_frame['Order'])
    sd_roo_data.insert(6, 'Team_Total', sd_hold_frame['Team_Total'])
    sd_roo_data.insert(7, 'Opp_Total', sd_hold_frame['Opp_Total'])

    collection = db["Scoring_Percentages"] 
    cursor = collection.find()
    team_frame = pd.DataFrame(cursor)
    scoring_percentages = team_frame.drop(columns=['_id'])
    scoring_percentages['Runs/$'] = scoring_percentages['Avg Score'] / (scoring_percentages['Avg_Salary'] / 1000)
    scoring_percentages = scoring_percentages[['Names', 'Avg_Salary_DK', 'Avg_Salary_FD', 'Stack_Prio', 'Opp_SP', 'Avg First Inning', 'First Inning Lead Percentage', 'Avg Fifth Inning', 'Fifth Inning Lead Percentage', 'Avg Score', 'Runs/$', '8+ runs', 'Win Percentage',
    'DK Main Slate', 'DK Secondary Slate', 'DK Turbo Slate', 'FD Main Slate', 'FD Secondary Slate', 'FD Turbo Slate', 'DK Main Top Score', 'FD Main Top Score', 'DK Secondary Top Score', 'FD Secondary Top Score',
    'DK Turbo Top Score', 'FD Turbo Top Score']]
    scoring_percentages['8+ runs'] = scoring_percentages['8+ runs'].replace('%', '', regex=True).astype(float)
    scoring_percentages['Win Percentage'] = scoring_percentages['Win Percentage'].replace('%', '', regex=True).astype(float)
    scoring_percentages['DK Main Top Score'] = scoring_percentages['DK Main Top Score'].replace('', np.nan).astype(float)
    scoring_percentages['FD Main Top Score'] = scoring_percentages['FD Main Top Score'].replace('', np.nan).astype(float)
    scoring_percentages['DK Secondary Top Score'] = scoring_percentages['DK Secondary Top Score'].replace('', np.nan).astype(float)
    scoring_percentages['FD Secondary Top Score'] = scoring_percentages['FD Secondary Top Score'].replace('', np.nan).astype(float)
    scoring_percentages['DK Turbo Top Score'] = scoring_percentages['DK Turbo Top Score'].replace('', np.nan).astype(float)
    scoring_percentages['FD Turbo Top Score'] = scoring_percentages['FD Turbo Top Score'].replace('', np.nan).astype(float)
    
    return roo_data, sd_roo_data, scoring_percentages, dk_roo, fd_roo, dk_id_map, fd_id_map

@st.cache_data(ttl = 60)
def init_DK_lineups(type_var, slate_var):  
    
    if type_var == 'Regular':
        if slate_var == 'Main':
            collection = db['DK_MLB_name_map']
            cursor = collection.find()
            raw_data = pd.DataFrame(list(cursor))
            names_dict = dict(zip(raw_data['key'], raw_data['value']))

            collection = db['DK_MLB_seed_frame']
            cursor = collection.find().limit(10000)

            raw_display = pd.DataFrame(list(cursor))
            raw_display = raw_display[['SP1', 'SP2', 'C', '1B', '2B', '3B', 'SS', 'OF1', 'OF2', 'OF3', 'salary', 'proj', 'Team', 'Team_count', 'Secondary', 'Secondary_count', 'Own']]
            dict_columns = ['SP1', 'SP2', 'C', '1B', '2B', '3B', 'SS', 'OF1', 'OF2', 'OF3']
            # Map names
            raw_display[dict_columns] = raw_display[dict_columns].apply(lambda x: x.map(names_dict))
        elif slate_var == 'Secondary':
            collection = db['DK_MLB_Secondary_name_map']
            cursor = collection.find()
            raw_data = pd.DataFrame(list(cursor))
            names_dict = dict(zip(raw_data['key'], raw_data['value']))
            
            collection = db['DK_MLB_Secondary_seed_frame']
            cursor = collection.find().limit(10000)

            raw_display = pd.DataFrame(list(cursor))
            raw_display = raw_display[['SP1', 'SP2', 'C', '1B', '2B', '3B', 'SS', 'OF1', 'OF2', 'OF3', 'salary', 'proj', 'Team', 'Team_count', 'Secondary', 'Secondary_count', 'Own']]
            dict_columns = ['SP1', 'SP2', 'C', '1B', '2B', '3B', 'SS', 'OF1', 'OF2', 'OF3']
            # Map names
            raw_display[dict_columns] = raw_display[dict_columns].apply(lambda x: x.map(names_dict))
        elif slate_var == 'Auxiliary':
            collection = db['DK_MLB_Turbo_name_map']
            cursor = collection.find()
            raw_data = pd.DataFrame(list(cursor))
            names_dict = dict(zip(raw_data['key'], raw_data['value']))
            
            collection = db['DK_MLB_Turbo_seed_frame']
            cursor = collection.find().limit(10000)

            raw_display = pd.DataFrame(list(cursor))
            raw_display = raw_display[['SP1', 'SP2', 'C', '1B', '2B', '3B', 'SS', 'OF1', 'OF2', 'OF3', 'salary', 'proj', 'Team', 'Team_count', 'Secondary', 'Secondary_count', 'Own']]
            dict_columns = ['SP1', 'SP2', 'C', '1B', '2B', '3B', 'SS', 'OF1', 'OF2', 'OF3']
            # Map names
            raw_display[dict_columns] = raw_display[dict_columns].apply(lambda x: x.map(names_dict))
    elif type_var == 'Showdown':
        if slate_var == 'Main':
            collection = db['DK_MLB_SD1_seed_frame']
            cursor = collection.find().limit(10000)

            raw_display = pd.DataFrame(list(cursor))
            raw_display = raw_display[['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'salary', 'proj', 'Team', 'Team_count', 'Secondary', 'Secondary_count', 'Own']]
        elif slate_var == 'Secondary':
            collection = db['DK_MLB_SD2_seed_frame']
            cursor = collection.find().limit(10000)

            raw_display = pd.DataFrame(list(cursor))
            raw_display = raw_display[['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'salary', 'proj', 'Team', 'Team_count', 'Secondary', 'Secondary_count', 'Own']]
        elif slate_var == 'Auxiliary':
            collection = db['DK_MLB_SD3_seed_frame']
            cursor = collection.find().limit(10000)

            raw_display = pd.DataFrame(list(cursor))
            raw_display = raw_display[['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5', 'salary', 'proj', 'Team', 'Team_count', 'Secondary', 'Secondary_count', 'Own']]

    DK_seed = raw_display.to_numpy()

    return DK_seed

@st.cache_data(ttl = 60)
def init_FD_lineups(type_var,slate_var):  
        
        if type_var == 'Regular':
            if slate_var == 'Main':
                collection = db['FD_MLB_name_map']
                cursor = collection.find()
                raw_data = pd.DataFrame(list(cursor))
                names_dict = dict(zip(raw_data['key'], raw_data['value']))

                collection = db['FD_MLB_seed_frame']
                cursor = collection.find().limit(10000)

                raw_display = pd.DataFrame(list(cursor))
                raw_display = raw_display[['P', 'C_1B', '2B', '3B', 'SS', 'OF1', 'OF2', 'OF3', 'UTIL', 'salary', 'proj', 'Team', 'Team_count', 'Secondary', 'Secondary_count', 'Own']]
                dict_columns = ['P', 'C_1B', '2B', '3B', 'SS', 'OF1', 'OF2', 'OF3', 'UTIL']
                # Map names
                raw_display[dict_columns] = raw_display[dict_columns].apply(lambda x: x.map(names_dict))
            elif slate_var == 'Secondary':
                collection = db['FD_MLB_Secondary_name_map']
                cursor = collection.find()
                raw_data = pd.DataFrame(list(cursor))
                names_dict = dict(zip(raw_data['key'], raw_data['value']))

                collection = db['FD_MLB_Secondary_seed_frame']
                cursor = collection.find().limit(10000)

                raw_display = pd.DataFrame(list(cursor))
                raw_display = raw_display[['P', 'C_1B', '2B', '3B', 'SS', 'OF1', 'OF2', 'OF3', 'UTIL', 'salary', 'proj', 'Team', 'Team_count', 'Secondary', 'Secondary_count', 'Own']]
                dict_columns = ['P', 'C_1B', '2B', '3B', 'SS', 'OF1', 'OF2', 'OF3', 'UTIL']
                # Map names
                raw_display[dict_columns] = raw_display[dict_columns].apply(lambda x: x.map(names_dict))
            elif slate_var == 'Auxiliary':
                collection = db['FD_MLB_Turbo_name_map']
                cursor = collection.find()
                raw_data = pd.DataFrame(list(cursor))
                names_dict = dict(zip(raw_data['key'], raw_data['value']))

                collection = db['FD_MLB_Turbo_seed_frame']
                cursor = collection.find().limit(10000)
            
                raw_display = pd.DataFrame(list(cursor))
                raw_display = raw_display[['P', 'C_1B', '2B', '3B', 'SS', 'OF1', 'OF2', 'OF3', 'UTIL', 'salary', 'proj', 'Team', 'Team_count', 'Secondary', 'Secondary_count', 'Own']]
                dict_columns = ['P', 'C_1B', '2B', '3B', 'SS', 'OF1', 'OF2', 'OF3', 'UTIL']
                # Map names
                raw_display[dict_columns] = raw_display[dict_columns].apply(lambda x: x.map(names_dict))

        elif type_var == 'Showdown':
            if slate_var == 'Main':
                collection = db['FD_MLB_SD1_seed_frame']
                cursor = collection.find().limit(10000)

                raw_display = pd.DataFrame(list(cursor))
                raw_display = raw_display[['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'salary', 'proj', 'Team', 'Team_count', 'Secondary', 'Secondary_count', 'Own']]
            elif slate_var == 'Secondary':
                collection = db['FD_MLB_SD2_seed_frame']
                cursor = collection.find().limit(10000)

                raw_display = pd.DataFrame(list(cursor))
                raw_display = raw_display[['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'salary', 'proj', 'Team', 'Team_count', 'Secondary', 'Secondary_count', 'Own']]
            elif slate_var == 'Auxiliary':
                collection = db['FD_MLB_SD3_seed_frame']
                cursor = collection.find().limit(10000)
            
                raw_display = pd.DataFrame(list(cursor))
                raw_display = raw_display[['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'salary', 'proj', 'Team', 'Team_count', 'Secondary', 'Secondary_count', 'Own']]
    
        FD_seed = raw_display.to_numpy()

        return FD_seed

@st.cache_data
def convert_df_to_csv(df):
    return df.to_csv().encode('utf-8')

@st.cache_data
def convert_df(array):
    array = pd.DataFrame(array, columns=column_names)
    return array.to_csv().encode('utf-8')

col1, col2 = st.columns([1, 9])
with col1:
    if st.button("Load/Reset Data", key='reset'):
        st.cache_data.clear()
        roo_data, sd_roo_data, scoring_percentages, dk_roo, fd_roo, dk_id_map, fd_id_map = init_baselines()
        hold_display = roo_data
        dk_lineups = init_DK_lineups('Regular', 'Main')
        fd_lineups = init_FD_lineups('Regular', 'Main')
        for key in st.session_state.keys():
            del st.session_state[key]
with col2:
    with st.container():
        col1, col2 = st.columns([3, 3])
        with col1:
            view_var = st.selectbox("Select view", ["Simple", "Advanced"], key='view_var')
        with col2:
            site_var = st.selectbox("What site do you want to view?", ('Draftkings', 'Fanduel'), key='site_var')
        

tab1, tab2, tab3, tab4 = st.tabs(["Scoring Percentages", "Player ROO", "Optimals", "Handbuilder"])

roo_data, sd_roo_data, scoring_percentages, dk_roo, fd_roo, dk_id_map, fd_id_map = init_baselines()
hold_display = roo_data

with tab1:
    st.header("Scoring Percentages")
    with st.expander("Info and Filters"):
        with st.container():
            slate_var1 = st.radio("Which data are you loading?", ('Main Slate', 'Secondary Slate', 'Turbo Slate'), key='slate_var1')
            prio_split = st.radio("Do you want to isolate a specific Stack Priority?", ('No', 'Yes'), key='prio_split')
            if prio_split == 'Yes':
                prio_var = st.radio("Which Stack Priority are you looking for?", ['OF_Prio', 'IF_Prio'], key='prio_var')
            else:
                prio_var = None

    
    if site_var == 'Draftkings':
        if slate_var1 == 'Main Slate':
            scoring_percentages = scoring_percentages[scoring_percentages['DK Main Slate'] == 1]
        elif slate_var1 == 'Secondary Slate':
            scoring_percentages = scoring_percentages[scoring_percentages['DK Secondary Slate'] == 1]
        elif slate_var1 == 'Turbo Slate':
            scoring_percentages = scoring_percentages[scoring_percentages['DK Turbo Slate'] == 1]
    elif site_var == 'Fanduel':
        if slate_var1 == 'Main Slate':
            scoring_percentages = scoring_percentages[scoring_percentages['FD Main Slate'] == 1]
        elif slate_var1 == 'Secondary Slate':
            scoring_percentages = scoring_percentages[scoring_percentages['FD Secondary Slate'] == 1]
        elif slate_var1 == 'Turbo Slate':
            scoring_percentages = scoring_percentages[scoring_percentages['FD Turbo Slate'] == 1]

    dk_hitters_only = dk_roo[dk_roo['pos_group'] != 'Pitchers']
    if slate_var1 == 'Main Slate':
        dk_hitters_only = dk_hitters_only[dk_hitters_only['Slate'] == 'main_slate']
    elif slate_var1 == 'Secondary Slate':
        dk_hitters_only = dk_hitters_only[dk_hitters_only['Slate'] == 'secondary_slate']
    elif slate_var1 == 'Turbo Slate':
        dk_hitters_only = dk_hitters_only[dk_hitters_only['Slate'] == 'turbo_slate']
    dk_hitters_only = dk_hitters_only.replace('CWS', 'CHW')
    dk_team_ownership = dk_hitters_only.groupby('Team')['Own%'].sum().reset_index()
    fd_hitters_only = fd_roo[fd_roo['pos_group'] != 'Pitchers']
    if slate_var1 == 'Main Slate':
        fd_hitters_only = fd_hitters_only[fd_hitters_only['Slate'] == 'main_slate']
    elif slate_var1 == 'Secondary Slate':
        fd_hitters_only = fd_hitters_only[fd_hitters_only['Slate'] == 'secondary_slate']
    elif slate_var1 == 'Turbo Slate':
        fd_hitters_only = fd_hitters_only[fd_hitters_only['Slate'] == 'turbo_slate']
    fd_hitters_only = fd_hitters_only.replace('CWS', 'CHW')
    fd_team_ownership = fd_hitters_only.groupby('Team')['Own%'].sum().reset_index()
    scoring_percentages = scoring_percentages.merge(dk_team_ownership, left_on='Names', right_on='Team', how='left')
    scoring_percentages.rename(columns={'Own%': 'DK Own%'}, inplace=True)
    scoring_percentages.drop('Team', axis=1, inplace=True)
    scoring_percentages = scoring_percentages.merge(fd_team_ownership, left_on='Names', right_on='Team', how='left')
    scoring_percentages.rename(columns={'Own%': 'FD Own%'}, inplace=True)
    scoring_percentages.drop('Team', axis=1, inplace=True)
    if site_var == 'Draftkings':
        if slate_var1 == 'Main Slate':
            scoring_percentages['DK LevX'] = scoring_percentages['DK Main Top Score'].rank(pct=True).astype(float) - scoring_percentages['DK Own%'].rank(pct=True).astype(float)
            scoring_percentages = scoring_percentages.rename(columns={'DK Main Top Score': 'Top Score'})
            scoring_percentages = scoring_percentages.drop(['DK Main Slate', 'DK Secondary Slate', 'DK Turbo Slate', 'FD Main Slate', 'FD Secondary Slate', 'FD Turbo Slate', 'FD Main Top Score', 'DK Secondary Top Score', 'FD Secondary Top Score', 'DK Turbo Top Score', 'FD Turbo Top Score'], axis=1)
        elif slate_var1 == 'Secondary Slate':
            scoring_percentages['DK LevX'] = scoring_percentages['DK Secondary Top Score'].rank(pct=True).astype(float) - scoring_percentages['DK Own%'].rank(pct=True).astype(float)
            scoring_percentages = scoring_percentages.rename(columns={'DK Secondary Top Score': 'Top Score'})
            scoring_percentages = scoring_percentages.drop(['DK Main Slate', 'DK Secondary Slate', 'DK Turbo Slate', 'FD Main Slate', 'FD Secondary Slate', 'FD Turbo Slate', 'FD Main Top Score', 'DK Main Top Score', 'FD Secondary Top Score', 'DK Turbo Top Score', 'FD Turbo Top Score'], axis=1)
        elif slate_var1 == 'Turbo Slate':
            scoring_percentages['DK LevX'] = scoring_percentages['DK Turbo Top Score'].rank(pct=True).astype(float) - scoring_percentages['DK Own%'].rank(pct=True).astype(float)
            scoring_percentages = scoring_percentages.rename(columns={'DK Turbo Top Score': 'Top Score'})
            scoring_percentages = scoring_percentages.drop(['DK Main Slate', 'DK Secondary Slate', 'DK Turbo Slate', 'FD Main Slate', 'FD Secondary Slate', 'FD Turbo Slate', 'FD Main Top Score', 'DK Main Top Score', 'FD Secondary Top Score', 'DK Secondary Top Score', 'FD Turbo Top Score'], axis=1)
    elif site_var == 'Fanduel':
        if slate_var1 == 'Main Slate':
            scoring_percentages['FD LevX'] = scoring_percentages['FD Main Top Score'].rank(pct=True).astype(float) - scoring_percentages['FD Own%'].rank(pct=True).astype(float)
            scoring_percentages = scoring_percentages.rename(columns={'FD Main Top Score': 'Top Score'})
            scoring_percentages = scoring_percentages.drop(['DK Main Slate', 'DK Secondary Slate', 'DK Turbo Slate', 'FD Main Slate', 'FD Secondary Slate', 'FD Turbo Slate', 'DK Main Top Score', 'DK Secondary Top Score', 'FD Secondary Top Score', 'DK Turbo Top Score', 'FD Turbo Top Score'], axis=1)
        elif slate_var1 == 'Secondary Slate':
            scoring_percentages['FD LevX'] = scoring_percentages['FD Secondary Top Score'].rank(pct=True).astype(float) - scoring_percentages['FD Own%'].rank(pct=True).astype(float)
            scoring_percentages = scoring_percentages.rename(columns={'FD Secondary Top Score': 'Top Score'})
            scoring_percentages = scoring_percentages.drop(['DK Main Slate', 'DK Secondary Slate', 'DK Turbo Slate', 'FD Main Slate', 'FD Secondary Slate', 'FD Turbo Slate', 'FD Main Top Score', 'DK Main Top Score', 'DK Secondary Top Score', 'DK Turbo Top Score', 'FD Turbo Top Score'], axis=1)
        elif slate_var1 == 'Turbo Slate':
            scoring_percentages['FD LevX'] = scoring_percentages['FD Turbo Top Score'].rank(pct=True).astype(float) - scoring_percentages['FD Own%'].rank(pct=True).astype(float)
            scoring_percentages = scoring_percentages.rename(columns={'FD Turbo Top Score': 'Top Score'})
            scoring_percentages = scoring_percentages.drop(['DK Main Slate', 'DK Secondary Slate', 'DK Turbo Slate', 'FD Main Slate', 'FD Secondary Slate', 'FD Turbo Slate', 'FD Main Top Score', 'DK Main Top Score', 'FD Secondary Top Score', 'DK Secondary Top Score', 'DK Turbo Top Score'], axis=1)
    scoring_percentages = scoring_percentages.sort_values(by='8+ runs', ascending=False)
    if site_var == 'Draftkings':
        scoring_percentages = scoring_percentages.rename(columns={'DK LevX': 'LevX', 'DK Own%': 'Own%', 'Avg Score': 'Runs', 'Win Percentage': 'Win%', '8+ runs': '8+ Runs'})
        scoring_percentages = scoring_percentages.drop(['FD Own%', 'Avg_Salary_FD'], axis=1)
    elif site_var == 'Fanduel':
        scoring_percentages = scoring_percentages.rename(columns={'FD LevX': 'LevX', 'FD Own%': 'Own%', 'Avg Score': 'Runs', 'Win Percentage': 'Win%', '8+ runs': '8+ Runs'})
        scoring_percentages = scoring_percentages.drop(['DK Own%', 'Avg_Salary_DK'], axis=1)
    
    if view_var == "Simple":
        scoring_percentages = scoring_percentages[['Names', 'Runs', '8+ Runs', 'Win%', 'LevX', 'Own%']]
        scoring_percentages = scoring_percentages.set_index('Names', drop=True)
        st.dataframe(scoring_percentages.style.background_gradient(axis=0).background_gradient(cmap='RdYlGn').background_gradient(cmap='RdYlGn_r', subset=['Own%']).format(game_format, precision=2), height=750, use_container_width = True)
    elif view_var == "Advanced":
        if prio_var is not None:
            scoring_percentages = scoring_percentages[scoring_percentages['Stack_Prio'] == prio_var]
        scoring_percentages = scoring_percentages.set_index('Names', drop=True)
        st.dataframe(scoring_percentages.style.background_gradient(axis=0).background_gradient(cmap='RdYlGn').background_gradient(cmap='RdYlGn_r', subset=['Avg_Salary', 'Own%']).format(game_format, precision=2), height=750, use_container_width = True)

with tab2:
    st.header("Player ROO")
    with st.expander("Info and Filters"):
        with st.container():
            slate_type_var2 = st.radio("Which slate type are you loading?", ('Regular', 'Showdown'), key='slate_type_var2')
            slate_var2 = st.radio("Which slate data are you loading?", ('Main', 'Secondary', 'Auxiliary'), key='slate_var2')
            group_var2 = st.radio("Which position group would you like to view?", ('All', 'Pitchers', 'Hitters'), key='group_var2')
            team_var2 = st.selectbox("Which team would you like to view?",  ['All', 'Specific'], key='team_var2')
            if team_var2 == 'Specific':
                team_select2 = st.multiselect("Select your team(s)", roo_data['Team'].unique(), key='team_select2')
            else:
                team_select2 = None
            pos_var2 = st.selectbox("Which position(s) would you like to view?",  ['All', 'Specific'], key='pos_var2')
            if pos_var2 == 'Specific':
                pos_select2 = st.multiselect("Select your position(s)", roo_data['Position'].unique(), key='pos_select2')
            else:
                pos_select2 = None
    if slate_type_var2 == 'Regular':
        if site_var == 'Draftkings':
        
            player_roo_raw = dk_roo.copy()

            if group_var2 == 'All':
                pass
            elif group_var2 == 'Pitchers':
                player_roo_raw = player_roo_raw[player_roo_raw['pos_group'] == 'Pitchers']
            elif group_var2 == 'Hitters':
                player_roo_raw = player_roo_raw[player_roo_raw['pos_group'] == 'Hitters']

        elif site_var == 'Fanduel':
            
            player_roo_raw = fd_roo.copy()

            if group_var2 == 'All':
                pass
            elif group_var2 == 'Pitchers':
                player_roo_raw = player_roo_raw[player_roo_raw['pos_group'] == 'Pitchers']
            elif group_var2 == 'Hitters':
                player_roo_raw = player_roo_raw[player_roo_raw['pos_group'] == 'Hitters']
        
        if slate_var2 == 'Main':
            player_roo_raw = player_roo_raw[player_roo_raw['Slate'] == 'main_slate']
        elif slate_var2 == 'Secondary':
            player_roo_raw = player_roo_raw[player_roo_raw['Slate'] == 'secondary_slate']
        elif slate_var2 == 'Auxiliary':
            player_roo_raw = player_roo_raw[player_roo_raw['Slate'] == 'turbo_slate']
            
    elif slate_type_var2 == 'Showdown':
        player_roo_raw = sd_roo_data.copy()
        if site_var == 'Draftkings':
            player_roo_raw['site'] = 'Draftkings'
        elif site_var == 'Fanduel':
            player_roo_raw['site'] = 'Fanduel'

        if slate_var2 == 'Main':
            player_roo_raw = player_roo_raw[player_roo_raw['slate'] == 'DK SD1']
        elif slate_var2 == 'Secondary':
            player_roo_raw = player_roo_raw[player_roo_raw['slate'] == 'DK SD2']
        elif slate_var2 == 'Auxiliary':
            player_roo_raw = player_roo_raw[player_roo_raw['slate'] == 'DK SD3']
    
    if team_select2:
        player_roo_raw = player_roo_raw[player_roo_raw['Team'].isin(team_select2)]
    if pos_select2:
        position_mask = player_roo_raw['Position'].apply(lambda x: any(pos in x for pos in pos_select2))
        player_roo_raw = player_roo_raw[position_mask]
    
    player_roo_disp = player_roo_raw
    
    if slate_type_var2 == 'Regular':
        player_roo_disp = player_roo_disp.drop(columns=['Site', 'Slate', 'pos_group', 'timestamp', 'player_ID'])
    elif slate_type_var2 == 'Showdown':
        player_roo_disp = player_roo_disp.drop(columns=['site', 'slate', 'version', 'timestamp'])
    
    player_roo_disp = player_roo_disp.drop_duplicates(subset=['Player'])

    if view_var == "Simple":
        try:
            player_roo_disp = player_roo_disp[['Player', 'Salary', 'Median', 'Ceiling', 'Own%', 'Position', 'Team']]
            player_roo_disp = player_roo_disp.set_index('Player', drop=True)
            st.dataframe(player_roo_disp.style.background_gradient(axis=0).background_gradient(cmap='RdYlGn').background_gradient(cmap='RdYlGn_r', subset=['Salary', 'Own%']).format(player_roo_format, precision=2), height=750, use_container_width = True)
        except:
            player_roo_disp = player_roo_disp.set_index('Player', drop=True)
            st.dataframe(player_roo_disp.style.background_gradient(axis=0).background_gradient(cmap='RdYlGn').background_gradient(cmap='RdYlGn_r', subset=['Salary', 'Own%']).format(player_roo_format, precision=2), height=750, use_container_width = True)
            
    elif view_var == "Advanced":
        try:
            player_roo_disp = player_roo_disp.set_index('Player', drop=True)
            st.dataframe(player_roo_disp.style.background_gradient(axis=0).background_gradient(cmap='RdYlGn').background_gradient(cmap='RdYlGn_r', subset=['Order', 'Salary', 'Own%', 'Small Field Own%', 'Large Field Own%', 'Cash Own%']).format(player_roo_format, precision=2), height=750, use_container_width = True)
        except:
            # player_roo_disp = player_roo_disp.set_index('Player', drop=True)
            st.dataframe(player_roo_disp.style.background_gradient(axis=0).background_gradient(cmap='RdYlGn').background_gradient(cmap='RdYlGn_r', subset=['Order', 'Salary', 'Own%', 'Small Field Own%', 'Large Field Own%', 'Cash Own%']).format(player_roo_format, precision=2), height=750, use_container_width = True)

with tab3:
    st.header("Optimals")
    with st.expander("Info and Filters"):
        col1, col2, col3 = st.columns(3)
        with col1:
            slate_type_var3 = st.radio("Which slate type are you loading?", ('Regular', 'Showdown'), key='slate_type_var3')
            if slate_type_var3 == 'Regular':
                raw_baselines = roo_data
            elif slate_type_var3 == 'Showdown':
                raw_baselines = sd_roo_data
            slate_var3 = st.radio("Which slate data are you loading?", ('Main', 'Secondary', 'Auxiliary'), key='slate_var3')
            if slate_type_var3 == 'Regular':
                if site_var == 'Draftkings':
                    dk_lineups = init_DK_lineups(slate_type_var3, slate_var3)
                elif site_var == 'Fanduel':
                    fd_lineups = init_FD_lineups(slate_type_var3, slate_var3)
            elif slate_type_var3 == 'Showdown':
                if site_var == 'Draftkings':
                    dk_lineups = init_DK_lineups(slate_type_var3, slate_var3)
                elif site_var == 'Fanduel':
                    fd_lineups = init_FD_lineups(slate_type_var3, slate_var3)
        with col2:
            lineup_num_var = st.number_input("How many lineups do you want to display?", min_value=1, max_value=1000, value=150, step=1)
            player_var1 = st.radio("Do you want a frame with specific Players?", ('Full Slate', 'Specific Players'), key='player_var1')
            if player_var1 == 'Specific Players':
                player_var2 = st.multiselect('Which players do you want?', options = raw_baselines['Player'].unique())
            elif player_var1 == 'Full Slate':
                    player_var2 = raw_baselines.Player.values.tolist()
        with col3:
            if site_var == 'Draftkings':
                salary_min_var = st.number_input("Minimum salary used", min_value = 0, max_value = 50000, value = 49000, step = 100, key = 'salary_min_var')
                salary_max_var = st.number_input("Maximum salary used", min_value = 0, max_value = 50000, value = 50000, step = 100, key = 'salary_max_var')
            elif site_var == 'Fanduel':
                salary_min_var = st.number_input("Minimum salary used", min_value = 0, max_value = 35000, value = 34000, step = 100, key = 'salary_min_var')
                salary_max_var = st.number_input("Maximum salary used", min_value = 0, max_value = 35000, value = 35000, step = 100, key = 'salary_max_var')
        
        
        if site_var == 'Draftkings':
            if slate_type_var3 == 'Regular':
                ROO_slice = raw_baselines[raw_baselines['Site'] == 'Draftkings']
                player_salaries = dict(zip(ROO_slice['Player'], ROO_slice['Salary']))
                column_names = dk_columns
            elif slate_type_var3 == 'Showdown':
                player_salaries = dict(zip(raw_baselines['Player'], raw_baselines['Salary']))
                column_names = dk_sd_columns
            # Get the minimum and maximum ownership values from dk_lineups
            min_own = np.min(dk_lineups[:,12])
            max_own = np.max(dk_lineups[:,12])
            
                    
        elif site_var == 'Fanduel':
            raw_baselines = hold_display
            if slate_type_var3 == 'Regular':
                ROO_slice = raw_baselines[raw_baselines['Site'] == 'Fanduel']
                player_salaries = dict(zip(ROO_slice['Player'], ROO_slice['Salary']))
                column_names = fd_columns
            elif slate_type_var3 == 'Showdown':
                player_salaries = dict(zip(raw_baselines['Player'], raw_baselines['Salary']))
                column_names = fd_sd_columns
            # Get the minimum and maximum ownership values from dk_lineups
            min_own = np.min(fd_lineups[:,11])
            max_own = np.max(fd_lineups[:,11])

        if st.button("Prepare full data export", key='data_export'):
            name_export = pd.DataFrame(st.session_state.working_seed.copy(), columns=column_names)
            data_export = pd.DataFrame(st.session_state.working_seed.copy(), columns=column_names)
            if site_var == 'Draftkings':
                if slate_type_var3 == 'Regular':
                    map_columns = ['SP1', 'SP2', 'C', '1B', '2B', '3B', 'SS', 'OF1', 'OF2', 'OF3']
                elif slate_type_var3 == 'Showdown':
                    map_columns = ['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5']
                for col_idx in map_columns:
                    data_export[col_idx] = data_export[col_idx].map(dk_id_map)
            elif site_var == 'Fanduel':
                if slate_type_var3 == 'Regular':
                    map_columns = ['P', 'C_1B', '2B', '3B', 'SS', 'OF1', 'OF2', 'OF3', 'UTIL']
                elif slate_type_var3 == 'Showdown':
                    map_columns = ['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4']
                for col_idx in map_columns:
                    data_export[col_idx] = data_export[col_idx].map(fd_id_map)
            st.download_button(
                label="Export optimals set (IDs)",
                data=convert_df(data_export),
                file_name='MLB_optimals_export.csv',
                mime='text/csv',
            )
            st.download_button(
                label="Export optimals set (Names)",
                data=convert_df(name_export),
                file_name='MLB_optimals_export.csv',
                mime='text/csv',
            )
        
    if site_var == 'Draftkings':
        if 'working_seed' in st.session_state:
            st.session_state.working_seed = st.session_state.working_seed
            if player_var1 == 'Specific Players':
                st.session_state.working_seed = st.session_state.working_seed[np.equal.outer(st.session_state.working_seed, player_var2).any(axis=1).all(axis=1)]
            elif player_var1 == 'Full Slate':
                st.session_state.working_seed = dk_lineups.copy()
            st.session_state.data_export_display = pd.DataFrame(st.session_state.working_seed[0:lineup_num_var], columns=column_names)
        elif 'working_seed' not in st.session_state:
            st.session_state.working_seed = dk_lineups.copy()
            st.session_state.working_seed = st.session_state.working_seed
            if player_var1 == 'Specific Players':
                st.session_state.working_seed = st.session_state.working_seed[np.equal.outer(st.session_state.working_seed, player_var2).any(axis=1).all(axis=1)]
            elif player_var1 == 'Full Slate':
                st.session_state.working_seed = dk_lineups.copy()
            st.session_state.data_export_display = pd.DataFrame(st.session_state.working_seed[0:lineup_num_var], columns=column_names)
        
    elif site_var == 'Fanduel':
        if 'working_seed' in st.session_state:
            st.session_state.working_seed = st.session_state.working_seed
            if player_var1 == 'Specific Players':
                st.session_state.working_seed = st.session_state.working_seed[np.equal.outer(st.session_state.working_seed, player_var2).any(axis=1).all(axis=1)]
            elif player_var1 == 'Full Slate':
                st.session_state.working_seed = fd_lineups.copy()
            st.session_state.data_export_display = pd.DataFrame(st.session_state.working_seed[0:lineup_num_var], columns=column_names)
        elif 'working_seed' not in st.session_state:
            st.session_state.working_seed = fd_lineups.copy()
            st.session_state.working_seed = st.session_state.working_seed
            if player_var1 == 'Specific Players':
                st.session_state.working_seed = st.session_state.working_seed[np.equal.outer(st.session_state.working_seed, player_var2).any(axis=1).all(axis=1)]
            elif player_var1 == 'Full Slate':
                st.session_state.working_seed = fd_lineups.copy()
            st.session_state.data_export_display = pd.DataFrame(st.session_state.working_seed[0:lineup_num_var], columns=column_names)
    st.session_state.data_export_display = st.session_state.data_export_display[st.session_state.data_export_display['salary'] >= salary_min_var]
    st.session_state.data_export_display = st.session_state.data_export_display[st.session_state.data_export_display['salary'] <= salary_max_var]
    export_file = st.session_state.data_export_display.copy()
    name_export = st.session_state.data_export_display.copy()
    if site_var == 'Draftkings':
        if slate_type_var3 == 'Regular':
            map_columns = ['SP1', 'SP2', 'C', '1B', '2B', '3B', 'SS', 'OF1', 'OF2', 'OF3']
        elif slate_type_var3 == 'Showdown':
            map_columns = ['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5']
        for col_idx in map_columns:
            export_file[col_idx] = export_file[col_idx].map(dk_id_map)
    elif site_var == 'Fanduel':
        if slate_type_var3 == 'Regular':
            map_columns = ['P', 'C_1B', '2B', '3B', 'SS', 'OF1', 'OF2', 'OF3', 'UTIL']
        elif slate_type_var3 == 'Showdown':
            map_columns = ['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4']
        for col_idx in map_columns:
            export_file[col_idx] = export_file[col_idx].map(fd_id_map)
            
    with st.container():
        if st.button("Reset Optimals", key='reset3'):
            for key in st.session_state.keys():
                del st.session_state[key]
            if site_var == 'Draftkings':
                st.session_state.working_seed = dk_lineups.copy()
            elif site_var == 'Fanduel':
                st.session_state.working_seed = fd_lineups.copy()
        if 'data_export_display' in st.session_state:
            st.dataframe(st.session_state.data_export_display.style.background_gradient(axis=0).background_gradient(cmap='RdYlGn').format(precision=2), height=500, use_container_width = True)
        st.download_button(
            label="Export display optimals (IDs)",
            data=convert_df(export_file),
            file_name='MLB_display_optimals.csv',
            mime='text/csv',
        )
        st.download_button(
            label="Export display optimals (Names)",
            data=convert_df(name_export),
            file_name='MLB_display_optimals.csv',
            mime='text/csv',
        )
    
    with st.container():
        if slate_type_var3 == 'Regular':
            if 'working_seed' in st.session_state:
                # Create a new dataframe with summary statistics
                if site_var == 'Draftkings':
                    summary_df = pd.DataFrame({
                        'Metric': ['Min', 'Average', 'Max', 'STDdev'],
                        'Salary': [
                            np.min(st.session_state.working_seed[:,10]),
                            np.mean(st.session_state.working_seed[:,10]),
                            np.max(st.session_state.working_seed[:,10]),
                            np.std(st.session_state.working_seed[:,10])
                        ],
                        'Proj': [
                            np.min(st.session_state.working_seed[:,11]),
                            np.mean(st.session_state.working_seed[:,11]),
                            np.max(st.session_state.working_seed[:,11]),
                            np.std(st.session_state.working_seed[:,11])
                        ],
                        'Own': [
                            np.min(st.session_state.working_seed[:,16]),
                            np.mean(st.session_state.working_seed[:,16]),
                            np.max(st.session_state.working_seed[:,16]),
                            np.std(st.session_state.working_seed[:,16])
                        ]
                    })
                elif site_var == 'Fanduel':
                    summary_df = pd.DataFrame({
                        'Metric': ['Min', 'Average', 'Max', 'STDdev'],
                        'Salary': [
                            np.min(st.session_state.working_seed[:,9]),
                            np.mean(st.session_state.working_seed[:,9]),
                            np.max(st.session_state.working_seed[:,9]),
                            np.std(st.session_state.working_seed[:,9])
                        ],
                        'Proj': [
                            np.min(st.session_state.working_seed[:,10]),
                            np.mean(st.session_state.working_seed[:,10]),
                            np.max(st.session_state.working_seed[:,10]),
                            np.std(st.session_state.working_seed[:,10])
                        ],
                        'Own': [
                            np.min(st.session_state.working_seed[:,15]),
                            np.mean(st.session_state.working_seed[:,15]),
                            np.max(st.session_state.working_seed[:,15]),
                            np.std(st.session_state.working_seed[:,15])
                        ]
                    })

                # Set the index of the summary dataframe as the "Metric" column
                summary_df = summary_df.set_index('Metric')

                # Display the summary dataframe
                st.subheader("Optimal Statistics")
                st.dataframe(summary_df.style.format({
                    'Salary': '{:.2f}',
                    'Proj': '{:.2f}',
                    'Own': '{:.2f}'
                }).background_gradient(cmap='RdYlGn', axis=0, subset=['Salary', 'Proj', 'Own']), use_container_width=True)

    with st.container():
        tab1, tab2 = st.tabs(["Display Frequency", "Seed Frame Frequency"])
        with tab1:
            if 'data_export_display' in st.session_state:
                if site_var == 'Draftkings':
                    if slate_type_var3 == 'Regular':
                        player_columns = st.session_state.data_export_display.iloc[:, :10]
                    elif slate_type_var3 == 'Showdown':
                        player_columns = st.session_state.data_export_display.iloc[:, :6]
                elif site_var == 'Fanduel':
                    if slate_type_var3 == 'Regular':
                        player_columns = st.session_state.data_export_display.iloc[:, :9]
                    elif slate_type_var3 == 'Showdown':
                        player_columns = st.session_state.data_export_display.iloc[:, :5]
                
                # Flatten the DataFrame and count unique values
                value_counts = player_columns.values.flatten().tolist()
                value_counts = pd.Series(value_counts).value_counts()
                
                percentages = (value_counts / lineup_num_var * 100).round(2)
                
                # Create a DataFrame with the results
                summary_df = pd.DataFrame({
                    'Player': value_counts.index,
                    'Frequency': value_counts.values,
                    'Percentage': percentages.values
                })
                
                # Sort by frequency in descending order
                summary_df['Salary'] = summary_df['Player'].map(player_salaries)
                summary_df = summary_df[['Player', 'Salary', 'Frequency', 'Percentage']]
                summary_df = summary_df.sort_values('Frequency', ascending=False)
                summary_df = summary_df.set_index('Player')
                
                # Display the table
                st.write("Player Frequency Table:")
                st.dataframe(summary_df.style.format({'Percentage': '{:.2f}%'}), height=500, use_container_width=True)
            
                st.download_button(
                    label="Export player frequency",
                    data=convert_df_to_csv(summary_df),
                    file_name='MLB_player_frequency.csv',
                    mime='text/csv',
                )
        with tab2:
            if 'working_seed' in st.session_state:
                if site_var == 'Draftkings':
                    if slate_type_var3 == 'Regular':
                        player_columns = st.session_state.working_seed[:, :10]
                    elif slate_type_var3 == 'Showdown':
                        player_columns = st.session_state.working_seed[:, :7]
                elif site_var == 'Fanduel':
                    if slate_type_var3 == 'Regular':
                        player_columns = st.session_state.working_seed[:, :9]
                    elif slate_type_var3 == 'Showdown':
                        player_columns = st.session_state.working_seed[:, :6]
                
                # Flatten the DataFrame and count unique values
                value_counts = player_columns.flatten().tolist()
                value_counts = pd.Series(value_counts).value_counts()
                
                percentages = (value_counts / len(st.session_state.working_seed) * 100).round(2)
                # Create a DataFrame with the results
                summary_df = pd.DataFrame({
                    'Player': value_counts.index,
                    'Frequency': value_counts.values,
                    'Percentage': percentages.values
                })
                
                # Sort by frequency in descending order
                summary_df['Salary'] = summary_df['Player'].map(player_salaries)
                summary_df = summary_df[['Player', 'Salary', 'Frequency', 'Percentage']]
                summary_df = summary_df.sort_values('Frequency', ascending=False)
                summary_df = summary_df.set_index('Player')
                
                # Display the table
                st.write("Seed Frame Frequency Table:")
                st.dataframe(summary_df.style.format({'Percentage': '{:.2f}%'}), height=500, use_container_width=True)
            
                st.download_button(
                    label="Export seed frame frequency",
                    data=convert_df_to_csv(summary_df),
                    file_name='MLB_seed_frame_frequency.csv',
                    mime='text/csv',
                )

with tab4:
    col1, col2 = st.columns(2)
    with col1:
        st.header("Handbuilder")
    with col2:
        slate_var3 = st.selectbox("Slate Selection", options=['Main', 'Secondary', 'Auxiliary'])
        if site_var == 'Draftkings':
            if slate_var3 == 'Main':
                handbuild_roo = dk_roo[dk_roo['Slate'] == 'main_slate']
            elif slate_var3 == 'Secondary':
                handbuild_roo = dk_roo[dk_roo['Slate'] == 'secondary_slate']
            elif slate_var3 == 'Auxiliary':
                handbuild_roo = dk_roo[dk_roo['Slate'] == 'turbo_slate']
        else:
            if slate_var3 == 'Main':
                handbuild_roo = fd_roo[fd_roo['Slate'] == 'main_slate']
            elif slate_var3 == 'Secondary':
                handbuild_roo = fd_roo[fd_roo['Slate'] == 'secondary_slate']
            elif slate_var3 == 'Auxiliary':
                handbuild_roo = fd_roo[fd_roo['Slate'] == 'turbo_slate']

    # --- POSITION LIMITS ---
    if site_var == 'Draftkings':
        position_limits = {
            'SP': 2,
            'C': 1,
            '1B': 1,
            '2B': 1,
            '3B': 1,
            'SS': 1,
            'OF': 3,
            # Add more as needed
        }
        max_salary = 50000
        max_players = 10
    else:
        position_limits = {
            'P': 1,
            'C_1B': 1,
            '2B': 1,
            '3B': 1,
            'SS': 1,
            'OF': 3,
            'UTIL': 1,
            # Add more as needed
        }
        max_salary = 35000
        max_players = 9

    # --- LINEUP STATE ---
    if 'handbuilder_lineup' not in st.session_state:
        st.session_state['handbuilder_lineup'] = pd.DataFrame(columns=['Player', 'Order', 'Position', 'Team', 'Team_Total', 'Opp_Total', 'Salary', 'Median', '2x%', 'Own%'])
    if 'handbuilder_select_key' not in st.session_state:
        st.session_state['handbuilder_select_key'] = 0

    # Count positions in the current lineup
    lineup = st.session_state['handbuilder_lineup']
    slot_counts = lineup['Slot'].value_counts() if not lineup.empty else {}

    # --- PLAYER FILTERS ---
    with st.expander("Player Filters"):
        col1, col2 = st.columns(2)
        with col1:
            pos_select3 = st.multiselect("Select your position(s)", options=['P', 'C', '1B', '2B', '3B', 'SS', 'OF'], key='pos_select3')
        with col2:
            salary_var = st.number_input("Salary Max", min_value = 0, max_value = 20000, value = 20000, step = 100)

    # --- TEAM FILTER UI ---
    with st.expander("Team Filters"):
        all_teams = sorted(handbuild_roo['Team'].unique())
        st.markdown("**Toggle teams to include:**")
        team_cols = st.columns(len(all_teams) // 2 + 1)
    
    selected_teams = []
    for idx, team in enumerate(all_teams):
        col = team_cols[idx % len(team_cols)]
        if f"handbuilder_team_{team}" not in st.session_state:
            st.session_state[f"handbuilder_team_{team}"] = False
        checked = col.toggle(team, value=st.session_state[f"handbuilder_team_{team}"], key=f"handbuilder_team_{team}")
        if checked:
            selected_teams.append(team)

    # If no teams selected, show all teams
    if selected_teams:
        player_select_df = handbuild_roo[
            handbuild_roo['Team'].isin(selected_teams)
        ][['Player', 'Position', 'Team', 'Team_Total', 'Opp_Total', 'Salary', 'Median', '2x%', 'Order', 'Hand', 'Own%']].drop_duplicates(subset=['Player', 'Team']).sort_values(by='Order', ascending=True).copy()
    else:
        player_select_df = handbuild_roo[['Player', 'Position', 'Team', 'Team_Total', 'Opp_Total', 'Salary', 'Median', '2x%', 'Order', 'Hand', 'Own%']].drop_duplicates(subset=['Player', 'Team']).copy()
    
    # If no teams selected, show all teams
    if pos_select3:
        position_mask_2 = handbuild_roo['Position'].apply(lambda x: any(pos in x for pos in pos_select3))
        player_select_df = player_select_df[position_mask_2][['Player', 'Position', 'Team', 'Team_Total', 'Opp_Total', 'Salary', 'Median', '2x%', 'Order', 'Hand', 'Own%']].drop_duplicates(subset=['Player', 'Team']).sort_values(by='Order', ascending=True).copy()
    else:
        player_select_df = player_select_df[['Player', 'Position', 'Team', 'Team_Total', 'Opp_Total', 'Salary', 'Median', '2x%', 'Order', 'Hand', 'Own%']].drop_duplicates(subset=['Player', 'Team']).copy()
    
    player_select_df = player_select_df[player_select_df['Salary'] <= salary_var]

    
    with st.expander("Quick Fill Options"):
        auto_team_var = st.selectbox("Auto Fill Team", options=all_teams)
        auto_size_var = st.selectbox("Auto Fill Size", options=[3, 4, 5])
        auto_range_var = st.selectbox("Auto Fill Order", options=['Top (1-5)', 'Mid (4-8)', 'Wrap (7-2)'])
        # --- QUICK FILL LOGIC ---
        if st.button("Quick Fill", key="quick_fill"):
            # 1. Get all eligible players from the selected team, not already in the lineup
            current_players = set(st.session_state['handbuilder_lineup']['Player'])
            team_players = player_select_df[
                (player_select_df['Team'] == auto_team_var) &
                (~player_select_df['Player'].isin(current_players))
            ].copy()

            # 2. Sort by Order
            team_players = team_players.sort_values(by='Order')

            # 3. Select the order range
            if auto_range_var == 'Top (1-5)':
                selected_players = team_players[team_players['Order'] > 0].head(auto_size_var)
            elif auto_range_var == 'Mid (4-8)':
                selected_players = team_players[team_players['Order'] > 0].iloc[3:3 + auto_size_var]
            elif auto_range_var == 'Wrap (7-2)':
                if auto_size_var == 5:
                    first_three = team_players[team_players['Order'] > 0].head(2)
                elif auto_size_var == 4:
                    first_three = team_players[team_players['Order'] > 0].head(1)
                elif auto_size_var == 3:
                    first_three = team_players[team_players['Order'] > 0].head(0)
                last_two = team_players[team_players['Order'] > 0].tail(3)
                selected_players = pd.concat([first_three, last_two])
            else:
                selected_players = team_players[team_players['Order'] > 0].head(auto_size_var)

            # 4. Add each player to the lineup, filling the first available eligible slot
            for _, player_row in selected_players.iterrows():
                eligible_positions = re.split(r'[/, ]+', player_row['Position'])
                slot_to_fill = None

                if site_var == 'Fanduel':
                    # Logic for handling Fanduel Positions (with C/1B and UTIL)
                    for slot in ['P', 'C_1B', '2B', '3B', 'SS', 'OF', 'UTIL']:
                        if slot_counts.get(slot, 0) < position_limits.get(slot, 0):
                            if slot == 'C_1B':
                                if any(pos in eligible_positions for pos in ['C', '1B']):
                                    slot_to_fill = slot
                                    break
                            elif slot == 'UTIL':
                                if 'P' not in eligible_positions:
                                    slot_to_fill = slot
                                    break
                            elif slot in eligible_positions:
                                slot_to_fill = slot
                                break
                else:
                    # General logic for handling Draftkings Positions
                    for pos in eligible_positions:
                        if slot_counts.get(pos, 0) < position_limits.get(pos, 0):
                            slot_to_fill = pos
                            break

                if slot_to_fill is not None:
                    # Avoid duplicates
                    if player_row['Player'] not in st.session_state['handbuilder_lineup']['Player'].values:
                        add_row = player_row.copy()
                        add_row['Slot'] = slot_to_fill
                        st.session_state['handbuilder_lineup'] = pd.concat(
                            [st.session_state['handbuilder_lineup'], pd.DataFrame([add_row[[
                                'Player', 'Order', 'Position', 'Team', 'Team_Total', 'Opp_Total', 'Salary', 'Median', '2x%', 'Own%', 'Slot'
                            ]]])],
                            ignore_index=True
                        )
                        # Update slot_counts for next player
                        slot_counts[slot_to_fill] = slot_counts.get(slot_to_fill, 0) + 1
            st.rerun()

    # --- FILTER OUT PLAYERS WHOSE ALL ELIGIBLE POSITIONS ARE FILLED ---
    def is_player_eligible(row):
        eligible_positions = re.split(r'[/, ]+', row['Position'])
        # Player is eligible if at least one of their positions is not at max
        for pos in eligible_positions:
            if slot_counts.get(pos, 0) < position_limits.get(pos, 0):
                return True
        return False

    # player_select_df = player_select_df[player_select_df.apply(is_player_eligible, axis=1)]

    col1, col2 = st.columns([1, 2])
    with col2:
        st.subheader("Player Select")
        event = st.dataframe(
            player_select_df.style.background_gradient(axis=0).background_gradient(cmap='RdYlGn').background_gradient(cmap='RdYlGn_r', subset=['Order', 'Salary', 'Own%']).format(precision=2),
            on_select="rerun",
            selection_mode=["single-row"],
            key=f"handbuilder_select_{st.session_state['handbuilder_select_key']}",
            height=500,
            hide_index=True
        )
        # If a row is selected, add that player to the lineup and reset selection
        if event and "rows" in event.selection and len(event.selection["rows"]) > 0:
            idx = event.selection["rows"][0]
            player_row = player_select_df.iloc[[idx]]
            eligible_positions = re.split(r'[/, ]+', player_row['Position'].iloc[0])
            # Find the first eligible slot that is not full
            slot_to_fill = None

            if site_var == 'Fanduel':
                # Logic for handling Fanduel Positions (with C/1B and UTIL)
                for slot in ['P', 'C_1B', '2B', '3B', 'SS', 'OF', 'UTIL']:
                    if slot_counts.get(slot, 0) < position_limits.get(slot, 0):
                        if slot == 'C_1B':
                            if any(pos in eligible_positions for pos in ['C', '1B']):
                                slot_to_fill = slot
                                break
                        elif slot == 'UTIL':
                            if 'P' not in eligible_positions:
                                slot_to_fill = slot
                                break
                        elif slot in eligible_positions:
                            slot_to_fill = slot
                            break
            else:
                # General logic for handling Draftkings Positions
                for pos in eligible_positions:
                    if slot_counts.get(pos, 0) < position_limits.get(pos, 0):
                        slot_to_fill = pos
                        break

            if slot_to_fill is not None:
                # Avoid duplicates
                if not player_row['Player'].iloc[0] in st.session_state['handbuilder_lineup']['Player'].values:
                    # Add the slot info
                    player_row = player_row.assign(Slot=slot_to_fill)
                    st.session_state['handbuilder_lineup'] = pd.concat(
                        [st.session_state['handbuilder_lineup'], player_row[['Player', 'Order', 'Position', 'Team', 'Team_Total', 'Opp_Total', 'Salary', 'Median', '2x%', 'Own%', 'Slot']]],
                        ignore_index=True
                    )
                st.session_state['handbuilder_select_key'] += 1
                st.rerun()


    with col1:
        st.subheader("Lineup Build")

        # --- EXPLICIT LINEUP ORDER ---
        if site_var == 'Draftkings':
            lineup_slots = ['SP', 'SP', 'C', '1B', '2B', '3B', 'SS', 'OF', 'OF', 'OF']
        else:
            lineup_slots = ['P', 'C_1B', '2B', '3B', 'SS', 'OF', 'OF', 'OF', 'UTIL']
        display_columns = ['Slot', 'Player', 'Order', 'Team', 'Salary', 'Median', 'Own%']

        filled_lineup = st.session_state['handbuilder_lineup']
        display_rows = []
        used_indices = set()
        if not filled_lineup.empty:
            for slot in lineup_slots:
                match = filled_lineup[(filled_lineup['Slot'] == slot) & (~filled_lineup.index.isin(used_indices))]
                if not match.empty:
                    row = match.iloc[0]
                    used_indices.add(match.index[0])
                    display_rows.append({
                        'Slot': slot,
                        'Player': row['Player'],
                        'Order': row['Order'],
                        'Position': row['Position'],
                        'Team': row['Team'],
                        'Salary': row['Salary'],
                        'Median': row['Median'],
                        '2x%': row['2x%'],
                        'Own%': row['Own%']
                    })
                else:
                    display_rows.append({
                        'Slot': slot,
                        'Player': '',
                        'Order': np.nan,
                        'Position': '',
                        'Team': '',
                        'Salary': np.nan,
                        'Median': np.nan,
                        '2x%': np.nan,
                        'Own%': np.nan
                    })

        lineup_display_df = pd.DataFrame(display_rows, columns=display_columns)

        # Show the lineup table with single-row selection for removal
        event_remove = st.dataframe(
            lineup_display_df.style.background_gradient(axis=0).background_gradient(cmap='RdYlGn', subset=['Median']).background_gradient(cmap='RdYlGn_r', subset=['Order', 'Salary', 'Own%']).format(precision=2),
            on_select="rerun",
            selection_mode=["single-row"],
            key="lineup_remove",
            height=445,
            hide_index=True
        )

        # If a row is selected and not blank, remove that player from the lineup
        if event_remove and "rows" in event_remove.selection and len(event_remove.selection["rows"]) > 0:
            idx = event_remove.selection["rows"][0]
            player_to_remove = lineup_display_df.iloc[idx]['Player']
            slot_to_remove = lineup_display_df.iloc[idx]['Slot']
            if player_to_remove:  # Only remove if not blank
                st.session_state['handbuilder_lineup'] = filled_lineup[
                    ~((filled_lineup['Player'] == player_to_remove) & (filled_lineup['Slot'] == slot_to_remove))
                ]
                st.rerun()

        # --- SUMMARY ROW ---
        if not filled_lineup.empty:
            total_salary = filled_lineup['Salary'].sum()
            total_median = filled_lineup['Median'].sum()
            avg_2x = filled_lineup['2x%'].mean()
            total_own = filled_lineup['Own%'].sum()
            most_common_team = filled_lineup['Team'].mode()[0] if not filled_lineup['Team'].mode().empty else ""

            summary_row = pd.DataFrame({
                'Slot': [''],
                'Player': ['TOTAL'],
                'Order': [''],
                'Position': [''],
                'Team': [most_common_team],
                'Salary': [total_salary],
                'Median': [total_median],
                '2x%': [avg_2x],
                'Own%': [total_own]
            })
            summary_row = summary_row[['Salary', 'Median', 'Own%']].head(max_players)
            
            col1, col3 = st.columns([2, 3])

            with col1:
                if (max_players - len(filled_lineup)) > 0:
                    st.markdown(f"""
                            <div style='text-align: left; vertical-align: top; margin-top: 0; padding-top: 0;''>
                                <b>💰 Per Player:</b> ${round((max_salary - total_salary) / (max_players - len(filled_lineup)), 0)} &nbsp;
                            </div>
                            """,
                            unsafe_allow_html=True)
                else:
                    st.markdown(f"""
                            <div style='text-align: left; vertical-align: top; margin-top: 0; padding-top: 0;''>
                                <b>💰 Leftover:</b> ${round(max_salary - total_salary, 0)} &nbsp;
                            </div>
                            """,
                            unsafe_allow_html=True)

            with col3:
                if total_salary <= max_salary:
                    st.markdown(
                        f"""
                        <div style='text-align: right; vertical-align: top; margin-top: 0; padding-top: 0;''>
                            <b>💰 Salary:</b> ${round(total_salary, 0)} &nbsp;
                            <b>🔥 Median:</b> {round(total_median, 2)} &nbsp;
                        </div>
                        """,
                        unsafe_allow_html=True
                    )
                else:
                    st.markdown(
                        f"""
                        <div style='text-align: right; vertical-align: top; margin-top: 0; padding-top: 0;''>
                            <b>❌ Salary:</b> ${round(total_salary, 0)} &nbsp;
                            <b>🔥 Median:</b> {round(total_median, 2)} &nbsp;
                        </div>
                        """,
                        unsafe_allow_html=True
                    )

    # Optionally, add a button to clear the lineup
    if st.button("Clear Lineup", key='clear_lineup'):
        st.session_state['handbuilder_lineup'] = pd.DataFrame(columns=['Player', 'Position', 'Team', 'Team_Total', 'Opp_Total', 'Salary', 'Median', '2x%', 'Own%', 'Slot', 'Order'])
        st.rerun()