app.py

import streamlit as st
st.set_page_config(layout="wide")
import numpy as np
import pandas as pd
import time
from rapidfuzz import process, fuzz
import random
import re
from collections import Counter

## import global functions
from global_func.clean_player_name import clean_player_name
from global_func.load_file import load_file
from global_func.load_ss_file import load_ss_file
from global_func.load_dk_fd_file import load_dk_fd_file
from global_func.find_name_mismatches import find_name_mismatches
from global_func.predict_dupes import predict_dupes
from global_func.highlight_rows import highlight_changes, highlight_changes_winners, highlight_changes_losers
from global_func.load_csv import load_csv
from global_func.find_csv_mismatches import find_csv_mismatches
from global_func.trim_portfolio import trim_portfolio
from global_func.get_portfolio_names import get_portfolio_names
from global_func.small_field_preset import small_field_preset
from global_func.large_field_preset import large_field_preset
from global_func.distribute_preset import distribute_preset

freq_format = {'Finish_percentile': '{:.2%}', 'Lineup Edge': '{:.2%}', 'Win%': '{:.2%}'}
stacking_sports = ['MLB', 'NHL', 'NFL']
player_wrong_names_mlb = ['Enrique Hernandez']
player_right_names_mlb = ['Kike Hernandez']

with st.container():
    
    col1, col2, col3, col4 = st.columns(4)
    with col1:
        if st.button('Clear data', key='reset3'):
            st.session_state.clear()
    with col2:
        site_var = st.selectbox("Select Site", ['Draftkings', 'Fanduel'])

    with col3:
        sport_var = st.selectbox("Select Sport", ['NFL', 'MLB', 'NBA', 'NHL', 'MMA', 'CS2', 'TENNIS', 'GOLF', 'WNBA'])
        
    with col4:
        type_var = st.selectbox("Select Game Type", ['Classic', 'Showdown'])

tab1, tab2 = st.tabs(["Data Load", "Manage Portfolio"])
with tab1:
    if st.button('Clear data', key='reset1'):
        st.session_state.clear()
    # Add file uploaders to your app
    col1, col2, col3 = st.columns(3)

    with col1:
        st.subheader("Draftkings/Fanduel CSV")
        st.info("Upload the player pricing CSV from the site you are playing on")

        upload_csv_col, csv_template_col = st.columns([3, 1])
        with upload_csv_col:
            csv_file = st.file_uploader("Upload CSV File", type=['csv'])
            if 'csv_file' in st.session_state:
                del st.session_state['csv_file']
        with csv_template_col:

            csv_template_df = pd.DataFrame(columns=['Name', 'ID', 'Roster Position', 'Salary'])

            st.download_button(
                label="CSV Template",
                data=csv_template_df.to_csv(index=False),
                file_name="csv_template.csv",
                mime="text/csv"
            )
        st.session_state['csv_file'] = load_csv(csv_file)
        try:
            st.session_state['csv_file']['Salary'] = st.session_state['csv_file']['Salary'].astype(str).str.replace(',', '').astype(int)
        except:
            pass
            
        if csv_file:
            # st.session_state['csv_file'] = st.session_state['csv_file'].drop_duplicates(subset=['Name'])
            st.success('Projections file loaded successfully!')
            st.dataframe(st.session_state['csv_file'].head(10))
    
    with col2:
        st.subheader("Portfolio File")
        st.info("Go ahead and upload a portfolio file here. Only include player columns.")

        upload_toggle = st.selectbox("What source are you uploading from?", options=['SaberSim (Just IDs)', 'Draftkings/Fanduel (Names + IDs)', 'Other (Just Names)'])
        if upload_toggle == 'SaberSim (Just IDs)' or upload_toggle == 'Draftkings/Fanduel (Names + IDs)':
            portfolio_file = st.file_uploader("Upload Portfolio File (CSV or Excel)", type=['csv', 'xlsx', 'xls'])
            if 'portfolio' in st.session_state:
                del st.session_state['portfolio']
            if 'export_portfolio' in st.session_state:
                del st.session_state['export_portfolio']

        else:
            portfolio_file = st.file_uploader("Upload Portfolio File (CSV or Excel)", type=['csv', 'xlsx', 'xls'])
            if 'portfolio' in st.session_state:
                del st.session_state['portfolio']
            if 'export_portfolio' in st.session_state:
                del st.session_state['export_portfolio']
        if 'portfolio' not in st.session_state:
            if portfolio_file:
                if upload_toggle == 'SaberSim (Just IDs)':
                    st.session_state['export_portfolio'], st.session_state['portfolio'] = load_ss_file(portfolio_file, st.session_state['csv_file'])
                    st.session_state['export_portfolio'] = st.session_state['export_portfolio'].dropna(how='all')
                    st.session_state['export_portfolio'] = st.session_state['export_portfolio'].reset_index(drop=True)
                    st.session_state['portfolio'] = st.session_state['portfolio'].dropna(how='all')
                    st.session_state['portfolio'] = st.session_state['portfolio'].reset_index(drop=True)
                elif upload_toggle == 'Draftkings/Fanduel (Names + IDs)':
                    st.session_state['export_portfolio'], st.session_state['portfolio'] = load_dk_fd_file(portfolio_file, st.session_state['csv_file'])
                    st.session_state['export_portfolio'] = st.session_state['export_portfolio'].dropna(how='all')
                    st.session_state['export_portfolio'] = st.session_state['export_portfolio'].reset_index(drop=True)
                    st.session_state['portfolio'] = st.session_state['portfolio'].dropna(how='all')
                    st.session_state['portfolio'] = st.session_state['portfolio'].reset_index(drop=True)
                else:
                    st.session_state['export_portfolio'], st.session_state['portfolio'] = load_file(portfolio_file)
                    st.session_state['export_portfolio'] = st.session_state['export_portfolio'].dropna(how='all')
                    st.session_state['export_portfolio'] = st.session_state['export_portfolio'].reset_index(drop=True)
                    st.session_state['portfolio'] = st.session_state['portfolio'].dropna(how='all')
                    st.session_state['portfolio'] = st.session_state['portfolio'].reset_index(drop=True)
                # Check if Stack column exists in the portfolio
                if 'Stack' in st.session_state['portfolio'].columns:
                    # Create dictionary mapping index to Stack values
                    stack_dict = dict(zip(st.session_state['portfolio'].index, st.session_state['portfolio']['Stack']))
                    st.write(f"Found {len(stack_dict)} stack assignments")
                    st.session_state['portfolio'] = st.session_state['portfolio'].drop(columns=['Stack'])
                else:
                    stack_dict = None
                if st.session_state['portfolio'] is not None:
                    st.success('Portfolio file loaded successfully!')
                    st.session_state['portfolio'] = st.session_state['portfolio'].apply(lambda x: x.replace(player_wrong_names_mlb, player_right_names_mlb))
                    st.dataframe(st.session_state['portfolio'].head(10))

    with col3:
        st.subheader("Projections File")
        st.info("upload a projections file that has 'player_names', 'salary', 'median', 'ownership', and 'captain ownership' columns. Note that the salary for showdown needs to be the FLEX salary, not the captain salary.")
        
        # Create two columns for the uploader and template button
        upload_col, template_col = st.columns([3, 1])
        
        with upload_col:
            projections_file = st.file_uploader("Upload Projections File (CSV or Excel)", type=['csv', 'xlsx', 'xls'])
            if 'projections_df' in st.session_state:
                del st.session_state['projections_df']
        
        with template_col:
            # Create empty DataFrame with required columns
            template_df = pd.DataFrame(columns=['player_names', 'position', 'team', 'salary', 'median', 'ownership', 'captain ownership'])
            # Add download button for template
            st.download_button(
                label="Template",
                data=template_df.to_csv(index=False),
                file_name="projections_template.csv",
                mime="text/csv"
            )
            
        if projections_file:
            export_projections, projections = load_file(projections_file)
            if projections is not None:
                st.success('Projections file loaded successfully!')
                try:
                    projections['salary'] = projections['salary'].str.replace(',', '').str.replace('$', '').str.replace(' ', '')
                    st.write('replaced salary symbols')
                except:
                    pass
                try:
                    projections['ownership'] = projections['ownership'].str.replace('%', '').str.replace(' ', '')
                    st.write('replaced ownership symbols')
                except:
                    pass
                projections['salary'] = projections['salary'].dropna().astype(int)
                projections['ownership'] = projections['ownership'].astype(float)
                if type_var == 'Showdown':
                    if projections['captain ownership'].isna().all():
                        projections['CPT_Own_raw'] = (projections['ownership'] / 2) * ((100 - (100-projections['ownership']))/100)
                        cpt_own_var = 100 / projections['CPT_Own_raw'].sum()
                        projections['captain ownership'] = projections['CPT_Own_raw'] * cpt_own_var
                        projections = projections.drop(columns='CPT_Own_raw', axis=1)
                            
                projections = projections.apply(lambda x: x.replace(player_wrong_names_mlb, player_right_names_mlb))
                st.dataframe(projections.head(10))

    if portfolio_file and projections_file:
        if st.session_state['portfolio'] is not None and projections is not None:
            st.subheader("Name Matching Analysis")
            # Initialize projections_df in session state if it doesn't exist
            # Get unique names from portfolio
            portfolio_names = get_portfolio_names(st.session_state['portfolio'])
            try:
                csv_names = st.session_state['csv_file']['Name'].tolist()
            except:
                csv_names = st.session_state['csv_file']['Nickname'].tolist()
            projection_names = projections['player_names'].tolist()
            
            # Create match dictionary for portfolio names to projection names
            portfolio_match_dict = {}
            unmatched_names = []
            for portfolio_name in portfolio_names:
                match = process.extractOne(
                    portfolio_name,
                    csv_names,
                    score_cutoff=87
                )
                if match:
                    portfolio_match_dict[portfolio_name] = match[0]
                    if match[1] < 100:
                        st.write(f"{portfolio_name} matched from portfolio to site csv {match[0]} with a score of {match[1]}%")
                else:
                    portfolio_match_dict[portfolio_name] = portfolio_name
                    unmatched_names.append(portfolio_name)
            
            # Update portfolio with matched names
            portfolio = st.session_state['portfolio'].copy()
            player_columns = [col for col in portfolio.columns 
                            if col not in ['salary', 'median', 'Own']]
            
            # For each player column, update names using the match dictionary
            for col in player_columns:
                portfolio[col] = portfolio[col].map(lambda x: portfolio_match_dict.get(x, x))
            st.session_state['portfolio'] = portfolio
            
            # Create match dictionary for portfolio names to projection names
            projections_match_dict = {}
            unmatched_proj_names = []
            for projections_name in projection_names:
                match = process.extractOne(
                    projections_name,
                    csv_names,
                    score_cutoff=87
                )
                if match:
                    projections_match_dict[projections_name] = match[0]
                    if match[1] < 100:
                        st.write(f"{projections_name} matched from projections to site csv {match[0]} with a score of {match[1]}%")
                else:
                    projections_match_dict[projections_name] = projections_name
                    unmatched_proj_names.append(projections_name)
            
            # Update projections with matched names
            projections['player_names'] = projections['player_names'].map(lambda x: projections_match_dict.get(x, x))
            st.session_state['projections_df'] = projections

            projections_names = st.session_state['projections_df']['player_names'].tolist()
            portfolio_names = get_portfolio_names(st.session_state['portfolio'])
            
            # Create match dictionary for portfolio names to projection names
            projections_match_dict = {}
            unmatched_proj_names = []
            for projections_name in projection_names:
                match = process.extractOne(
                    projections_name,
                    portfolio_names,
                    score_cutoff=87
                )
                if match:
                    projections_match_dict[projections_name] = match[0]
                    if match[1] < 100:
                        st.write(f"{projections_name} matched from portfolio to projections {match[0]} with a score of {match[1]}%")
                else:
                    projections_match_dict[projections_name] = projections_name
                    unmatched_proj_names.append(projections_name)
            
            # Update projections with matched names
            projections['player_names'] = projections['player_names'].map(lambda x: projections_match_dict.get(x, x))
            st.session_state['projections_df'] = projections

            if sport_var in stacking_sports:
                team_dict = dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['team']))
                st.session_state['portfolio']['Stack'] = st.session_state['portfolio'].apply(
                    lambda row: Counter(
                        team_dict.get(player, '') for player in row[2:]
                        if team_dict.get(player, '') != ''
                    ).most_common(1)[0][0] if any(team_dict.get(player, '') for player in row[2:]) else '',
                    axis=1
                )
                st.session_state['portfolio']['Size'] = st.session_state['portfolio'].apply(
                    lambda row: Counter(
                        team_dict.get(player, '') for player in row[2:]
                        if team_dict.get(player, '') != ''
                    ).most_common(1)[0][1] if any(team_dict.get(player, '') for player in row[2:]) else 0,
                    axis=1
                )
                stack_dict = dict(zip(st.session_state['portfolio'].index, st.session_state['portfolio']['Stack']))
                size_dict = dict(zip(st.session_state['portfolio'].index, st.session_state['portfolio']['Size']))

            working_frame = st.session_state['portfolio'].copy()
            try:
                st.session_state['export_dict'] = dict(zip(st.session_state['csv_file']['Name'], st.session_state['csv_file']['Name + ID']))
            except:
                st.session_state['export_dict'] = dict(zip(st.session_state['csv_file']['Nickname'], st.session_state['csv_file']['Id']))
            st.session_state['origin_portfolio'] = st.session_state['portfolio'].copy()

