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

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.markdown("""
<style>
    /* Tab styling */
    .stTabs [data-baseweb="tab-list"] {
        gap: 8px;
        padding: 4px;
    }
    .stTabs [data-baseweb="tab"] {
        height: 50px;
        white-space: pre-wrap;
        background-color: #DAA520;
        color: white;
        border-radius: 10px;
        gap: 1px;
        padding: 10px 20px;
        font-weight: bold;
        transition: all 0.3s ease;
    }
    .stTabs [aria-selected="true"] {
        background-color: #DAA520;
        border: 3px solid #FFD700;
        color: white;
    }
    .stTabs [data-baseweb="tab"]:hover {
        background-color: #FFD700;
        cursor: pointer;
    }
    div[data-baseweb="select"] > div {
        background-color: #DAA520;
        color: white;
    }
</style>""", unsafe_allow_html=True)

@st.cache_resource(ttl = 60)
def init_baselines():
    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)
    
    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%'})

    collection = db["Scoring_Percentages"] 
    cursor = collection.find()
    team_frame = pd.DataFrame(cursor)
    scoring_percentages = team_frame.drop(columns=['_id'])
    scoring_percentages = scoring_percentages[['Names', 'Avg First Inning', 'First Inning Lead Percentage', 'Avg Fifth Inning', 'Fifth Inning Lead Percentage', 'Avg Score', '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 = st.tabs(["Scoring Percentages", "Player ROO", "Optimals"])

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"):
        st.info("In this demo you'll be able to see information and statistics, but names/teams have been redacted. To see more information, grab a subscription! (https://paydirtdfs.com/subscriptions-choices/)")
        with st.container():
            slate_var1 = st.radio("Which data are you loading?", ('Main Slate', 'Secondary Slate', 'Turbo Slate'), key='slate_var1')
            own_var1 = st.radio("How would you like to display team ownership?", ('Sum', 'Average'), key='own_var1')
    
    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%'], 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%'], axis=1)
    
    if view_var == "Simple":
        scoring_percentages = scoring_percentages[['Names', 'Runs', '8+ Runs', 'Win%', 'LevX', 'Own%']]
        for col in ['Names', 'Own%']:
            scoring_percentages[col] = 'https://paydirtdfs.com/subscriptions-choices/'
        st.dataframe(scoring_percentages.style.background_gradient(axis=0).background_gradient(cmap='RdYlGn').format(game_format, precision=2),
                    column_config={
                        "Names": st.column_config.LinkColumn(
                            "Teams",
                            max_chars=25,
                            help="The Team being projected",
                            display_text="Paywalled!"
                        ),
                        "Own%": st.column_config.LinkColumn(
                            "Own%",
                            max_chars=25,
                            help="The projected sum ownership of hitters on the Team",
                            display_text="Paywalled!"
                        )
                    }, height=750, use_container_width = True, hide_index = True)
    elif view_var == "Advanced":
        for col in ['Names', 'Own%']:
            scoring_percentages[col] = 'https://paydirtdfs.com/subscriptions-choices/'
        st.dataframe(scoring_percentages.style.background_gradient(axis=0).background_gradient(cmap='RdYlGn').format(game_format, precision=2),
                    column_config={
                        "Names": st.column_config.LinkColumn(
                            "Teams",
                            max_chars=25,
                            help="The Team being projected",
                            display_text="Paywalled!"
                        ),
                        "Own%": st.column_config.LinkColumn(
                            "Own%",
                            max_chars=25,
                            help="The projected sum ownership of hitters on the Team",
                            display_text="Paywalled!"
                        )
                    }, height=750, use_container_width = True, hide_index = True)

