import streamlit as st
st.set_page_config(layout="wide")
import pandas as pd
from rapidfuzz import process
import random
from collections import Counter
import io

## 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.hedging_preset import hedging_preset
from global_func.volatility_preset import volatility_preset
from global_func.reduce_volatility_preset import reduce_volatility_preset
from global_func.analyze_player_combos import analyze_player_combos
from global_func.stratification_function import stratification_function
from global_func.exposure_spread import exposure_spread
from global_func.reassess_edge import reassess_edge
from global_func.recalc_diversity import recalc_diversity

freq_format = {'Finish_percentile': '{:.2%}', 'Lineup Edge': '{:.2%}', 'Lineup Edge_Raw': '{:.2%}', 'Win%': '{:.2%}'}
stacking_sports = ['MLB', 'NHL', 'NFL', 'LOL', 'NCAAF']
stack_column_dict = {
    'Draftkings': {
        'Classic': {
            'MLB': ['C', '1B', '2B', '3B', 'SS', 'OF1', 'OF2', 'OF3'],
            'NHL': ['C', 'W', 'D'],
            'NFL': ['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX'],
            'LOL': ['TOP', 'JNG', 'MID', 'ADC', 'SUP', 'TEAM'],
            'NCAAF': ['QB', 'WR1', 'WR2', 'WR3', 'FLEX', 'SFLEX'],
        },
        'Showdown': {
            'MLB': ['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5'],
            'NHL': ['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5'],
            'NFL': ['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5'],
            'LOL': ['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5'],
            'NCAAF': ['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5'],
        },
    },
    'Fanduel': {
        'Classic': {
            'MLB': ['C/1B', '2B', '3B', 'SS', 'OF1', 'OF2', 'OF3', 'UTIL'],
            'NHL': ['C', 'W', 'D'],
            'NFL': ['QB', 'RB1', 'RB2', 'WR1', 'WR2', 'WR3', 'TE', 'FLEX'],
            'LOL': ['TOP', 'JNG', 'MID', 'ADC', 'SUP', 'TEAM'],
            'NCAAF': ['QB', 'WR1', 'WR2', 'WR3', 'FLEX', 'SFLEX'],
        },
        'Showdown': {
            'MLB': ['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5'],
            'NHL': ['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5'],
            'NFL': ['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5'],
            'LOL': ['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5'],
            'NCAAF': ['CPT', 'FLEX1', 'FLEX2', 'FLEX3', 'FLEX4', 'FLEX5'],
        },
    },
}
player_wrong_names_mlb = ['Enrique Hernandez', 'Joseph Cantillo', 'Mike Soroka', 'Jakob Bauers', 'Temi Fágbénlé']
player_right_names_mlb = ['Kike Hernandez', 'Joey Cantillo', 'Michael Soroka', 'Jake Bauers', 'Temi Fagbenle']

st.markdown("""
<style>
    /* Tab styling */
    .stElementContainer [data-baseweb="button-group"] {
        gap: 2.000rem;
        padding: 4px;
    }
    .stElementContainer [kind="segmented_control"] {
        height: 2.000rem;
        white-space: pre-wrap;
        background-color: #DAA520;
        color: white;
        border-radius: 20px;
        gap: 1px;
        padding: 10px 20px;
        font-weight: bold;
        transition: all 0.3s ease;
    }
    .stElementContainer [kind="segmented_controlActive"] {
        height: 3.000rem;
        background-color: #DAA520;
        border: 3px solid #FFD700;
        border-radius: 10px;
        color: black;
    }
    .stElementContainer [kind="segmented_control"]:hover {
        background-color: #FFD700;
        cursor: pointer;
    }

    div[data-baseweb="select"] > div {
        background-color: #DAA520;
        color: white;
    }

</style>""", unsafe_allow_html=True)

# Memory optimization helper functions
def chunk_name_matching(portfolio_names, csv_names, chunk_size=1000):
    """Process name matching in chunks to reduce memory usage"""
    portfolio_match_dict = {}
    unmatched_names = []
    
    for i in range(0, len(portfolio_names), chunk_size):
        chunk = portfolio_names[i:i+chunk_size]
        for portfolio_name in chunk:
            match = process.extractOne(
                portfolio_name,
                csv_names,
                score_cutoff=90
            )
            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)
    
    return portfolio_match_dict, unmatched_names

def optimize_dataframe_dtypes(df):
    """Optimize DataFrame data types for memory efficiency"""
    # For now, disable categorical conversion entirely to avoid issues with exposure_spread and other operations
    # This maintains compatibility while still providing other memory optimizations
    # Future enhancement: implement smarter categorical handling that preserves mutability
    
    # Only optimize numeric columns to more efficient dtypes
    for col in df.columns:
        if df[col].dtype == 'float64':
            # Convert float64 to float32 if possible without significant precision loss
            try:
                if df[col].max() < 3.4e+38 and df[col].min() > -3.4e+38:  # float32 range
                    df[col] = df[col].astype('float32')
            except:
                pass
        elif df[col].dtype == 'int64':
            # Convert int64 to smaller int types if possible
            try:
                if df[col].max() <= 32767 and df[col].min() >= -32768:
                    df[col] = df[col].astype('int16')
                elif df[col].max() <= 2147483647 and df[col].min() >= -2147483648:
                    df[col] = df[col].astype('int32')
            except:
                pass
    
    return df

def create_memory_efficient_mappings(projections_df, site_var, type_var, sport_var):
    """Create mappings with optimized data types"""
    # Optimize projections data types first
    projections_df = projections_df.copy()
    
    # Convert to more efficient data types
    if 'position' in projections_df.columns:
        projections_df['position'] = projections_df['position'].astype('category')
    if 'team' in projections_df.columns:
        projections_df['team'] = projections_df['team'].astype('category')
    if 'salary' in projections_df.columns:
        projections_df['salary'] = projections_df['salary'].astype('int32')
    if 'median' in projections_df.columns:
        projections_df['median'] = projections_df['median'].astype('float32')
    if 'ownership' in projections_df.columns:
        projections_df['ownership'] = projections_df['ownership'].astype('float32')
    if 'captain ownership' in projections_df.columns:
        projections_df['captain ownership'] = projections_df['captain ownership'].astype('float32')
    
    # Create base mappings
    base_mappings = {
        'pos_map': dict(zip(projections_df['player_names'], projections_df['position'])),
        'team_map': dict(zip(projections_df['player_names'], projections_df['team'])),
        'salary_map': dict(zip(projections_df['player_names'], projections_df['salary'])),
        'proj_map': dict(zip(projections_df['player_names'], projections_df['median'])),
        'own_map': dict(zip(projections_df['player_names'], projections_df['ownership'])),
        'own_percent_rank': dict(zip(projections_df['player_names'], projections_df['ownership'].rank(pct=True).astype('float32')))
    }
    
    # Add site/type specific mappings
    if site_var == 'Draftkings':
        if type_var == 'Classic':
            if sport_var == 'CS2' or sport_var == 'LOL':
                base_mappings.update({
                    'cpt_salary_map': dict(zip(projections_df['player_names'], projections_df['salary'] * 1.5)),
                    'cpt_proj_map': dict(zip(projections_df['player_names'], projections_df['median'] * 1.5)),
                    'cpt_own_map': dict(zip(projections_df['player_names'], projections_df['captain ownership']))
                })
            else:
                base_mappings.update({
                    'cpt_salary_map': dict(zip(projections_df['player_names'], projections_df['salary'])),
                    'cpt_proj_map': dict(zip(projections_df['player_names'], projections_df['median'] * 1.5)),
                    'cpt_own_map': dict(zip(projections_df['player_names'], projections_df['captain ownership']))
                })
        elif type_var == 'Showdown':
            if sport_var == 'GOLF':
                base_mappings.update({
                    'cpt_salary_map': dict(zip(projections_df['player_names'], projections_df['salary'])),
                    'cpt_proj_map': dict(zip(projections_df['player_names'], projections_df['median'])),
                    'cpt_own_map': dict(zip(projections_df['player_names'], projections_df['ownership']))
                })
            else:
                base_mappings.update({
                    'cpt_salary_map': dict(zip(projections_df['player_names'], projections_df['salary'] * 1.5)),
                    'cpt_proj_map': dict(zip(projections_df['player_names'], projections_df['median'] * 1.5)),
                    'cpt_own_map': dict(zip(projections_df['player_names'], projections_df['captain ownership']))
                })
    elif site_var == 'Fanduel':
        base_mappings.update({
            'cpt_salary_map': dict(zip(projections_df['player_names'], projections_df['salary'] * 1.5)),
            'cpt_proj_map': dict(zip(projections_df['player_names'], projections_df['median'] * 1.5)),
            'cpt_own_map': dict(zip(projections_df['player_names'], projections_df['captain ownership']))
        })
    
    return base_mappings

def calculate_salary_vectorized(df, player_columns, map_dict, type_var, sport_var):
    """Vectorized salary calculation to replace expensive apply operations"""
    def safe_map_and_fill(series, mapping, fill_value=0):
        """Safely map values and fill NaN, handling categorical columns"""
        mapped = series.map(mapping)
        if hasattr(series, 'cat'):
            # Handle categorical columns by converting to object first
            mapped = mapped.astype('object')
        return mapped.fillna(fill_value)
    
    if type_var == 'Classic' and (sport_var == 'CS2' or sport_var == 'LOL'):
        # Captain + flex calculations
        cpt_salaries = safe_map_and_fill(df.iloc[:, 0], map_dict['cpt_salary_map'])
        flex_salaries = sum(safe_map_and_fill(df.iloc[:, i], map_dict['salary_map']) for i in range(1, len(player_columns)))
        return cpt_salaries + flex_salaries
    elif type_var == 'Showdown':
        if sport_var == 'GOLF':
            return sum(safe_map_and_fill(df[col], map_dict['salary_map']) for col in player_columns)
        else:
            cpt_salaries = safe_map_and_fill(df.iloc[:, 0], map_dict['cpt_salary_map'])
            flex_salaries = sum(safe_map_and_fill(df.iloc[:, i], map_dict['salary_map']) for i in range(1, len(player_columns)))
            return cpt_salaries + flex_salaries
    else:
        # Classic non-CS2/LOL
        return sum(safe_map_and_fill(df[col], map_dict['salary_map']) for col in player_columns)

