Update src/streamlit_app.py

src/streamlit_app.py

@@ -1,1031 +1,291 @@
 import streamlit as st
 import pandas as pd
 import numpy as np
-import plotly.express as px
-import plotly.graph_objects as go
-from plotly.subplots import make_subplots
 import requests
-from bs4 import BeautifulSoup # New import
-import re # New import for regex
-import time # For rate limiting
-from datetime import datetime
-import json
 import os
+from datetime import datetime
 
-
-# -----------------------------------------------------------------------
-
-# Page configuration
-st.set_page_config(
-    page_title="NBA Analytics Hub",
-    page_icon="🏀",
-    layout="wide",
-    initial_sidebar_state="expanded"
-)
-
-# Custom CSS
+# —————————————————————————————————————————————————————————————————————————————
+# CSS (black & white theme)
 st.markdown("""
 <style>
-    .main-header {
-        font-size: 3rem;
-        font-weight: bold;
-        text-align: center;
-        color: #1f77b4;
-        margin-bottom: 2rem;
-    }
-    .section-header {
-        font-size: 1.5rem;
-        font-weight: bold;
-        color: #2e8b57;
-        margin: 1rem 0;
-    }
-    .metric-card {
-        background-color: #f0f2f6;
-        padding: 1rem;
-        border-radius: 10px;
-        margin: 0.5rem 0;
-    }
+  .main-header {font-size:3rem; font-weight:bold; text-align:center; color:#000;}
+  .section-header {font-size:1.5rem; font-weight:bold; color:#333; margin:1rem 0;}
+  table.dataframe {width:100%;}
 </style>
 """, unsafe_allow_html=True)
 
-# Initialize session state
-if 'chat_history' not in st.session_state:
-    st.session_state.chat_history = []
-
-# Perplexity API configuration
-PERPLEXITY_API_KEY = os.getenv("PERPLEXITY_API_KEY")
-PERPLEXITY_API_URL = "https://api.perplexity.ai/chat/completions"
-
-# Base URL for Basketball-Reference
-BBR_BASE_URL = "https://www.basketball-reference.com"
-
-# Hardcoded Team Name to BBR Abbreviation mapping
-# This is more reliable than scraping for team abbreviations.
-TEAM_NAME_TO_BBR_ABBR = {
-    "Atlanta Hawks": "ATL", "Boston Celtics": "BOS", "Brooklyn Nets": "BRK",
-    "Charlotte Hornets": "CHO", "Chicago Bulls": "CHI", "Cleveland Cavaliers": "CLE",
-    "Dallas Mavericks": "DAL", "Denver Nuggets": "DEN", "Detroit Pistons": "DET",
-    "Golden State Warriors": "GSW", "Houston Rockets": "HOU", "Indiana Pacers": "IND",
-    "Los Angeles Clippers": "LAC", "Los Angeles Lakers": "LAL", "Memphis Grizzlies": "MEM",
-    "Miami Heat": "MIA", "Milwaukee Bucks": "MIL", "Minnesota Timberwolves": "MIN",
-    "New Orleans Pelicans": "NOP", "New York Knicks": "NYK", "Oklahoma City Thunder": "OKC",
-    "Orlando Magic": "ORL", "Philadelphia 76ers": "PHI", "Phoenix Suns": "PHO",
-    "Portland Trail Blazers": "POR", "Sacramento Kings": "SAC", "San Antonio Spurs": "SAS",
-    "Toronto Raptors": "TOR", "Utah Jazz": "UTA", "Washington Wizards": "WAS"
-}
-
-# Mapping for season year in BBR URLs (e.g., 2023-24 -> 2024)
-BBR_SEASON_URL_MAP = {
-    "2023-24": "2024", "2022-23": "2023", "2021-22": "2022",
-    "2020-21": "2021", "2019-20": "2020", "2018-19": "2019",
-    "2017-18": "2018", "2016-17": "2017", "2015-16": "2016",
-    "2014-15": "2015", "2013-14": "2014", "2012-13": "2013",
-    "2011-12": "2012", "2010-11": "2011", "2009-10": "2010"
-}
-
-
-# ---------- Perplexity API Functions ----------
-def get_perplexity_response(api_key, prompt, system_message="You are a helpful NBA analyst AI.", max_tokens=500, temperature=0.2):
-    """
-    Queries the Perplexity AI API with a given prompt and system message.
-    """
-    if not api_key:
-        st.error("Perplexity API Key is not set. Please configure it as an environment variable (PERPLEXITY_API_KEY).")
-        return None
-
-    headers = {
-        'Authorization': f'Bearer {api_key}',
-        'Content-Type': 'application/json'
-    }
-    payload = {
-        'model': 'sonar-pro', # keep 'sonar-pro' 
-        'messages': [
-            {'role': 'system', 'content': system_message},
-            {'role': 'user', 'content': prompt}
-        ],
-        "max_tokens": max_tokens,
-        "temperature": temperature
-    }
-    try:
-        with st.spinner("Querying Perplexity AI..."):
-            response = requests.post(PERPLEXITY_API_URL, headers=headers, json=payload, timeout=45)
-            response.raise_for_status() # Raise HTTPError for bad responses (4xx or 5xx)
-        data = response.json()
-        return data.get('choices', [{}])[0].get('message', {}).get('content', '')
-    except requests.exceptions.RequestException as e:
-        error_message = f"Error communicating with Perplexity API: {e}"
-        if e.response is not None:
-            try:
-                error_detail = e.response.json().get("error", {}).get("message", e.response.text)
-                error_message = f"Perplexity API error: {error_detail}"
-            except ValueError: # If response is not valid JSON
-                error_message = f"Perplexity API error: {e.response.status_code} - {e.response.reason}"
-        st.error(error_message)
-        return None
-    except Exception as e:
-        st.error(f"An unexpected error occurred with Perplexity API: {e}")
-        return None
-
-# ---------- Basketball-Reference Data Fetching Functions ----------
-
-@st.cache_data(ttl=3600)
-def get_all_players_bbr():
-    """
-    Scrapes a list of active players from Basketball-Reference's 2024 per-game stats page.
-    Note: This will not get ALL historical players, only those listed on this specific page.
-    For a comprehensive list, a more extensive scrape of player index pages (A-Z) would be needed.
-    """
-    players_list = []
-    url = f"{BBR_BASE_URL}/leagues/NBA_2024_per_game.html" # Using 2024 for current season
-    try:
-        response = requests.get(url, timeout=10)
-        response.raise_for_status()
-        soup = BeautifulSoup(response.content, 'lxml')
-        table = soup.find('table', {'id': 'per_game_stats'})
-        if table:
-            for row in table.find_all('tr')[1:]: # Skip header row
-                player_name_tag = row.find('a')
-                if player_name_tag:
-                    player_name = player_name_tag.get_text()
-                    # BBR player ID is part of the href (e.g., /players/j/jamesle01.html)
-                    player_bbr_id = player_name_tag['href'].split('/')[-1].replace('.html', '')
-                    players_list.append({'full_name': player_name, 'id': player_bbr_id})
-            st.success(f"Loaded {len(players_list)} players from Basketball-Reference.")
-        else:
-            st.warning(f"Could not find player stats table on {url}")
-    except requests.exceptions.RequestException as e:
-        st.error(f"Error fetching player list from Basketball-Reference: {e}")
-    except Exception as e:
-        st.error(f"An unexpected error occurred while parsing player list: {e}")
-    return players_list
-
+# —————————————————————————————————————————————————————————————————————————————
+# Caching helpers
 @st.cache_data(ttl=3600)
