Update src/streamlit_app.py

src/streamlit_app.py

@@ -45,6 +45,15 @@ SCRAPE_HEADERS = {
 }
 
 PERPLEXITY_API_URL = 'https://api.perplexity.ai/chat/completions'
+PERPLEXITY_MODELS = [
+    "sonar-deep-research",
+    "sonar-reasoning-pro",
+    "sonar-reasoning",
+    "sonar-pro",
+    "sonar", # Defaulting to this if sonar-medium-online is not listed
+    "r1-1776"
+]
+
 
 # Initialize session state for storing data
 if 'player_stats_data' not in st.session_state:
@@ -55,12 +64,23 @@ if 'fixtures_data' not in st.session_state:
     st.session_state.fixtures_data = {}
 if 'perplexity_api_key' not in st.session_state:
     st.session_state.perplexity_api_key = ""
+if 'selected_perplexity_model' not in st.session_state:
+    st.session_state.selected_perplexity_model = "sonar" # Default model
 
 
 # ---------- Helper Functions (from Flask app) ----------
 def clean_fbref_df_columns(df):
     if isinstance(df.columns, pd.MultiIndex):
-        df.columns = df.columns.droplevel(0)
+        # Attempt to drop the top level if it's generic or a category header
+        # This is common for FBRef player stats tables
+        try:
+            df.columns = df.columns.droplevel(0)
+        except Exception as e:
+            st.warning(f"Could not droplevel(0) from columns: {e}. Columns: {df.columns}")
+            # If droplevel fails, try to flatten in a different way or use as is
+            # For now, we'll proceed, but this might need adjustment based on specific table structures
+    
+    # Further cleaning
     df.columns = ["".join(c if c.isalnum() or c == '%' else "_" for c in str(col)) for col in df.columns]
     df.columns = [col.replace('%', 'Pct') for col in df.columns]
     df = df.rename(columns=lambda x: re.sub(r'_+', '_', x))
@@ -70,174 +90,231 @@ def clean_fbref_df_columns(df):
 # ---------- Scraping Functions (modified for Streamlit) ----------
 def scrape_player_stats_st(league_keys_to_scrape):
     st.write("### Scraping Player Stats...")
-    progress_bar = st.progress(0)
+    my_bar = st.progress(0)
     total_leagues = len(league_keys_to_scrape)
     
     for i, key in enumerate(league_keys_to_scrape):
         url = LEAGUES[key]['player_stats_url']
-        st.write(f"Fetching player stats for: {LEAGUES[key]['name']}...")
+        st.info(f"Fetching player stats for: {LEAGUES[key]['name']} from {url}")
         try:
-            r = requests.get(url, headers=SCRAPE_HEADERS, timeout=30)
+            r = requests.get(url, headers=SCRAPE_HEADERS, timeout=45) # Increased timeout
             r.raise_for_status()
             soup = BeautifulSoup(r.text, 'html.parser')
+            
+            # Player standard stats table usually has id="stats_standard" on these specific stats pages
             table_player_standard = soup.find('table', {'id': 'stats_standard'})
 
             if table_player_standard:
-                df = pd.read_html(str(table_player_standard))[0]
+                df_list = pd.read_html(str(table_player_standard), flavor='lxml') # Use lxml
+                if not df_list:
+                    st.error(f"Pandas could not read any table from the HTML for player stats: {LEAGUES[key]['name']}.")
+                    continue
+                df = df_list[0] # Usually the first table
+                
                 df = clean_fbref_df_columns(df)
-                df = df[df['Player'].notna() & (df['Player'] != 'Player')]
-                df = df[df['Rk'].notna() & (df['Rk'] != 'Rk')]
                 
+                # Ensure 'Player' and 'Rk' columns exist after cleaning for filtering
+                if 'Player' not in df.columns:
+                    st.error(f"'Player' column not found after cleaning for {LEAGUES[key]['name']}. Columns: {df.columns}")
+                    st.dataframe(df.head()) # Show what columns are there
+                    continue
+                if 'Rk' not in df.columns:
+                    st.warning(f"'Rk' column not found after cleaning for {LEAGUES[key]['name']}. Filtering might be less effective. Columns: {df.columns}")
+                    # Proceed without Rk filtering if not present
+                    df = df[df['Player'].notna() & (df['Player'] != 'Player')]
+                else:
+                    df = df[df['Player'].notna() & (df['Player'] != 'Player')]
+                    df = df[df['Rk'].notna() & (df['Rk'] != 'Rk')] # Filter out non-player rows if 'Rk' (Rank) column exists
+                
+                # Convert potential numeric columns
                 for col in df.columns:
