Update src/streamlit_app.py

src/streamlit_app.py

@@ -4,6 +4,34 @@ import numpy as np
 import requests
 import os
 from datetime import datetime
+from bs4 import BeautifulSoup
+import re # New import for regex operations
+
+# --- IMPORTANT: Addressing PermissionError in Containerized Environments ---
+# The error "PermissionError: [Errno 13] Permission denied: '/.streamlit'"
+# occurs because Streamlit tries to write to a non-writable directory.
+# To fix this in your Dockerfile or when running your Docker container,
+# you should set one of the following environment variables:
+#
+# Option 1 (Recommended): Set the HOME environment variable to a writable path.
+#    In your Dockerfile: ENV HOME /tmp
+#    Or when running: docker run -e HOME=/tmp your_image_name
+#
+# Option 2: Disable Streamlit's usage statistics gathering.
+#    In your Dockerfile: ENV STREAMLIT_BROWSER_GATHER_USAGE_STATS=False
+#    Or when running: docker run -e STREAMLIT_BROWSER_GATHER_USAGE_STATS=False your_image_name
+#
+# Option 1 is generally more robust as it provides a writable home directory
+# for any application that might need it.
+# -----------------------------------------------------------------------
+
+# Page configuration
+st.set_page_config(
+    page_title="NBA Analytics Hub",
+    page_icon="🏀",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
 
 # —————————————————————————————————————————————————————————————————————————————
 # CSS (black & white theme)
@@ -15,11 +43,14 @@ st.markdown("""
 </style>
 """, unsafe_allow_html=True)
 
-# —————————————————————————————————————————————————————————————————————————————
-import requests
-from bs4 import BeautifulSoup
+# Initialize session state for chat history
+if 'chat_history' not in st.session_state:
+    st.session_state.chat_history = []
 
 # —————————————————————————————————————————————————————————————————————————————
+# Basketball-Reference Data Fetching Utilities
+# —————————————————————————————————————————————————————————————————————————————
+
 @st.cache_data(ttl=3600)
 def fetch_html(url):
     """Fetch raw HTML for a URL (with error handling)."""
@@ -27,31 +58,57 @@ def fetch_html(url):
         resp = requests.get(url, timeout=20)
         resp.raise_for_status()
         return resp.text
-    except Exception as e:
+    except requests.exceptions.RequestException as e:
         st.error(f"Failed to fetch {url}: {e}")
         return ""
+    except Exception as e:
+        st.error(f"An unexpected error occurred while fetching {url}: {e}")
+        return ""
 
 def parse_table(html, table_id=None):
     """
-    Given raw HTML and optional table_id, locate that <table> via BeautifulSoup,
-    then parse it with pandas.read_html.
+    Given raw HTML and optional table_id, locate that <table>,
+    handling cases where it's commented out, then parse it with pandas.read_html.
     """
-    soup = BeautifulSoup(html, "html.parser")
+    soup = BeautifulSoup(html, "lxml") # Using lxml for potentially faster parsing
+    tbl_html = ""
+
     if table_id:
+        # First, try to find the table directly
         tbl = soup.find("table", {"id": table_id})
-        if not tbl:
-            return pd.DataFrame()
-        tbl_html = str(tbl)
+        if tbl:
+            tbl_html = str(tbl)
+        else:
+            # If not found directly, search for it within HTML comments
+            # Basketball-Reference often comments out tables
+            comment_pattern = re.compile(r'<!--.*?<table[^>]*id="%s"[^>]*>.*?</table>.*?-->' % table_id, re.DOTALL)
+            comment_match = comment_pattern.search(html)
+            if comment_match:
+                # Extract the content of the comment
+                comment_content = comment_match.group(0)
+                # Remove the comment tags
+                comment_content = comment_content.replace('<!--', '').replace('-->', '')
+                # Parse the comment content as new HTML
+                comment_soup = BeautifulSoup(comment_content, 'lxml')
+                tbl = comment_soup.find('table', {'id': table_id})
+                if tbl:
+                    tbl_html = str(tbl)
     else:
-        # fallback: first table on page
+        # fallback: first table on page (only if no table_id specified)
         first = soup.find("table")
-        if not first:
-            return pd.DataFrame()
-        tbl_html = str(first)
+        if first:
+            tbl_html = str(first)
+
+    if not tbl_html:
+        return pd.DataFrame()
 
     try:
+        # pd.read_html returns a list of DataFrames, we want the first one
         return pd.read_html(tbl_html)[0]
-    except ValueError:
+    except ValueError: # No tables found in the provided HTML string
+        return pd.DataFrame()
+    except Exception as e:
+        st.error(f"Error parsing table with pandas: {e}")
         return pd.DataFrame()
 
 # —————————————————————————————————————————————————————————————————————————————
@@ -67,13 +124,16 @@ def get_player_index():
     for letter in map(chr, range(ord('a'), ord('z')+1)):
         url = f"{base}{letter}/"
         html = fetch_html(url)
-        df = parse_table(html, table_id="players")
-        if df.empty:
+        if not html:
+            continue
+
+        soup = BeautifulSoup(html, "lxml")
+        # The players table is usually directly available, not commented out.
+        table = soup.find("table", {"id": "players"})
+        if not table:
             continue
 
-        # each row: <th data-stat="player"><a href="/players/x/xxxxx.html">Name</a></th>
-        soup = BeautifulSoup(html, "html.parser")
-        for row in soup.select("table#players tbody tr"):
+        for row in table.select("tbody tr"):
             th = row.find("th", {"data-stat": "player"})
             if not th:
                 continue
@@ -95,18 +155,36 @@ def player_season_stats(bbr_url):
     Returns cleaned DataFrame.
     """
     html = fetch_html(bbr_url)
+    if not html:
+        return pd.DataFrame()
+
     df = parse_table(html, table_id="per_game")
     if df.empty or "Season" not in df.columns:
         return pd.DataFrame()
 
-    # drop repeated header rows
+    # drop repeated header rows (e.g., rows where 'Season' is literally 'Season')
     df = df[df["Season"] != "Season"].copy()
-    df["Season"] = df["Season"].astype(str)
-    # coerce all numeric columns
-    nonnum = {"Season", "Tm", "Lg", "Pos"}
+    df["Season"] = df["Season"].astype(str) # Ensure season is string
+
+    # Standardize column names to match previous nba_api output expectations
+    df = df.rename(columns={
+        'G': 'GP', 'GS': 'GS', 'MP': 'MIN',
+        'FG%': 'FG_PCT', '3P%': 'FG3_PCT', 'FT%': 'FT_PCT',
+        'TRB': 'REB', 'AST': 'AST', 'STL': 'STL', 'BLK': 'BLK', 'TOV': 'TO',
+        'PF': 'PF', 'PTS': 'PTS',
+        'Age': 'AGE', 'Tm': 'TEAM_ABBREVIATION', 'Lg': 'LEAGUE_ID', 'Pos': 'POSITION',
+        'FG': 'FGM', 'FGA': 'FGA', '3P': 'FG3M', '3PA': 'FG3A',
+        '2P': 'FGM2', '2PA': 'FGA2', '2P%': 'FG2_PCT', 'eFG%': 'EFG_PCT',
+        'FT': 'FTM', 'FTA': 'FTA', 'ORB': 'OREB', 'DRB': 'DREB'
+    })
+
+    # Coerce all numeric columns
+    # Exclude columns that are definitely not numeric or are identifiers
+    non_numeric_cols = {'Season', 'TEAM_ABBREVIATION', 'LEAGUE_ID', 'POSITION', 'Player'}
     for col in df.columns:
-        if col not in nonnum:
+        if col not in non_numeric_cols:
             df[col] = pd.to_numeric(df[col], errors="coerce")
+
     return df
 
 # —————————————————————————————————————————————————————————————————————————————
@@ -119,23 +197,39 @@ def team_per_game(year):
     """
     url = f"https://www.basketball-reference.com/leagues/NBA_{year}_per_game.html"
     html = fetch_html(url)
-    df = parse_table(html, table_id="per_game-team")
+    if not html:
+        return pd.DataFrame()
+
+    df = parse_table(html, table_id="per_game-team") # Correct table ID for team stats
     if df.empty or "Team" not in df.columns:
         return pd.DataFrame()
 
     # drop repeated headers & rename
     df = df[df["Team"] != "Team"].copy()
     df.rename(columns={"Team": "Tm"}, inplace=True)
+
+    # Standardize column names
+    df = df.rename(columns={
+        'G': 'GP', 'MP': 'MIN',
+        'FG%': 'FG_PCT', '3P%': 'FG3_PCT', 'FT%': 'FT_PCT',
+        'TRB': 'REB', 'AST': 'AST', 'STL': 'STL', 'BLK': 'BLK', 'TOV': 'TO',
+        'PF': 'PF', 'PTS': 'PTS',
+        'Rk': 'RANK', 'W': 'WINS', 'L': 'LOSSES', 'W/L%': 'WIN_LOSS_PCT',
+        'FG': 'FGM', 'FGA': 'FGA', '3P': 'FG3M', '3PA': 'FG3A',
+        '2P': 'FGM2', '2PA': 'FGA2', '2P%': 'FG2_PCT', 'eFG%': 'EFG_PCT',
+        'FT': 'FTM', 'FTA': 'FTA', 'ORB': 'OREB', 'DRB': 'DREB'
+    })
+
     # coerce numeric columns
-    nonnum = {"Player", "Pos", "Tm"}
+    non_numeric_cols = {"Tm", "RANK"} # 'RANK' is usually numeric, but 'Tm' is not
     for col in df.columns:
-        if col not in nonnum:
+        if col not in non_numeric_cols:
             df[col] = pd.to_numeric(df[col], errors="coerce")
 
     return df
 
 # —————————————————————————————————————————————————————————————————————————————
-# Perplexity integration (unchanged)
+# Perplexity integration
 PERP_KEY = os.getenv("PERPLEXITY_API_KEY")
 PERP_URL = "https://api.perplexity.ai/chat/completions"
 
@@ -145,7 +239,7 @@ def ask_perp(prompt, system="You are a helpful NBA analyst AI.", max_tokens=500,
         return ""
     hdr = {'Authorization':f'Bearer {PERP_KEY}','Content-Type':'application/json'}
     payload = {
-      "model":"sonar-pro",
+      "model":"sonar-medium-online", # Changed to a commonly available online model
       "messages":[{"role":"system","content":system},{"role":"user","content":prompt}],
       "max_tokens":max_tokens, "temperature":temp
     }
@@ -153,10 +247,44 @@ def ask_perp(prompt, system="You are a helpful NBA analyst AI.", max_tokens=500,
         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 requests.exceptions.RequestException as e:
+        error_message = f"Error communicating with Perplexity API: {e}"
+        if r.response is not None:
+            try:
+                error_detail = r.response.json().get("error", {}).get("message", r.response.text)
+                error_message = f"Perplexity API error: {error_detail}"
+            except ValueError:
+                error_message = f"Perplexity API error: {r.response.status_code} - {r.response.reason}"
+        st.error(error_message)
+        return ""
     except Exception as e:
-        st.error(f"Perplexity error: {e}")
+        st.error(f"An unexpected error occurred with Perplexity API: {e}")
         return ""
 
+# —————————————————————————————————————————————————————————————————————————————
+# Helper for dynamic season generation
+def get_available_seasons(num_seasons=6):
+    """Generates a list of recent NBA seasons in 'YYYY–YY' format."""
+    current_year = datetime.now().year
+    current_month = datetime.now().month
+
+    # Determine the latest season end year.
+    # If it's before July (e.g., May 2025), the current season is 2024-25 (ends 2025).
+    # If it's July or later (e.g., July 2025), the 2024-25 season just finished,
+    # and the next season (2025-26) is considered the "current" one for future projections.
+    latest_season_end_year = current_year
+    if current_month >= 7: # NBA season typically ends in June
+        latest_season_end_year += 1
+
+    seasons_list = []
+    for i in range(num_seasons):
+        end_year = latest_season_end_year - i
+        start_year = end_year - 1
+        seasons_list.append(f"{start_year}–{end_year}")
+    return sorted(seasons_list, reverse=True) # Sort to show most recent first
+
+# —————————————————————————————————————————————————————————————————————————————
+# Main App Structure
 # —————————————————————————————————————————————————————————————————————————————
 def main():
     st.markdown('<h1 class="main-header">🏀 NBA Analytics Hub (BBR Edition)</h1>', unsafe_allow_html=True)
@@ -177,51 +305,236 @@ def main():
     elif page == "Roster Builder":                     roster_builder()
     else:                                              trade_analyzer()
 
+# —————————————————————————————————————————————————————————————————————————————
+# Page Implementations
 # —————————————————————————————————————————————————————————————————————————————
 def player_vs_player():
     st.markdown('<h2 class="section-header">Player vs Player Comparison</h2>', unsafe_allow_html=True)
     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"])
+    selected_players = st.multiselect("Select Players (up to 4)", names, max_selections=4)
+
+    available_seasons = get_available_seasons()
+    selected_seasons = st.multiselect("Select Seasons", available_seasons, default=[available_seasons[0]])
 
     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)
+        if not selected_players:
+            st.warning("Please select at least one player to compare.")
+            return
+
+        stats_tabs = st.tabs(["Basic Stats", "Advanced Stats", "Visualizations"])
+        all_player_season_data = [] # To store individual season rows for each player
+
+        with st.spinner("Fetching player data..."):
+            for player_name in selected_players:
+                player_url = idx.loc[idx.name == player_name, 'url'].iat[0]
+                df_player_career = player_season_stats(player_url)
+
+                if not df_player_career.empty:
+                    # Filter for selected seasons and ensure 'Season' column is consistent
+                    df_player_career['Season'] = df_player_career['Season'].str.replace('-', '–')
+                    filtered_df = df_player_career[df_player_career['Season'].isin(selected_seasons)].copy()
+
+                    if not filtered_df.empty:
+                        filtered_df['Player'] = player_name # Add player name for identification
+                        all_player_season_data.append(filtered_df)
+                    else:
+                        st.info(f"No data found for {player_name} in selected seasons.")
+                else:
+                    st.info(f"Could not fetch career stats for {player_name}.")
+
+        if not all_player_season_data:
+            st.info("No data available for the selected players and seasons.")
+            return
+
+        # Concatenate all collected season data into one DataFrame
+        comparison_df_raw = pd.concat(all_player_season_data, ignore_index=True)
+
+        with stats_tabs[0]:
+            st.subheader("Basic Statistics")
+            # Group by player and average for the basic stats table if multiple seasons are selected
+            # Otherwise, show individual season stats if only one season is selected
+            if len(selected_seasons) > 1:
+                basic_display_df = comparison_df_raw.groupby('Player').mean(numeric_only=True).reset_index()
+                basic_cols = ['Player', 'GP', 'MIN', 'PTS', 'REB', 'AST', 'STL', 'BLK', 'FG_PCT', 'FT_PCT', 'FG3_PCT']
+            else:
+                basic_display_df = comparison_df_raw.copy()
+                basic_cols = ['Player', 'Season', 'GP', 'MIN', 'PTS', 'REB', 'AST', 'STL', 'BLK', 'FG_PCT', 'FT_PCT', 'FG3_PCT']
+
+            display_cols = [col for col in basic_cols if col in basic_display_df.columns]
+            st.dataframe(basic_display_df[display_cols].round(2), use_container_width=True)
+
+        with stats_tabs[1]:
+            st.subheader("Advanced Statistics")
+            if not comparison_df_raw.empty:
+                advanced_df = comparison_df_raw.copy()
+
+                # Calculate TS% (True Shooting Percentage)
+                # Ensure FGA and FTA are numeric and not zero to avoid division by zero
+                advanced_df['FGA'] = pd.to_numeric(advanced_df['FGA'], errors='coerce').fillna(0)
+                advanced_df['FTA'] = pd.to_numeric(advanced_df['FTA'], errors='coerce').fillna(0)
+                advanced_df['PTS'] = pd.to_numeric(advanced_df['PTS'], errors='coerce').fillna(0)
+
+                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
+                )
+
+                if len(selected_seasons) > 1:
+                    advanced_display_df = advanced_df.groupby('Player').mean(numeric_only=True).reset_index()
+                    advanced_cols = ['Player', 'PTS', 'REB', 'AST', 'FG_PCT', 'TS_PCT']
+                else:
+                    advanced_display_df = advanced_df.copy()
+                    advanced_cols = ['Player', 'Season', 'PTS', 'REB', 'AST', 'FG_PCT', 'TS_PCT']
+
+                display_cols = [col for col in advanced_cols if col in advanced_display_df.columns]
+                st.dataframe(advanced_display_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 not comparison_df_raw.empty:
+                metrics = ['PTS', 'REB', 'AST', 'FG_PCT', '3P_PCT', 'FT_PCT', 'STL', 'BLK']
+                available_metrics = [m for m in metrics if m in comparison_df_raw.columns]
+
+                if available_metrics:
+                    selected_metric = st.selectbox("Select Metric to Visualize", available_metrics)
+
+                    if selected_metric:
+                        # Determine if we are showing a trend for one player or comparison for multiple
+                        if len(selected_players) == 1 and len(selected_seasons) > 1:
+                            # Show trend over seasons for one player
+                            player_trend_df = comparison_df_raw[comparison_df_raw['Player'] == selected_players[0]].sort_values(by='Season')
+                            fig = px.line(
+                                player_trend_df,
+                                x='Season',
+                                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_raw.groupby('Player')[available_metrics].mean().reset_index()
+                            fig = px.bar(
+                                avg_comparison_df,
+                                x='Player',
+                                y=selected_metric,
+                                title=f"Average {selected_metric} Comparison (Selected Seasons)",
+                                color='Player'
+                            )
+                        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_raw.columns]
+
+                        if len(radar_metrics_for_chart) >= 3:
+                            radar_data = {}
+                            # Use the averaged data for radar chart if multiple seasons
+                            if len(selected_seasons) > 1:
+                                radar_source_df = comparison_df_raw.groupby('Player')[radar_metrics_for_chart].mean(numeric_only=True).reset_index()
+                            else:
+                                radar_source_df = comparison_df_raw.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']] = {
+                                    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_vs_team():
     st.markdown('<h2 class="section-header">Team vs Team Analysis</h2>', unsafe_allow_html=True)
-    year = st.selectbox("Season End Year", [2024,2023,2022,2021], index=0)
-    tm_df = team_per_game(year)
+    
+    available_seasons = get_available_seasons()
+    selected_season_str = st.selectbox("Select Season", available_seasons, index=0)
+    
+    # Extract the end year from the season string (e.g., "2024–25" -> 2025)
+    year_for_team_stats = int(selected_season_str.split('–')[1])
+
+    tm_df = team_per_game(year_for_team_stats)
+    if tm_df.empty:
+        st.info(f"No team data available for the {selected_season_str} season.")
+        return
+
     teams = tm_df['Tm'].unique().tolist()
-    sel = st.multiselect("Select Teams (up to 4)", teams, max_selections=4)
+    selected_teams = 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.")
+        if not selected_teams:
+            st.warning("Please select at least one team.")
+            return
+
         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)
+        for t in selected_teams:
+            df = tm_df[tm_df.Tm == t].copy() # Use .copy() to avoid SettingWithCopyWarning
+            if not df.empty:
+                # For team stats, we usually get one row per team per season from team_per_game
+                # So, no need for .mean() here, just take the row.
+                df['Team'] = t # Add 'Team' column for consistency
+                df['Season'] = selected_season_str # Add 'Season' column
+                stats.append(df.iloc[0].to_dict()) # Convert the single row to dict
+            else:
+                st.info(f"No data found for team {t} in {selected_season_str}.")
+
+        if not stats:
+            st.info("No data available for the selected teams.")
+            return
+
+        comp = pd.DataFrame(stats)
+        # Ensure numeric columns are actually numeric for display and calculations
+        for col in ['PTS', 'REB', 'AST', 'STL', 'BLK', 'FG_PCT', '3P_PCT', 'FT_PCT']:
+            if col in comp.columns:
+                comp[col] = pd.to_numeric(comp[col], errors='coerce')
+
+        st.subheader("Team Statistics Comparison")
+        cols = ['Team', 'Season', 'PTS', 'REB', 'AST', 'STL', 'BLK', 'FG_PCT', '3P_PCT', 'FT_PCT']
+        display_cols = [col for col in cols if col in comp.columns]
+        st.dataframe(comp[display_cols].round(2), use_container_width=True)
+
+        st.subheader("Team Performance Visualization")
+        metric_options = ['PTS', 'REB', 'AST', 'FG_PCT', '3P_PCT', 'FT_PCT']
+        available_metrics = [m for m in metric_options if m in comp.columns]
+
+        if available_metrics:
+            selected_metric = st.selectbox("Select Metric", available_metrics)
+
+            fig = px.bar(
+                comp,
+                x='Team',
+                y=selected_metric,
+                color='Team', # Color by team for clarity
+                title=f"Team {selected_metric} Comparison ({selected_season_str} Season)",
+                barmode='group'
+            )
+            st.plotly_chart(fig, use_container_width=True)
+        else:
+            st.info("No common metrics available for visualization.")
+
 
 def awards_predictor():
     st.markdown('<h2 class="section-header">NBA Awards Predictor</h2>', unsafe_allow_html=True)
@@ -258,28 +571,37 @@ def awards_predictor():
 
 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:
+    if 'chat_history' not in st.session_state: st.session_state.chat_history=[]
+    for msg in st.session_state.chat_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})
+        st.session_state.chat_history.append({"role":"user","content":prompt})
+        with st.chat_message("user"):
+            st.write(prompt) # Display user message immediately
         with st.chat_message("assistant"):
             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.session_state.chat_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?"))