def calculate_median_vectorized(df, player_columns, map_dict, type_var, sport_var):
    """Vectorized median calculation to replace expensive apply operations"""
    def safe_map_and_fill(series, mapping, fill_value=0):
        """Safely map values and fill NaN, handling categorical columns"""
        mapped = series.map(mapping)
        if hasattr(series, 'cat'):
            # Handle categorical columns by converting to object first
            mapped = mapped.astype('object')
        return mapped.fillna(fill_value)
    
    if type_var == 'Classic' and (sport_var == 'CS2' or sport_var == 'LOL'):
        cpt_medians = safe_map_and_fill(df.iloc[:, 0], map_dict['cpt_proj_map'])
        flex_medians = sum(safe_map_and_fill(df.iloc[:, i], map_dict['proj_map']) for i in range(1, len(player_columns)))
        return cpt_medians + flex_medians
    elif type_var == 'Showdown':
        if sport_var == 'GOLF':
            return sum(safe_map_and_fill(df[col], map_dict['proj_map']) for col in player_columns)
        else:
            cpt_medians = safe_map_and_fill(df.iloc[:, 0], map_dict['cpt_proj_map'])
            flex_medians = sum(safe_map_and_fill(df.iloc[:, i], map_dict['proj_map']) for i in range(1, len(player_columns)))
            return cpt_medians + flex_medians
    else:
        return sum(safe_map_and_fill(df[col], map_dict['proj_map']) for col in player_columns)

def calculate_ownership_vectorized(df, player_columns, map_dict, type_var, sport_var):
    """Vectorized ownership calculation to replace expensive apply operations"""
    def safe_map_and_fill(series, mapping, fill_value=0):
        """Safely map values and fill NaN, handling categorical columns"""
        mapped = series.map(mapping)
        if hasattr(series, 'cat'):
            # Handle categorical columns by converting to object first
            mapped = mapped.astype('object')
        return mapped.fillna(fill_value)
    
    if type_var == 'Classic' and (sport_var == 'CS2' or sport_var == 'LOL'):
        cpt_own = safe_map_and_fill(df.iloc[:, 0], map_dict['cpt_own_map'])
        flex_own = sum(safe_map_and_fill(df.iloc[:, i], map_dict['own_map']) for i in range(1, len(player_columns)))
        return cpt_own + flex_own
    elif type_var == 'Showdown':
        if sport_var == 'GOLF':
            return sum(safe_map_and_fill(df[col], map_dict['own_map']) for col in player_columns)
        else:
            cpt_own = safe_map_and_fill(df.iloc[:, 0], map_dict['cpt_own_map'])
            flex_own = sum(safe_map_and_fill(df.iloc[:, i], map_dict['own_map']) for i in range(1, len(player_columns)))
            return cpt_own + flex_own
    else:
        return sum(safe_map_and_fill(df[col], map_dict['own_map']) for col in player_columns)

def calculate_lineup_metrics(df, player_columns, map_dict, type_var, sport_var, projections_df=None):
    """Centralized function to calculate salary, median, and ownership efficiently"""
    df = df.copy()  # Work on a copy to avoid modifying original
    
    # Ensure player columns are object type to avoid categorical issues with exposure_spread
    for col in player_columns:
        if df[col].dtype.name == 'category':
            df[col] = df[col].astype('object')
    
    # Vectorized calculations
    df['salary'] = calculate_salary_vectorized(df[player_columns], player_columns, map_dict, type_var, sport_var)
    df['median'] = calculate_median_vectorized(df[player_columns], player_columns, map_dict, type_var, sport_var)
    df['Own'] = calculate_ownership_vectorized(df[player_columns], player_columns, map_dict, type_var, sport_var)
    
    return df

def create_team_filter_mask(df, player_columns, team_map, teams_to_filter, focus_type='Overall', type_var='Classic'):
    """Create boolean mask for team filtering without creating intermediate DataFrames"""
    mask = pd.Series(False, index=df.index)
    
    if type_var == 'Showdown' and focus_type != 'Overall':
        if focus_type == 'CPT':
            focus_columns = [player_columns[0]]  # First column only
        elif focus_type == 'FLEX':
            focus_columns = player_columns[1:]  # All except first
        else:
            focus_columns = player_columns
    else:
        # For Classic or Overall focus, use appropriate columns
        if type_var == 'Classic':
            focus_columns = [col for col in player_columns if col not in ['SP1', 'SP2']]  # Exclude pitchers
        else:
            focus_columns = player_columns
    
    for team in teams_to_filter:
        for col in focus_columns:
            team_mask = df[col].map(team_map) == team
            mask |= team_mask
    
    return mask

def prepare_dataframe_for_exposure_spread(df, player_columns):
    """Ensure DataFrame is ready for exposure_spread by converting player columns to object type"""
    df_prepared = df.copy()
    
    # Convert any categorical player columns back to object type
    for col in player_columns:
        if col in df_prepared.columns and df_prepared[col].dtype.name == 'category':
            df_prepared[col] = df_prepared[col].astype('object')
    
    return df_prepared

def create_position_export_dict(column_name, csv_file, site_var, type_var, sport_var):
    try:
        # Remove any numbers from the column name to get the position
        import re
        position_filter = re.sub(r'\d+$', '', column_name)

        # Filter CSV file by position
        if 'Position' in csv_file.columns:
            if type_var == 'Showdown':
                filtered_df = csv_file.copy()
            else:
                if position_filter == 'SP':
                    filtered_df = csv_file[
                        csv_file['Roster Position'] == 'P'
                    ]
                elif position_filter == 'CPT':
                    filtered_df = csv_file.copy()
                elif position_filter == 'FLEX' or position_filter == 'UTIL':
                    if sport_var == 'NFL':
                        filtered_df = csv_file[csv_file['Position'].isin(['RB', 'WR', 'TE'])]
                    elif sport_var == 'SOC':
                        filtered_df = csv_file[csv_file['Position'].str.contains('D|M|F', na=False, regex=True)]
                    elif sport_var == 'NCAAF':
                        filtered_df = csv_file[csv_file['Position'].str.contains('RB|WR', na=False, regex=True)]
                    elif sport_var == 'NHL':
                        filtered_df = csv_file[csv_file['Position'].str.contains('C|W|D', na=False, regex=True)]
                    else:
                        filtered_df = csv_file.copy()
                elif position_filter == 'SFLEX':
                    filtered_df = csv_file.copy()
                elif position_filter == 'C/1B':
                    filtered_df = csv_file[
                        csv_file['Position'].str.contains(['C', '1B'], na=False, regex=False)
                    ]
                else:
                    filtered_df = csv_file[
                        csv_file['Position'].str.contains(position_filter, na=False, regex=False)
                    ]
        else:
            # Fallback to all players if no position column found
            filtered_df = csv_file
        
        # Create the export dictionary for this position
        if site_var == 'Draftkings':
            filtered_df = filtered_df.sort_values(by='Salary', ascending=False).drop_duplicates(subset=['Name'])
            return dict(zip(filtered_df['Name'], filtered_df['Name + ID']))
        else:
            filtered_df = filtered_df.sort_values(by='Salary', ascending=False).drop_duplicates(subset=['Nickname'])
            return dict(zip(filtered_df['Nickname'], filtered_df['Id']))
                
    except Exception as e:
        st.error(f"Error creating position export dict for {column_name}: {str(e)}")
        return {}