-                    if col not in ['Player', 'Nation', 'Pos', 'Squad', 'Comp', 'Matches']:
+                    if col.lower() not in ['player', 'nation', 'pos', 'squad', 'comp', 'matches', 'match_report']: # Non-numeric columns
                         try:
                             df[col] = pd.to_numeric(df[col], errors='coerce')
                         except Exception:
-                            pass
-                df = df.fillna(0)
+                            pass # Keep as is if conversion fails
+                df = df.fillna(0) # Or use more sophisticated NaN handling for specific columns
 
                 st.session_state.player_stats_data[key] = df
-                st.success(f"Successfully scraped player stats for {LEAGUES[key]['name']}.")
+                st.success(f"Successfully scraped and processed player stats for {LEAGUES[key]['name']}.")
+                st.dataframe(df.head()) # Show a preview
             else:
-                st.error(f"Could not find player stats table for {LEAGUES[key]['name']}.")
-            time.sleep(3) 
+                st.error(f"Could not find player standard stats table (id='stats_standard') for {LEAGUES[key]['name']} at {url}")
+            time.sleep(5) # Be polite
         except Exception as e:
             st.error(f"Error scraping player stats for {LEAGUES[key]['name']}: {e}")
-        progress_bar.progress((i + 1) / total_leagues)
+        my_bar.progress((i + 1) / total_leagues)
     st.write("Player stats scraping complete.")
 
+
 def scrape_squad_stats_st(league_keys_to_scrape):
     st.write("### Scraping Squad Stats (League Tables)...")
-    progress_bar = st.progress(0)
+    my_bar = st.progress(0)
     total_leagues = len(league_keys_to_scrape)
 
     for i, key in enumerate(league_keys_to_scrape):
         url = LEAGUES[key]['squad_stats_url']
-        st.write(f"Fetching squad stats for: {LEAGUES[key]['name']}...")
+        st.info(f"Fetching squad stats for: {LEAGUES[key]['name']} from {url}")
         try:
             r = requests.get(url, headers=SCRAPE_HEADERS, timeout=30)
             r.raise_for_status()
             soup = BeautifulSoup(r.text, 'html.parser')
             
             league_table = None
-            all_captions = soup.find_all('caption')
-            for caption_tag in all_captions:
-                if "table" in caption_tag.get_text().lower() and "squad" not in caption_tag.get_text().lower() and "standard stats" not in caption_tag.get_text().lower():
-                    parent_table = caption_tag.find_parent('table')
-                    temp_df_check = pd.read_html(str(parent_table))[0]
-                    temp_cols = temp_df_check.columns
-                    if isinstance(temp_cols, pd.MultiIndex): temp_cols = temp_cols.droplevel(0)
-                    if all(col in temp_cols for col in ['Squad', 'MP', 'W', 'D', 'L', 'Pts']):
-                        league_table = parent_table
-                        break
-            
+            # Try finding the main league table first (often has "overall" in id or a specific caption)
+            possible_ids = [id_val for id_val in soup.find_all(id=True) if "overall" in str(id_val.get('id','')).lower() and "results" in str(id_val.get('id','')).lower()]
+            if possible_ids:
+                 table_tag = soup.find('table', id=possible_ids[0].get('id'))
+                 if table_tag: league_table = table_tag
+
             if not league_table:
-                potential_table = soup.find('table', id=lambda x: x and 'overall' in x)
-                if potential_table: league_table = potential_table
+                all_captions = soup.find_all('caption')
+                for caption_tag in all_captions:
+                    caption_text = caption_tag.get_text().lower()
+                    if ("league table" in caption_text or "regular season" in caption_text or "overall" in caption_text) and "squad" not in caption_text :
+                        parent_table = caption_tag.find_parent('table')
+                        if parent_table:
+                            temp_df_check = pd.read_html(str(parent_table), flavor='lxml')[0]
+                            temp_cols = temp_df_check.columns
+                            if isinstance(temp_cols, pd.MultiIndex): temp_cols = temp_cols.droplevel(0)
+                            if all(col in temp_cols for col in ['Squad', 'MP', 'W', 'D', 'L', 'Pts']):
+                                league_table = parent_table
+                                break
             
-            if not league_table:
+            if not league_table: # Fallback to first 'stats_standard' if it's a squad table
                 table_squad_standard = soup.find('table', {'id': 'stats_standard'})
                 if table_squad_standard:
-                    temp_df_check = pd.read_html(str(table_squad_standard))[0]
+                    temp_df_check = pd.read_html(str(table_squad_standard), flavor='lxml')[0]
                     temp_cols = temp_df_check.columns
                     if isinstance(temp_cols, pd.MultiIndex): temp_cols = temp_cols.droplevel(0)
                     if all(col in temp_cols for col in ['Squad', 'MP', 'W', 'D', 'L', 'Pts']):
                          league_table = table_squad_standard
 
             if league_table:
-                df = pd.read_html(str(league_table))[0]
+                df = pd.read_html(str(league_table), flavor='lxml')[0]
                 df = clean_fbref_df_columns(df)
+                
+                if 'Squad' not in df.columns or 'Rk' not in df.columns:
+                    st.error(f"Squad or Rk column missing after cleaning for squad stats {LEAGUES[key]['name']}. Columns: {df.columns}")
+                    st.dataframe(df.head())
+                    continue
+
                 df = df[df['Squad'].notna() & (df['Squad'] != 'Squad')]
                 df = df[df['Rk'].notna() & (df['Rk'] != 'Rk')]
 
-                numeric_cols = ['MP', 'W', 'D', 'L', 'GF', 'GA', 'GD', 'Pts', 'xG', 'xGA', 'xGD']
+                numeric_cols = ['MP', 'W', 'D', 'L', 'GF', 'GA', 'GD', 'Pts', 'xG', 'xGA', 'xGD', 'Attendance']
                 for col in df.columns:
-                    if col in numeric_cols:
+                    if col in numeric_cols: # Check if column exists before trying to convert
                         df[col] = pd.to_numeric(df[col], errors='coerce')
                 df = df.fillna(0)
 
                 st.session_state.squad_stats_data[key] = df
                 st.success(f"Successfully scraped squad stats for {LEAGUES[key]['name']}.")
             else:
-                st.error(f"Could not find squad stats table for {LEAGUES[key]['name']}.")
+                st.error(f"Could not find a suitable squad stats/league table for {LEAGUES[key]['name']} at {url}")
             time.sleep(3)
         except Exception as e:
             st.error(f"Error scraping squad stats for {LEAGUES[key]['name']}: {e}")
-        progress_bar.progress((i + 1) / total_leagues)
+        my_bar.progress((i + 1) / total_leagues)
     st.write("Squad stats scraping complete.")
 
 def scrape_fixtures_st(league_keys_to_scrape):
     st.write("### Scraping Fixtures...")
-    progress_bar = st.progress(0)
+    my_bar = st.progress(0)
     total_leagues = len(league_keys_to_scrape)
 
     for i, key in enumerate(league_keys_to_scrape):
         url = LEAGUES[key]['fixtures_url']
-        st.write(f"Fetching fixtures for: {LEAGUES[key]['name']}...")
+        st.info(f"Fetching fixtures for: {LEAGUES[key]['name']} from {url}")
         try:
             r = requests.get(url, headers=SCRAPE_HEADERS, timeout=30)
             r.raise_for_status()
             soup = BeautifulSoup(r.text, 'html.parser')
             
             fixture_table = None
+            # Fixture tables often have a caption containing "Scores and Fixtures"
             all_captions = soup.find_all('caption')
             for caption_tag in all_captions:
                 if "scores and fixtures" in caption_tag.get_text().lower():
                     fixture_table = caption_tag.find_parent('table')
                     if fixture_table: break
             
-            if not fixture_table:
-                 potential_tables = soup.find_all('table', class_="stats_table")
-                 if potential_tables: fixture_table = potential_tables[0]
+            if not fixture_table: # Fallback if caption not found
+                 potential_tables = soup.find_all('table', class_=lambda x: x and "stats_table" in x and "sched" in x) # More specific class
+                 if not potential_tables:
+                     potential_tables = soup.find_all('table', class_="stats_table") # Generic fallback
+                 if potential_tables:
+                     # Iterate to find one with typical fixture columns
+                     for pt in potential_tables:
+                         temp_df_check = pd.read_html(str(pt), flavor='lxml')[0]
+                         temp_cols = temp_df_check.columns
+                         if isinstance(temp_cols, pd.MultiIndex): temp_cols = temp_cols.droplevel(0)
+                         if all(c in temp_cols for c in ['Wk', 'Date', 'Home', 'Away']):
+                             fixture_table = pt
+                             break
+
 
             if fixture_table:
-                df = pd.read_html(str(fixture_table))[0]
+                df = pd.read_html(str(fixture_table), flavor='lxml')[0]
                 df = clean_fbref_df_columns(df)
-                df = df[df['Wk'].notna()]
-                df = df[df['Home'].notna() & (df['Home'] != 'Home')]
+
+                if 'Wk' not in df.columns or 'Home' not in df.columns:
+                    st.error(f"Wk or Home column missing after cleaning for fixtures {LEAGUES[key]['name']}. Columns: {df.columns}")
+                    st.dataframe(df.head())
+                    continue
+                
+                df = df[df['Wk'].notna()] # Week column usually present for fixtures
+                df = df[df['Home'].notna() & (df['Home'] != 'Home')] # Ensure Home team is present and not a header
 
                 if 'Score' in df.columns:
-                    score_split = df['Score'].astype(str).str.split('–', expand=True)
+                    score_split = df['Score'].astype(str).str.split('–', expand=True) # Use en-dash
                     if score_split.shape[1] == 2:
                         df['HomeGoals'] = pd.to_numeric(score_split[0], errors='coerce')
                         df['AwayGoals'] = pd.to_numeric(score_split[1], errors='coerce')
-                    else:
-                        df['HomeGoals'] = None
-                        df['AwayGoals'] = None
-                
+                    else: 
+                        df['HomeGoals'] = pd.NA # Use pandas NA for missing numeric
+                        df['AwayGoals'] = pd.NA
+                else:
+                    df['HomeGoals'] = pd.NA
+                    df['AwayGoals'] = pd.NA
+
                 if 'Date' in df.columns:
-                    df['Date'] = pd.to_datetime(df['Date'], errors='coerce').dt.strftime('%Y-%m-%d')
+                    # Attempt to parse date, handling potential errors
+                    df['Date_parsed'] = pd.to_datetime(df['Date'], errors='coerce')
+                    df['Date'] = df['Date_parsed'].dt.strftime('%Y-%m-%d')
+                    # df = df.drop(columns=['Date_parsed']) # Optional: drop the intermediate column
 
                 st.session_state.fixtures_data[key] = df
                 st.success(f"Successfully scraped fixtures for {LEAGUES[key]['name']}.")
             else:
-                st.error(f"Could not find fixtures table for {LEAGUES[key]['name']}.")
+                st.error(f"Could not find a suitable fixtures table for {LEAGUES[key]['name']} at {url}")
             time.sleep(3)
         except Exception as e:
             st.error(f"Error scraping fixtures for {LEAGUES[key]['name']}: {e}")
-        progress_bar.progress((i + 1) / total_leagues)
+        my_bar.progress((i + 1) / total_leagues)
     st.write("Fixtures scraping complete.")
 
 # ---------- Perplexity API Functions ----------
-def get_perplexity_response(api_key, prompt, system_message="You are a helpful football analyst AI."):
+def get_perplexity_response(api_key, model_name, prompt, system_message="You are a helpful football analyst AI."):
     if not api_key:
         st.error("Perplexity API Key is not set. Please enter it in the sidebar.")
         return None
 
     headers = {
         'Authorization': f'Bearer {api_key}',
-        'Content-Type': 'application/json'
+        'Content-Type': 'application/json',
+        'Accept': 'application/json',
     }
     payload = {
-        'model': 'sonar-medium-online', # Or 'sonar-pro-online'
+        'model': model_name,
         'messages': [
             {'role': 'system', 'content': system_message},
             {'role': 'user', 'content': prompt}
         ]
     }
     try:
-        with st.spinner("Querying Perplexity AI..."):
-            response = requests.post(PERPLEXITY_API_URL, headers=headers, json=payload, timeout=45)
+        with st.spinner(f"Querying Perplexity AI with model: {model_name}..."):
+            response = requests.post(PERPLEXITY_API_URL, headers=headers, json=payload, timeout=60) # Increased timeout
             response.raise_for_status()
         data = response.json()
         return data.get('choices', [{}])[0].get('message', {}).get('content', '')