+        prompt = "Analyze the current NBA championship contenders for 2024. Who are the top 5 teams and why?"
+        response = ask_perp(prompt)
+        if response: st.write(response)
     if c2.button("⭐ Rising Stars"):
-        st.write(ask_perp("Most promising NBA players age ≤23 in 2024?"))
+        prompt = "Who are the most promising young NBA players to watch in 2024? Focus on players 23 and under."
+        response = ask_perp(prompt)
+        if response: st.write(response)
     if c3.button("📊 Trades"):
-        st.write(ask_perp("Potential NBA trades this season with analysis."))
+        prompt = "What are some potential NBA trades that could happen this season? Analyze team needs and available players."
+        response = ask_perp(prompt)
+        if response: st.write(response)
 
 def young_projections():
     st.markdown('<h2 class="section-header">Young Player Projections</h2>', unsafe_allow_html=True)
-    all_p = get_player_index()['name'].tolist()
+    all_p_df = get_player_index()
+    all_p = all_p_df['name'].tolist()
     sp = st.selectbox("Select or enter player", [""]+all_p)
     if not sp:
         sp = st.text_input("Enter player name manually")
@@ -299,28 +621,32 @@ def young_projections():
             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)
+            fig = go.Figure()
+            fig.add_trace(go.Scatter(x=yrs_lbl, y=vals, mode='lines+markers', name='Projected PPG'))
+            fig.update_layout(title=f"{sp} - PPG Projection", xaxis_title="Years", yaxis_title="Points Per Game")
+            st.plotly_chart(fig, use_container_width=True)
 
 def similar_players():
     st.markdown('<h2 class="section-header">Similar Players Finder</h2>', unsafe_allow_html=True)