-def get_all_teams_bbr():
-    """
-    Returns a list of NBA teams using a hardcoded mapping.
-    """
-    teams_list = []
-    for full_name, abbr in TEAM_NAME_TO_BBR_ABBR.items():
-        teams_list.append({'full_name': full_name, 'id': abbr}) # Using abbr as ID for consistency
-    return teams_list
-
-@st.cache_data(ttl=300)
-def get_player_stats_bbr(player_name, season="2023-24"):
-    """
-    Scrapes player career stats for a given player from Basketball-Reference.
-    Then filters for the specified season.
-    Returns a DataFrame.
-    """
-    # Step 1: Find the player's BBR URL by searching
-    search_url = f"{BBR_BASE_URL}/search/search.fcgi?search={player_name.replace(' ', '+')}"
-    player_url = None
+def fetch_table(url, idx=0):
     try:
-        search_response = requests.get(search_url, timeout=10)
-        search_response.raise_for_status()
-        search_soup = BeautifulSoup(search_response.content, 'lxml')
-        # Look for a link to the player's page in the search results
-        # This assumes the first search result is the correct player
-        player_link_div = search_soup.find('div', {'class': 'search-item-name'})
-        if player_link_div:
-            player_link = player_link_div.find('a')
-            if player_link and player_link['href'].startswith('/players/'):
-                player_url = f"{BBR_BASE_URL}{player_link['href']}"
-        if not player_url:
-            st.warning(f"Could not find Basketball-Reference page for {player_name}.")
-            return pd.DataFrame()
-    except requests.exceptions.RequestException as e:
-        st.error(f"Error searching for player {player_name} on Basketball-Reference: {e}")
-        return pd.DataFrame()
+        resp = requests.get(url, timeout=20)
+        resp.raise_for_status()
+        dfs = pd.read_html(resp.text)
+        return dfs[idx]
     except Exception as e:
-        st.error(f"An unexpected error occurred during player search for {player_name}: {e}")
+        st.error(f"Failed to fetch {url}: {e}")
         return pd.DataFrame()
 
-    # Step 2: Scrape the player's page for career stats
-    try:
-        response = requests.get(player_url, timeout=10)
-        response.raise_for_status()
-        soup = BeautifulSoup(response.content, 'lxml')
+# —————————————————————————————————————————————————————————————————————————————
+# Basketball-Reference scrapers
 
-        # Basketball-Reference often hides tables in comments.
-        # Find the comment containing the 'per_game' table
-        comment = soup.find(string=lambda text: isinstance(text, str) and 'id="per_game"' in text)
-        if comment:
-            soup_from_comment = BeautifulSoup(comment, 'lxml')
-            table = soup_from_comment.find('table', {'id': 'per_game'})
-        else:
-            table = soup.find('table', {'id': 'per_game'}) # Try direct find if not in comment
-
-        if table:
-            df = pd.read_html(str(table))[0]
-            # Clean up column names (remove special characters, make consistent)
-            # Handle multi-index columns if present (e.g., 'Shooting' -> 'FG', 'FGA')
-            if isinstance(df.columns, pd.MultiIndex):
-                df.columns = ['_'.join(col).strip() for col in df.columns.values]
-            else:
-                df.columns = [col.strip() for col in df.columns.values]
-
-            # Standardize column names to match original app's expectations
-            df = df.rename(columns={
-                'Season': 'SEASON_ID_BBR', # Keep original BBR season for filtering
-                'Age': 'AGE', 'Tm': 'TEAM_ABBREVIATION', 'Lg': 'LEAGUE_ID', 'Pos': 'POSITION',
-                'G': 'GP', 'GS': 'GS', 'MP': 'MIN',
-                'FG': 'FGM', 'FGA': 'FGA', 'FG%': 'FG_PCT',
-                '3P': 'FG3M', '3PA': 'FG3A', '3P%': 'FG3_PCT',
-                '2P': 'FGM2', '2PA': 'FGA2', '2P%': 'FG2_PCT',
-                'eFG%': 'EFG_PCT', 'FT': 'FTM', 'FTA': 'FTA', 'FT%': 'FT_PCT',
-                'ORB': 'OREB', 'DRB': 'DREB', 'TRB': 'REB', 'AST': 'AST',
-                'STL': 'STL', 'BLK': 'BLK', 'TOV': 'TO', 'PF': 'PF', 'PTS': 'PTS'
-            })
-
-            # Filter for the specific season
-            # BBR table's 'Season' column is like '2023-24', not just '2024' for the row.
-            # So, we filter using the original `season` string.
-            filtered_df = df[df['SEASON_ID_BBR'] == season].copy()
-
-            if not filtered_df.empty:
-                # Add PLAYER_NAME and SEASON_ID for consistency with original code
-                filtered_df['PLAYER_NAME'] = player_name
-                filtered_df['SEASON_ID'] = season # Keep original season format
-                return filtered_df
-            else:
-                st.info(f"No stats found for {player_name} in season {season} on Basketball-Reference.")
-                return pd.DataFrame()
-        else:
-            st.warning(f"Could not find 'per_game' table for {player_name} on Basketball-Reference.")
-            return pd.DataFrame()
-    except requests.exceptions.RequestException as e:
-        st.error(f"Error fetching player stats for {player_name} from Basketball-Reference: {e}")
-        return pd.DataFrame()
-    except Exception as e:
-        st.error(f"An unexpected error occurred while parsing player stats for {player_name}: {e}")
-        return pd.DataFrame()
+@st.cache_data(ttl=3600)
+def get_player_index():
+    base = "https://www.basketball-reference.com/players/"
+    rows = []
+    for letter in map(chr, range(ord('a'), ord('z')+1)):
+        df = fetch_table(f"{base}{letter}/")
+        if df.empty: continue
+        for _, r in df.iterrows():
+            raw = r['Player']
+            href = raw.split('href="')[1].split('"')[0]
+            name = raw.split('>')[1].split('<')[0]
+            rows.append({'name': name, 'url': f"https://www.basketball-reference.com{href}"})
+    return pd.DataFrame(rows)
 
 @st.cache_data(ttl=300)
-def get_team_stats_bbr(team_name, season="2023-24"):
-    """
-    Scrapes team stats for a given team and season from Basketball-Reference.
-    Returns a DataFrame.
-    """
-    team_abbr = TEAM_NAME_TO_BBR_ABBR.get(team_name)
-    if not team_abbr:
-        st.error(f"Could not find abbreviation for team: {team_name}")
+def player_season_stats(bbr_url):
+    df = fetch_table(bbr_url, 0)
+    if 'Season' not in df.columns:
         return pd.DataFrame()