@@ -246,9 +323,9 @@ def get_perplexity_response(api_key, prompt, system_message="You are a helpful f
         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:
-                error_message = f"Perplexity API error: {e.response.status_code} - {e.response.reason}"
+                error_message = f"Perplexity API error ({e.response.status_code}): {error_detail}"
+            except ValueError: # Not JSON
+                error_message = f"Perplexity API error: {e.response.status_code} - {e.response.reason}. Response: {e.response.text[:200]}"
         st.error(error_message)
         return None
     except Exception as e:
@@ -257,18 +334,24 @@ def get_perplexity_response(api_key, prompt, system_message="You are a helpful f
 
 # ---------- Streamlit UI ----------
 st.set_page_config(layout="wide")
-st.title("⚽ Football Data Scraper & Perplexity Tester")
+st.title("⚽ Football Data Scraper & Perplexity Tester v2")
 st.markdown("Test data retrieval from FBRef and Perplexity API integration. No Firebase calls.")
 
 # --- Sidebar ---
-st.sidebar.header("API Keys")
+st.sidebar.header("API Configuration")
 st.session_state.perplexity_api_key = st.sidebar.text_input(
     "Perplexity API Key:", 
     type="password", 
     value=st.session_state.perplexity_api_key,
-    help="Your Perplexity AI API key. Will not be stored permanently."
+    help="Your Perplexity AI API key."
+)
+st.session_state.selected_perplexity_model = st.sidebar.selectbox(
+    "Select Perplexity Model:",
+    options=PERPLEXITY_MODELS,
+    index=PERPLEXITY_MODELS.index(st.session_state.selected_perplexity_model) if st.session_state.selected_perplexity_model in PERPLEXITY_MODELS else 4 # Default to 'sonar'
 )
 
+
 st.sidebar.markdown("---")
 st.sidebar.header("Scraping Controls")
 selected_league_keys = st.sidebar.multiselect(
@@ -278,17 +361,17 @@ selected_league_keys = st.sidebar.multiselect(
     default=[]
 )
 
-if st.sidebar.button("Scrape Player Stats"):
+if st.sidebar.button("Scrape Player Stats", key="scrape_player_btn"):
     if selected_league_keys: scrape_player_stats_st(selected_league_keys)
-    else: st.sidebar.warning("Select leagues.")
+    else: st.sidebar.warning("Select leagues for player stats.")
 
-if st.sidebar.button("Scrape Squad Stats"):
+if st.sidebar.button("Scrape Squad Stats", key="scrape_squad_btn"):
     if selected_league_keys: scrape_squad_stats_st(selected_league_keys)
-    else: st.sidebar.warning("Select leagues.")
+    else: st.sidebar.warning("Select leagues for squad stats.")
 
-if st.sidebar.button("Scrape Fixtures"):
+if st.sidebar.button("Scrape Fixtures", key="scrape_fixture_btn"):
     if selected_league_keys: scrape_fixtures_st(selected_league_keys)
-    else: st.sidebar.warning("Select leagues.")
+    else: st.sidebar.warning("Select leagues for fixtures.")
 
 st.sidebar.markdown("---")
 st.sidebar.header("View Scraped Data")
@@ -300,21 +383,20 @@ display_league_key = st.sidebar.selectbox(
 
 # --- Main Content Area ---
 if display_league_key:
-    tab1, tab2, tab3 = st.tabs(["Player Stats", "Squad Stats (League Table)", "Fixtures"])
+    tab1, tab2, tab3 = st.tabs([f"Player Stats ({LEAGUES[display_league_key]['name']})", 
+                                f"Squad Stats ({LEAGUES[display_league_key]['name']})", 
+                                f"Fixtures ({LEAGUES[display_league_key]['name']})"])
     with tab1:
-        st.subheader(f"Player Stats for {LEAGUES[display_league_key]['name']}")
         if display_league_key in st.session_state.player_stats_data:
             st.dataframe(st.session_state.player_stats_data[display_league_key])
         else:
             st.info("No player stats data loaded. Scrape first.")
     with tab2:
-        st.subheader(f"Squad Stats for {LEAGUES[display_league_key]['name']}")
         if display_league_key in st.session_state.squad_stats_data:
             st.dataframe(st.session_state.squad_stats_data[display_league_key])
         else:
             st.info("No squad stats data loaded. Scrape first.")
     with tab3:
-        st.subheader(f"Fixtures for {LEAGUES[display_league_key]['name']}")
         if display_league_key in st.session_state.fixtures_data:
             st.dataframe(st.session_state.fixtures_data[display_league_key])
         else:
@@ -327,18 +409,29 @@ st.header("FBRef Data Feature Testing (Local)")
 
 # --- 1. Player Comparison Tool ---
 st.subheader("1. Player Comparison (Local Data)")
-col1_pc, col2_pc, col3_pc = st.columns(3)
-pc_league = col1_pc.selectbox("League (Player Comparison):", options=[""] + list(st.session_state.player_stats_data.keys()), format_func=lambda k: LEAGUES[k]['name'] if k else "Select")
-pc_player1_name = col2_pc.text_input("Player 1 Name:", key="pc_p1")
-pc_player2_name = col3_pc.text_input("Player 2 Name:", key="pc_p2")
+col1_pc, col2_pc, col3_pc = st.columns([1,2,2])
+pc_league_options = [""] + [k for k in st.session_state.player_stats_data.keys() if not st.session_state.player_stats_data[k].empty]
+pc_league = col1_pc.selectbox("League:", options=pc_league_options, format_func=lambda k: LEAGUES[k]['name'] if k else "Select", key="pc_league_select")
+
+pc_player1_name = ""
+pc_player2_name = ""
+
+if pc_league and pc_league in st.session_state.player_stats_data:
+    player_list = sorted(st.session_state.player_stats_data[pc_league]['Player'].unique())
+    pc_player1_name = col2_pc.selectbox("Player 1 Name:", options=[""] + player_list, key="pc_p1_select")
+    pc_player2_name = col3_pc.selectbox("Player 2 Name:", options=[""] + player_list, key="pc_p2_select")
+else:
+    pc_player1_name = col2_pc.text_input("Player 1 Name (Type if no league selected):", key="pc_p1_text")
+    pc_player2_name = col3_pc.text_input("Player 2 Name (Type if no league selected):", key="pc_p2_text")
+
 
 if st.button("Compare Players (Local)", key="compare_local_btn"):
-    # ... (Player comparison logic remains the same as before) ...
     if pc_league and pc_player1_name and pc_player2_name:
         if pc_league in st.session_state.player_stats_data:
             all_players_df = st.session_state.player_stats_data[pc_league]
-            player1_data = all_players_df[all_players_df['Player'].str.contains(pc_player1_name, case=False, na=False)]
-            player2_data = all_players_df[all_players_df['Player'].str.contains(pc_player2_name, case=False, na=False)]
+            # Exact match from selectbox, or contains if text input was used (though selectbox is preferred now)
+            player1_data = all_players_df[all_players_df['Player'] == pc_player1_name]
+            player2_data = all_players_df[all_players_df['Player'] == pc_player2_name]
 
             if not player1_data.empty:
                 st.write(f"**Stats for {pc_player1_name}:**")
@@ -352,78 +445,108 @@ if st.button("Compare Players (Local)", key="compare_local_btn"):
             else:
                 st.warning(f"Could not find data for player: {pc_player2_name} in {LEAGUES[pc_league]['name']}")
         else:
-            st.error(f"Player stats data for {LEAGUES[pc_league]['name']} not loaded. Please scrape first.")
+            st.error(f"Player stats data for {LEAGUES[pc_league]['name']} not loaded or is empty. Please scrape first.")
     else:
-        st.warning("Please select a league and enter two player names for comparison.")
+        st.warning("Please select a league and two player names for comparison.")
 
 
 # --- 2. Fixture Analysis (Local Data) ---
 st.subheader("2. Fixture Analysis (Local Data)")
-# ... (Fixture analysis logic remains the same as before) ...
-col1_fa, col2_fa, col3_fa = st.columns(3)
-fa_league = col1_fa.selectbox("League (Fixture Analysis):", options=[""] + list(st.session_state.fixtures_data.keys()), format_func=lambda k: LEAGUES[k]['name'] if k else "Select")
-fa_home_team = col2_fa.text_input("Home Team Name:", key="fa_home")
-fa_away_team = col3_fa.text_input("Away Team Name:", key="fa_away")
+col1_fa, col2_fa, col3_fa = st.columns([1,2,2])
+fa_league_options = [""] + [k for k in st.session_state.fixtures_data.keys() if not st.session_state.fixtures_data[k].empty]
+fa_league = col1_fa.selectbox("League:", options=fa_league_options, format_func=lambda k: LEAGUES[k]['name'] if k else "Select", key="fa_league_select")
+
+fa_home_team = ""
+fa_away_team = ""
+
+if fa_league and fa_league in st.session_state.fixtures_data:
+    # Get unique team names from both Home and Away columns
+    home_teams = st.session_state.fixtures_data[fa_league]['Home'].unique()
+    away_teams = st.session_state.fixtures_data[fa_league]['Away'].unique()
+    all_teams = sorted(list(set(list(home_teams) + list(away_teams))))
+    fa_home_team = col2_fa.selectbox("Home Team:", options=[""] + all_teams, key="fa_home_select")
+    fa_away_team = col3_fa.selectbox("Away Team:", options=[""] + all_teams, key="fa_away_select")
+else:
+    fa_home_team = col2_fa.text_input("Home Team (Type if no league selected):", key="fa_home_text")
+    fa_away_team = col3_fa.text_input("Away Team (Type if no league selected):", key="fa_away_text")
+
 
 if st.button("Analyze Fixture (Local)", key="analyze_local_btn"):
     if fa_league and fa_home_team and fa_away_team:
         if fa_league in st.session_state.fixtures_data:
-            all_fixtures_df = st.session_state.fixtures_data[fa_league]
+            all_fixtures_df = st.session_state.fixtures_data[fa_league].copy() # Use a copy
             home_team_norm = fa_home_team.strip().lower()
             away_team_norm = fa_away_team.strip().lower()
 
+            # Ensure 'Date' column is suitable for sorting (already converted to YYYY-MM-DD string)
+            # If 'Date_parsed' exists and is datetime, use it for sorting then drop
+            if 'Date_parsed' in all_fixtures_df.columns:
+                all_fixtures_df = all_fixtures_df.sort_values(by='Date_parsed', ascending=False)
+            elif 'Date' in all_fixtures_df.columns:
+                 all_fixtures_df = all_fixtures_df.sort_values(by='Date', ascending=False)
+
+
             h2h_matches = all_fixtures_df[
                 (all_fixtures_df['Home'].str.lower() == home_team_norm) & (all_fixtures_df['Away'].str.lower() == away_team_norm) |
                 (all_fixtures_df['Home'].str.lower() == away_team_norm) & (all_fixtures_df['Away'].str.lower() == home_team_norm)
             ]
             st.write(f"**Head-to-Head between {fa_home_team} and {fa_away_team}:**")
             if not h2h_matches.empty:
-                st.dataframe(h2h_matches.sort_values(by='Date', ascending=False))
+                st.dataframe(h2h_matches) # Already sorted by date
             else:
                 st.info("No H2H matches found in the scraped data.")
 
-            def get_form_df(team_name, all_fixtures, num_matches=5):
-                team_matches = all_fixtures[
-                    (all_fixtures['Home'].str.lower() == team_name.lower()) | (all_fixtures['Away'].str.lower() == team_name.lower())
+            def get_form_df(team_name_norm, all_fixtures_sorted_df, num_matches=5):
+                team_matches = all_fixtures_sorted_df[ # Use already sorted df
+                    (all_fixtures_sorted_df['Home'].str.lower() == team_name_norm) | 
+                    (all_fixtures_sorted_df['Away'].str.lower() == team_name_norm)
                 ]
-                played_matches = team_matches[team_matches['HomeGoals'].notna()].sort_values(by='Date', ascending=False)
+                # Consider only played matches (where HomeGoals is not NA after conversion)
+                played_matches = team_matches[team_matches['HomeGoals'].notna()]
                 return played_matches.head(num_matches)
 
             st.write(f"**Recent Form for {fa_home_team} (last 5 played):**")
-            home_form_df = get_form_df(fa_home_team, all_fixtures_df)
+            home_form_df = get_form_df(home_team_norm, all_fixtures_df)
             if not home_form_df.empty: st.dataframe(home_form_df)
             else: st.info(f"No recent played matches found for {fa_home_team}.")
             
             st.write(f"**Recent Form for {fa_away_team} (last 5 played):**")
-            away_form_df = get_form_df(fa_away_team, all_fixtures_df)
+            away_form_df = get_form_df(away_team_norm, all_fixtures_df)
             if not away_form_df.empty: st.dataframe(away_form_df)
             else: st.info(f"No recent played matches found for {fa_away_team}.")
         else:
-            st.error(f"Fixtures data for {LEAGUES[fa_league]['name']} not loaded. Please scrape first.")
+            st.error(f"Fixtures data for {LEAGUES[fa_league]['name']} not loaded or is empty. Please scrape first.")
     else:
-        st.warning("Please select a league and enter home/away team names for analysis.")
+        st.warning("Please select a league and enter/select home & away team names for analysis.")
 
 # --- 3. Visualization Data (Local Data) ---
 st.subheader("3. Visualization Data (Example: Top Scorers - Local Data)")
-# ... (Visualization logic remains the same as before) ...
 col1_vd, col2_vd = st.columns(2)
-vd_league = col1_vd.selectbox("League (Visualization):", options=[""] + list(st.session_state.player_stats_data.keys()), format_func=lambda k: LEAGUES[k]['name'] if k else "Select")
+vd_league_options = [""] + [k for k in st.session_state.player_stats_data.keys() if not st.session_state.player_stats_data[k].empty]
+vd_league = col1_vd.selectbox("League:", options=vd_league_options, format_func=lambda k: LEAGUES[k]['name'] if k else "Select", key="vd_league_select")
 
 if st.button("Show Top Scorers (Local)", key="top_scorers_local_btn"):
     if vd_league:
         if vd_league in st.session_state.player_stats_data:
             player_df = st.session_state.player_stats_data[vd_league].copy()
-            player_df['Gls'] = pd.to_numeric(player_df.get('Gls'), errors='coerce').fillna(0)
-            player_df['Ast'] = pd.to_numeric(player_df.get('Ast'), errors='coerce').fillna(0)
-            top_scorers = player_df.sort_values(by=['Gls', 'Ast'], ascending=[False, False]).head(10)
-            st.write(f"**Top 10 Scorers Data for {LEAGUES[vd_league]['name']}:**")
-            st.dataframe(top_scorers[['Player', 'Squad', 'Gls', 'Ast']])
-            if not top_scorers.empty:
-                st.write("**Chart: Goals by Top Scorers**")
-                chart_data = top_scorers.set_index('Player')[['Gls', 'Ast']]
-                st.bar_chart(chart_data)
+            
+            # Ensure 'Gls' and 'Ast' columns exist and are numeric
+            if 'Gls' not in player_df.columns or 'Ast' not in player_df.columns:
+                st.error(f"Required columns 'Gls' or 'Ast' not found in player stats for {LEAGUES[vd_league]['name']}.")
+            else:
+                player_df['Gls'] = pd.to_numeric(player_df['Gls'], errors='coerce').fillna(0)
+                player_df['Ast'] = pd.to_numeric(player_df['Ast'], errors='coerce').fillna(0)
+                
+                top_scorers = player_df.sort_values(by=['Gls', 'Ast'], ascending=[False, False]).head(10)
+                
+                st.write(f"**Top 10 Scorers Data for {LEAGUES[vd_league]['name']}:**")
+                st.dataframe(top_scorers[['Player', 'Squad', 'Gls', 'Ast']])
+                if not top_scorers.empty and 'Player' in top_scorers.columns:
+                    st.write("**Chart: Goals & Assists by Top Scorers**")
+                    chart_data = top_scorers.set_index('Player')[['Gls', 'Ast']]
+                    st.bar_chart(chart_data)
         else:
-            st.error(f"Player stats data for {LEAGUES[vd_league]['name']} not loaded. Please scrape first.")
+            st.error(f"Player stats data for {LEAGUES[vd_league]['name']} not loaded or is empty. Please scrape first.")
     else:
         st.warning("Please select a league for visualization data.")
 
@@ -432,9 +555,9 @@ st.header("Perplexity API Testing")
 
 # --- 4. Fixture Report via Perplexity ---
 st.subheader("4. Fixture Report (via Perplexity AI)")
-fr_home_team = st.text_input("Home Team (for Perplexity Report):", key="fr_home")
-fr_away_team = st.text_input("Away Team (for Perplexity Report):", key="fr_away")
-fr_match_date = st.text_input("Match Date (e.g., YYYY-MM-DD) (for Perplexity Report):", key="fr_date")
+fr_home_team = st.text_input("Home Team (for Perplexity Report):", key="fr_home_pplx")
+fr_away_team = st.text_input("Away Team (for Perplexity Report):", key="fr_away_pplx")
+fr_match_date = st.text_input("Match Date (e.g., YYYY-MM-DD) (for Perplexity Report):", key="fr_date_pplx", placeholder="YYYY-MM-DD")
 
 if st.button("Get Fixture Report from Perplexity", key="fr_perplexity_btn"):
     if fr_home_team and fr_away_team and fr_match_date:
@@ -450,7 +573,12 @@ if st.button("Get Fixture Report from Perplexity", key="fr_perplexity_btn"):
                 "4. Brief Tactical Outlook or Prediction (optional, if confident).\n"
                 "Prioritize information from reputable football sources. Be objective."
             )
-            report = get_perplexity_response(st.session_state.perplexity_api_key, prompt, "You are a football analyst providing pre-match reports.")
+            report = get_perplexity_response(
+                st.session_state.perplexity_api_key, 
+                st.session_state.selected_perplexity_model,
+                prompt, 
+                "You are a football analyst providing pre-match reports."
+            )
             if report:
                 st.markdown("**Perplexity AI Fixture Report:**")
                 st.markdown(report)
@@ -459,14 +587,18 @@ if st.button("Get Fixture Report from Perplexity", key="fr_perplexity_btn"):
 
 # --- 5. Custom Query via Perplexity ---
 st.subheader("5. Custom Query (via Perplexity AI)")
-custom_query_text = st.text_area("Enter your football-related question:", height=100, key="custom_q")
+custom_query_text = st.text_area("Enter your football-related question:", height=100, key="custom_q_pplx")
 
 if st.button("Ask Perplexity AI", key="custom_q_btn"):
     if custom_query_text:
         if not st.session_state.perplexity_api_key:
             st.error("Perplexity API Key is not set in the sidebar.")
         else:
-            answer = get_perplexity_response(st.session_state.perplexity_api_key, custom_query_text)
+            answer = get_perplexity_response(
+                st.session_state.perplexity_api_key,
+                st.session_state.selected_perplexity_model,
+                custom_query_text
+            )
             if answer:
                 st.markdown("**Perplexity AI Answer:**")
                 st.markdown(answer)
@@ -475,4 +607,4 @@ if st.button("Ask Perplexity AI", key="custom_q_btn"):
 
 
 st.markdown("---")
-st.caption("Streamlit test app by your AI assistant. API keys are not stored after session.")
+st.caption("Streamlit test app. API keys are not stored after session.")