-    all_p = get_player_index()['name'].tolist()
+    all_p_df = get_player_index()
+    all_p = all_p_df['name'].tolist()
     tp = st.selectbox("Target Player", all_p)
-    crit = st.multiselect("Criteria",["Position","Height/Weight","Style","Stats","Experience"],default=["Style","Stats"])
+    crit = st.multiselect("Criteria",["Position","Height/Weight","Playing Style","Statistical Profile","Age/Experience"],default=["Playing Style","Statistical Profile"])
     if tp and crit and st.button("Find Similar"):
-        prompt = f"Find top 5 current and top 3 historical similar to {tp} by {crit}."
+        prompt = f"Find top 5 current and top 3 historical similar to {tp} by {', '.join(crit)}. Provide detailed reasoning."
         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."
+        prompt = f"Compare {p1} vs {p2} on statistical comparison (current season), playing style similarities and differences, strengths and weaknesses, team impact and role, and overall similarity score (1-10)."
         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)
-    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"])
+    cap = st.number_input("Salary Cap (Millions)",100,200,136)
+    strat = st.selectbox("Strategy",["Championship Contender","Young Core Development","Balanced Veteran Mix","Small Ball","Defense First"])
+    pos = st.multiselect("Priority Positions",["Point Guard","Shooting Guard","Small Forward","Power Forward","Center"],default=["Point Guard","Center"])
     st.subheader("Budget Allocation")
     cols = st.columns(5)
     alloc = {}