with st.container():
    
    col1, col2, col3, col4 = st.columns([1, 4, 4, 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', 'NCAAF', 'MMA', 'CS2', 'LOL', 'TENNIS', 'NASCAR', 'GOLF', 'WNBA', 'F1'])
        
    with col4:
        type_var = st.selectbox("Select Game Type", ['Classic', 'Showdown'])
    
    if sport_var == 'GOLF':
        position_var = 'G'
        team_var = 'GOLF'
    elif sport_var == 'TENNIS':
        position_var = 'T'
        team_var = 'TENNIS'
    elif sport_var == 'MMA':
        position_var = 'F'
        team_var = 'MMA'
    elif sport_var == 'NASCAR':
        position_var = 'D'
        team_var = 'NASCAR'
    elif sport_var == 'F1':
        position_var = 'D'
        team_var = 'F1'
    else:
        position_var = None
        team_var = None

    if site_var == 'Draftkings':
        salary_max = 50000
    elif site_var == 'Fanduel':
        if type_var == 'Classic':
            if sport_var == 'MLB':
                salary_max = 40000
            elif sport_var == 'WNBA':
                salary_max = 40000
            elif sport_var == 'GOLF':
                salary_max = 60000
            elif sport_var == 'MMA':
                salary_max = 100
            elif sport_var == 'NFL':
                salary_max = 60000
            elif sport_var == 'NASCAR':
                salary_max = 50000
            else:
                salary_max = 60000
        elif type_var == 'Showdown':
            salary_max = 60000

try:
    selected_tab = st.segmented_control(
    "Select Tab",
    options=["Data Load", "Manage Portfolio"],
    selection_mode='single',
    default='Data Load',
    label_visibility='collapsed',
    width='stretch',
    key='tab_selector'
    )
except:
    selected_tab = st.segmented_control(
    "Select Tab",
    options=["Data Load", "Manage Portfolio"],
    selection_mode='single',
    default='Data Load',
    label_visibility='collapsed',
    key='tab_selector'
    )

if selected_tab == 'Data Load':
    # 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:
            if site_var == 'Draftkings':
                csv_template_df = pd.DataFrame(columns=['Name', 'ID', 'Roster Position', 'Salary'])
            else:
                csv_template_df = pd.DataFrame(columns=['Nickname', '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:
            if type_var == 'Showdown':
                st.session_state['csv_file']['Position'] = 'FLEX'
            else:
                if sport_var == 'GOLF':
                    st.session_state['csv_file']['Position'] = 'FLEX'
                    st.session_state['csv_file']['Team'] = 'GOLF'
                elif sport_var == 'TENNIS':
                    st.session_state['csv_file']['Position'] = 'FLEX'
                    st.session_state['csv_file']['Team'] = 'TENNIS'
                elif sport_var == 'MMA':
                    st.session_state['csv_file']['Position'] = 'FLEX'
                    st.session_state['csv_file']['Team'] = 'MMA'
                elif sport_var == 'NASCAR':
                    st.session_state['csv_file']['Position'] = 'FLEX'
                    st.session_state['csv_file']['Team'] = 'NASCAR'
            if site_var == 'Fanduel':
                try:
                    st.session_state['csv_file']['Position'] = st.session_state['csv_file']['Position'].replace('D', 'DST', regex=False)
                except:
                    pass
            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'], site_var, type_var, sport_var)
                    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'], site_var, type_var, sport_var)
                    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, site_var, type_var, sport_var, 'portfolio')
                    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)
                if st.session_state['portfolio'] is not None:

                    # Optimize data types early for memory efficiency
                    st.session_state['portfolio'] = optimize_dataframe_dtypes(st.session_state['portfolio'])
                    
                    st.success('Portfolio file loaded successfully!')
                    for col in st.session_state['portfolio'].select_dtypes(include=['object', 'category']).columns:
                        if st.session_state['portfolio'][col].dtype == 'category':
                            # Handle categorical columns
                            st.session_state['portfolio'][col] = st.session_state['portfolio'][col].cat.rename_categories(
                                lambda x: player_right_names_mlb.get(x, x) if x in player_wrong_names_mlb else x
                            )
                        else:
                            # Handle object columns
                            st.session_state['portfolio'][col] = st.session_state['portfolio'][col].replace(player_wrong_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, site_var, type_var, sport_var, 'projections')
            if projections is not None:
                st.success('Projections file loaded successfully!')
                
                # Optimize projections data types early
                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
                
                # Convert to efficient data types
                projections['salary'] = projections['salary'].dropna().astype('int32')
                projections['ownership'] = projections['ownership'].astype('float32')
                
                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['captain ownership'] = projections['captain ownership'].astype('float32')
                projections['median'] = projections['median'].astype('float32')
                
                # More efficient string replacement for projections
                for col in projections.select_dtypes(include=['object']).columns:
                    projections[col] = projections[col].replace(player_wrong_names_mlb)
                
                # Set position/team variables if needed
                if position_var is not None:
                    projections['position'] = position_var
                if team_var is not None:
                    projections['team'] = team_var

                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")
            
            # 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()
            
            # Use chunked name matching for memory efficiency
            portfolio_match_dict, unmatched_names = chunk_name_matching(portfolio_names, csv_names)
            
            # Update portfolio with matched names (in-place to save memory)
            player_columns = [col for col in st.session_state['portfolio'].columns 
                            if col not in ['salary', 'median', 'Own']]
            
            # For each player column, update names using the match dictionary
            for col in player_columns:
                st.session_state['portfolio'][col] = st.session_state['portfolio'][col].map(lambda x: portfolio_match_dict.get(x, x))
            
            # Create match dictionary for projections to CSV names (chunked)
            projections_match_dict, unmatched_proj_names = chunk_name_matching(projection_names, csv_names)
            
            # 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
            
            # Second round of matching (projections to portfolio)
            projections_names = st.session_state['projections_df']['player_names'].tolist()
            portfolio_names = get_portfolio_names(st.session_state['portfolio'])
            
            projections_match_dict2, unmatched_proj_names2 = chunk_name_matching(projection_names, portfolio_names)
            
            # Update projections with matched names
            projections['player_names'] = projections['player_names'].map(lambda x: projections_match_dict2.get(x, x))
            st.session_state['projections_df'] = projections

            # Handle stacking if needed
            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[stack_column_dict[site_var][type_var][sport_var]]
                        if team_dict.get(player, '') != ''
                    ).most_common(1)[0][0] if any(team_dict.get(player, '') for player in row[stack_column_dict[site_var][type_var][sport_var]]) else '',
                    axis=1
                )
                st.session_state['portfolio']['Size'] = st.session_state['portfolio'].apply(
                    lambda row: Counter(
                        team_dict.get(player, '') for player in row[stack_column_dict[site_var][type_var][sport_var]]
                        if team_dict.get(player, '') != ''
                    ).most_common(1)[0][1] if any(team_dict.get(player, '') for player in row[stack_column_dict[site_var][type_var][sport_var]]) else 0,
                    axis=1
                )
                st.session_state['stack_dict'] = dict(zip(st.session_state['portfolio'].index, st.session_state['portfolio']['Stack']))
                st.session_state['size_dict'] = dict(zip(st.session_state['portfolio'].index, st.session_state['portfolio']['Size']))

            # Create export dictionary
            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']))
            
            # Create memory-efficient mappings
            if 'map_dict' not in st.session_state:
                st.session_state['map_dict'] = create_memory_efficient_mappings(st.session_state['projections_df'], site_var, type_var, sport_var)
            
            # Store portfolio in compressed format and clean up
            st.session_state['portfolio'] = st.session_state['portfolio'].astype(str)
            st.session_state['portfolio'] = st.session_state['portfolio'][~st.session_state['portfolio'].isin(['', 'nan', 'None', 'NaN']).any(axis=1)].reset_index(drop=True)
            buffer = io.BytesIO()
            st.session_state['portfolio'].to_parquet(buffer, compression='snappy')
            st.session_state['origin_portfolio'] = buffer.getvalue()
            
            # Clear large objects from session state to free memory
            del st.session_state['portfolio'], st.session_state['export_portfolio']

# 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
#             )