# with tab2:
#     if st.button('Clear data', key='reset2'):
#         st.session_state.clear()
    
#     if 'portfolio' in st.session_state and 'projections_df' in st.session_state:

#         optimized_df = None

#         map_dict = {
#                     'pos_map': dict(zip(st.session_state['projections_df']['player_names'], 
#                                     st.session_state['projections_df']['position'])),
#                     'salary_map': dict(zip(st.session_state['projections_df']['player_names'], 
#                                         st.session_state['projections_df']['salary'])),
#                     'proj_map': dict(zip(st.session_state['projections_df']['player_names'], 
#                                     st.session_state['projections_df']['median'])),
#                     'own_map': dict(zip(st.session_state['projections_df']['player_names'],
#                                     st.session_state['projections_df']['ownership'])),
#                     'team_map': dict(zip(st.session_state['projections_df']['player_names'], 
#                                         st.session_state['projections_df']['team']))
#                 }
#         # Calculate new stats for optimized lineups
#         st.session_state['portfolio']['salary'] = st.session_state['portfolio'].apply(
#             lambda row: sum(map_dict['salary_map'].get(player, 0) for player in row if player in map_dict['salary_map']), axis=1
#         )
#         st.session_state['portfolio']['median'] = st.session_state['portfolio'].apply(
#             lambda row: sum(map_dict['proj_map'].get(player, 0) for player in row if player in map_dict['proj_map']), axis=1
#         )

#         st.session_state['portfolio']['Own'] = st.session_state['portfolio'].apply(
#             lambda row: sum(map_dict['own_map'].get(player, 0) for player in row if player in map_dict['own_map']), axis=1
#         )

#         options_container = st.container()
#         with options_container:
#             col1, col2, col3, col4, col5, col6 = st.columns(6)
#             with col1:
#                 curr_site_var = st.selectbox("Select your current site", options=['DraftKings', 'FanDuel'])
#             with col2:
#                 curr_sport_var = st.selectbox("Select your current sport", options=['NBA', 'MLB', 'NFL', 'NHL', 'MMA'])
#             with col3:
#                 swap_var = st.multiselect("Select late swap strategy", options=['Optimize', 'Increase volatility', 'Decrease volatility'])
#             with col4:
#                 remove_teams_var = st.multiselect("What teams have already played?", options=st.session_state['projections_df']['team'].unique())
#             with col5:
#                 winners_var = st.multiselect("Are there any players doing exceptionally well?", options=st.session_state['projections_df']['player_names'].unique(), max_selections=3)
#             with col6:
#                 losers_var = st.multiselect("Are there any players doing exceptionally poorly?", options=st.session_state['projections_df']['player_names'].unique(), max_selections=3)
#         if st.button('Clear Late Swap'):
#             if 'optimized_df' in st.session_state:
#                 del st.session_state['optimized_df']

