Update src/streamlit_app.py

src/streamlit_app.py

@@ -1,68 +1,709 @@
-
 import streamlit as st
 import pandas as pd
-from nba_data import get_player_id, get_player_stats
-import altair as alt
+import numpy as np
+import plotly.express as px
+import plotly.graph_objects as go
+from plotly.subplots import make_subplots
+import requests
+from nba_api.stats.endpoints import (
+    playercareerstats, playercompare, teamdetails, teamgamelog,
+    leaguegamelog, playergamelog, commonplayerinfo, teamplayerdashboard,
+    leagueleaders, playerestimatedmetrics, teamestimatedmetrics
+)
+from nba_api.stats.static import players, teams
+import time
+from datetime import datetime
+import json
+
+# Page configuration
+st.set_page_config(
+    page_title="NBA Analytics Hub",
+    page_icon="🏀",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+# Custom CSS
+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;
+    }
+</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 = st.secrets.get("PERPLEXITY_API_KEY", "")
 
-st.set_page_config(page_title="NBA Head-to-Head", page_icon="🏀")
-st.title("🏀 NBA Head-to-Head Player Comparison")
+def query_perplexity(prompt, max_tokens=500):
+    """Query Perplexity Sonar API"""
+    if not PERPLEXITY_API_KEY:
+        return "Please configure your Perplexity API key in Streamlit secrets."
+    
+    url = "https://api.perplexity.ai/chat/completions"
+    headers = {
+        "Authorization": f"Bearer {PERPLEXITY_API_KEY}",
+        "Content-Type": "application/json"
+    }
+    
+    data = {
+        "model": "llama-3.1-sonar-small-128k-online",
+        "messages": [{"role": "user", "content": prompt}],
+        "max_tokens": max_tokens,
+        "temperature": 0.2
+    }
+    
+    try:
+        response = requests.post(url, json=data, headers=headers)
+        response.raise_for_status()
+        return response.json()["choices"][0]["message"]["content"]
+    except Exception as e:
+        return f"Error querying Perplexity API: {str(e)}"
 
-# --- Player 1 ---
-player_1 = st.text_input("🔎 Player 1 Full Name", key="player_1")
-player_2 = st.text_input("🆚 Player 2 Full Name", key="player_2")
+@st.cache_data(ttl=3600)
+def get_all_players():
+    """Get all NBA players"""
+    return players.get_players()
 
-stats_1 = None
-stats_2 = None
-season_selected = None
+@st.cache_data(ttl=3600)
+def get_all_teams():
+    """Get all NBA teams"""
+    return teams.get_teams()
 
-if player_1 and player_2:
-    player_1_id = get_player_id(player_1)
-    player_2_id = get_player_id(player_2)
+@st.cache_data(ttl=300)
+def get_player_stats(player_id, season_type="Regular Season"):
+    """Get player career stats"""
+    try:
+        career_stats = playercareerstats.PlayerCareerStats(player_id=player_id)
+        return career_stats.get_data_frames()[0]
+    except Exception as e:
+        st.error(f"Error fetching player stats: {str(e)}")
+        return pd.DataFrame()
 
-    if player_1_id and player_2_id:
-        stats_1 = get_player_stats(player_1_id)
-        stats_2 = get_player_stats(player_2_id)
+@st.cache_data(ttl=300)
+def get_team_stats(team_id, season="2023-24"):
+    """Get team stats"""
+    try:
+        team_dashboard = teamplayerdashboard.TeamPlayerDashboard(team_id=team_id, season=season)
+        return team_dashboard.get_data_frames()[1]  # Team stats
+    except Exception as e:
+        st.error(f"Error fetching team stats: {str(e)}")
+        return pd.DataFrame()
 