+    df = df[df['Season']!='Season']
+    df['Season'] = df['Season'].astype(str)
+    nonnum = ['Season','Tm','Lg','Pos']
+    for c in df.columns.difference(nonnum):
+        df[c] = pd.to_numeric(df[c], errors='coerce')
+    return df
 
-    bbr_season_year = BBR_SEASON_URL_MAP.get(season)
-    if not bbr_season_year:
-        st.warning(f"Invalid season format for Basketball-Reference: {season}")
-        return pd.DataFrame()
-
-    url = f"{BBR_BASE_URL}/teams/{team_abbr}/{bbr_season_year}.html"
-
+@st.cache_data(ttl=300)
+def team_per_game(year):
+    url = f"https://www.basketball-reference.com/leagues/NBA_{year}_per_game.html"
+    df = fetch_table(url)
+    if df.empty: return df
+    df = df[df['Player']!='Player']
+    df.rename(columns={'Team':'Tm'}, inplace=True)
+    for c in df.columns.difference(['Player','Pos','Tm']):
+        df[c] = pd.to_numeric(df[c], errors='coerce')
+    return df
+
+# —————————————————————————————————————————————————————————————————————————————
+# Perplexity integration (unchanged)
+PERP_KEY = os.getenv("PERPLEXITY_API_KEY")
+PERP_URL = "https://api.perplexity.ai/chat/completions"
+
+def ask_perp(prompt, system="You are a helpful NBA analyst AI.", max_tokens=500, temp=0.2):
+    if not PERP_KEY:
+        st.error("Set PERPLEXITY_API_KEY env var.")
+        return ""
+    hdr = {'Authorization':f'Bearer {PERP_KEY}','Content-Type':'application/json'}
+    payload = {
+      "model":"sonar-pro",
+      "messages":[{"role":"system","content":system},{"role":"user","content":prompt}],
+      "max_tokens":max_tokens, "temperature":temp
+    }
     try:
-        response = requests.get(url, timeout=10)
-        response.raise_for_status()
-        soup = BeautifulSoup(response.content, 'lxml')
-
-        # Team stats are usually in a table with id 'team_and_opponent' or similar
-        comment = soup.find(string=lambda text: isinstance(text, str) and 'id="team_and_opponent"' in text)
-        if comment:
-            soup_from_comment = BeautifulSoup(comment, 'lxml')
-            table = soup_from_comment.find('table', {'id': 'team_and_opponent'})
-        else:
-            table = soup.find('table', {'id': 'team_and_opponent'}) # Try direct find
-
-        if table:
-            df = pd.read_html(str(table))[0]
-            # Clean up column names
-            if isinstance(df.columns, pd.MultiIndex):
-                df.columns = ['_'.join(col).strip() for col in df.columns.values]
-            else:
-                df.columns = [col.strip() for col in df.columns.values]
-
-            # Standardize column names
-            df = df.rename(columns={
-                'G': 'GP', 'MP': 'MIN', 'FG': 'FGM', 'FGA': 'FGA', 'FG%': 'FG_PCT',
-                '3P': 'FG3M', '3PA': 'FG3A', '3P%': 'FG3_PCT', 'FT': 'FTM', 'FTA': 'FTA', 'FT%': 'FT_PCT',
-                'TRB': 'REB', 'AST': 'AST', 'STL': 'STL', 'BLK': 'BLK', 'TOV': 'TO', 'PF': 'PF', 'PTS': 'PTS'
-            })
-
-            if not df.empty:
-                # The 'team_and_opponent' table has two main rows: 'Team' and 'Opponent'.
-                # We want the 'Team' row.
-                team_stats_row = df[df['Rk'] == 'Team'].copy()
-                if team_stats_row.empty:
-                    # Fallback: if 'Rk' isn't 'Team', try the first row (common for overall team stats)
-                    team_stats_row = df.iloc[[0]].copy()
-
-                if not team_stats_row.empty:
-                    team_stats_row['TEAM_NAME'] = team_name
-                    team_stats_row['SEASON'] = season
-                    return team_stats_row
-                else:
-                    st.info(f"Could not extract team stats row for {team_name} in season {season}.")
-                    return pd.DataFrame()
-            else:
-                st.info(f"No stats found for team {team_name} in season {season} on Basketball-Reference.")
-                return pd.DataFrame()
-        else:
-            st.warning(f"Could not find team stats table for {team_name} on Basketball-Reference.")
-            return pd.DataFrame()
-    except requests.exceptions.RequestException as e:
-        st.error(f"Error fetching team stats for {team_name} from Basketball-Reference: {e}")
-        return pd.DataFrame()
+        r = requests.post(PERP_URL, json=payload, headers=hdr, timeout=45)
+        r.raise_for_status()
+        return r.json().get("choices", [{}])[0].get("message",{}).get("content","")
     except Exception as e:
-        st.error(f"An unexpected error occurred while parsing team stats for {team_name}: {e}")
-        return pd.DataFrame()
+        st.error(f"Perplexity error: {e}")
+        return ""
 
-# Redefine the main data fetching functions to use Basketball-Reference versions
-@st.cache_data(ttl=3600)
-def get_all_players():
-    """Get all NBA players (from BBR)."""
-    return get_all_players_bbr()
-
-@st.cache_data(ttl=3600)
-def get_all_teams():
-    """Get all NBA teams (from BBR)."""
-    return get_all_teams_bbr()
-
-@st.cache_data(ttl=300)
-def get_player_stats(player_name, season="2023-24"):
-    """Get player stats (from BBR)."""
-    return get_player_stats_bbr(player_name, season)
-
-@st.cache_data(ttl=300)
-def get_team_stats(team_name, season="2023-24"):
-    """Get team stats (from BBR)."""
-    return get_team_stats_bbr(team_name, season)
-
-
-def create_comparison_chart(data, players_names, metric):
-    """Create comparison chart for players"""
-    fig = go.Figure()
-
-    for i, player in enumerate(players_names):
-        if player in data['PLAYER_NAME'].values:
-            player_data = data[data['PLAYER_NAME'] == player]
-            fig.add_trace(go.Scatter(
-                x=player_data['SEASON_ID'],
-                y=player_data[metric],
-                mode='lines+markers',
-                name=player,
-                line=dict(width=3)
-            ))
-
-    fig.update_layout(
-        title=f"{metric} Comparison",
-        xaxis_title="Season",
-        yaxis_title=metric,
-        hovermode='x unified',
-        height=500
-    )
-
-    return fig
-
-def create_radar_chart(player_stats, categories):
-    """Create radar chart for player comparison"""
-    fig = go.Figure()
-
-    for player_name, stats in player_stats.items():
-        # Ensure all categories are present, default to 0 if not
-        r_values = [stats.get(cat, 0) for cat in categories]
-
-        fig.add_trace(go.Scatterpolar(
-            r=r_values,
-            theta=categories,
-            fill='toself',
-            name=player_name,
-            opacity=0.7
-        ))
-
-    fig.update_layout(
-        polar=dict(
-            radialaxis=dict(
-                visible=True,
-                # The range should be adjusted based on the scaled data (0-100)
-                range=[0, 100]
-            )),
-        showlegend=True,
-        title="Player Comparison Radar Chart"
-    )
-
-    return fig
-
-# Main app
+# —————————————————————————————————————————————————————————————————————————————
 def main():