#             map_dict = {
#                         'pos_map': dict(zip(st.session_state['projections_df']['player_names'], 
#                                         st.session_state['projections_df']['position'])),
#                         'salary_map': dict(zip(st.session_state['projections_df']['player_names'], 
#                                             st.session_state['projections_df']['salary'])),
#                         'proj_map': dict(zip(st.session_state['projections_df']['player_names'], 
#                                         st.session_state['projections_df']['median'])),
#                         'own_map': dict(zip(st.session_state['projections_df']['player_names'], 
#                                         st.session_state['projections_df']['ownership'])),
#                         'team_map': dict(zip(st.session_state['projections_df']['player_names'], 
#                                         st.session_state['projections_df']['team']))
#                     }
#             # Calculate new stats for optimized lineups
#             st.session_state['portfolio']['salary'] = st.session_state['portfolio'].apply(
#                 lambda row: sum(map_dict['salary_map'].get(player, 0) for player in row if player in map_dict['salary_map']), axis=1
#             )
#             st.session_state['portfolio']['median'] = st.session_state['portfolio'].apply(
#                 lambda row: sum(map_dict['proj_map'].get(player, 0) for player in row if player in map_dict['proj_map']), axis=1
#             )
#             st.session_state['portfolio']['Own'] = st.session_state['portfolio'].apply(
#                 lambda row: sum(map_dict['own_map'].get(player, 0) for player in row if player in map_dict['own_map']), axis=1
#             )

#         if st.button('Run Late Swap'):
#             st.session_state['portfolio'] = st.session_state['portfolio'].drop(columns=['salary', 'median', 'Own'])
#             if curr_sport_var == 'NBA':
#                 if curr_site_var == 'DraftKings':
#                     st.session_state['portfolio'] = st.session_state['portfolio'].set_axis(['PG', 'SG', 'SF', 'PF', 'C', 'G', 'F', 'UTIL'], axis=1)
#                 else:
#                     st.session_state['portfolio'] = st.session_state['portfolio'].set_axis(['PG', 'PG', 'SG', 'SG', 'SF', 'SF', 'PF', 'PF', 'C'], axis=1)
            
#             # Define roster position rules
#             if curr_site_var == 'DraftKings':
#                 position_rules = {
#                     'PG': ['PG'],
#                     'SG': ['SG'],
#                     'SF': ['SF'],
#                     'PF': ['PF'],
#                     'C': ['C'],
#                     'G': ['PG', 'SG'],
#                     'F': ['SF', 'PF'],
#                     'UTIL': ['PG', 'SG', 'SF', 'PF', 'C']
#                     }
#             else:
#                 position_rules = {
#                     'PG': ['PG'],
#                     'SG': ['SG'],
#                     'SF': ['SF'],
#                     'PF': ['PF'],
#                     'C': ['C'],
#                 }
#             # Create position groups from projections data
#             position_groups = {}
#             for _, player in st.session_state['projections_df'].iterrows():
#                 positions = player['position'].split('/')
#                 for pos in positions:
#                     if pos not in position_groups:
#                         position_groups[pos] = []
#                     position_groups[pos].append({
#                         'player_names': player['player_names'],
#                         'salary': player['salary'],
#                         'median': player['median'],
#                         'ownership': player['ownership'],
#                         'positions': positions  # Store all eligible positions
#                     })

#             def optimize_lineup(row):
#                 current_lineup = []
#                 total_salary = 0
#                 if curr_site_var == 'DraftKings':
#                     salary_cap = 50000
#                 else:
#                     salary_cap = 60000
#                 used_players = set()

#                 # Convert row to dictionary with roster positions
#                 roster = {}
#                 for col, player in zip(row.index, row):
#                     if col not in ['salary', 'median', 'Own', 'Finish_percentile', 'Dupes', 'Lineup Edge']:
#                         roster[col] = {
#                             'name': player,
#                             'position': map_dict['pos_map'].get(player, '').split('/'),
#                             'team': map_dict['team_map'].get(player, ''),
#                             'salary': map_dict['salary_map'].get(player, 0),
#                             'median': map_dict['proj_map'].get(player, 0),
#                             'ownership': map_dict['own_map'].get(player, 0)
#                         }
#                         total_salary += roster[col]['salary']
#                         used_players.add(player)

#                 # Optimize each roster position in random order
#                 roster_positions = list(roster.items())
#                 random.shuffle(roster_positions)
                
#                 for roster_pos, current in roster_positions:
#                     # Skip optimization for players from removed teams
#                     if current['team'] in remove_teams_var:
#                         continue
                    
#                     valid_positions = position_rules[roster_pos]
#                     better_options = []

#                     # Find valid replacements for this roster position
#                     for pos in valid_positions:
#                         if pos in position_groups:
#                             pos_options = [
#                                 p for p in position_groups[pos]
#                                 if p['median'] > current['median']
#                                 and (total_salary - current['salary'] + p['salary']) <= salary_cap
#                                 and p['player_names'] not in used_players
#                                 and any(valid_pos in p['positions'] for valid_pos in valid_positions)
#                                 and map_dict['team_map'].get(p['player_names']) not in remove_teams_var  # Check team restriction
#                             ]
#                             better_options.extend(pos_options)

#                     if better_options:
#                         # Remove duplicates
#                         better_options = {opt['player_names']: opt for opt in better_options}.values()
                        
#                         # Sort by median projection and take the best one
#                         best_replacement = max(better_options, key=lambda x: x['median'])
                        
#                         # Update the lineup and tracking variables
#                         used_players.remove(current['name'])
#                         used_players.add(best_replacement['player_names'])
#                         total_salary = total_salary - current['salary'] + best_replacement['salary']
#                         roster[roster_pos] = {
#                             'name': best_replacement['player_names'],
#                             'position': map_dict['pos_map'][best_replacement['player_names']].split('/'),
#                             'team': map_dict['team_map'][best_replacement['player_names']],
#                             'salary': best_replacement['salary'],
#                             'median': best_replacement['median'],
#                             'ownership': best_replacement['ownership']
#                         }

#                 # Return optimized lineup maintaining original column order
#                 return [roster[pos]['name'] for pos in row.index if pos in roster]

#             def optimize_lineup_winners(row):
#                 current_lineup = []
#                 total_salary = 0
#                 if curr_site_var == 'DraftKings':
#                     salary_cap = 50000
#                 else:
#                     salary_cap = 60000
#                 used_players = set()

#                 # Check if any winners are in the lineup and count them
#                 winners_in_lineup = sum(1 for player in row if player in winners_var)
#                 changes_needed = min(winners_in_lineup, 3) if winners_in_lineup > 0 else 0
#                 changes_made = 0

#                 # Convert row to dictionary with roster positions
#                 roster = {}
#                 for col, player in zip(row.index, row):
#                     if col not in ['salary', 'median', 'Own', 'Finish_percentile', 'Dupes', 'Lineup Edge']:
#                         roster[col] = {
#                             'name': player,
#                             'position': map_dict['pos_map'].get(player, '').split('/'),
#                             'team': map_dict['team_map'].get(player, ''),
#                             'salary': map_dict['salary_map'].get(player, 0),
#                             'median': map_dict['proj_map'].get(player, 0),
#                             'ownership': map_dict['own_map'].get(player, 0)
#                         }
#                         total_salary += roster[col]['salary']
#                         used_players.add(player)

#                 # Only proceed with ownership-based optimization if we have winners in the lineup
#                 if changes_needed > 0:
#                     # Randomize the order of positions to optimize
#                     roster_positions = list(roster.items())
#                     random.shuffle(roster_positions)
                    
#                     for roster_pos, current in roster_positions:
#                         # Stop if we've made enough changes
#                         if changes_made >= changes_needed:
#                             break
                            
#                         # Skip optimization for players from removed teams or if the current player is a winner
#                         if current['team'] in remove_teams_var or current['name'] in winners_var:
#                             continue
                        
#                         valid_positions = list(position_rules[roster_pos])
#                         random.shuffle(valid_positions)
#                         better_options = []