-        common_seasons = sorted(
-            list(set(stats_1["SEASON_ID"]).intersection(set(stats_2["SEASON_ID"]))), reverse=True
+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():
+        fig.add_trace(go.Scatterpolar(
+            r=[stats.get(cat, 0) for cat in categories],
+            theta=categories,
+            fill='toself',
+            name=player_name,
+            opacity=0.7
+        ))
+    
+    fig.update_layout(
+        polar=dict(
+            radialaxis=dict(
+                visible=True,
+                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.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():
+    st.markdown('<h2 class="section-header">Player vs Player Comparison</h2>', unsafe_allow_html=True)
+    
+    # Get all players
+    all_players = get_all_players()
+    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",
+            ["2023-24", "2022-23", "2021-22", "2020-21", "2019-20"],
+            default=["2023-24"]
+        )
+    
+    if selected_players:
+        # Get player IDs
+        player_ids = []
+        for name in selected_players:
+            player_id = next((p['id'] for p in all_players if p['full_name'] == name), None)
+            if player_id:
+                player_ids.append(player_id)
+        
+        # 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 i, player_id in enumerate(player_ids):
+                stats_df = get_player_stats(player_id)
+                if not stats_df.empty:
+                    # Filter by selected seasons
+                    filtered_stats = stats_df[stats_df['SEASON_ID'].isin(seasons)]
+                    if not filtered_stats.empty:
+                        avg_stats = filtered_stats.mean(numeric_only=True)
+                        avg_stats['PLAYER_NAME'] = selected_players[i]
+                        basic_stats_data.append(avg_stats)
+            
+            if basic_stats_data:
+                comparison_df = pd.DataFrame(basic_stats_data)
+                basic_cols = ['PLAYER_NAME', '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)
+        
+        with stats_tabs[1]:
+            st.subheader("Advanced Statistics")
+            # Display advanced metrics like PER, TS%, etc.
+            if basic_stats_data:
+                advanced_df = comparison_df.copy()
+                # Calculate some advanced stats
+                if all(col in advanced_df.columns for col in ['PTS', 'FGA', 'FTA']):
+                    advanced_df['TS%'] = advanced_df['PTS'] / (2 * (advanced_df['FGA'] + 0.44 * advanced_df['FTA']))
+                
+                advanced_cols = ['PLAYER_NAME', 'PTS', 'REB', 'AST', 'FG_PCT', 'TS%'] if 'TS%' in advanced_df.columns else ['PLAYER_NAME', '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)
+        
+        with stats_tabs[2]:
+            st.subheader("Player Comparison Charts")
+            
+            if basic_stats_data:
+                # Create comparison charts
+                metrics = ['PTS', 'REB', 'AST', 'FG_PCT']
+                available_metrics = [m for m in metrics if m in comparison_df.columns]
+                
+                selected_metric = st.selectbox("Select Metric to Visualize", available_metrics)
+                
+                if selected_metric:
+                    # Bar chart comparison
+                    fig = px.bar(
+                        comparison_df,
+                        x='PLAYER_NAME',
+                        y=selected_metric,
+                        title=f"{selected_metric} Comparison",
+                        color='PLAYER_NAME'
+                    )
+                    st.plotly_chart(fig, use_container_width=True)
+                    
+                    # Radar chart for multi-metric comparison
+                    if len(available_metrics) >= 3:
+                        radar_data = {}
+                        for _, row in comparison_df.iterrows():
+                            radar_data[row['PLAYER_NAME']] = {
+                                metric: row[metric] for metric in available_metrics[:5]
+                            }
+                        
+                        if radar_data:
+                            radar_fig = create_radar_chart(radar_data, available_metrics[:5])
+                            st.plotly_chart(radar_fig, use_container_width=True)
 
-        if common_seasons:
-            season_selected = st.selectbox("📅 Select Season", common_seasons)
-
-            df_1 = stats_1[stats_1["SEASON_ID"] == season_selected]
-            df_2 = stats_2[stats_2["SEASON_ID"] == season_selected]
-
-            st.subheader(f"📊 {player_1} vs {player_2} - {season_selected}")
-            combined = pd.DataFrame({
-                "Stat": ["PTS", "AST", "REB", "STL", "BLK"],
-                player_1: [
-                    float(df_1["PTS"].values[0]),
-                    float(df_1["AST"].values[0]),
-                    float(df_1["REB"].values[0]),
-                    float(df_1["STL"].values[0]),
-                    float(df_1["BLK"].values[0]),
-                ],
-                player_2: [
-                    float(df_2["PTS"].values[0]),
-                    float(df_2["AST"].values[0]),
-                    float(df_2["REB"].values[0]),
-                    float(df_2["STL"].values[0]),
-                    float(df_2["BLK"].values[0]),
-                ],
-            })
-
-            chart_data = combined.melt("Stat", var_name="Player", value_name="Value")
-
-            chart = alt.Chart(chart_data).mark_bar().encode(
-                x="Stat:N",
-                y="Value:Q",
-                color="Player:N",
-                tooltip=["Player", "Stat", "Value"]
-            ).properties(width=600, height=400)
-
-            st.altair_chart(chart, use_container_width=True)
-        else:
-            st.warning("These players do not have overlapping seasons.")
+def team_comparison_page():
+    st.markdown('<h2 class="section-header">Team vs Team Analysis</h2>', unsafe_allow_html=True)
+    
+    all_teams = get_all_teams()
+    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",
+            ["2023-24", "2022-23", "2021-22", "2020-21"],
+            default=["2023-24"]
+        )
+    
+    if selected_teams:
+        team_stats_data = []
+        
+        for team_name in selected_teams:
+            team_id = next((t['id'] for t in all_teams if t['full_name'] == team_name), None)
+            if team_id:
+                for season in seasons:
+                    stats_df = get_team_stats(team_id, season)
+                    if not stats_df.empty:
+                        team_avg = stats_df.mean(numeric_only=True)
+                        team_avg['TEAM_NAME'] = team_name
+                        team_avg['SEASON'] = season
+                        team_stats_data.append(team_avg)
+        
+        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)
+
+def awards_predictor_page():
+    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
+    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:
-        st.error("One or both players not found.")
+        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 st.button("Generate Predictions"):
+        # Use AI to analyze and predict
+        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.
+        """
+        
+        with st.spinner("Analyzing candidates..."):
+            prediction = query_perplexity(prompt, max_tokens=800)
+            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
+        with st.chat_message("assistant"):
+            with st.spinner("Thinking..."):
+                # 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 = query_perplexity(enhanced_prompt, max_tokens=700)
+                st.write(response)
+                
+                # Add assistant response to chat history
+                st.session_state.chat_history.append({"role": "assistant", "content": response})
+    
+    # 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 = query_perplexity(prompt)
+            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 = query_perplexity(prompt)
+            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 = query_perplexity(prompt)
+            st.write(response)
+
+def young_player_projections_page():
+    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.
+            """
+            
+            with st.spinner("Generating projection..."):
+                projection = query_perplexity(prompt, max_tokens=800)
+                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.
+            """
+            
+            with st.spinner("Finding similar players..."):
+                similar_players = query_perplexity(prompt, max_tokens=800)
+                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 = query_perplexity(prompt, max_tokens=700)
+            st.markdown("### Player Comparison Analysis")
+            st.write(comparison)
+
+def roster_builder_page():
+    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
+    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"):
+        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.
+        """
+        
+        with st.spinner("Building your roster..."):
+            roster_suggestions = query_perplexity(prompt, max_tokens=900)
+            st.markdown("### AI Roster Recommendations")
+            st.write(roster_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 = query_perplexity(prompt, max_tokens=700)
+            st.markdown("### Trade Analysis")
+            st.write(trade_analysis)
+
+if __name__ == "__main__":
+    main()