@@ -328,28 +654,40 @@ def roster_builder():
     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!")
+    st.write(f"Total Allocated: ${total}M / ${cap}M")
+    if total>cap: st.error("Budget exceeds salary cap!")
 
-    if st.button("Generate Roster"):
+    if st.button("Generate Roster Suggestions"):
         if total<=cap:
             prompt = (
-              f"Build roster with cap=${cap}M, strat={strat}, "
-              f"priority={pos}, budgets={alloc}."
+              f"Build an NBA roster with the following constraints: "
+              f"Salary Cap: ${cap} million, Team Strategy: {strat}, "
+              f"Priority Positions: {', '.join(pos)}, "
+              f"Position Budgets: {alloc}. "
+              "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."
             )
-            st.markdown("### Suggestions")
-            st.write(ask_perp(prompt, system="You are a roster builder AI.", max_tokens=900))
+            st.markdown("### AI Roster Recommendations")
+            st.write(ask_perp(prompt, system="You are an NBA roster building expert AI.", max_tokens=900))
         else:
-            st.warning("Adjust budgets under cap.")
+            st.warning("Please adjust your budget to be within the salary cap before generating suggestions.")
 
 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")
+    t1 = st.text_input("Team 1 trades (e.g., 'LeBron James for Anthony Davis')")
+    t2 = st.text_input("Team 2 trades (e.g., 'Anthony Davis for LeBron James')")
     if t1 and t2 and st.button("Analyze Trade"):
         prompt = (
-          f"Team1 trades: {t1}. Team2 trades: {t2}. "
-          "Assess fairness, cap, impact, chemistry, likelihood, alternatives."
+          f"Analyze this potential NBA trade: Team 1 trades: {t1}. Team 2 trades: {t2}. "
+          "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."
         )
         st.write(ask_perp(prompt, system="You are a trade analysis AI.", max_tokens=700))