-    st.markdown('<h1 class="main-header">🏀 NBA Analytics Hub</h1>', unsafe_allow_html=True)
-
-    # Sidebar navigation
+    st.markdown('<h1 class="main-header">🏀 NBA Analytics Hub (BBR Edition)</h1>', unsafe_allow_html=True)
     st.sidebar.title("Navigation")
-    page = st.sidebar.selectbox(
-        "Choose Analysis Type",
-        [
-            "Player vs Player Comparison",
-            "Team vs Team Analysis",
-            "NBA Awards Predictor",
-            "AI Chat & Insights",
-            "Young Player Projections",
-            "Similar Players Finder",
-            "Roster Builder"
-        ]
-    )
-
-    if page == "Player vs Player Comparison":
-        player_comparison_page()
-    elif page == "Team vs Team Analysis":
-        team_comparison_page()
-    elif page == "NBA Awards Predictor":
-        awards_predictor_page()
-    elif page == "AI Chat & Insights":
-        ai_chat_page()
-    elif page == "Young Player Projections":
-        young_player_projections_page()
-    elif page == "Similar Players Finder":
-        similar_players_page()
-    elif page == "Roster Builder":
-        roster_builder_page()
-
-def player_comparison_page():
+    page = st.sidebar.radio("", [
+        "Player vs Player Comparison", "Team vs Team Analysis",
+        "NBA Awards Predictor", "AI Chat & Insights",
+        "Young Player Projections", "Similar Players Finder",
+        "Roster Builder", "Trade Scenario Analyzer"
+    ])
+
+    if page == "Player vs Player Comparison":          player_vs_player()
+    elif page == "Team vs Team Analysis":              team_vs_team()
+    elif page == "NBA Awards Predictor":               awards_predictor()
+    elif page == "AI Chat & Insights":                 ai_chat()
+    elif page == "Young Player Projections":           young_projections()
+    elif page == "Similar Players Finder":             similar_players()
+    elif page == "Roster Builder":                     roster_builder()
+    else:                                              trade_analyzer()
+
+# —————————————————————————————————————————————————————————————————————————————
+def player_vs_player():
     st.markdown('<h2 class="section-header">Player vs Player Comparison</h2>', unsafe_allow_html=True)
-
-    # Get all players
-    all_players = get_all_players() # This now calls get_all_players_bbr()
-    player_names = [player['full_name'] for player in all_players]
-
-    col1, col2 = st.columns(2)
-
-    with col1:
-        selected_players = st.multiselect(
-            "Select Players to Compare (up to 4)",
-            player_names,
-            max_selections=4
-        )
-
-    with col2:
-        seasons = st.multiselect(
-            "Select Seasons",
-            list(BBR_SEASON_URL_MAP.keys()), # Use keys from the BBR season map
-            default=["2023-24"]
-        )
-
-    # Add a button to trigger the comparison
-    if st.button("Run Player Comparison"):
-        if not selected_players:
-            st.warning("Please select at least one player to compare.")
-            return
-
-        # Fetch and display stats
-        stats_tabs = st.tabs(["Basic Stats", "Advanced Stats", "Visualizations"])
-
-        with stats_tabs[0]:
-            st.subheader("Basic Statistics")
-            basic_stats_data = []
-
-            for player_name in selected_players: # Iterate by name directly
-                for season in seasons:
-                    stats_df = get_player_stats(player_name, season) # Pass name and season
-                    if not stats_df.empty:
-                        # BBR returns one row per season, so no need to mean()
-                        # Ensure numeric columns are actually numeric
-                        for col in ['GP', 'MIN', 'PTS', 'REB', 'AST', 'STL', 'BLK', 'FG_PCT', 'FT_PCT', 'FG3_PCT']:
-                            if col in stats_df.columns:
-                                stats_df[col] = pd.to_numeric(stats_df[col], errors='coerce')
-                        basic_stats_data.append(stats_df.iloc[0].to_dict()) # Take the first (and only) row
-
-            if basic_stats_data:
-                comparison_df = pd.DataFrame(basic_stats_data)
-                basic_cols = ['PLAYER_NAME', 'SEASON_ID', 'GP', 'MIN', 'PTS', 'REB', 'AST', 'STL', 'BLK', 'FG_PCT', 'FT_PCT', 'FG3_PCT']
-                display_cols = [col for col in basic_cols if col in comparison_df.columns]
-                st.dataframe(comparison_df[display_cols].round(2), use_container_width=True)
-            else:
-                st.info("No data available for the selected players and seasons.")
-
-        with stats_tabs[1]:
-            st.subheader("Advanced Statistics")
-            if basic_stats_data:
-                advanced_df = pd.DataFrame(basic_stats_data).copy()
-                # Ensure numeric columns for calculations
-                for col in ['PTS', 'FGA', 'FTA']:
-                    if col in advanced_df.columns:
-                        advanced_df[col] = pd.to_numeric(advanced_df[col], errors='coerce')
-
-                # Calculate TS% (True Shooting Percentage)
-                if all(col in advanced_df.columns for col in ['PTS', 'FGA', 'FTA']):
-                    advanced_df['TS_PCT'] = advanced_df.apply(
-                        lambda row: row['PTS'] / (2 * (row['FGA'] + 0.44 * row['FTA'])) if (row['FGA'] + 0.44 * row['FTA']) != 0 else 0,
-                        axis=1
-                    )
-
-                advanced_cols = ['PLAYER_NAME', 'SEASON_ID', 'PTS', 'REB', 'AST', 'FG_PCT', 'TS_PCT'] if 'TS_PCT' in advanced_df.columns else ['PLAYER_NAME', 'SEASON_ID', 'PTS', 'REB', 'AST', 'FG_PCT']
-                display_cols = [col for col in advanced_cols if col in advanced_df.columns]
-                st.dataframe(advanced_df[display_cols].round(3), use_container_width=True)
-            else:
-                st.info("No data available for advanced statistics.")
-
-        with stats_tabs[2]:
-            st.subheader("Player Comparison Charts")
-
-            if basic_stats_data:
-                comparison_df = pd.DataFrame(basic_stats_data)
-                metrics = ['PTS', 'REB', 'AST', 'FG_PCT']
-                available_metrics = [m for m in metrics if m in comparison_df.columns]
-
-                if available_metrics:
-                    selected_metric = st.selectbox("Select Metric to Visualize", available_metrics)
-
-                    if selected_metric:
-                        # Bar chart comparison (for average over selected seasons if multiple seasons selected)
-                        # Or for each season if only one player selected
-                        if len(selected_players) == 1 and len(seasons) > 1:
-                            # Show trend over seasons for one player
-                            fig = px.line(
-                                comparison_df[comparison_df['PLAYER_NAME'] == selected_players[0]],
-                                x='SEASON_ID',
-                                y=selected_metric,
-                                title=f"{selected_players[0]} - {selected_metric} Trend",
-                                markers=True
-                            )
-                        else:
-                            # Average over selected seasons for multiple players for bar chart
-                            avg_comparison_df = comparison_df.groupby('PLAYER_NAME')[available_metrics].mean().reset_index()
-                            fig = px.bar(
-                                avg_comparison_df,
-                                x='PLAYER_NAME',
-                                y=selected_metric,
-                                title=f"Average {selected_metric} Comparison (Selected Seasons)",
-                                color='PLAYER_NAME'
-                            )
-                        st.plotly_chart(fig, use_container_width=True)
-
-                        # Radar chart for multi-metric comparison
-                        radar_metrics_for_chart = ['PTS', 'REB', 'AST', 'STL', 'BLK']
-                        radar_metrics_for_chart = [m for m in radar_metrics_for_chart if m in comparison_df.columns]
-
-                        if len(radar_metrics_for_chart) >= 3:
-                            radar_data = {}
-                            # Use the averaged data for radar chart if multiple seasons
-                            if len(seasons) > 1:
-                                radar_source_df = comparison_df.groupby('PLAYER_NAME')[radar_metrics_for_chart].mean().reset_index()
-                            else:
-                                radar_source_df = comparison_df.copy()
-
-                            scaled_radar_df = radar_source_df.copy()
-
-                            # Simple min-max scaling for radar chart visualization (0-100)
-                            for col in radar_metrics_for_chart:
-                                min_val = scaled_radar_df[col].min()
-                                max_val = scaled_radar_df[col].max()
-                                if max_val > min_val:
-                                    scaled_radar_df[col] = ((scaled_radar_df[col] - min_val) / (max_val - min_val)) * 100
-                                else:
-                                    scaled_radar_df[col] = 0 # Default if all values are the same
-
-                            for _, row in scaled_radar_df.iterrows():
-                                radar_data[row['PLAYER_NAME']] = {
-                                    metric: row[metric] for metric in radar_metrics_for_chart
-                                }
-
-                            if radar_data:
-                                radar_fig = create_radar_chart(radar_data, radar_metrics_for_chart)
-                                st.plotly_chart(radar_fig, use_container_width=True)
-                            else:
-                                st.info("Could not generate radar chart data.")
-                        else:
-                            st.info("Select at least 3 common metrics for a radar chart (e.g., PTS, REB, AST, STL, BLK).")
-                else:
-                    st.info("No common metrics available for visualization.")
-            else:
-                st.info("No data available for visualizations.")
-
-
-def team_comparison_page():
+    idx = get_player_index()
+    names = idx['name'].tolist()
+    sel = st.multiselect("Select Players (up to 4)", names, max_selections=4)
+    seasons = st.multiselect("Select Seasons", ["2023–24","2022–23","2021–22","2020–21"], default=["2023–24"])
+
+    if st.button("Run Comparison"):
+        if not sel: return st.warning("Pick at least one player.")
+        stats = []
+        for p in sel:
+            url = idx.loc[idx.name==p,'url'].iat[0]
+            df = player_season_stats(url)
+            df['Season'] = df['Season'].str.replace('-','–')
+            df = df[df['Season'].isin(seasons)]
+            if df.empty: continue
+            avg = df.mean(numeric_only=True).to_frame().T
+            avg['Player'] = p
+            stats.append(avg)
+        if not stats: return st.info("No data.")
+        comp = pd.concat(stats, ignore_index=True)
+        cols = ['Player','PTS','TRB','AST','STL','BLK','FG%','3P%','FT%']
+        st.dataframe(comp[cols].round(2), use_container_width=True)
+
+def team_vs_team():
     st.markdown('<h2 class="section-header">Team vs Team Analysis</h2>', unsafe_allow_html=True)