with tab2:
    st.header("Player ROO")
    with st.expander("Info and Filters"):
        st.info("In this demo you'll be able to see information and statistics, but names/teams have been redacted. To see more information, grab a subscription! (https://paydirtdfs.com/subscriptions-choices/)")
        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":
        for col in ['Player', 'Team', 'Own%']:
            player_roo_disp[col] = 'https://paydirtdfs.com/subscriptions-choices/'
        try:
            player_roo_disp = player_roo_disp[['Player', 'Position', 'Team', 'Salary', 'Median', 'Ceiling', 'Own%']]
            st.dataframe(player_roo_disp.style.background_gradient(axis=0).background_gradient(cmap='RdYlGn').format(player_roo_format, precision=2),
                    column_config={
                        "Player": st.column_config.LinkColumn(
                            "Player",
                            max_chars=25,
                            help="The Player being projected",
                            display_text="Paywalled!"
                        ),
                        "Team": st.column_config.LinkColumn(
                            "Team",
                            max_chars=25,
                            help="The Team of the Player",
                            display_text="Paywalled!"
                        ),
                        "Salary": st.column_config.LinkColumn(
                            "Salary",
                            max_chars=25,
                            help="The Salary of the Player",
                            display_text="Paywalled!"
                        ),
                        "Own%": st.column_config.LinkColumn(
                            "Own%",
                            max_chars=25,
                            help="The projected ownership of the Player being projected",
                            display_text="Paywalled!"
                        )
                    }, height=750, use_container_width = True, hide_index = True)
        except:
            st.dataframe(player_roo_disp.style.background_gradient(axis=0).background_gradient(cmap='RdYlGn').format(player_roo_format, precision=2),
                    column_config={
                        "Player": st.column_config.LinkColumn(
                            "Player",
                            max_chars=25,
                            help="The Player being projected",
                            display_text="Paywalled!"
                        ),
                        "Team": st.column_config.LinkColumn(
                            "Team",
                            max_chars=25,
                            help="The Team of the Player",
                            display_text="Paywalled!"
                        ),
                        "Salary": st.column_config.LinkColumn(
                            "Salary",
                            max_chars=25,
                            help="The Salary of the Player",
                            display_text="Paywalled!"
                        ),
                        "Own%": st.column_config.LinkColumn(
                            "Own%",
                            max_chars=25,
                            help="The projected ownership of the Player being projected",
                            display_text="Paywalled!"
                        )
                    }, height=750, use_container_width = True, hide_index = True)
            
    elif view_var == "Advanced":
        for col in ['Player', 'Team', 'Salary', 'Own%', 'Small Field Own%', 'Large Field Own%', 'Cash Own%']:
            player_roo_disp[col] = 'https://paydirtdfs.com/subscriptions-choices/'
        try:
            st.dataframe(player_roo_disp.style.background_gradient(axis=0).background_gradient(cmap='RdYlGn').format(player_roo_format, precision=2),
                    column_config={
                        "Player": st.column_config.LinkColumn(
                            "Player",
                            max_chars=25,
                            help="The Player being projected",
                            display_text="Paywalled!"
                        ),
                        "Team": st.column_config.LinkColumn(
                            "Team",
                            max_chars=25,
                            help="The Team of the Player",
                            display_text="Paywalled!"
                        ),
                        "Salary": st.column_config.LinkColumn(
                            "Salary",
                            max_chars=25,
                            help="The Salary of the Player",
                            display_text="Paywalled!"
                        ),
                        "Own%": st.column_config.LinkColumn(
                            "Own%",
                            max_chars=25,
                            help="The projected ownership of the Player being projected",
                            display_text="Paywalled!"
                        ),
                        "Small Field Own%": st.column_config.LinkColumn(
                            "Small Field Own%",
                            max_chars=25,
                            help="The projected ownership of the Player being projected in smaller/sharper fields",
                            display_text="Paywalled!"
                        ),
                        "Large Field Own%": st.column_config.LinkColumn(
                            "Large Field Own%",
                            max_chars=25,
                            help="The projected ownership of the Player being projected in larger/softer fields",
                            display_text="Paywalled!"
                        ),
                        "Cash Own%": st.column_config.LinkColumn(
                            "Cash Own%",
                            max_chars=25,
                            help="The projected ownership of the Player being projected for cash games",
                            display_text="Paywalled!"
                        )
                    }, height=750, use_container_width = True, hide_index = True)
        except:
            st.dataframe(player_roo_disp.style.background_gradient(axis=0).background_gradient(cmap='RdYlGn').format(player_roo_format, precision=2),
                    column_config={
                        "Player": st.column_config.LinkColumn(
                            "Player",
                            max_chars=25,
                            help="The Player being projected",
                            display_text="Paywalled!"
                        ),
                        "Team": st.column_config.LinkColumn(
                            "Team",
                            max_chars=25,
                            help="The Team of the Player",
                            display_text="Paywalled!"
                        ),
                        "Salary": st.column_config.LinkColumn(
                            "Salary",
                            max_chars=25,
                            help="The Salary of the Player",
                            display_text="Paywalled!"
                        ),
                        "Own%": st.column_config.LinkColumn(
                            "Own%",
                            max_chars=25,
                            help="The projected ownership of the Player being projected",
                            display_text="Paywalled!"
                        ),
                        "Small Field Own%": st.column_config.LinkColumn(
                            "Small Field Own%",
                            max_chars=25,
                            help="The projected ownership of the Player being projected in smaller/sharper fields",
                            display_text="Paywalled!"
                        ),
                        "Large Field Own%": st.column_config.LinkColumn(
                            "Large Field Own%",
                            max_chars=25,
                            help="The projected ownership of the Player being projected in larger/softer fields",
                            display_text="Paywalled!"
                        ),
                        "Cash Own%": st.column_config.LinkColumn(
                            "Cash Own%",
                            max_chars=25,
                            help="The projected ownership of the Player being projected for cash games",
                            display_text="Paywalled!"
                        )
                    }, height=750, use_container_width = True, hide_index = True)

with tab3:
    st.header("Optimals")
    VIDEO_URL = "https://www.youtube.com/watch?v=nCr-XKdXm0c"
    st.video(VIDEO_URL)