#                         # Find valid replacements with higher ownership
#                         for pos in valid_positions:
#                             if pos in position_groups:
#                                 pos_options = [
#                                     p for p in position_groups[pos]
#                                     if p['ownership'] > current['ownership']
#                                     and p['median'] >= current['median'] - 3
#                                     and (total_salary - current['salary'] + p['salary']) <= salary_cap
#                                     and (total_salary - current['salary'] + p['salary']) >= salary_cap - 1000
#                                     and p['player_names'] not in used_players
#                                     and any(valid_pos in p['positions'] for valid_pos in valid_positions)
#                                     and map_dict['team_map'].get(p['player_names']) not in remove_teams_var
#                                 ]
#                                 better_options.extend(pos_options)

#                         if better_options:
#                             # Remove duplicates
#                             better_options = {opt['player_names']: opt for opt in better_options}.values()
                            
#                             # Sort by ownership and take the highest owned option
#                             best_replacement = max(better_options, key=lambda x: x['ownership'])
                            
#                             # Update the lineup and tracking variables
#                             used_players.remove(current['name'])
#                             used_players.add(best_replacement['player_names'])
#                             total_salary = total_salary - current['salary'] + best_replacement['salary']
#                             roster[roster_pos] = {
#                                 'name': best_replacement['player_names'],
#                                 'position': map_dict['pos_map'][best_replacement['player_names']].split('/'),
#                                 'team': map_dict['team_map'][best_replacement['player_names']],
#                                 'salary': best_replacement['salary'],
#                                 'median': best_replacement['median'],
#                                 'ownership': best_replacement['ownership']
#                             }
#                             changes_made += 1

#                 # Return optimized lineup maintaining original column order
#                 return [roster[pos]['name'] for pos in row.index if pos in roster]
            
#             def optimize_lineup_losers(row):
#                 current_lineup = []
#                 total_salary = 0
#                 if curr_site_var == 'DraftKings':
#                     salary_cap = 50000
#                 else:
#                     salary_cap = 60000
#                 used_players = set()

#                 # Check if any winners are in the lineup and count them
#                 losers_in_lineup = sum(1 for player in row if player in losers_var)
#                 changes_needed = min(losers_in_lineup, 3) if losers_in_lineup > 0 else 0
#                 changes_made = 0

#                 # Convert row to dictionary with roster positions
#                 roster = {}
#                 for col, player in zip(row.index, row):
#                     if col not in ['salary', 'median', 'Own', 'Finish_percentile', 'Dupes', 'Lineup Edge']:
#                         roster[col] = {
#                             'name': player,
#                             'position': map_dict['pos_map'].get(player, '').split('/'),
#                             'team': map_dict['team_map'].get(player, ''),
#                             'salary': map_dict['salary_map'].get(player, 0),
#                             'median': map_dict['proj_map'].get(player, 0),
#                             'ownership': map_dict['own_map'].get(player, 0)
#                         }
#                         total_salary += roster[col]['salary']
#                         used_players.add(player)

#                 # Only proceed with ownership-based optimization if we have winners in the lineup
#                 if changes_needed > 0:
#                     # Randomize the order of positions to optimize
#                     roster_positions = list(roster.items())
#                     random.shuffle(roster_positions)
                    
#                     for roster_pos, current in roster_positions:
#                         # Stop if we've made enough changes
#                         if changes_made >= changes_needed:
#                             break
                            
#                         # Skip optimization for players from removed teams or if the current player is a winner
#                         if current['team'] in remove_teams_var or current['name'] in losers_var:
#                             continue
                        
#                         valid_positions = list(position_rules[roster_pos])
#                         random.shuffle(valid_positions)
#                         better_options = []

#                         # Find valid replacements with higher ownership
#                         for pos in valid_positions:
#                             if pos in position_groups:
#                                 pos_options = [
#                                     p for p in position_groups[pos]
#                                     if p['ownership'] < current['ownership']
#                                     and p['median'] >= current['median'] - 3
#                                     and (total_salary - current['salary'] + p['salary']) <= salary_cap
#                                     and (total_salary - current['salary'] + p['salary']) >= salary_cap - 1000
#                                     and p['player_names'] not in used_players
#                                     and any(valid_pos in p['positions'] for valid_pos in valid_positions)
#                                     and map_dict['team_map'].get(p['player_names']) not in remove_teams_var
#                                 ]
#                                 better_options.extend(pos_options)

#                         if better_options:
#                             # Remove duplicates
#                             better_options = {opt['player_names']: opt for opt in better_options}.values()
                            
#                             # Sort by ownership and take the highest owned option
#                             best_replacement = max(better_options, key=lambda x: x['ownership'])
                            
#                             # Update the lineup and tracking variables
#                             used_players.remove(current['name'])
#                             used_players.add(best_replacement['player_names'])
#                             total_salary = total_salary - current['salary'] + best_replacement['salary']
#                             roster[roster_pos] = {
#                                 'name': best_replacement['player_names'],
#                                 'position': map_dict['pos_map'][best_replacement['player_names']].split('/'),
#                                 'team': map_dict['team_map'][best_replacement['player_names']],
#                                 'salary': best_replacement['salary'],
#                                 'median': best_replacement['median'],
#                                 'ownership': best_replacement['ownership']
#                             }
#                             changes_made += 1

#                 # Return optimized lineup maintaining original column order
#                 return [roster[pos]['name'] for pos in row.index if pos in roster]

#             # Create a progress bar
#             progress_bar = st.progress(0)
#             status_text = st.empty()
            
#             # Process each lineup
#             optimized_lineups = []
#             total_lineups = len(st.session_state['portfolio'])
            
#             for idx, row in st.session_state['portfolio'].iterrows():
#                 # First optimization pass
#                 first_pass = optimize_lineup(row)
#                 first_pass_series = pd.Series(first_pass, index=row.index)

#                 second_pass = optimize_lineup(first_pass_series)
#                 second_pass_series = pd.Series(second_pass, index=row.index)

#                 third_pass = optimize_lineup(second_pass_series)
#                 third_pass_series = pd.Series(third_pass, index=row.index)

#                 fourth_pass = optimize_lineup(third_pass_series)
#                 fourth_pass_series = pd.Series(fourth_pass, index=row.index)

#                 fifth_pass = optimize_lineup(fourth_pass_series)
#                 fifth_pass_series = pd.Series(fifth_pass, index=row.index)
                
#                 # Second optimization pass
#                 final_lineup = optimize_lineup(fifth_pass_series)
#                 optimized_lineups.append(final_lineup)
                
#                 if 'Optimize' in swap_var:
#                     progress = (idx + 1) / total_lineups
#                     progress_bar.progress(progress)
#                     status_text.text(f'Optimizing Lineups {idx + 1} of {total_lineups}')
#                 else:
#                     pass
            
#             # Create new dataframe with optimized lineups
#             if 'Optimize' in swap_var:
#                 st.session_state['optimized_df_medians'] = pd.DataFrame(optimized_lineups, columns=st.session_state['portfolio'].columns)
#             else:
#                 st.session_state['optimized_df_medians'] = st.session_state['portfolio']

#             # Create a progress bar
#             progress_bar_winners = st.progress(0)
#             status_text_winners = st.empty()
            
#             # Process each lineup
#             optimized_lineups_winners = []
#             total_lineups = len(st.session_state['optimized_df_medians'])
            
#             for idx, row in st.session_state['optimized_df_medians'].iterrows():

#                 final_lineup = optimize_lineup_winners(row)
#                 optimized_lineups_winners.append(final_lineup)
                
#                 if 'Decrease volatility' in swap_var:
#                     progress_winners = (idx + 1) / total_lineups
#                     progress_bar_winners.progress(progress_winners)
#                     status_text_winners.text(f'Lowering Volatility around Winners {idx + 1} of {total_lineups}')
#                 else:
#                     pass
            
#             # Create new dataframe with optimized lineups
#             if 'Decrease volatility' in swap_var:
#                 st.session_state['optimized_df_winners'] = pd.DataFrame(optimized_lineups_winners, columns=st.session_state['optimized_df_medians'].columns)
#             else:
#                 st.session_state['optimized_df_winners'] = st.session_state['optimized_df_medians']