-
-    all_teams = get_all_teams() # This now calls get_all_teams_bbr()
-    team_names = [team['full_name'] for team in all_teams]
-
-    col1, col2 = st.columns(2)
-
-    with col1:
-        selected_teams = st.multiselect(
-            "Select Teams to Compare",
-            team_names,
-            max_selections=4
-        )
-
-    with col2:
-        seasons = st.multiselect(
-            "Select Seasons",
-            list(BBR_SEASON_URL_MAP.keys()), # Use keys from the BBR season map
-            default=["2023-24"]
-        )
-
-    # Add a button to trigger the comparison
-    if st.button("Run Team Comparison"):
-        if not selected_teams:
-            st.warning("Please select at least one team to compare.")
-            return
-
-        team_stats_data = []
-
-        for team_name in selected_teams:
-            for season in seasons:
-                stats_df = get_team_stats(team_name, season) # Pass name and season
-                if not stats_df.empty:
-                    # Ensure numeric columns are actually numeric
-                    for col in ['PTS', 'REB', 'AST', 'FG_PCT', 'FG3_PCT', 'FT_PCT']:
-                        if col in stats_df.columns:
-                            stats_df[col] = pd.to_numeric(stats_df[col], errors='coerce')
-                    team_stats_data.append(stats_df.iloc[0].to_dict()) # Take the first (and only) row
-
-        if team_stats_data:
-            team_df = pd.DataFrame(team_stats_data)
-
-            # Display team comparison
-            st.subheader("Team Statistics Comparison")
-            team_cols = ['TEAM_NAME', 'SEASON', 'PTS', 'REB', 'AST', 'FG_PCT', 'FG3_PCT', 'FT_PCT']
-            display_cols = [col for col in team_cols if col in team_df.columns]
-            st.dataframe(team_df[display_cols].round(2), use_container_width=True)
-
-            # Visualization
-            st.subheader("Team Performance Visualization")
-            metric_options = ['PTS', 'REB', 'AST', 'FG_PCT']
-            available_metrics = [m for m in metric_options if m in team_df.columns]
-
-            if available_metrics:
-                selected_metric = st.selectbox("Select Metric", available_metrics)
-
-                fig = px.bar(
-                    team_df,
-                    x='TEAM_NAME',
-                    y=selected_metric,
-                    color='SEASON',
-                    title=f"Team {selected_metric} Comparison",
-                    barmode='group'
-                )
-                st.plotly_chart(fig, use_container_width=True)
-            else:
-                st.info("No common metrics available for visualization.")
-        else:
-            st.info("No data available for the selected teams and seasons.")
-
-
-def awards_predictor_page():
+    year = st.selectbox("Season End Year", [2024,2023,2022,2021], index=0)
+    tm_df = team_per_game(year)
+    teams = tm_df['Tm'].unique().tolist()
+    sel = st.multiselect("Select Teams (up to 4)", teams, max_selections=4)
+
+    if st.button("Run Comparison"):
+        if not sel: return st.warning("Pick at least one team.")
+        stats = []
+        for t in sel:
+            df = tm_df[tm_df.Tm==t]
+            if df.empty: continue
+            avg = df.mean(numeric_only=True).to_frame().T
+            avg['Team'] = t
+            stats.append(avg)
+        if not stats: return st.info("No data.")
+        comp = pd.concat(stats, ignore_index=True)
+        cols = ['Team','PTS','TRB','AST','STL','BLK','FG%','3P%','FT%']
+        st.dataframe(comp[cols].round(2), use_container_width=True)
+
+def awards_predictor():
     st.markdown('<h2 class="section-header">NBA Awards Predictor</h2>', unsafe_allow_html=True)