if selected_tab == 'Manage Portfolio':
    if 'origin_portfolio' in st.session_state and 'projections_df' in st.session_state:
        with st.container():
            reset_port_col, recalc_div_col, blank_reset_col, contest_size_col = st.columns([1, 1, 6, 4])
            with reset_port_col:
                if st.button('Reset Portfolio', key='reset_port'):
                    st.session_state['settings_base'] = True
                    st.session_state['working_frame'] = st.session_state['base_frame']
            with recalc_div_col:
                if st.button("Recalculate Diversity"):
                        st.session_state['display_frame']['Diversity'] = recalc_diversity(st.session_state['display_frame'], st.session_state['player_columns'])

            with contest_size_col:
                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', 'Lineup Edge_Raw', 'Weighted Own', 'Geomean', 'Diversity']
        

        if 'working_frame' not in st.session_state:
            st.session_state['settings_base'] = True
            st.session_state['working_frame'] = pd.read_parquet(io.BytesIO(st.session_state['origin_portfolio']))
            st.session_state['player_columns'] = [col for col in st.session_state['working_frame'].columns if col not in excluded_cols]
            
            # Use vectorized calculation function
            st.session_state['working_frame'] = calculate_lineup_metrics(
                st.session_state['working_frame'], 
                st.session_state['player_columns'], 
                st.session_state['map_dict'], 
                type_var, 
                sport_var, 
                st.session_state['projections_df'] if 'stack_dict' in st.session_state else None
            )
            st.session_state['working_frame'] = st.session_state['working_frame'][st.session_state['working_frame']['salary'] <= salary_max]
            
            # Map existing stack/size data if available
            if 'stack_dict' in st.session_state:
                st.session_state['working_frame']['Stack'] = st.session_state['working_frame'].index.map(st.session_state['stack_dict'])
                st.session_state['working_frame']['Size'] = st.session_state['working_frame'].index.map(st.session_state['size_dict'])
            
            st.session_state['base_frame'] = predict_dupes(st.session_state['working_frame'], st.session_state['map_dict'], site_var, type_var, Contest_Size, strength_var, sport_var, salary_max)
            st.session_state['working_frame'] = st.session_state['base_frame'].copy()
            # 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()

            #set some maxes for trimming variables
            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(),
                    'Diversity': st.session_state['working_frame']['Diversity'].max()
                }

        with st.sidebar:
            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,
                    'Diversity': 1.0
                }
            with st.expander('Macro Filter Options'):
                # recent changes for showdown included
                with st.form(key='macro_filter_form'):
                    macro_min_col, macro_max_col = st.columns(2)
                    with macro_min_col:
                        min_salary = st.number_input("Min acceptable salary?", value=0, min_value=0, max_value=salary_max, step=100)
                        min_proj = st.number_input("Min acceptable projection?", value=0.0, min_value=0.0, max_value=500.0, step=1.0)
                        min_own = st.number_input("Min acceptable ownership?", value=0.0, min_value=0.0, max_value=500.0, step=1.0)
                        min_dupes = st.number_input("Min acceptable dupes?", value=0, min_value=0, max_value=1000, step=1)
                        min_finish_percentile = st.number_input("Min acceptable finish percentile?", value=0.00, min_value=0.00, max_value=1.00, step=.001)
                        min_lineup_edge = st.number_input("Min acceptable Lineup Edge?", value=-1.00, min_value=-1.00, max_value=1.00, step=.001)
                    with macro_max_col:
                        max_salary = st.number_input("Max acceptable salary?", value=salary_max, min_value=0, max_value=salary_max, step=100)
                        max_proj = st.number_input("Max acceptable projection?", value=500.0, min_value=0.0, max_value=500.0, step=1.0)
                        max_own = st.number_input("Max acceptable ownership?", value=500.0, min_value=0.0, max_value=500.0, step=1.0)
                        max_dupes = st.number_input("Max acceptable dupes?", value=1000, min_value=1, max_value=1000, step=1)
                        max_finish_percentile = st.number_input("Max acceptable finish percentile?", value=1.00, min_value=0.00, max_value=1.00, step=.001)
                        max_lineup_edge = st.number_input("Max acceptable Lineup Edge?", value=1.00, min_value=-1.00, max_value=1.00, step=.001)

                    if sport_var in stacking_sports:
                        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(st.session_state['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(st.session_state['stack_dict'].values()))), default=[])
                    
                    submitted_col, export_col = st.columns(2)
                    st.info("Portfolio Button applies to your overall Portfolio, Export button applies to your Custom Export")
                    with submitted_col:
                        reg_submitted = st.form_submit_button("Portfolio")
                    with export_col:
                        exp_submitted = st.form_submit_button("Export")
                    
                    if reg_submitted:
                        st.session_state['settings_base'] = False
                        
                        # Use index-based filtering instead of copying DataFrame
                        filter_mask = (
                            (st.session_state['working_frame']['salary'] >= min_salary) &
                            (st.session_state['working_frame']['salary'] <= max_salary) &
                            (st.session_state['working_frame']['median'] >= min_proj) &
                            (st.session_state['working_frame']['median'] <= max_proj) &
                            (st.session_state['working_frame']['Own'] >= min_own) &
                            (st.session_state['working_frame']['Own'] <= max_own) &
                            (st.session_state['working_frame']['Dupes'] >= min_dupes) &
                            (st.session_state['working_frame']['Dupes'] <= max_dupes) &
                            (st.session_state['working_frame']['Finish_percentile'] >= min_finish_percentile) &
                            (st.session_state['working_frame']['Finish_percentile'] <= max_finish_percentile) &
                            (st.session_state['working_frame']['Lineup Edge'] >= min_lineup_edge) &
                            (st.session_state['working_frame']['Lineup Edge'] <= max_lineup_edge)
                        )
                        
                        
                        # Handle stack filtering
                        if 'Stack' in st.session_state['working_frame'].columns:
                            if stack_include_toggle != 'All Stacks':
                                filter_mask &= st.session_state['working_frame']['Stack'].isin(stack_selections)
                            if stack_remove_toggle == 'Yes':
                                filter_mask &= ~st.session_state['working_frame']['Stack'].isin(stack_remove)
                        
                        # Apply all filters at once
                        st.session_state['working_frame'] = st.session_state['working_frame'][filter_mask].sort_values(by='median', ascending=False).reset_index(drop=True)
                        st.session_state['export_merge'] = st.session_state['working_frame'].copy()
                    if exp_submitted:
                        st.session_state['settings_base'] = False
                        
                        # Use index-based filtering for export_base
                        export_filter_mask = (
                            (st.session_state['export_base']['salary'] >= min_salary) &
                            (st.session_state['export_base']['salary'] <= max_salary) &
                            (st.session_state['export_base']['median'] >= min_proj) &
                            (st.session_state['export_base']['median'] <= max_proj) &
                            (st.session_state['export_base']['Own'] >= min_own) &
                            (st.session_state['export_base']['Own'] <= max_own) &
                            (st.session_state['export_base']['Dupes'] >= min_dupes) &
                            (st.session_state['export_base']['Dupes'] <= max_dupes) &
                            (st.session_state['export_base']['Finish_percentile'] >= min_finish_percentile) &
                            (st.session_state['export_base']['Finish_percentile'] <= max_finish_percentile) &
                            (st.session_state['export_base']['Lineup Edge'] >= min_lineup_edge) &
                            (st.session_state['export_base']['Lineup Edge'] <= max_lineup_edge)
                        )

                        if 'Stack' in st.session_state['export_base'].columns:
                            if stack_include_toggle != 'All Stacks':
                                export_filter_mask &= st.session_state['export_base']['Stack'].isin(stack_selections)
                            if stack_remove_toggle == 'Yes':
                                export_filter_mask &= ~st.session_state['export_base']['Stack'].isin(stack_remove)
                        
                        st.session_state['export_base'] = st.session_state['export_base'][export_filter_mask].sort_values(by='median', ascending=False).reset_index(drop=True)
                        st.session_state['export_merge'] = st.session_state['export_base'].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())
                    if type_var == 'Showdown':
                        cpt_flex_focus = st.selectbox("Focus on Overall, CPT, or FLEX?", options=['Overall', 'CPT', 'FLEX'], index=0)
                    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 stacking_sports:
                        size_include = st.multiselect("Include sizes?", options=sorted(list(set(st.session_state['working_frame']['Size'].unique()))), default=[])
                    else:
                        size_include = []
                    if sport_var == 'NFL':
                        qb_force = st.selectbox("Force QB Stacks?", options=['No', 'Yes'], index=0)
                    else:
                        qb_force = 'No'
                    
                    submitted_col, export_col = st.columns(2)
                    st.info("Portfolio Button applies to your overall Portfolio, Export button applies to your Custom Export")
                    with submitted_col:
                        reg_submitted = st.form_submit_button("Portfolio")
                    with export_col:
                        exp_submitted = st.form_submit_button("Export")
                    if reg_submitted:
                        st.session_state['settings_base'] = False
                        parsed_frame = st.session_state['working_frame'].copy()
                        if player_remove:
                            if type_var == 'Showdown':
                                if cpt_flex_focus == 'CPT':
                                    remove_mask = parsed_frame.iloc[:, 0].apply(
                                        lambda player: not any(remove_player in str(player) for remove_player in player_remove)
                                    )
                                elif cpt_flex_focus == 'FLEX':
                                    remove_mask = parsed_frame.iloc[:, 1:].apply(
                                        lambda row: not any(player in list(row) for player in player_remove), axis=1
                                    )
                                elif cpt_flex_focus == 'Overall':
                                    remove_mask = parsed_frame[st.session_state['player_columns']].apply(
                                        lambda row: not any(player in list(row) for player in player_remove), axis=1
                                    )
                            else:
                                # Create mask for lineups that contain any of the removed players
                                remove_mask = parsed_frame[st.session_state['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:
                            if type_var == 'Showdown':
                                if cpt_flex_focus == 'CPT':
                                    lock_mask = parsed_frame.iloc[:, 0].apply(
                                        lambda player: any(lock_player in str(player) for lock_player in player_lock)
                                    )
                                elif cpt_flex_focus == 'FLEX':
                                    lock_mask = parsed_frame.iloc[:, 1:].apply(
                                        lambda row: all(player in list(row) for player in player_lock), axis=1
                                    )
                                elif cpt_flex_focus == 'Overall':
                                    lock_mask = parsed_frame[st.session_state['player_columns']].apply(
                                        lambda row: all(player in list(row) for player in player_lock), axis=1
                                    )
                            else:
                                lock_mask = parsed_frame[st.session_state['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:
                            if type_var == 'Showdown':
                                if cpt_flex_focus == 'CPT':
                                    team_frame = parsed_frame.iloc[:, 0].apply(
                                        lambda x: x.map(st.session_state['map_dict']['team_map'])
                                    )
                                    include_mask = team_frame.apply(
                                        lambda row: any(team in list(row) for team in team_include), axis=1
                                    )
                                elif cpt_flex_focus == 'FLEX':
                                    team_frame = parsed_frame.iloc[:, 1:].apply(
                                        lambda x: x.map(st.session_state['map_dict']['team_map'])
                                    )
                                    include_mask = team_frame.apply(
                                        lambda row: any(team in list(row) for team in team_include), axis=1
                                    )
                                elif cpt_flex_focus == 'Overall':
                                    team_frame = parsed_frame[st.session_state['player_columns']].apply(
                                        lambda x: x.map(st.session_state['map_dict']['team_map'])
                                    )
                                    include_mask = team_frame.apply(
                                        lambda row: any(team in list(row) for team in team_include), axis=1
                                    )
                            else:
                                # Create a copy of the frame with player names replaced by teams, excluding SP1 and SP2
                                filtered_player_columns = [col for col in st.session_state['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:
                            if type_var == 'Showdown':
                                if cpt_flex_focus == 'CPT':
                                    team_frame = parsed_frame.iloc[:, 0].apply(
                                        lambda x: x.map(st.session_state['map_dict']['team_map'])
                                    )
                                    remove_mask = team_frame.apply(
                                        lambda row: not any(team in list(row) for team in team_remove), axis=1
                                    )
                                elif cpt_flex_focus == 'FLEX':
                                    team_frame = parsed_frame.iloc[:, 1:].apply(
                                        lambda x: x.map(st.session_state['map_dict']['team_map'])
                                    )
                                    remove_mask = team_frame.apply(
                                        lambda row: not any(team in list(row) for team in team_remove), axis=1
                                    )
                                elif cpt_flex_focus == 'Overall':
                                    team_frame = parsed_frame[st.session_state['player_columns']].apply(
                                        lambda x: x.map(st.session_state['map_dict']['team_map'])
                                    )
                                    remove_mask = team_frame.apply(
                                        lambda row: not any(team in list(row) for team in team_remove), axis=1
                                    )
                            else:
                                # Create a copy of the frame with player names replaced by teams, excluding SP1 and SP2
                                filtered_player_columns = [col for col in st.session_state['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)]
                        
                        if qb_force == 'Yes':
                            if type_var == 'Classic':
                                # Get team for the first player column for each lineup
                                team_frame = parsed_frame.iloc[:, 0].map(st.session_state['map_dict']['team_map'])
                                
                                # Create mask where the first player's team matches the Stack column
                                include_mask = team_frame == parsed_frame['Stack']
                            parsed_frame = parsed_frame[include_mask]
                        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()
                    elif exp_submitted:
                        st.session_state['settings_base'] = False
                        parsed_frame = st.session_state['export_base'].copy()
                        if player_remove:
                            if type_var == 'Showdown':
                                if cpt_flex_focus == 'CPT':
                                    remove_mask = parsed_frame.iloc[:, 0].apply(
                                        lambda player: not any(remove_player in str(player) for remove_player in player_remove)
                                    )
                                elif cpt_flex_focus == 'FLEX':
                                    remove_mask = parsed_frame.iloc[:, 1:].apply(
                                        lambda row: not any(player in list(row) for player in player_remove), axis=1
                                    )
                                elif cpt_flex_focus == 'Overall':
                                    remove_mask = parsed_frame[st.session_state['player_columns']].apply(
                                        lambda row: not any(player in list(row) for player in player_remove), axis=1
                                    )
                            else:
                                remove_mask = parsed_frame[st.session_state['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:
                            if type_var == 'Showdown':
                                if cpt_flex_focus == 'CPT':
                                    lock_mask = parsed_frame.iloc[:, 0].apply(
                                        lambda player: any(lock_player in str(player) for lock_player in player_lock)
                                    )
                                elif cpt_flex_focus == 'FLEX':
                                    lock_mask = parsed_frame.iloc[:, 1:].apply(
                                        lambda row: all(player in list(row) for player in player_lock), axis=1
                                    )
                                elif cpt_flex_focus == 'Overall':
                                    lock_mask = parsed_frame[st.session_state['player_columns']].apply(
                                        lambda row: all(player in list(row) for player in player_lock), axis=1
                                    )
                            else:
                                lock_mask = parsed_frame[st.session_state['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:
                            if type_var == 'Showdown':
                                if cpt_flex_focus == 'CPT':
                                    team_frame = parsed_frame.iloc[:, 0].apply(
                                        lambda x: x.map(st.session_state['map_dict']['team_map'])
                                    )
                                    include_mask = team_frame.apply(
                                        lambda row: any(team in list(row) for team in team_include), axis=1
                                    )
                                elif cpt_flex_focus == 'FLEX':
                                    team_frame = parsed_frame.iloc[:, 1:].apply(
                                        lambda x: x.map(st.session_state['map_dict']['team_map'])
                                    )
                                    include_mask = team_frame.apply(
                                        lambda row: any(team in list(row) for team in team_include), axis=1
                                    )
                                elif cpt_flex_focus == 'Overall':
                                    team_frame = parsed_frame[st.session_state['player_columns']].apply(
                                        lambda x: x.map(st.session_state['map_dict']['team_map'])
                                    )
                                    include_mask = team_frame.apply(
                                        lambda row: any(team in list(row) for team in team_include), axis=1
                                    )
                            else:
                                # Create a copy of the frame with player names replaced by teams, excluding SP1 and SP2
                                filtered_player_columns = [col for col in st.session_state['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:
                            if type_var == 'Showdown':
                                if cpt_flex_focus == 'CPT':
                                    team_frame = parsed_frame.iloc[:, 0].apply(
                                        lambda x: x.map(st.session_state['map_dict']['team_map'])
                                    )
                                    remove_mask = team_frame.apply(
                                        lambda row: not any(team in list(row) for team in team_remove), axis=1
                                    )
                                elif cpt_flex_focus == 'FLEX':
                                    team_frame = parsed_frame.iloc[:, 1:].apply(
                                        lambda x: x.map(st.session_state['map_dict']['team_map'])
                                    )
                                    remove_mask = team_frame.apply(
                                        lambda row: not any(team in list(row) for team in team_remove), axis=1
                                    )
                                elif cpt_flex_focus == 'Overall':
                                    team_frame = parsed_frame[st.session_state['player_columns']].apply(
                                        lambda x: x.map(st.session_state['map_dict']['team_map'])
                                    )
                                    remove_mask = team_frame.apply(
                                        lambda row: not any(team in list(row) for team in team_remove), axis=1
                                    )
                            else:
                                # Create a copy of the frame with player names replaced by teams, excluding SP1 and SP2
                                filtered_player_columns = [col for col in st.session_state['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['export_base'] = parsed_frame.sort_values(by='median', ascending=False).reset_index(drop=True)
                        st.session_state['export_merge'] = st.session_state['export_base'].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', 'Own', 'Weighted Own'], key='sort_var')
                    with own_var:
                        own_type = st.selectbox("Trimming variable", ['Own', 'Geomean', 'Weighted Own', 'Diversity'], 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=float(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=float(st.session_state['trimming_dict_maxes'][own_type]), min_value=0.0, step=1.0, key='max_trim')
                    
                    submitted_col, export_col = st.columns(2)
                    st.info("Portfolio Button applies to your overall Portfolio, Export button applies to your Custom Export")
                    with submitted_col:
                        reg_submitted = st.form_submit_button("Portfolio")
                    with export_col:
                        exp_submitted = st.form_submit_button("Export")
                    if reg_submitted:
                        st.session_state['settings_base'] = False
                        st.write('initiated')
                        parsed_frame = st.session_state['working_frame'].copy()
                        parsed_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'] = parsed_frame.sort_values(by='median', ascending=False)
                        st.session_state['export_merge'] = st.session_state['working_frame'].copy()
                    elif exp_submitted:
                        st.session_state['settings_base'] = False
                        parsed_frame = st.session_state['export_base'].copy()
                        parsed_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['export_base'] = parsed_frame.sort_values(by='median', ascending=False)
                        st.session_state['export_merge'] = st.session_state['export_base'].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 (Manage Diversity)', 'Hedge Chalk (Manage Leverage)', 'Volatility (Heavy Lineup Edge)'], index=0)
                    lineup_target = st.number_input("Lineups to produce", value=150, min_value=1, step=1)
                    submitted_col, export_col = st.columns(2)
                    st.info("Portfolio Button applies to your overall Portfolio, Export button applies to your Custom Export")
                    with submitted_col:
                        reg_submitted = st.form_submit_button("Portfolio")
                    with export_col:
                        exp_submitted = st.form_submit_button("Export")
                    if reg_submitted:
                        st.session_state['settings_base'] = False
                        if preset_choice == 'Small Field (Heavy Own)':
                            parsed_frame = small_field_preset(st.session_state['working_frame'], lineup_target, excluded_cols, sport_var)
                        elif preset_choice == 'Large Field (Manage Diversity)':
                            parsed_frame = large_field_preset(st.session_state['working_frame'], lineup_target, excluded_cols, sport_var)
                        elif preset_choice == 'Volatility (Heavy Lineup Edge)':
                            parsed_frame = volatility_preset(st.session_state['working_frame'], lineup_target, excluded_cols, sport_var)
                        elif preset_choice == 'Hedge Chalk (Manage Leverage)':
                            parsed_frame = hedging_preset(st.session_state['working_frame'], lineup_target, st.session_state['projections_df'], sport_var)
                        elif preset_choice == 'Reduce Volatility (Manage Own)':
                            parsed_frame = reduce_volatility_preset(st.session_state['working_frame'], lineup_target, excluded_cols, sport_var)

                        st.session_state['working_frame'] = parsed_frame.reset_index(drop=True)
                        st.session_state['export_merge'] = st.session_state['working_frame'].copy()
                    elif exp_submitted:
                        st.session_state['settings_base'] = False
                        parsed_frame = st.session_state['export_base'].copy()
                        if preset_choice == 'Small Field (Heavy Own)':
                            parsed_frame = small_field_preset(st.session_state['export_base'], lineup_target, excluded_cols, sport_var)
                        elif preset_choice == 'Large Field (Manage Diversity)':
                            parsed_frame = large_field_preset(st.session_state['export_base'], lineup_target, excluded_cols, sport_var)
                        elif preset_choice == 'Volatility (Heavy Lineup Edge)':
                            parsed_frame = volatility_preset(st.session_state['export_base'], lineup_target, excluded_cols, sport_var)
                        elif preset_choice == 'Hedge Chalk (Manage Leverage)':
                            parsed_frame = hedging_preset(st.session_state['export_base'], lineup_target, st.session_state['projections_df'], sport_var)
                        elif preset_choice == 'Reduce Volatility (Manage Own)':
                            parsed_frame = reduce_volatility_preset(st.session_state['export_base'], lineup_target, excluded_cols, sport_var)

                        st.session_state['export_base'] = parsed_frame.reset_index(drop=True)
                        st.session_state['export_merge'] = st.session_state['export_base'].copy()
            with st.expander('Stratify'):
                with st.form(key='Stratification'):
                    sorting_choice = st.selectbox("Stat Choice", options=['median', 'Own', 'Weighted Own', 'Geomean', 'Lineup Edge', 'Finish_percentile', 'Diversity'], index=0)
                    lineup_target = st.number_input("Lineups to produce", value=150, min_value=1, step=1)
                    strat_sample = st.slider("Sample range", value=[0.0, 100.0], min_value=0.0, max_value=100.0, step=1.0)
                    submitted_col, export_col = st.columns(2)
                    st.info("Portfolio Button applies to your overall Portfolio, Export button applies to your Custom Export")
                    with submitted_col:
                        reg_submitted = st.form_submit_button("Portfolio")
                    with export_col:
                        exp_submitted = st.form_submit_button("Export")
                    if reg_submitted:
                        st.session_state['settings_base'] = False
                        parsed_frame = stratification_function(st.session_state['working_frame'], lineup_target, excluded_cols, sport_var, sorting_choice, strat_sample[0], strat_sample[1])
                        st.session_state['working_frame'] = parsed_frame.reset_index(drop=True)
                        st.session_state['export_merge'] = st.session_state['working_frame'].copy()
                    elif exp_submitted:
                        st.session_state['settings_base'] = False
                        parsed_frame = stratification_function(st.session_state['export_base'], lineup_target, excluded_cols, sport_var, sorting_choice, strat_sample[0], strat_sample[1])
                        st.session_state['export_base'] = parsed_frame.reset_index(drop=True)
                        st.session_state['export_merge'] = st.session_state['export_base'].copy()
            
            with st.expander('Conditionals Manager (players)'):
                # a set of functions for removing lineups that contain a conditional between players and stacks
                with st.form(key='conditional_players_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())
                    keep_remove_var = st.selectbox("Conditional:", options=['Keep', 'Remove'], index=0)
                    conditional_side_alpha = st.multiselect("Lineups containing:", options=sorted(list(player_names)), default=[])
                    cpt_flex_alpha = st.selectbox("in slot:", options=['Overall', 'CPT', 'FLEX'], index=0, key='cpt_flex_alpha')
                    conditional_var = st.selectbox("where they also contain:", options=['Any', 'All', 'None'], index=0)
                    conditional_side_beta = st.multiselect("of the following player(s):", options=sorted(list(player_names)), default=[])
                    cpt_flex_beta = st.selectbox("in slot:", options=['Overall', 'CPT', 'FLEX'], index=0, key='cpt_flex_beta')
                    
                    submitted_col, export_col = st.columns(2)
                    st.info("Portfolio Button applies to your overall Portfolio, Export button applies to your Custom Export")
                    with submitted_col:
                        reg_submitted = st.form_submit_button("Portfolio")
                    with export_col:
                        exp_submitted = st.form_submit_button("Export")
                    if reg_submitted:
                        st.session_state['settings_base'] = False
                        parsed_frame = st.session_state['working_frame'].copy()

                        # Check if we have players selected for both alpha and beta sides
                        if conditional_side_alpha and conditional_side_beta:
                            # Create boolean mask for rows containing ALL players from alpha side
                            alpha_mask = pd.Series([True] * len(parsed_frame), index=parsed_frame.index)
                            for player in conditional_side_alpha:
                                if type_var == 'Showdown':
                                    if cpt_flex_alpha == 'Overall':
                                        player_present = parsed_frame.apply(lambda row: player in row.values, axis=1)
                                    elif cpt_flex_alpha == 'CPT':
                                        player_present = parsed_frame.iloc[:, 0].apply(lambda row: player in row)
                                    elif cpt_flex_alpha == 'FLEX':
                                        player_present = parsed_frame.iloc[:, 1:].apply(lambda row: player in row.values, axis=1)
                                else:
                                    player_present = parsed_frame.apply(lambda row: player in row.values, axis=1)
                                alpha_mask = alpha_mask & player_present
                            
                            # Only apply beta logic to rows that match alpha condition
                            rows_to_process = alpha_mask
                            
                            # For rows that match alpha condition, check beta condition
                            if conditional_var == 'Any':
                                # Check if row contains ANY of the beta players
                                beta_mask = pd.Series([False] * len(parsed_frame), index=parsed_frame.index)
                                for player in conditional_side_beta:
                                    if type_var == 'Showdown':
                                        if cpt_flex_beta == 'Overall':
                                            player_present = parsed_frame.apply(lambda row: player in row.values, axis=1)
                                        elif cpt_flex_beta == 'CPT':
                                            player_present = parsed_frame.iloc[:, 0].apply(lambda row: player in row)
                                        elif cpt_flex_beta == 'FLEX':
                                            player_present = parsed_frame.iloc[:, 1:].apply(lambda row: player in row.values, axis=1)
                                    else:
                                        player_present = parsed_frame.apply(lambda row: player in row.values, axis=1)
                                    beta_mask = beta_mask | player_present
                            elif conditional_var == 'All':
                                # Check if row contains ALL of the beta players
                                beta_mask = pd.Series([True] * len(parsed_frame), index=parsed_frame.index)
                                for player in conditional_side_beta:
                                    if type_var == 'Showdown':
                                        if cpt_flex_beta == 'Overall':
                                            player_present = parsed_frame.apply(lambda row: player in row.values, axis=1)
                                        elif cpt_flex_beta == 'CPT':
                                            player_present = parsed_frame.iloc[:, 0].apply(lambda row: player in row)
                                        elif cpt_flex_beta == 'FLEX':
                                            player_present = parsed_frame.iloc[:, 1:].apply(lambda row: player in row.values, axis=1)
                                    else:
                                        player_present = parsed_frame.apply(lambda row: player in row.values, axis=1)
                                    beta_mask = beta_mask & player_present
                            elif conditional_var == 'None':
                                # Check if row contains NONE of the beta players
                                beta_mask = pd.Series([True] * len(parsed_frame), index=parsed_frame.index)
                                for player in conditional_side_beta:
                                    if type_var == 'Showdown':
                                        if cpt_flex_beta == 'Overall':
                                            player_present = parsed_frame.apply(lambda row: player in row.values, axis=1)
                                        elif cpt_flex_beta == 'CPT':
                                            player_present = parsed_frame.iloc[:, 0].apply(lambda row: player in row)
                                        elif cpt_flex_beta == 'FLEX':
                                            player_present = parsed_frame.iloc[:, 1:].apply(lambda row: player in row.values, axis=1)
                                    else:
                                        player_present = parsed_frame.apply(lambda row: player in row.values, axis=1)
                                    player_present = parsed_frame.apply(lambda row: player in row.values, axis=1)
                                    beta_mask = beta_mask & (~player_present)
                            
                            # Combine conditions: alpha_mask AND beta_mask
                            final_condition = rows_to_process & beta_mask
                            
                            # Apply keep or remove logic
                            if keep_remove_var == 'Keep':
                                parsed_frame = parsed_frame[~rows_to_process | final_condition]
                            else:  # Remove
                                parsed_frame = parsed_frame[~final_condition]
                        
                        elif conditional_side_alpha:
                            # Only alpha side specified - filter based on presence of alpha players
                            alpha_mask = pd.Series([True] * len(parsed_frame), index=parsed_frame.index)
                            for player in conditional_side_alpha:
                                if type_var == 'Showdown':
                                    if cpt_flex_alpha == 'Overall':
                                        player_present = parsed_frame.apply(lambda row: player in row.values, axis=1)
                                    elif cpt_flex_alpha == 'CPT':
                                        player_present = parsed_frame.iloc[:, 0].apply(lambda row: player in row)
                                    elif cpt_flex_alpha == 'FLEX':
                                        player_present = parsed_frame.iloc[:, 1:].apply(lambda row: player in row.values, axis=1)
                                else:
                                    player_present = parsed_frame.apply(lambda row: player in row.values, axis=1)
                                player_present = parsed_frame.apply(lambda row: player in row.values, axis=1)
                                alpha_mask = alpha_mask & player_present
                            
                            if keep_remove_var == 'Keep':
                                parsed_frame = parsed_frame[alpha_mask]
                            else:  # Remove
                                parsed_frame = parsed_frame[~alpha_mask]

                        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()
                    elif exp_submitted:
                        st.session_state['settings_base'] = False
                        parsed_frame = st.session_state['export_base'].copy()

                        # Check if we have players selected for both alpha and beta sides
                        if conditional_side_alpha and conditional_side_beta:
                            # Create boolean mask for rows containing ALL players from alpha side
                            alpha_mask = pd.Series([True] * len(parsed_frame), index=parsed_frame.index)
                            for player in conditional_side_alpha:
                                if type_var == 'Showdown':
                                    if cpt_flex_alpha == 'Overall':
                                        player_present = parsed_frame.apply(lambda row: player in row.values, axis=1)
                                    elif cpt_flex_alpha == 'CPT':
                                        player_present = parsed_frame.iloc[:, 0].apply(lambda row: player in row)
                                    elif cpt_flex_alpha == 'FLEX':
                                        player_present = parsed_frame.iloc[:, 1:].apply(lambda row: player in row.values, axis=1)
                                else:
                                    player_present = parsed_frame.apply(lambda row: player in row.values, axis=1)
                                alpha_mask = alpha_mask & player_present
                            
                            # Only apply beta logic to rows that match alpha condition
                            rows_to_process = alpha_mask
                            
                            # For rows that match alpha condition, check beta condition
                            if conditional_var == 'Any':
                                # Check if row contains ANY of the beta players
                                beta_mask = pd.Series([False] * len(parsed_frame), index=parsed_frame.index)
                                for player in conditional_side_beta:
                                    if type_var == 'Showdown':
                                        if cpt_flex_beta == 'Overall':
                                            player_present = parsed_frame.apply(lambda row: player in row.values, axis=1)
                                        elif cpt_flex_beta == 'CPT':
                                            player_present = parsed_frame.iloc[:, 0].apply(lambda row: player in row)
                                        elif cpt_flex_beta == 'FLEX':
                                            player_present = parsed_frame.iloc[:, 1:].apply(lambda row: player in row.values, axis=1)
                                    else:
                                        player_present = parsed_frame.apply(lambda row: player in row.values, axis=1)
                                    beta_mask = beta_mask | player_present
                            elif conditional_var == 'All':
                                # Check if row contains ALL of the beta players
                                beta_mask = pd.Series([True] * len(parsed_frame), index=parsed_frame.index)
                                for player in conditional_side_beta:
                                    if type_var == 'Showdown':
                                        if cpt_flex_beta == 'Overall':
                                            player_present = parsed_frame.apply(lambda row: player in row.values, axis=1)
                                        elif cpt_flex_beta == 'CPT':
                                            player_present = parsed_frame.iloc[:, 0].apply(lambda row: player in row)
                                        elif cpt_flex_beta == 'FLEX':
                                            player_present = parsed_frame.iloc[:, 1:].apply(lambda row: player in row.values, axis=1)
                                    else:
                                        player_present = parsed_frame.apply(lambda row: player in row.values, axis=1)
                                    beta_mask = beta_mask & player_present
                            elif conditional_var == 'None':
                                # Check if row contains NONE of the beta players
                                beta_mask = pd.Series([True] * len(parsed_frame), index=parsed_frame.index)
                                for player in conditional_side_beta:
                                    if type_var == 'Showdown':
                                        if cpt_flex_beta == 'Overall':
                                            player_present = parsed_frame.apply(lambda row: player in row.values, axis=1)
                                        elif cpt_flex_beta == 'CPT':
                                            player_present = parsed_frame.iloc[:, 0].apply(lambda row: player in row)
                                        elif cpt_flex_beta == 'FLEX':
                                            player_present = parsed_frame.iloc[:, 1:].apply(lambda row: player in row.values, axis=1)
                                    else:
                                        player_present = parsed_frame.apply(lambda row: player in row.values, axis=1)
                                    player_present = parsed_frame.apply(lambda row: player in row.values, axis=1)
                                    beta_mask = beta_mask & (~player_present)
                            
                            # Combine conditions: alpha_mask AND beta_mask
                            final_condition = rows_to_process & beta_mask
                            
                            # Apply keep or remove logic
                            if keep_remove_var == 'Keep':
                                parsed_frame = parsed_frame[~rows_to_process | final_condition]
                            else:  # Remove
                                parsed_frame = parsed_frame[~final_condition]
                        
                        elif conditional_side_alpha:
                            # Only alpha side specified - filter based on presence of alpha players
                            alpha_mask = pd.Series([True] * len(parsed_frame), index=parsed_frame.index)
                            for player in conditional_side_alpha:
                                if type_var == 'Showdown':
                                    if cpt_flex_alpha == 'Overall':
                                        player_present = parsed_frame.apply(lambda row: player in row.values, axis=1)
                                    elif cpt_flex_alpha == 'CPT':
                                        player_present = parsed_frame.iloc[:, 0].apply(lambda row: player in row)
                                    elif cpt_flex_alpha == 'FLEX':
                                        player_present = parsed_frame.iloc[:, 1:].apply(lambda row: player in row.values, axis=1)
                                else:
                                    player_present = parsed_frame.apply(lambda row: player in row.values, axis=1)
                                player_present = parsed_frame.apply(lambda row: player in row.values, axis=1)
                                alpha_mask = alpha_mask & player_present
                            
                            if keep_remove_var == 'Keep':
                                parsed_frame = parsed_frame[alpha_mask]
                            else:  # Remove
                                parsed_frame = parsed_frame[~alpha_mask]
                        
                        st.session_state['export_base'] = parsed_frame.sort_values(by='median', ascending=False).reset_index(drop=True)
                        st.session_state['export_merge'] = st.session_state['export_base'].copy()

            with st.expander('Exposure Management'):
                with st.form(key='Exposures'):
                    exposure_player = st.selectbox("Player", options=sorted(list(set(st.session_state['projections_df']['player_names'].unique()))), key='exposure_player')
                    exposure_target = st.number_input("Target Exposure", value=.50, min_value=0.0, max_value=1.0, step=0.01)
                    if 'Stack' in st.session_state['working_frame'].columns:
                        ignore_stacks = st.multiselect("Ignore Specific Stacks?", options=sorted(list(set(st.session_state['projections_df']['team'].unique()))), default=[])
                    else:
                        ignore_stacks = []
                    remove_teams_exposure = st.multiselect("Removed/Locked teams?", options=sorted(list(set(st.session_state['projections_df']['team'].unique()))), default=[])
                    specific_replacements = st.multiselect("Specific Replacements?", options=sorted(list(set(st.session_state['projections_df']['player_names'].unique()))), default=[])
                    # Considering making it so Showdown is CPT/FLEX not column specific but eh
                    specific_columns = st.multiselect("Specific Positions?", options=sorted(list(st.session_state['player_columns'])), default=[])
                    submitted_col, export_col = st.columns(2)
                    st.info("Portfolio Button applies to your overall Portfolio, Export button applies to your Custom Export")
                    with submitted_col:
                        reg_submitted = st.form_submit_button("Portfolio")
                    with export_col:
                        exp_submitted = st.form_submit_button("Export")
                    if reg_submitted:
                        st.session_state['settings_base'] = False
                        # Prepare DataFrame for exposure_spread to avoid categorical issues
                        working_frame_prepared = prepare_dataframe_for_exposure_spread(st.session_state['working_frame'], st.session_state['player_columns'])
                        parsed_frame = exposure_spread(working_frame_prepared, st.session_state['exposure_player'], exposure_target, ignore_stacks, remove_teams_exposure, specific_replacements, specific_columns, st.session_state['projections_df'], sport_var, type_var, salary_max, stacking_sports)
                        
                        # Use consolidated calculation function
                        parsed_frame = calculate_lineup_metrics(
                            parsed_frame, 
                            st.session_state['player_columns'], 
                            st.session_state['map_dict'], 
                            type_var, 
                            sport_var, 
                            st.session_state['projections_df']
                        )
                        
                        st.session_state['working_frame'] = parsed_frame.reset_index(drop=True)
                        
                        # 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['working_frame'] = reassess_edge(st.session_state['working_frame'], st.session_state['base_frame'], st.session_state['map_dict'], site_var, type_var, Contest_Size, strength_var, sport_var, salary_max)
                        team_dict = dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['team']))
                        st.session_state['working_frame']['Stack'] = st.session_state['working_frame'].apply(
                            lambda row: Counter(
                                team_dict.get(player, '') for player in row[stack_column_dict[site_var][type_var][sport_var]]
                                if team_dict.get(player, '') != ''
                            ).most_common(1)[0][0] if any(team_dict.get(player, '') for player in row[stack_column_dict[site_var][type_var][sport_var]]) else '',
                            axis=1
                        )
                        st.session_state['working_frame']['Size'] = st.session_state['working_frame'].apply(
                            lambda row: Counter(
                                team_dict.get(player, '') for player in row[stack_column_dict[site_var][type_var][sport_var]]
                                if team_dict.get(player, '') != ''
                            ).most_common(1)[0][1] if any(team_dict.get(player, '') for player in row[stack_column_dict[site_var][type_var][sport_var]]) else 0,
                            axis=1
                        )
                        st.session_state['export_merge'] = st.session_state['working_frame'].copy()
                    elif exp_submitted:
                        st.session_state['settings_base'] = False
                        # Prepare DataFrame for exposure_spread to avoid categorical issues
                        export_base_prepared = prepare_dataframe_for_exposure_spread(st.session_state['export_base'], st.session_state['player_columns'])
                        parsed_frame = exposure_spread(export_base_prepared, st.session_state['exposure_player'], exposure_target, ignore_stacks, remove_teams_exposure, specific_replacements, specific_columns, st.session_state['projections_df'], sport_var, type_var, salary_max, stacking_sports)
                        
                        # Use consolidated calculation function for export
                        parsed_frame = calculate_lineup_metrics(
                            parsed_frame, 
                            st.session_state['player_columns'], 
                            st.session_state['map_dict'], 
                            type_var, 
                            sport_var, 
                            st.session_state['projections_df']
                        )

                        
                        st.session_state['export_base'] = parsed_frame.reset_index(drop=True)
                        
                        # st.session_state['export_base'] = predict_dupes(st.session_state['export_base'], st.session_state['map_dict'], site_var, type_var, Contest_Size, strength_var, sport_var)
                        st.session_state['export_base'] = reassess_edge(st.session_state['export_base'], st.session_state['base_frame'], st.session_state['map_dict'], site_var, type_var, Contest_Size, strength_var, sport_var, salary_max)
                        team_dict = dict(zip(st.session_state['projections_df']['player_names'], st.session_state['projections_df']['team']))
                        st.session_state['working_frame']['Stack'] = st.session_state['working_frame'].apply(
                            lambda row: Counter(
                                team_dict.get(player, '') for player in row[stack_column_dict[site_var][type_var][sport_var]]
                                if team_dict.get(player, '') != ''
                            ).most_common(1)[0][0] if any(team_dict.get(player, '') for player in row[stack_column_dict[site_var][type_var][sport_var]]) else '',
                            axis=1
                        )
                        st.session_state['working_frame']['Size'] = st.session_state['working_frame'].apply(
                            lambda row: Counter(
                                team_dict.get(player, '') for player in row[stack_column_dict[site_var][type_var][sport_var]]
                                if team_dict.get(player, '') != ''
                            ).most_common(1)[0][1] if any(team_dict.get(player, '') for player in row[stack_column_dict[site_var][type_var][sport_var]]) else 0,
                            axis=1
                        )
                        st.session_state['export_merge'] = st.session_state['export_base'].copy()
                        
        with st.container():
            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':
                st.session_state['display_frame'] = st.session_state['working_frame']
                st.session_state['export_file'] = st.session_state['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':
                st.session_state['display_frame'] = st.session_state['export_base']
                st.session_state['export_file'] = st.session_state['display_frame'].copy()
                
                for col in st.session_state['export_file'].columns:
                    if col not in excluded_cols:
                        # Create position-specific export dictionary on the fly
                        position_dict = create_position_export_dict(col, st.session_state['csv_file'], site_var, type_var, sport_var)
                        st.session_state['export_file'][col] = st.session_state['export_file'][col].map(position_dict)
            
            if 'export_file' in st.session_state:
                download_port, merge_port, clear_export, add_rows_col, remove_rows_col, blank_export_col = st.columns([1, 1, 1, 2, 2, 6])
                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 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':
                            st.session_state['display_frame'] = st.session_state['working_frame']
                        elif display_frame_source == 'Export Base':
                            st.session_state['display_frame'] = st.session_state['export_base']
                    
                with add_rows_col:
                    select_custom_index = st.multiselect("Select rows to add (based on first column):", options=st.session_state['display_frame'].index, default=[])
                    if st.button("Add selected to Custom Export"):
                        st.session_state['export_base'] = pd.concat([st.session_state['export_base'], st.session_state['display_frame'].loc[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 remove_rows_col:
                    remove_custom_index = st.multiselect("Remove rows (based on first column):", options=st.session_state['display_frame'].index, default=[])
                    if st.button("Remove selected from Display"):
                        st.session_state['display_frame'] = st.session_state['display_frame'].drop(remove_custom_index)
                    st.session_state['display_frame'] = st.session_state['display_frame'].drop_duplicates()
                    st.session_state['display_frame'] = st.session_state['display_frame'].reset_index(drop=True)
                    

            total_rows = len(st.session_state['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 = st.session_state['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),
                column_config={
                    "Finish_percentile": st.column_config.NumberColumn(
                        "Finish%",
                        help="Projected finishing percentile",
                        width="small",
                        min_value=0.0,
                        max_value=1.0
                    ),
                    "Lineup Edge": st.column_config.NumberColumn(
                        "Edge",
                        help="Projected lineup edge",
                        width="small",
                        min_value=-1.0,
                        max_value=1.0
                    ),
                    "Diversity": st.column_config.NumberColumn(
                        "Diversity",
                        help="Projected lineup diversity",
                        width="small",
                        min_value=0.0,
                        max_value=1.0
                    ),
                },
                height=499,
                use_container_width=True
            )
        player_stats_col, stack_stats_col, combos_col = st.tabs(['Player Stats', 'Stack Stats', 'Combos'])
        with player_stats_col:
            if st.button("Analyze Players", key='analyze_players'):
                player_stats = []
                
                if st.session_state['settings_base'] and 'origin_player_exposures' in st.session_state and display_frame_source == 'Portfolio':
                    st.session_state['player_summary'] = st.session_state['origin_player_exposures']
                else:
                    if type_var == 'Showdown':
                        if sport_var == 'GOLF':
                            for player in player_names:
                                player_mask = st.session_state['display_frame'][st.session_state['player_columns']].apply(
                                    lambda row: player in list(row), axis=1
                                )
                                
                                if player_mask.any():
                                    player_stats.append({
                                        'Player': player,
                                        'Position': st.session_state['map_dict']['pos_map'][player],
                                        'Lineup Count': player_mask.sum(),
                                        'Exposure': player_mask.sum() / len(st.session_state['display_frame']),
                                        'Avg Median': st.session_state['display_frame'][player_mask]['median'].mean(),
                                        'Avg Own': st.session_state['display_frame'][player_mask]['Own'].mean(),
                                        'Avg Dupes': st.session_state['display_frame'][player_mask]['Dupes'].mean(),
                                        'Avg Finish %': st.session_state['display_frame'][player_mask]['Finish_percentile'].mean(),
                                        'Avg Lineup Edge': st.session_state['display_frame'][player_mask]['Lineup Edge'].mean(),
                                        'Avg Diversity': st.session_state['display_frame'][player_mask]['Diversity'].mean(),
                                    })
                        else:
                            for player in player_names:
                                # Create mask for lineups where this player is Captain (first column)
                                cpt_mask = st.session_state['display_frame'][st.session_state['player_columns'][0]] == player
                                
                                if cpt_mask.any():
                                    player_stats.append({
                                        'Player': f"{player} (CPT)",
                                        'Position': st.session_state['map_dict']['pos_map'][player],
                                        'Lineup Count': cpt_mask.sum(),
                                        'Exposure': cpt_mask.sum() / len(st.session_state['display_frame']),
                                        'Avg Median': st.session_state['display_frame'][cpt_mask]['median'].mean(),
                                        'Avg Own': st.session_state['display_frame'][cpt_mask]['Own'].mean(),
                                        'Avg Dupes': st.session_state['display_frame'][cpt_mask]['Dupes'].mean(),
                                        'Avg Finish %': st.session_state['display_frame'][cpt_mask]['Finish_percentile'].mean(),
                                        'Avg Lineup Edge': st.session_state['display_frame'][cpt_mask]['Lineup Edge'].mean(),
                                        'Avg Diversity': st.session_state['display_frame'][cpt_mask]['Diversity'].mean(),
                                    })
                                
                                # Create mask for lineups where this player is FLEX (other columns)
                                flex_mask = st.session_state['display_frame'][st.session_state['player_columns'][1:]].apply(
                                    lambda row: player in list(row), axis=1
                                )
                                
                                if flex_mask.any():
                                    player_stats.append({
                                        'Player': f"{player} (FLEX)",
                                        'Position': st.session_state['map_dict']['pos_map'][player],
                                        'Lineup Count': flex_mask.sum(),
                                        'Exposure': flex_mask.sum() / len(st.session_state['display_frame']),
                                        'Avg Median': st.session_state['display_frame'][flex_mask]['median'].mean(),
                                        'Avg Own': st.session_state['display_frame'][flex_mask]['Own'].mean(),
                                        'Avg Dupes': st.session_state['display_frame'][flex_mask]['Dupes'].mean(),
                                        'Avg Finish %': st.session_state['display_frame'][flex_mask]['Finish_percentile'].mean(),
                                        'Avg Lineup Edge': st.session_state['display_frame'][flex_mask]['Lineup Edge'].mean(),
                                        'Avg Diversity': st.session_state['display_frame'][flex_mask]['Diversity'].mean(),
                                    })
                    else:
                        if sport_var == 'CS2' or sport_var == 'LOL':
                            # Handle Captain positions
                            for player in player_names:
                                # Create mask for lineups where this player is Captain (first column)
                                cpt_mask = st.session_state['display_frame'][st.session_state['player_columns'][0]] == player
                                
                                if cpt_mask.any():
                                    player_stats.append({
                                        'Player': f"{player} (CPT)",
                                        'Position': st.session_state['map_dict']['pos_map'][player],
                                        'Lineup Count': cpt_mask.sum(),
                                        'Exposure': cpt_mask.sum() / len(st.session_state['display_frame']),
                                        'Avg Median': st.session_state['display_frame'][cpt_mask]['median'].mean(),
                                        'Avg Own': st.session_state['display_frame'][cpt_mask]['Own'].mean(),
                                        'Avg Dupes': st.session_state['display_frame'][cpt_mask]['Dupes'].mean(),
                                        'Avg Finish %': st.session_state['display_frame'][cpt_mask]['Finish_percentile'].mean(),
                                        'Avg Lineup Edge': st.session_state['display_frame'][cpt_mask]['Lineup Edge'].mean(),
                                        'Avg Diversity': st.session_state['display_frame'][cpt_mask]['Diversity'].mean(),
                                    })
                                
                                # Create mask for lineups where this player is FLEX (other columns)
                                flex_mask = st.session_state['display_frame'][st.session_state['player_columns'][1:]].apply(
                                    lambda row: player in list(row), axis=1
                                )
                                
                                if flex_mask.any():
                                    player_stats.append({
                                        'Player': f"{player} (FLEX)",
                                        'Position': st.session_state['map_dict']['pos_map'][player],
                                        'Lineup Count': flex_mask.sum(),
                                        'Exposure': flex_mask.sum() / len(st.session_state['display_frame']),
                                        'Avg Median': st.session_state['display_frame'][flex_mask]['median'].mean(),
                                        'Avg Own': st.session_state['display_frame'][flex_mask]['Own'].mean(),
                                        'Avg Dupes': st.session_state['display_frame'][flex_mask]['Dupes'].mean(),
                                        'Avg Finish %': st.session_state['display_frame'][flex_mask]['Finish_percentile'].mean(),
                                        'Avg Lineup Edge': st.session_state['display_frame'][flex_mask]['Lineup Edge'].mean(),
                                        'Avg Diversity': st.session_state['display_frame'][flex_mask]['Diversity'].mean(),
                                    })
                        elif sport_var != 'CS2' and sport_var != 'LOL':
                            # Original Classic format processing
                            for player in player_names:
                                player_mask = st.session_state['display_frame'][st.session_state['player_columns']].apply(
                                    lambda row: player in list(row), axis=1
                                )
                                
                                if player_mask.any():
                                    player_stats.append({
                                        'Player': player,
                                        'Position': st.session_state['map_dict']['pos_map'][player],
                                        'Lineup Count': player_mask.sum(),
                                        'Exposure': player_mask.sum() / len(st.session_state['display_frame']),
                                        'Avg Median': st.session_state['display_frame'][player_mask]['median'].mean(),
                                        'Avg Own': st.session_state['display_frame'][player_mask]['Own'].mean(),
                                        'Avg Dupes': st.session_state['display_frame'][player_mask]['Dupes'].mean(),
                                        'Avg Finish %': st.session_state['display_frame'][player_mask]['Finish_percentile'].mean(),
                                        'Avg Lineup Edge': st.session_state['display_frame'][player_mask]['Lineup Edge'].mean(),
                                        'Avg Diversity': st.session_state['display_frame'][player_mask]['Diversity'].mean(),
                                    })
                    
                    player_summary = pd.DataFrame(player_stats)
                    player_summary = player_summary.sort_values('Lineup Count', ascending=False)
                    st.session_state['player_summary'] = player_summary.copy()
                    if 'origin_player_exposures' not in st.session_state:
                        st.session_state['origin_player_exposures'] = player_summary.copy()
                
                st.subheader("Player Summary")
                st.dataframe(
                    st.session_state['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%}',
                        'Avg Diversity': '{:.2%}'
                    }),
                    height=400,
                    use_container_width=True
                )
        
        with stack_stats_col:
            if 'Stack' in st.session_state['display_frame'].columns:
                if st.button("Analyze Stacks", key='analyze_stacks'):
                    stack_stats = []
                    stack_columns = [col for col in st.session_state['display_frame'].columns if col.startswith('Stack')]

                    if st.session_state['settings_base'] and 'origin_stack_exposures' in st.session_state and display_frame_source == 'Portfolio':
                        st.session_state['stack_summary'] = st.session_state['origin_stack_exposures']
                    else:
                        for stack in st.session_state['stack_dict'].values():
                            stack_mask = st.session_state['display_frame']['Stack'] == stack
                            if stack_mask.any():
                                stack_stats.append({
                                    'Stack': stack,
                                    'Lineup Count': stack_mask.sum(),
                                    'Exposure': stack_mask.sum() / len(st.session_state['display_frame']),
                                    'Avg Median': st.session_state['display_frame'][stack_mask]['median'].mean(),
                                    'Avg Own': st.session_state['display_frame'][stack_mask]['Own'].mean(),
                                    'Avg Dupes': st.session_state['display_frame'][stack_mask]['Dupes'].mean(),
                                    'Avg Finish %': st.session_state['display_frame'][stack_mask]['Finish_percentile'].mean(),
                                    'Avg Lineup Edge': st.session_state['display_frame'][stack_mask]['Lineup Edge'].mean(),
                                    'Avg Diversity': st.session_state['display_frame'][stack_mask]['Diversity'].mean(),
                                })
                        stack_summary = pd.DataFrame(stack_stats)
                        stack_summary = stack_summary.sort_values('Lineup Count', ascending=False).drop_duplicates()
                        st.session_state['stack_summary'] = stack_summary.copy()
                        if 'origin_stack_exposures' not in st.session_state:
                            st.session_state['origin_stack_exposures'] = stack_summary.copy()

                    st.subheader("Stack Summary")
                    st.dataframe(
                        st.session_state['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%}',
                            'Avg Diversity': '{:.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'])
            
            with combos_col:
                st.subheader("Player Combinations")
                
                # Add controls for combo analysis
                with st.form("combo_analysis_form"):
                    combo_size_col, columns_excluded_col, combo_analyze_col = st.columns(3)
                    with combo_size_col:
                        combo_size = st.selectbox("Combo Size", [2, 3], key='combo_size')
                    with columns_excluded_col:
                        try:
                            excluded_cols_extended = st.multiselect("Exclude Columns?", st.session_state['display_frame'].drop(columns=excluded_cols).columns, key='excluded_cols_extended')
                        except:
                            excluded_cols_extended = st.multiselect("Exclude Columns?", st.session_state['display_frame'].columns, key='excluded_cols_extended')
                    with combo_analyze_col:
                        submitted = st.form_submit_button("Analyze Combos")
                        if submitted:
                            st.session_state['combo_analysis'] = analyze_player_combos(
                                st.session_state['display_frame'], excluded_cols + excluded_cols_extended, combo_size
                            )
                
                # Display results
                if 'combo_analysis' in st.session_state:
                    st.dataframe(
                        st.session_state['combo_analysis'].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%}',
                            'Avg Diversity': '{:.2%}'
                        }),
                        height=400,
                        use_container_width=True
                    )
                else:
                    st.info("Click 'Analyze Combos' to see the most common player combinations.")