#             # Create a progress bar
#             progress_bar_losers = st.progress(0)
#             status_text_losers = st.empty()
            
#             # Process each lineup
#             optimized_lineups_losers = []
#             total_lineups = len(st.session_state['optimized_df_winners'])
            
#             for idx, row in st.session_state['optimized_df_winners'].iterrows():

#                 final_lineup = optimize_lineup_losers(row)
#                 optimized_lineups_losers.append(final_lineup)
                
#                 if 'Increase volatility' in swap_var:
#                     progress_losers = (idx + 1) / total_lineups
#                     progress_bar_losers.progress(progress_losers)
#                     status_text_losers.text(f'Increasing Volatility around Losers {idx + 1} of {total_lineups}')
#                 else:
#                     pass
            
#             # Create new dataframe with optimized lineups
#             if 'Increase volatility' in swap_var:
#                 st.session_state['optimized_df'] = pd.DataFrame(optimized_lineups_losers, columns=st.session_state['optimized_df_winners'].columns)
#             else:
#                 st.session_state['optimized_df'] = st.session_state['optimized_df_winners']
            
#             # Calculate new stats for optimized lineups
#             st.session_state['optimized_df']['salary'] = st.session_state['optimized_df'].apply(
#                 lambda row: sum(map_dict['salary_map'].get(player, 0) for player in row if player in map_dict['salary_map']), axis=1
#             )
#             st.session_state['optimized_df']['median'] = st.session_state['optimized_df'].apply(
#                 lambda row: sum(map_dict['proj_map'].get(player, 0) for player in row if player in map_dict['proj_map']), axis=1
#             )
#             st.session_state['optimized_df']['Own'] = st.session_state['optimized_df'].apply(
#                 lambda row: sum(map_dict['own_map'].get(player, 0) for player in row if player in map_dict['own_map']), axis=1
#             )

#             # Display results
#             st.success('Optimization complete!')

#         if 'optimized_df' in st.session_state:
#             st.write("Increase in median highlighted in yellow, descrease in volatility highlighted in blue, increase in volatility highlighted in red:")
#             st.dataframe(
#                 st.session_state['optimized_df'].style
#                 .apply(highlight_changes, axis=1)
#                 .apply(highlight_changes_winners, axis=1)
#                 .apply(highlight_changes_losers, axis=1)
#                 .background_gradient(axis=0)
#                 .background_gradient(cmap='RdYlGn')
#                 .format(precision=2),
#                 height=1000,
#                 use_container_width=True
#             )
            
#             # Option to download optimized lineups
#             if st.button('Prepare Late Swap Export'):
#                 export_df = st.session_state['optimized_df'].copy()
                
#                 # Map player names to their export IDs for all player columns
#                 for col in export_df.columns:
#                     if col not in ['salary', 'median', 'Own']:
#                         export_df[col] = export_df[col].map(st.session_state['export_dict'])
                
#                 csv = export_df.to_csv(index=False)
#                 st.download_button(
#                     label="Download CSV",
#                     data=csv,
#                     file_name="optimized_lineups.csv",
#                     mime="text/csv"
#                 )
#         else:
#             st.write("Current Portfolio")
#             st.dataframe(
#                 st.session_state['portfolio'].style
#                 .background_gradient(axis=0)
#                 .background_gradient(cmap='RdYlGn')
#                 .format(precision=2),
#                 height=1000,
#                 use_container_width=True
#             )