-
-    award_type = st.selectbox(
-        "Select Award Type",
-        ["MVP", "Defensive Player of the Year", "Rookie of the Year", "6th Man of the Year", "All-NBA First Team"]
-    )
-
-    st.subheader(f"{award_type} Prediction Criteria")
-
-    # Define criteria for different awards
+    award = st.selectbox("Select Award", ["MVP","Defensive Player of the Year","Rookie of the Year","6th Man of the Year","All-NBA First Team"])
+    st.subheader(f"{award} Criteria")
+    # (same sliders as before…)
     criteria = {}
-    if award_type == "MVP":
-        criteria = {
-            "Points Per Game": st.slider("Minimum PPG", 15.0, 35.0, 25.0),
-            "Team Wins": st.slider("Minimum Team Wins", 35, 70, 50),
-            "Player Efficiency Rating": st.slider("Minimum PER", 15.0, 35.0, 25.0),
-            "Win Shares": st.slider("Minimum Win Shares", 5.0, 20.0, 10.0)
-        }
-    elif award_type == "Defensive Player of the Year":
-        criteria = {
-            "Blocks Per Game": st.slider("Minimum BPG", 0.0, 4.0, 1.5),
-            "Steals Per Game": st.slider("Minimum SPG", 0.0, 3.0, 1.0),
-            "Defensive Rating": st.slider("Maximum Defensive Rating", 90.0, 120.0, 105.0),
-            "Team Defensive Ranking": st.slider("Maximum Team Def Rank", 1, 30, 10)
-        }
-    else: # Default for Rookie of the Year, 6th Man, All-NBA
-        criteria = {
-            "Points Per Game": st.slider("Minimum PPG", 10.0, 30.0, 15.0),
-            "Games Played": st.slider("Minimum Games", 50, 82, 65),
-            "Shooting Efficiency": st.slider("Minimum FG%", 0.35, 0.65, 0.45)
-        }
+    if award=="MVP":
+      criteria = {
+        "PPG":st.slider("Min PPG",15.0,35.0,25.0),
+        "Wins":st.slider("Min Team Wins",35,70,50),
+        "PER":st.slider("Min PER",15.0,35.0,25.0),
+        "WS":st.slider("Min Win Shares",5.0,20.0,10.0)
+      }
+    elif award=="Defensive Player of the Year":
+      criteria = {
+        "BPG":st.slider("Min BPG",0.0,4.0,1.5),
+        "SPG":st.slider("Min SPG",0.0,3.0,1.0),
+        "DefRtgMax":st.slider("Max Def Rating",90.0,120.0,105.0),
+        "DefRankMax":st.slider("Max Team Def Rank",1,30,10)
+      }
+    else:
+      criteria = {
+        "PPG":st.slider("Min PPG",10.0,30.0,15.0),
+        "Games":st.slider("Min Games",50,82,65),
+        "FG%":st.slider("Min FG%",0.35,0.65,0.45)
+      }
 
     if st.button("Generate Predictions"):
-        prompt = f"""
-        Based on the following criteria for {award_type}, analyze current NBA players and provide predictions:
-
-        Criteria: {criteria}
-
-        Please provide:
-        1. Top 5 candidates with their stats
-        2. Analysis of why each candidate fits the criteria
-        3. Your prediction for the winner with reasoning
-
-        Focus on current 2023-24 season performance and recent trends.
-        """
-
-        prediction = get_perplexity_response(PERPLEXITY_API_KEY, prompt, max_tokens=800, system_message="You are an NBA awards prediction expert AI.")
-        if prediction:
-            st.markdown("### AI Prediction Analysis")
-            st.write(prediction)
-
-def ai_chat_page():
-    st.markdown('<h2 class="section-header">AI NBA Chat & Insights</h2>', unsafe_allow_html=True)
-
-    # Chat interface
-    st.subheader("Ask AI About NBA Stats and Insights")
-
-    # Display chat history
-    for message in st.session_state.chat_history:
-        with st.chat_message(message["role"]):
-            st.write(message["content"])
-
-    # Chat input
-    if prompt := st.chat_input("Ask about NBA players, teams, stats, or strategies..."):
-        # Add user message to chat history
-        st.session_state.chat_history.append({"role": "user", "content": prompt})
-
-        # Display user message
-        with st.chat_message("user"):
-            st.write(prompt)
-
-        # Generate AI response
+        p = f"Predict top 5 {award} based on {criteria}. Focus on 2023-24 season."
+        resp = ask_perp(p, system="You are an NBA awards expert AI.", max_tokens=800)
+        st.markdown("### Predictions")
+        st.write(resp)
+
+def ai_chat():
+    st.markdown('<h2 class="section-header">AI Chat & Insights</h2>', unsafe_allow_html=True)
+    if 'history' not in st.session_state: st.session_state.history=[]
+    for msg in st.session_state.history:
+        with st.chat_message(msg["role"]):
+            st.write(msg["content"])
+    if prompt:=st.chat_input("Ask me anything about NBA…"):
+        st.session_state.history.append({"role":"user","content":prompt})
         with st.chat_message("assistant"):
-            # Enhance prompt with NBA context
-            enhanced_prompt = f"""
-            As an NBA expert analyst, please answer this question about basketball:
-
-            {prompt}
-
-            Please provide detailed analysis with current stats, trends, and insights when relevant.
-            If specific player or team stats are mentioned, include recent performance data.
-            """
-
-            response = get_perplexity_response(PERPLEXITY_API_KEY, enhanced_prompt, max_tokens=700, system_message="You are an NBA expert analyst AI.")
-            if response:
-                st.write(response)
-                # Add assistant response to chat history
-                st.session_state.chat_history.append({"role": "assistant", "content": response})
-            else:
-                st.session_state.chat_history.append({"role": "assistant", "content": "Sorry, I couldn't get a response from the AI."})
-
-
-    # Quick action buttons
-    st.subheader("Quick Insights")
-    col1, col2, col3 = st.columns(3)
-
-    with col1:
-        if st.button("🏆 Championship Contenders"):
-            prompt = "Analyze the current NBA championship contenders for 2024. Who are the top 5 teams and why?"
-            response = get_perplexity_response(PERPLEXITY_API_KEY, prompt, system_message="You are an NBA expert analyst AI.")
-            if response:
-                st.write(response)
-
-    with col2:
-        if st.button("⭐ Rising Stars"):
-            prompt = "Who are the most promising young NBA players to watch in 2024? Focus on players 23 and under."
-            response = get_perplexity_response(PERPLEXITY_API_KEY, prompt, system_message="You are an NBA expert analyst AI.")
-            if response:
-                st.write(response)
-
-    with col3:
-        if st.button("📊 Trade Analysis"):
-            prompt = "What are some potential NBA trades that could happen this season? Analyze team needs and available players."
-            response = get_perplexity_response(PERPLEXITY_API_KEY, prompt, system_message="You are an NBA expert analyst AI.")
-            if response:
-                st.write(response)
-
-def young_player_projections_page():
+            ans = ask_perp(prompt, system="You are an NBA expert analyst AI.", max_tokens=700)
+            st.write(ans)
+            st.session_state.history.append({"role":"assistant","content":ans})
+    st.subheader("Quick Actions")
+    c1,c2,c3 = st.columns(3)
+    if c1.button("🏆 Contenders"):
+        st.write(ask_perp("Top 5 championship contenders for 2024 and why?"))
+    if c2.button("⭐ Rising Stars"):
+        st.write(ask_perp("Most promising NBA players age ≤23 in 2024?"))
+    if c3.button("📊 Trades"):
+        st.write(ask_perp("Potential NBA trades this season with analysis."))
+
+def young_projections():
     st.markdown('<h2 class="section-header">Young Player Projections</h2>', unsafe_allow_html=True)
-
-    # Player selection
-    all_players = get_all_players()
-    player_names = [player['full_name'] for player in all_players]
-
-    selected_player = st.selectbox("Select Young Player (or enter manually)", [""] + player_names)
-
-    if not selected_player:
-        manual_player = st.text_input("Enter Player Name Manually")
-        if manual_player:
-            selected_player = manual_player
-
-    if selected_player:
-        col1, col2 = st.columns(2)
-
-        with col1:
-            current_age = st.number_input("Current Age", min_value=18, max_value=25, value=21)
-            years_in_league = st.number_input("Years in NBA", min_value=0, max_value=7, value=2)
-
-        with col2:
-            current_ppg = st.number_input("Current PPG", min_value=0.0, max_value=40.0, value=15.0)
-            current_rpg = st.number_input("Current RPG", min_value=0.0, max_value=20.0, value=5.0)
-            current_apg = st.number_input("Current APG", min_value=0.0, max_value=15.0, value=3.0)
-
-        if st.button("Generate AI Projection"):
-            prompt = f"""
-            Analyze and project the future potential of NBA player {selected_player}:
-
-            Current Stats:
-            - Age: {current_age}
-            - Years in NBA: {years_in_league}
-            - PPG: {current_ppg}
-            - RPG: {current_rpg}
-            - APG: {current_apg}
-
-            Please provide:
-            1. 3-year projection of their stats
-            2. Peak potential analysis
-            3. Areas for improvement
-            4. Comparison to similar players at the same age
-            5. Career trajectory prediction
-
-            Base your analysis on historical player development patterns and current NBA trends.
-            """
-
-            projection = get_perplexity_response(PERPLEXITY_API_KEY, prompt, max_tokens=800, system_message="You are an NBA player projection expert AI.")
-            if projection:
-                st.markdown("### AI Player Projection")
-                st.write(projection)
-
-                # Create a simple projection visualization
-                years = [f"Year {i+1}" for i in range(5)]
-                projected_ppg = [current_ppg * (1 + 0.1 * i) for i in range(5)]  # Simple growth model
-
-                fig = go.Figure()
-                fig.add_trace(go.Scatter(
-                    x=years,
-                    y=projected_ppg,
-                    mode='lines+markers',
-                    name='Projected PPG',
-                    line=dict(width=3, color='blue')
-                ))
-
-                fig.update_layout(
-                    title=f"{selected_player} - PPG Projection",
-                    xaxis_title="Years",
-                    yaxis_title="Points Per Game",
-                    height=400
-                )
-
-                st.plotly_chart(fig, use_container_width=True)
-
-def similar_players_page():
-    st.markdown('<h2 class="section-header">Find Similar Players</h2>', unsafe_allow_html=True)
-
-    all_players = get_all_players()
-    player_names = [player['full_name'] for player in all_players]
-
-    target_player = st.selectbox("Select Target Player", player_names)
-
-    similarity_criteria = st.multiselect(
-        "Select Similarity Criteria",
-        ["Position", "Height/Weight", "Playing Style", "Statistical Profile", "Age/Experience"],
-        default=["Playing Style", "Statistical Profile"]
-    )
-
-    if target_player and similarity_criteria:
-        if st.button("Find Similar Players"):
-            prompt = f"""
-            Find NBA players similar to {target_player} based on the following criteria:
-            {', '.join(similarity_criteria)}
-
-            Please provide:
-            1. Top 5 most similar current NBA players
-            2. Top 3 historical comparisons
-            3. Explanation of similarities for each player
-            4. Key differences that distinguish them
-            5. Playing style analysis
-
-            Focus on both statistical similarities and playing style/role similarities.
-            """
-
-            similar_players = get_perplexity_response(PERPLEXITY_API_KEY, prompt, max_tokens=800, system_message="You are an NBA player similarity expert AI.")
-            if similar_players:
-                st.markdown("### Similar Players Analysis")
-                st.write(similar_players)
-
-    # Alternative: Manual similarity finder
-    st.subheader("Manual Player Comparison Tool")
-
-    col1, col2 = st.columns(2)
-
-    with col1:
-        player1 = st.selectbox("Player 1", player_names, key="sim1")
-
-    with col2:
-        player2 = st.selectbox("Player 2", player_names, key="sim2")
-
-    if player1 and player2 and player1 != player2:
-        if st.button("Compare Players"):
-            prompt = f"""
-            Compare {player1} and {player2} in detail:
-
-            Please analyze:
-            1. Statistical comparison (current season)
-            2. Playing style similarities and differences
-            3. Strengths and weaknesses of each
-            4. Team impact and role
-            5. Overall similarity score (1-10)
-
-            Provide a comprehensive comparison with specific examples.
-            """
-
-            comparison = get_perplexity_response(PERPLEXITY_API_KEY, prompt, max_tokens=700, system_message="You are an NBA player comparison expert AI.")
-            if comparison:
-                st.markdown("### Player Comparison Analysis")
-                st.write(comparison)
-
-def roster_builder_page():
+    all_p = get_player_index()['name'].tolist()
+    sp = st.selectbox("Select or enter player", [""]+all_p)
+    if not sp:
+        sp = st.text_input("Enter player name manually")
+    if sp:
+        age = st.number_input("Current Age",18,25,21)
+        yrs = st.number_input("Years in NBA",0,7,2)
+        ppg = st.number_input("PPG",0.0,40.0,15.0)
+        rpg = st.number_input("RPG",0.0,20.0,5.0)
+        apg = st.number_input("APG",0.0,15.0,3.0)
+        if st.button("Project"):
+            prompt = (
+              f"Project {sp}'s next 5-year stats based on Age={age}, "
+              f"Yrs={yrs}, PPG={ppg}, RPG={rpg}, APG={apg}."
+            )
+            out = ask_perp(prompt, system="You are an NBA projection expert AI.", max_tokens=800)
+            st.markdown("### Projection Analysis")
+            st.write(out)
+            yrs_lbl = [f"Year {i+1}" for i in range(5)]
+            vals = [ppg*(1+0.1*i) for i in range(5)]
+            st.line_chart({'PPG':vals}, x=yrs_lbl)
+
+def similar_players():
+    st.markdown('<h2 class="section-header">Similar Players Finder</h2>', unsafe_allow_html=True)
+    all_p = get_player_index()['name'].tolist()
+    tp = st.selectbox("Target Player", all_p)
+    crit = st.multiselect("Criteria",["Position","Height/Weight","Style","Stats","Experience"],default=["Style","Stats"])
+    if tp and crit and st.button("Find Similar"):
+        prompt = f"Find top 5 current and top 3 historical similar to {tp} by {crit}."
+        st.write(ask_perp(prompt, system="You are a similarity expert AI.", max_tokens=800))
+    st.subheader("Manual Compare")
+    p1 = st.selectbox("Player 1", all_p, key="p1")
+    p2 = st.selectbox("Player 2", all_p, key="p2")
+    if p1 and p2 and p1!=p2 and st.button("Compare Players"):
+        prompt = f"Compare {p1} vs {p2} on stats, style, strengths/weaknesses, team impact."
+        st.write(ask_perp(prompt, system="You are a comparison expert AI.", max_tokens=700))
+
+def roster_builder():
     st.markdown('<h2 class="section-header">NBA Roster Builder</h2>', unsafe_allow_html=True)