with tab2:
    if 'portfolio' in st.session_state and 'projections_df' in st.session_state:
        with st.container():
            col1, col2 = st.columns(2)
            with col1:
                if st.button('Reset Portfolio', key='reset_port'):
                    del st.session_state['working_frame']

            with col2:
                with st.form(key='contest_size_form'):
                    size_col, strength_col, submit_col = st.columns(3)
                    with size_col:
                        Contest_Size = st.number_input("Enter Contest Size", value=25000, min_value=1, step=1)
                    with strength_col:
                        strength_var = st.selectbox("Select field strength", ['Average', 'Sharp', 'Weak'])
                    with submit_col:
                        submitted = st.form_submit_button("Submit Size/Strength")
                    if submitted:
                        del st.session_state['working_frame']
        
        excluded_cols = ['salary', 'median', 'Own', 'Finish_percentile', 'Dupes', 'Stack', 'Size', 'Win%', 'Lineup Edge', 'Weighted Own', 'Geomean']

        if 'working_frame' not in st.session_state:
            st.session_state['working_frame'] = st.session_state['origin_portfolio'].copy()
            if site_var == 'Draftkings':
                if type_var == 'Classic':
                    if sport_var == 'CS2':
                        st.session_state['map_dict'] = {
                            'pos_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['position'])),
                            'team_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['team'])),
                            'salary_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['salary'])),
                            'proj_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['median'])),
                            'own_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['ownership'])),
                            'own_percent_rank':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['ownership'].rank(pct=True))),
                            'cpt_salary_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['salary'] * 1.5)),
                            'cpt_proj_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['median'] * 1.5)),
                            'cpt_own_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['captain ownership']))
                        }
                    elif sport_var != 'CS2':
                        st.session_state['map_dict'] = {
                            'pos_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['position'])),
                            'team_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['team'])),
                            'salary_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['salary'])),
                            'proj_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['median'])),
                            'own_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['ownership'])),
                            'own_percent_rank':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['ownership'].rank(pct=True))),
                            'cpt_salary_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['salary'])),
                            'cpt_proj_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['median'] * 1.5)),
                            'cpt_own_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['captain ownership']))
                        }
                elif type_var == 'Showdown':
                    if sport_var == 'GOLF':
                        st.session_state['map_dict'] = {
                            'pos_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['position'])),
                            'team_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['team'])),
                            'salary_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['salary'])),
                            'proj_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['median'])),
                            'own_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['ownership'])),
                            'own_percent_rank':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['ownership'].rank(pct=True))),
                            'cpt_salary_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['salary'])),
                            'cpt_proj_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['median'])),
                            'cpt_own_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['ownership']))
                        }
                    if sport_var != 'GOLF':
                        st.session_state['map_dict'] = {
                            'pos_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['position'])),
                            'team_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['team'])),
                            'salary_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['salary'])),
                            'proj_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['median'])),
                            'own_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['ownership'])),
                            'own_percent_rank':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['ownership'].rank(pct=True))),
                            'cpt_salary_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['salary'] * 1.5)),
                            'cpt_proj_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['median'] * 1.5)),
                            'cpt_own_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['captain ownership']))
                        }
            elif site_var == 'Fanduel':
                st.session_state['map_dict'] = {
                    'pos_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['position'])),
                    'team_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['team'])),
                    'salary_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['salary'])),
                    'proj_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['median'])),
                    'own_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['ownership'])),
                    'own_percent_rank':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['ownership'].rank(pct=True))),
                    'cpt_salary_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['salary'])),
                    'cpt_proj_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['median'] * 1.5)),
                    'cpt_own_map':dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['captain ownership']))
                }
            if type_var == 'Classic':
                if sport_var == 'CS2':
                    # Calculate salary (CPT uses cpt_salary_map, others use salary_map)
                    st.session_state['working_frame']['salary'] = st.session_state['working_frame'].apply(
                        lambda row: st.session_state['map_dict']['cpt_salary_map'].get(row.iloc[0], 0) + 
                                sum(st.session_state['map_dict']['salary_map'].get(player, 0) for player in row.iloc[1:]),
                        axis=1
                    )
                    
                    # Calculate median (CPT uses cpt_proj_map, others use proj_map)
                    st.session_state['working_frame']['median'] = st.session_state['working_frame'].apply(
                        lambda row: st.session_state['map_dict']['cpt_proj_map'].get(row.iloc[0], 0) + 
                                sum(st.session_state['map_dict']['proj_map'].get(player, 0) for player in row.iloc[1:]),
                        axis=1
                    )
                    
                    # Calculate ownership (CPT uses cpt_own_map, others use own_map)
                    st.session_state['working_frame']['Own'] = st.session_state['working_frame'].apply(
                        lambda row: st.session_state['map_dict']['cpt_own_map'].get(row.iloc[0], 0) + 
                                sum(st.session_state['map_dict']['own_map'].get(player, 0) for player in row.iloc[1:]),
                        axis=1
                    )

                elif sport_var != 'CS2':
                    st.session_state['working_frame']['salary'] = st.session_state['working_frame'].apply(lambda row: sum(st.session_state['map_dict']['salary_map'].get(player, 0) for player in row), axis=1)
                    st.session_state['working_frame']['median'] = st.session_state['working_frame'].apply(lambda row: sum(st.session_state['map_dict']['proj_map'].get(player, 0) for player in row), axis=1)
                    st.session_state['working_frame']['Own'] = st.session_state['working_frame'].apply(lambda row: sum(st.session_state['map_dict']['own_map'].get(player, 0) for player in row), axis=1)
                    if stack_dict is not None:
                        st.session_state['working_frame']['Stack'] = st.session_state['working_frame'].index.map(stack_dict)
                        st.session_state['working_frame']['Size'] = st.session_state['working_frame'].index.map(size_dict)
            elif type_var == 'Showdown':
                # Calculate salary (CPT uses cpt_salary_map, others use salary_map)
                st.session_state['working_frame']['salary'] = st.session_state['working_frame'].apply(
                    lambda row: st.session_state['map_dict']['cpt_salary_map'].get(row.iloc[0], 0) + 
                            sum(st.session_state['map_dict']['salary_map'].get(player, 0) for player in row.iloc[1:]),
                    axis=1
                )
                
                # Calculate median (CPT uses cpt_proj_map, others use proj_map)
                st.session_state['working_frame']['median'] = st.session_state['working_frame'].apply(
                    lambda row: st.session_state['map_dict']['cpt_proj_map'].get(row.iloc[0], 0) + 
                            sum(st.session_state['map_dict']['proj_map'].get(player, 0) for player in row.iloc[1:]),
                    axis=1
                )
                
                # Calculate ownership (CPT uses cpt_own_map, others use own_map)
                st.session_state['working_frame']['Own'] = st.session_state['working_frame'].apply(
                    lambda row: st.session_state['map_dict']['cpt_own_map'].get(row.iloc[0], 0) + 
                            sum(st.session_state['map_dict']['own_map'].get(player, 0) for player in row.iloc[1:]),
                    axis=1
                )
            st.session_state['working_frame'] = predict_dupes(st.session_state['working_frame'], st.session_state['map_dict'], site_var, type_var, Contest_Size, strength_var, sport_var)
            # st.session_state['highest_owned_teams'] = st.session_state['projections_df'][~st.session_state['projections_df']['position'].isin(['P', 'SP'])].groupby('team')['ownership'].sum().sort_values(ascending=False).head(3).index.tolist()
            # st.session_state['highest_owned_pitchers'] = st.session_state['projections_df'][st.session_state['projections_df']['position'].isin(['P', 'SP'])]['player_names'].sort_values(by='ownership', ascending=False).head(3).tolist()
            if 'info_columns_dict' not in st.session_state:
                st.session_state['info_columns_dict'] = {
                    'Dupes': st.session_state['working_frame']['Dupes'],
                    'Finish_percentile': st.session_state['working_frame']['Finish_percentile'],
                    'Win%': st.session_state['working_frame']['Win%'],
                    'Lineup Edge': st.session_state['working_frame']['Lineup Edge'],
                    'Weighted Own': st.session_state['working_frame']['Weighted Own'],
                    'Geomean': st.session_state['working_frame']['Geomean'],
                }

            if 'trimming_dict_maxes' not in st.session_state:
                st.session_state['trimming_dict_maxes'] = {
                    'Own': st.session_state['working_frame']['Own'].max(),
                    'Geomean': st.session_state['working_frame']['Geomean'].max(),
                    'Weighted Own': st.session_state['working_frame']['Weighted Own'].max(),
                    'median': st.session_state['working_frame']['median'].max(),
                    'Finish_percentile': st.session_state['working_frame']['Finish_percentile'].max()
                }

        col1, col2 = st.columns([2, 8])
        with col1:
            if 'trimming_dict_maxes' not in st.session_state:
                st.session_state['trimming_dict_maxes'] = {
                    'Own': 500.0,
                    'Geomean': 500.0,
                    'Weighted Own': 500.0,
                    'median': 500.0,
                    'Finish_percentile': 1.0
                }
            with st.expander('Macro Filter Options'):
                with st.form(key='macro_filter_form'):
                    max_dupes = st.number_input("Max acceptable dupes?", value=1000, min_value=1, step=1)
                    min_salary = st.number_input("Min acceptable salary?", value=1000, min_value=1000, step=100)
                    max_salary = st.number_input("Max acceptable salary?", value=100000, min_value=1000, step=100)
                    max_finish_percentile = st.number_input("Max acceptable finish percentile?", value=.50, min_value=0.005, step=.001)
                    min_lineup_edge = st.number_input("Min acceptable Lineup Edge?", value=-.5, min_value=-1.00, step=.001)
                    if sport_var in ['NFL', 'MLB', 'NHL']:
                        stack_include_toggle = st.selectbox("Include specific stacks?", options=['All Stacks', 'Specific Stacks'], index=0)
                        stack_selections = st.multiselect("If Specific Stacks, Which to include?", options=sorted(list(set(stack_dict.values()))), default=[])

                        stack_remove_toggle = st.selectbox("Remove specific stacks?", options=['No', 'Yes'], index=0)
                        stack_remove = st.multiselect("If Specific Stacks, Which to remove?", options=sorted(list(set(stack_dict.values()))), default=[])
                    
                    submitted = st.form_submit_button("Submit")
                    if submitted:
                        parsed_frame = st.session_state['working_frame'].copy()
                        parsed_frame = parsed_frame[parsed_frame['Dupes'] <= max_dupes]
                        parsed_frame = parsed_frame[parsed_frame['salary'] >= min_salary]
                        parsed_frame = parsed_frame[parsed_frame['salary'] <= max_salary]
                        parsed_frame = parsed_frame[parsed_frame['Finish_percentile'] <= max_finish_percentile]
                        parsed_frame = parsed_frame[parsed_frame['Lineup Edge'] >= min_lineup_edge]
                        if 'Stack' in parsed_frame.columns:
                            if stack_include_toggle == 'All Stacks':
                                parsed_frame = parsed_frame
                            else:
                                parsed_frame = parsed_frame[parsed_frame['Stack'].isin(stack_selections)]
                            if stack_remove_toggle == 'Yes':
                                parsed_frame = parsed_frame[~parsed_frame['Stack'].isin(stack_remove)]
                            else:
                                parsed_frame = parsed_frame
                        st.session_state['working_frame'] = parsed_frame.sort_values(by='median', ascending=False).reset_index(drop=True)
                        st.session_state['export_merge'] = st.session_state['working_frame'].copy()

            with st.expander('Micro Filter Options'):
                with st.form(key='micro_filter_form'):
                    player_names = set()
                    for col in st.session_state['working_frame'].columns:
                        if col not in excluded_cols:
                            player_names.update(st.session_state['working_frame'][col].unique())
                    player_lock = st.multiselect("Lock players?", options=sorted(list(player_names)), default=[])
                    player_remove = st.multiselect("Remove players?", options=sorted(list(player_names)), default=[])
                    team_include = st.multiselect("Include teams?", options=sorted(list(set(st.session_state['projections_df']['team'].unique()))), default=[])
                    team_remove = st.multiselect("Remove teams?", options=sorted(list(set(st.session_state['projections_df']['team'].unique()))), default=[])
                    if sport_var in ['NFL', 'MLB', 'NHL']:
                        size_include = st.multiselect("Include sizes?", options=sorted(list(set(st.session_state['working_frame']['Size'].unique()))), default=[])
                    else:
                        size_include = []
                    
                    submitted = st.form_submit_button("Submit")
                    if submitted:
                        parsed_frame = st.session_state['working_frame'].copy()
                        if player_remove:
                            # Create mask for lineups that contain any of the removed players
                            player_columns = [col for col in parsed_frame.columns if col not in excluded_cols]
                            remove_mask = parsed_frame[player_columns].apply(
                                lambda row: not any(player in list(row) for player in player_remove), axis=1
                            )
                            parsed_frame = parsed_frame[remove_mask]
                        
                        if player_lock:
                            # Create mask for lineups that contain all locked players
                            player_columns = [col for col in parsed_frame.columns if col not in excluded_cols]
                            
                            lock_mask = parsed_frame[player_columns].apply(
                                lambda row: all(player in list(row) for player in player_lock), axis=1
                            )
                            parsed_frame = parsed_frame[lock_mask]
                        
                        if team_include:
                            # Create a copy of the frame with player names replaced by teams, excluding SP1 and SP2
                            filtered_player_columns = [col for col in player_columns if col not in ['SP1', 'SP2']]
                            team_frame = parsed_frame[filtered_player_columns].apply(
                                lambda x: x.map(st.session_state['map_dict']['team_map'])
                            )
                            # Create mask for lineups that contain any of the included teams
                            include_mask = team_frame.apply(
                                lambda row: any(team in list(row) for team in team_include), axis=1
                            )
                            parsed_frame = parsed_frame[include_mask]
                        
                        if team_remove:
                            # Create a copy of the frame with player names replaced by teams, excluding SP1 and SP2
                            filtered_player_columns = [col for col in player_columns if col not in ['SP1', 'SP2']]
                            team_frame = parsed_frame[filtered_player_columns].apply(
                                lambda x: x.map(st.session_state['map_dict']['team_map'])
                            )
                            # Create mask for lineups that don't contain any of the removed teams
                            remove_mask = team_frame.apply(
                                lambda row: not any(team in list(row) for team in team_remove), axis=1
                            )
                            parsed_frame = parsed_frame[remove_mask]
                        
                        if size_include:
                            parsed_frame = parsed_frame[parsed_frame['Size'].isin(size_include)]
                            
                        st.session_state['working_frame'] = parsed_frame.sort_values(by='median', ascending=False).reset_index(drop=True)
                        st.session_state['export_merge'] = st.session_state['working_frame'].copy()

            with st.expander('Trimming Options'):
                with st.form(key='trim_form'):
                    st.write("Sorting and trimming variables:")
                    perf_var, own_var = st.columns(2)
                    with perf_var:
                        performance_type = st.selectbox("Sorting variable", ['median', 'Finish_percentile'], key='sort_var')
                    with own_var:
                        own_type = st.selectbox("Trimming variable", ['Own', 'Geomean', 'Weighted Own'], key='trim_var')

                    trim_slack_var = st.number_input("Trim slack (percentile addition to trimming variable ceiling)", value=0.0, min_value=0.0, max_value=1.0, step=0.1, key='trim_slack')

                    st.write("Sorting threshold range:")
                    min_sort, max_sort = st.columns(2)
                    with min_sort:
                        performance_threshold_low = st.number_input("Min", value=0.0, min_value=0.0, step=1.0, key='min_sort')
                    with max_sort:
                        performance_threshold_high = st.number_input("Max", value=st.session_state['trimming_dict_maxes'][performance_type], min_value=0.0, step=1.0, key='max_sort')
                    
                    st.write("Trimming threshold range:")
                    min_trim, max_trim = st.columns(2)
                    with min_trim:
                        own_threshold_low = st.number_input("Min", value=0.0, min_value=0.0, step=1.0, key='min_trim')
                    with max_trim:
                        own_threshold_high = st.number_input("Max", value=st.session_state['trimming_dict_maxes'][own_type], min_value=0.0, step=1.0, key='max_trim')
                    
                    submitted = st.form_submit_button("Trim")
                    if submitted:
                        st.write('initiated')
                        parsed_frame = st.session_state['working_frame'].copy()
                        
                        st.session_state['working_frame'] = trim_portfolio(parsed_frame, trim_slack_var, performance_type, own_type, performance_threshold_high, performance_threshold_low, own_threshold_high, own_threshold_low)
                        st.session_state['working_frame'] = st.session_state['working_frame'].sort_values(by='median', ascending=False)
                        st.session_state['export_merge'] = st.session_state['working_frame'].copy()
            with st.expander('Presets'):
                st.info("Still heavily in testing here, I'll announce when they are ready for use.")
                with st.form(key='Small Field Preset'):
                    preset_choice = st.selectbox("Preset", options=['Small Field (Heavy Own)', 'Large Field (Finish Percentile / Edge)', 'Distributed (Spread Out Risk)'], index=0)
                    lineup_target = st.number_input("Lineups to produce", value=150, min_value=1, step=1)
                    submitted = st.form_submit_button("Submit")
                    if submitted:
                        if preset_choice == 'Small Field (Heavy Own)':
                            parsed_frame = small_field_preset(st.session_state['working_frame'], lineup_target, excluded_cols)
                        elif preset_choice == 'Large Field (Finish Percentile / Edge)':
                            parsed_frame = large_field_preset(st.session_state['working_frame'], lineup_target, excluded_cols)
                        elif preset_choice == 'Distributed (Spread Out Risk)':
                            parsed_frame = distribute_preset(st.session_state['working_frame'], lineup_target, excluded_cols)
                        st.session_state['working_frame'] = parsed_frame.reset_index(drop=True)
                        st.session_state['export_merge'] = st.session_state['working_frame'].copy()

        with col2:
            if 'export_base' not in st.session_state:
                    st.session_state['export_base'] = pd.DataFrame(columns=st.session_state['working_frame'].columns)
            
            display_frame_source = st.selectbox("Display:", options=['Portfolio', 'Export Base'], key='display_frame_source')
            if display_frame_source == 'Portfolio':
                display_frame = st.session_state['working_frame']
                st.session_state['export_file'] = display_frame.copy()
                
                for col in st.session_state['export_file'].columns:
                    if col not in excluded_cols:
                        st.session_state['export_file'][col] = st.session_state['export_file'][col].map(st.session_state['export_dict'])
            elif display_frame_source == 'Export Base':
                display_frame = st.session_state['export_base']
                st.session_state['export_file'] = display_frame.copy()
                
                for col in st.session_state['export_file'].columns:
                    if col not in excluded_cols:
                        st.session_state['export_file'][col] = st.session_state['export_file'][col].map(st.session_state['export_dict'])
            
            if 'export_file' in st.session_state:
                download_port, merge_port, partial_col, clear_export, blank_export_col = st.columns([1, 1, 1, 1, 8])
                with download_port:
                    st.download_button(label="Download Portfolio", data=st.session_state['export_file'].to_csv(index=False), file_name="portfolio.csv", mime="text/csv")
                with merge_port:
                    if st.button("Add all to Custom Export"):
                        st.session_state['export_base'] = pd.concat([st.session_state['export_base'], st.session_state['export_merge']])
                        st.session_state['export_base'] = st.session_state['export_base'].drop_duplicates()
                        st.session_state['export_base'] = st.session_state['export_base'].reset_index(drop=True)
                with partial_col:
                    if 'export_merge' in st.session_state:
                        select_custom_index = st.number_input("Select rows to add (from top)", min_value=0, max_value=len(st.session_state['export_merge']), value=0)
                        if st.button("Add selected to Custom Export"):
                            st.session_state['export_base'] = pd.concat([st.session_state['export_base'], st.session_state['export_merge'].head(select_custom_index)])
                        st.session_state['export_base'] = st.session_state['export_base'].drop_duplicates()
                        st.session_state['export_base'] = st.session_state['export_base'].reset_index(drop=True)
                with clear_export:
                    if st.button("Clear Custom Export"):
                        st.session_state['export_base'] = pd.DataFrame(columns=st.session_state['working_frame'].columns)
                        if display_frame_source == 'Portfolio':
                            display_frame = st.session_state['working_frame']
                        elif display_frame_source == 'Export Base':
                            display_frame = st.session_state['export_base']

            total_rows = len(display_frame)
            rows_per_page = 500
            total_pages = (total_rows + rows_per_page - 1) // rows_per_page  # Ceiling division

            # Initialize page number in session state if not exists
            if 'current_page' not in st.session_state:
                st.session_state.current_page = 1

            # Display current page range info and pagination control in a single line
            st.write(
                f"Showing rows {(st.session_state.current_page - 1) * rows_per_page + 1} "
                f"to {min(st.session_state.current_page * rows_per_page, total_rows)} of {total_rows}"
            )
            
            # Add page number input
            st.session_state.current_page = st.number_input(
                f"Page (1-{total_pages})", 
                min_value=1, 
                max_value=total_pages,
                value=st.session_state.current_page
            )

            # Calculate start and end indices for current page
            start_idx = (st.session_state.current_page - 1) * rows_per_page
            end_idx = min(start_idx + rows_per_page, total_rows)

            # Get the subset of data for the current page
            current_page_data = display_frame.iloc[start_idx:end_idx]
            # Display the paginated dataframe first
            st.dataframe(
                current_page_data.style
                .background_gradient(axis=0)
                .background_gradient(cmap='RdYlGn')
                .background_gradient(cmap='RdYlGn_r', subset=['Finish_percentile', 'Own', 'Dupes'])
                .format(freq_format, precision=2), 
                height=1000,
                use_container_width=True
            )
        player_stats_col, stack_stats_col = st.tabs(['Player Stats', 'Stack Stats'])
        with player_stats_col:

            player_stats = []
            player_columns = [col for col in display_frame.columns if col not in excluded_cols]
            
            if type_var == 'Showdown':
                for player in player_names:
                    # Create mask for lineups where this player is Captain (first column)
                    cpt_mask = display_frame[player_columns[0]] == player
                    
                    if cpt_mask.any():
                        player_stats.append({
                            'Player': f"{player} (CPT)",
                            'Lineup Count': cpt_mask.sum(),
                            'Exposure': cpt_mask.sum() / len(display_frame),
                            'Avg Median': display_frame[cpt_mask]['median'].mean(),
                            'Avg Own': display_frame[cpt_mask]['Own'].mean(),
                            'Avg Dupes': display_frame[cpt_mask]['Dupes'].mean(),
                            'Avg Finish %': display_frame[cpt_mask]['Finish_percentile'].mean(),
                            'Avg Lineup Edge': display_frame[cpt_mask]['Lineup Edge'].mean(),
                        })
                    
                    # Create mask for lineups where this player is FLEX (other columns)
                    flex_mask = display_frame[player_columns[1:]].apply(
                        lambda row: player in list(row), axis=1
                    )
                    
                    if flex_mask.any():
                        player_stats.append({
                            'Player': f"{player} (FLEX)",
                            'Lineup Count': flex_mask.sum(),
                            'Exposure': flex_mask.sum() / len(display_frame),
                            'Avg Median': display_frame[flex_mask]['median'].mean(),
                            'Avg Own': display_frame[flex_mask]['Own'].mean(),
                            'Avg Dupes': display_frame[flex_mask]['Dupes'].mean(),
                            'Avg Finish %': display_frame[flex_mask]['Finish_percentile'].mean(),
                            'Avg Lineup Edge': display_frame[flex_mask]['Lineup Edge'].mean(),
                        })
            else:
                if sport_var == 'CS2':
                    # Handle Captain positions
                    for player in player_names:
                        # Create mask for lineups where this player is Captain (first column)
                        cpt_mask = display_frame[player_columns[0]] == player
                        
                        if cpt_mask.any():
                            player_stats.append({
                                'Player': f"{player} (CPT)",
                                'Lineup Count': cpt_mask.sum(),
                                'Exposure': cpt_mask.sum() / len(display_frame),
                                'Avg Median': display_frame[cpt_mask]['median'].mean(),
                                'Avg Own': display_frame[cpt_mask]['Own'].mean(),
                                'Avg Dupes': display_frame[cpt_mask]['Dupes'].mean(),
                                'Avg Finish %': display_frame[cpt_mask]['Finish_percentile'].mean(),
                                'Avg Lineup Edge': display_frame[cpt_mask]['Lineup Edge'].mean(),
                            })
                        
                        # Create mask for lineups where this player is FLEX (other columns)
                        flex_mask = display_frame[player_columns[1:]].apply(
                            lambda row: player in list(row), axis=1
                        )
                        
                        if flex_mask.any():
                            player_stats.append({
                                'Player': f"{player} (FLEX)",
                                'Lineup Count': flex_mask.sum(),
                                'Exposure': flex_mask.sum() / len(display_frame),
                                'Avg Median': display_frame[flex_mask]['median'].mean(),
                                'Avg Own': display_frame[flex_mask]['Own'].mean(),
                                'Avg Dupes': display_frame[flex_mask]['Dupes'].mean(),
                                'Avg Finish %': display_frame[flex_mask]['Finish_percentile'].mean(),
                                'Avg Lineup Edge': display_frame[flex_mask]['Lineup Edge'].mean(),
                            })
                elif sport_var != 'CS2':
                    # Original Classic format processing
                    for player in player_names:
                        player_mask = display_frame[player_columns].apply(
                            lambda row: player in list(row), axis=1
                        )
                        
                        if player_mask.any():
                            player_stats.append({
                                'Player': player,
                                'Lineup Count': player_mask.sum(),
                                'Exposure': player_mask.sum() / len(display_frame),
                                'Avg Median': display_frame[player_mask]['median'].mean(),
                                'Avg Own': display_frame[player_mask]['Own'].mean(),
                                'Avg Dupes': display_frame[player_mask]['Dupes'].mean(),
                                'Avg Finish %': display_frame[player_mask]['Finish_percentile'].mean(),
                                'Avg Lineup Edge': display_frame[player_mask]['Lineup Edge'].mean(),
                            })
            
            player_summary = pd.DataFrame(player_stats)
            player_summary = player_summary.sort_values('Lineup Count', ascending=False)
            
            st.subheader("Player Summary")
            st.dataframe(
                player_summary.style
                .background_gradient(axis=0).background_gradient(cmap='RdYlGn').background_gradient(cmap='RdYlGn_r', subset=['Avg Finish %', 'Avg Own', 'Avg Dupes'])
                .format({
                    'Avg Median': '{:.2f}',
                    'Avg Own': '{:.2f}',
                    'Avg Dupes': '{:.2f}',
                    'Avg Finish %': '{:.2%}',
                    'Avg Lineup Edge': '{:.2%}',
                    'Exposure': '{:.2%}'
                }),
                height=400,
                use_container_width=True
            )
        
        with stack_stats_col:
            if 'Stack' in display_frame.columns:
                stack_stats = []
                stack_columns = [col for col in display_frame.columns if col.startswith('Stack')]
                for stack in stack_dict.values():
                    stack_mask = display_frame['Stack'] == stack
                    if stack_mask.any():
                        stack_stats.append({
                            'Stack': stack,
                            'Lineup Count': stack_mask.sum(),
                            'Exposure': stack_mask.sum() / len(display_frame),
                            'Avg Median': display_frame[stack_mask]['median'].mean(),
                            'Avg Own': display_frame[stack_mask]['Own'].mean(),
                            'Avg Dupes': display_frame[stack_mask]['Dupes'].mean(),
                            'Avg Finish %': display_frame[stack_mask]['Finish_percentile'].mean(),
                            'Avg Lineup Edge': display_frame[stack_mask]['Lineup Edge'].mean(),
                        })
                stack_summary = pd.DataFrame(stack_stats)
                stack_summary = stack_summary.sort_values('Lineup Count', ascending=False).drop_duplicates()
                st.subheader("Stack Summary")
                st.dataframe(
                    stack_summary.style
                    .background_gradient(axis=0).background_gradient(cmap='RdYlGn').background_gradient(cmap='RdYlGn_r', subset=['Avg Finish %', 'Avg Own', 'Avg Dupes'])
                    .format({
                        'Avg Median': '{:.2f}',
                        'Avg Own': '{:.2f}',
                        'Avg Dupes': '{:.2f}',
                        'Avg Finish %': '{:.2%}',
                        'Avg Lineup Edge': '{:.2%}',
                        'Exposure': '{:.2%}'
                    }),
                    height=400,
                    use_container_width=True
                )
            else:
                stack_summary = pd.DataFrame(columns=['Stack', 'Lineup Count', 'Avg Median', 'Avg Own', 'Avg Dupes', 'Avg Finish %', 'Avg Lineup Edge'])