-
-    st.subheader("Build Your Ideal NBA Roster")
-
-    # Roster building parameters
-    col1, col2 = st.columns(2)
-
-    with col1:
-        salary_cap = st.number_input("Salary Cap (Millions)", min_value=100, max_value=200, value=136)
-        team_strategy = st.selectbox(
-            "Team Strategy",
-            ["Championship Contender", "Young Core Development", "Balanced Veteran Mix", "Small Ball", "Defense First"]
-        )
-
-    with col2:
-        key_positions = st.multiselect(
-            "Priority Positions",
-            ["Point Guard", "Shooting Guard", "Small Forward", "Power Forward", "Center"],
-            default=["Point Guard", "Center"]
-        )
-
-    # Player budget allocation
+    cap = st.number_input("Salary Cap (M)",100,200,136)
+    strat = st.selectbox("Strategy",["Champ Contender","Young Development","Balanced","Small Ball","Defense First"])
+    pos = st.multiselect("Priority Positions",["PG","SG","SF","PF","C"],default=["PG","C"])
     st.subheader("Budget Allocation")
-    position_budgets = {}
-
-    positions = ["PG", "SG", "SF", "PF", "C"]
     cols = st.columns(5)
-
-    total_allocated = 0
-    for i, pos in enumerate(positions):
-        with cols[i]:
-            budget = st.number_input(f"{pos} Budget ($M)", min_value=0, max_value=50, value=20, key=f"budget_{pos}")
-            position_budgets[pos] = budget
-            total_allocated += budget
-
-    st.write(f"Total Allocated: ${total_allocated}M / ${salary_cap}M")
-
-    if total_allocated > salary_cap:
-        st.error("Budget exceeds salary cap!")
-
-    # Generate roster suggestions
-    if st.button("Generate Roster Suggestions"):
-        if total_allocated <= salary_cap:
-            prompt = f"""
-            Build an NBA roster with the following constraints:
-
-            - Salary Cap: ${salary_cap} million
-            - Team Strategy: {team_strategy}
-            - Priority Positions: {', '.join(key_positions)}
-            - Position Budgets: {position_budgets}
-
-            Please provide:
-            1. Starting lineup with specific player recommendations
-            2. Key bench players (6th man, backup center, etc.)
-            3. Total estimated salary breakdown
-            4. Rationale for each major signing
-            5. How this roster fits the chosen strategy
-            6. Potential weaknesses and how to address them
-
-            Focus on realistic player availability and current market values.
-            """
-
-            roster_suggestions = get_perplexity_response(PERPLEXITY_API_KEY, prompt, max_tokens=900, system_message="You are an NBA roster building expert AI.")
-            if roster_suggestions:
-                st.markdown("### AI Roster Recommendations")
-                st.write(roster_suggestions)
+    alloc = {}
+    total = 0
+    for i,p in enumerate(["PG","SG","SF","PF","C"]):
+        val = cols[i].number_input(f"{p} Budget ($M)",0,50,20, key=f"b{p}")
+        alloc[p]=val; total+=val
+    st.write(f"Total: ${total}M / ${cap}M")
+    if total>cap: st.error("Over cap!")
+
+    if st.button("Generate Roster"):
+        if total<=cap:
+            prompt = (
+              f"Build roster with cap=${cap}M, strat={strat}, "
+              f"priority={pos}, budgets={alloc}."
+            )
+            st.markdown("### Suggestions")
+            st.write(ask_perp(prompt, system="You are a roster builder AI.", max_tokens=900))
         else:
-            st.warning("Please adjust your budget to be within the salary cap before generating suggestions.")
-
-    # Trade scenario analyzer
-    st.subheader("Trade Scenario Analyzer")
-
-    trade_team1 = st.text_input("Team 1 Trading:")
-    trade_team2 = st.text_input("Team 2 Trading:")
-
-    if trade_team1 and trade_team2:
-        if st.button("Analyze Trade"):
-            prompt = f"""
-            Analyze this potential NBA trade:
-
-            Team 1 trades: {trade_team1}
-            Team 2 trades: {trade_team2}
-
-            Please evaluate:
-            1. Fair value assessment
-            2. How this trade helps each team
-            3. Salary cap implications
-            4. Impact on team chemistry and performance
-            5. Likelihood of this trade happening
-            6. Alternative trade suggestions
-
-            Consider current team needs and player contracts.
-            """
-
-            trade_analysis = get_perplexity_response(PERPLEXITY_API_KEY, prompt, max_tokens=700, system_message="You are an NBA trade analysis expert AI.")
-            if trade_analysis:
-                st.markdown("### Trade Analysis")
-                st.write(trade_analysis)
+            st.warning("Adjust budgets under cap.")
+
+def trade_analyzer():
+    st.markdown('<h2 class="section-header">Trade Scenario Analyzer</h2>', unsafe_allow_html=True)
+    t1 = st.text_input("Team 1 trades")
+    t2 = st.text_input("Team 2 trades")
+    if t1 and t2 and st.button("Analyze Trade"):
+        prompt = (
+          f"Team1 trades: {t1}. Team2 trades: {t2}. "
+          "Assess fairness, cap, impact, chemistry, likelihood, alternatives."
+        )
+        st.write(ask_perp(prompt, system="You are a trade analysis AI.", max_tokens=700))
 
 if __name__ == "__main__":
     main()