Update main.py

main.py

@@ -30,29 +30,33 @@ CORS(app)
 
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 
-Firebase_DB = os.getenv("Firebase_DB")
-Firebase_Storage = os.getenv("Firebase_Storage")
+# --- Firebase Initialization (CRITICAL FIXES HERE) ---
+# Ensure these environment variables are correctly set in your Hugging Face Space
+FIREBASE_CREDENTIALS_JSON_STRING = os.getenv("FIREBASE")
+FIREBASE_DB_URL = os.getenv("Firebase_DB") # Using a more descriptive name
+FIREBASE_STORAGE_BUCKET = os.getenv("Firebase_Storage") # Using a more descriptive name
 
 FIREBASE_INITIALIZED = False
+bucket = None # Initialize bucket to None
 
 try:
-    credentials_json_string = os.environ.get("FIREBASE")
-    if credentials_json_string:
-        credentials_json = json.loads(credentials_json_string)
+    if FIREBASE_CREDENTIALS_JSON_STRING and FIREBASE_DB_URL and FIREBASE_STORAGE_BUCKET:
+        credentials_json = json.loads(FIREBASE_CREDENTIALS_JSON_STRING)
         cred = credentials.Certificate(credentials_json)
         firebase_admin.initialize_app(cred, {
-            'databaseURL': f'{Firebase_DB}',
-            'storageBucket': f'{Firebase_Storage}'
+            'databaseURL': FIREBASE_DB_URL,
+            'storageBucket': FIREBASE_STORAGE_BUCKET
         })
         FIREBASE_INITIALIZED = True
+        bucket = storage.bucket() # Initialize bucket only if Firebase is initialized
         logging.info("Firebase Admin SDK initialized successfully.")
     else:
-        logging.warning("FIREBASE secret not set. Firebase Admin SDK not initialized.")
+        logging.error("Firebase environment variables (FIREBASE, Firebase_DB, Firebase_Storage) not fully set. Firebase Admin SDK not initialized.")
 except Exception as e:
     logging.error(f"Error initializing Firebase: {e}")
     traceback.print_exc()
+# --- END Firebase Initialization Fixes ---
 
-bucket = storage.bucket() if FIREBASE_INITIALIZED else None
 
 def verify_token(token):
     try:
@@ -63,21 +67,35 @@ def verify_token(token):
         return None
 
 def verify_admin(auth_header):
+    if not FIREBASE_INITIALIZED:
+        logging.error("Firebase not initialized. Admin verification skipped.")
+        raise PermissionError('Server configuration error: Firebase not ready.')
+
     if not auth_header or not auth_header.startswith('Bearer '):
         raise ValueError('Invalid token format')
     token = auth_header.split(' ')[1]
     uid = verify_token(token)
     if not uid:
         raise PermissionError('Invalid user token')
+    
     user_ref = db.reference(f'users/{uid}')
     user_data = user_ref.get()
-    if not user_data or not user_data.get('is_admin', False):
+    
+    if not user_data:
+        logging.warning(f"User {uid} found in Auth but not in Realtime DB. Cannot verify admin status.")
+        raise PermissionError('User profile not found in database. Admin access denied.')
+    
+    if not user_data.get('is_admin', False):
         raise PermissionError('Admin access required')
     return uid
 
 def credit_required(cost=1):
     def decorator(f):
         def wrapper(*args, **kwargs):
+            if not FIREBASE_INITIALIZED:
+                logging.error("Firebase not initialized. Credit deduction skipped.")
+                return jsonify({'error': 'Server configuration error: Firebase not ready.'}), 500
+
             auth_header = request.headers.get('Authorization', '')
             if not auth_header.startswith('Bearer '):
                 return jsonify({'error': 'Authorization header missing or malformed'}), 401
@@ -88,8 +106,10 @@ def credit_required(cost=1):
 
             user_ref = db.reference(f'users/{uid}')
             user_data = user_ref.get()
+            
             if not user_data:
-                return jsonify({'error': 'User not found'}), 404
+                logging.warning(f"User {uid} found in Auth but not in Realtime DB. Cannot process credits.")
+                return jsonify({'error': 'User profile not found in database. Please try logging in again.'}), 404
             
             if user_data.get('suspended', False):
                 return jsonify({'error': 'Account suspended. Please contact support.'}), 403
@@ -113,6 +133,10 @@ def credit_required(cost=1):
 
 @app.route('/api/auth/signup', methods=['POST'])
 def signup():
+    if not FIREBASE_INITIALIZED:
+        logging.error("Firebase not initialized. Signup skipped.")
+        return jsonify({'error': 'Server configuration error: Firebase not ready.'}), 500
+
     try:
         data = request.get_json()
         email = data.get('email')
@@ -120,15 +144,21 @@ def signup():
         if not email or not password:
             return jsonify({'error': 'Email and password are required'}), 400
 
+        # Create user in Firebase Authentication
         user = auth.create_user(email=email, password=password)
+        
+        # Create corresponding user entry in Firebase Realtime Database
         user_ref = db.reference(f'users/{user.uid}')
         user_data = {
             'email': email,
             'credits': 10,
             'is_admin': False,
-            'created_at': datetime.utcnow().isoformat()
+            'created_at': datetime.utcnow().isoformat(),
+            'suspended': False # Ensure new accounts are not suspended by default
         }
         user_ref.set(user_data)
+        logging.info(f"New user {user.uid} signed up and DB entry created.")
+
         return jsonify({
             'success': True,
             'user': {
@@ -138,10 +168,17 @@ def signup():
         }), 201
     except Exception as e:
         logging.error(f"Signup error: {e}")
+        # Firebase Auth errors can be specific, e.g., email-already-in-use
+        if 'email-already-in-use' in str(e):
+            return jsonify({'error': 'Email already in use.'}), 409 # Conflict
         return jsonify({'error': str(e)}), 400
 
 @app.route('/api/user/profile', methods=['GET'])
 def get_user_profile():
+    if not FIREBASE_INITIALIZED:
+        logging.error("Firebase not initialized. Profile retrieval skipped.")
+        return jsonify({'error': 'Server configuration error: Firebase not ready.'}), 500
+
     try:
         auth_header = request.headers.get('Authorization', '')
         if not auth_header.startswith('Bearer '):
@@ -154,13 +191,15 @@ def get_user_profile():
         
         user_data = db.reference(f'users/{uid}').get()
         if not user_data:
-            return jsonify({'error': 'User not found'}), 404
+            logging.warning(f"User {uid} found in Auth but not in Realtime DB when fetching profile.")
+            return jsonify({'error': 'User profile not found in database. Please try logging in again.'}), 404
         
         return jsonify({
             'uid': uid,
             'email': user_data.get('email'),
             'credits': user_data.get('credits', 0),
-            'is_admin': user_data.get('is_admin', False)
+            'is_admin': user_data.get('is_admin', False),
+            'suspended': user_data.get('suspended', False) # Include suspended status
         })
     except Exception as e:
         logging.error(f"Error fetching user profile: {e}")
@@ -168,6 +207,10 @@ def get_user_profile():
 
 @app.route('/api/auth/google-signin', methods=['POST'])
 def google_signin():
+    if not FIREBASE_INITIALIZED:
+        logging.error("Firebase not initialized. Google Sign-In skipped.")
+        return jsonify({'error': 'Server configuration error: Firebase not ready.'}), 500
+
     try:
         auth_header = request.headers.get('Authorization', '')
         if not auth_header.startswith('Bearer '):
@@ -182,13 +225,18 @@ def google_signin():
         user_data = user_ref.get()
 
         if not user_data:
+            # If user doesn't exist in DB, create a new entry
             user_data = {
                 'email': email,
                 'credits': 10,
                 'is_admin': False,
                 'created_at': datetime.utcnow().isoformat(),
+                'suspended': False
             }
             user_ref.set(user_data)
+            logging.info(f"New Google user {uid} signed up and DB entry created.")
+        else:
+            logging.info(f"Existing Google user {uid} logged in.")
 
         return jsonify({
             'success': True,
@@ -205,6 +253,10 @@ def google_signin():
 @app.route('/api/user/request-credits', methods=['POST'])
 @credit_required(cost=0)
 def request_credits():
+    if not FIREBASE_INITIALIZED:
+        logging.error("Firebase not initialized. Request credits skipped.")
+        return jsonify({'error': 'Server configuration error: Firebase not ready.'}), 500
+
     try:
         auth_header = request.headers.get('Authorization', '')
         token = auth_header.split(' ')[1]
@@ -231,6 +283,10 @@ def request_credits():
 @credit_required(cost=0)
 @cross_origin()
 def submit_feedback():
+    if not FIREBASE_INITIALIZED:
+        logging.error("Firebase not initialized. Submit feedback skipped.")
+        return jsonify({'error': 'Server configuration error: Firebase not ready.'}), 500
+
     try:
         auth_header = request.headers.get('Authorization', '')
         token = auth_header.split(' ')[1]
@@ -262,6 +318,10 @@ def submit_feedback():
 
 @app.route('/api/admin/profile', methods=['GET'])
 def get_admin_profile():
+    if not FIREBASE_INITIALIZED:
+        logging.error("Firebase not initialized. Admin profile skipped.")
+        return jsonify({'error': 'Server configuration error: Firebase not ready.'}), 500
+
     try:
         admin_uid = verify_admin(request.headers.get('Authorization', ''))
         admin_data = db.reference(f'users/{admin_uid}').get()
@@ -300,6 +360,10 @@ def get_admin_profile():
 
 @app.route('/api/admin/credit_requests', methods=['GET'])
 def list_credit_requests():
+    if not FIREBASE_INITIALIZED:
+        logging.error("Firebase not initialized. List credit requests skipped.")
+        return jsonify({'error': 'Server configuration error: Firebase not ready.'}), 500
+
     try:
         verify_admin(request.headers.get('Authorization', ''))
         requests_ref = db.reference('credit_requests')
@@ -312,6 +376,10 @@ def list_credit_requests():
 
 @app.route('/api/admin/credit_requests/<string:request_id>', methods=['PUT'])
 def process_credit_request(request_id):
+    if not FIREBASE_INITIALIZED:
+        logging.error("Firebase not initialized. Process credit request skipped.")
+        return jsonify({'error': 'Server configuration error: Firebase not ready.'}), 500
+
     try:
         admin_uid = verify_admin(request.headers.get('Authorization', ''))
         req_ref = db.reference(f'credit_requests/{request_id}')
@@ -350,6 +418,10 @@ def process_credit_request(request_id):
 
 @app.route('/api/admin/users', methods=['GET'])
 def admin_list_users():
+    if not FIREBASE_INITIALIZED:
+        logging.error("Firebase not initialized. Admin list users skipped.")
+        return jsonify({'error': 'Server configuration error: Firebase not ready.'}), 500
+
     try:
         verify_admin(request.headers.get('Authorization', ''))
         users_ref = db.reference('users')
@@ -372,6 +444,10 @@ def admin_list_users():
 
 @app.route('/api/admin/users/search', methods=['GET'])
 def admin_search_users():
+    if not FIREBASE_INITIALIZED:
+        logging.error("Firebase not initialized. Admin search users skipped.")
+        return jsonify({'error': 'Server configuration error: Firebase not ready.'}), 500
+
     try:
         verify_admin(request.headers.get('Authorization', ''))
         email_query = request.args.get('email', '').lower().strip()
@@ -400,6 +476,10 @@ def admin_search_users():
 
 @app.route('/api/admin/users/<string:uid>/suspend', methods=['PUT'])
 def admin_suspend_user(uid):
+    if not FIREBASE_INITIALIZED:
+        logging.error("Firebase not initialized. Admin suspend user skipped.")
+        return jsonify({'error': 'Server configuration error: Firebase not ready.'}), 500
+
     try:
         verify_admin(request.headers.get('Authorization', ''))
         data = request.get_json()
@@ -424,6 +504,10 @@ def admin_suspend_user(uid):
 
 @app.route('/api/admin/notifications', methods=['POST'])
 def send_notifications():
+    if not FIREBASE_INITIALIZED:
+        logging.error("Firebase not initialized. Send notifications skipped.")
+        return jsonify({'error': 'Server configuration error: Firebase not ready.'}), 500
+
     try:
         admin_uid = verify_admin(request.headers.get('Authorization', ''))
         data = request.get_json()
@@ -471,6 +555,10 @@ def send_notifications():
 
 @app.route('/api/admin/feedback', methods=['GET'])
 def admin_view_feedback():
+    if not FIREBASE_INITIALIZED:
+        logging.error("Firebase not initialized. Admin view feedback skipped.")
+        return jsonify({'error': 'Server configuration error: Firebase not ready.'}), 500
+
     try:
         admin_uid = verify_admin(request.headers.get('Authorization', ''))
         feedback_type = request.args.get('type')
@@ -502,6 +590,10 @@ def admin_view_feedback():
         
 @app.route('/api/admin/users/<string:uid>/credits', methods=['PUT'])
 def admin_update_credits(uid):
+    if not FIREBASE_INITIALIZED:
+        logging.error("Firebase not initialized. Admin update credits skipped.")
+        return jsonify({'error': 'Server configuration error: Firebase not ready.'}), 500
+
     try:
         verify_admin(request.headers.get('Authorization', ''))
         data = request.get_json()
@@ -658,8 +750,7 @@ def get_player_index_brscraper():
         return df
 
 def _scrape_player_index_brscraper():
-    # Prioritize getting real player data from recent seasons
-    seasons_to_try_for_index = get_available_seasons_util(num_seasons=2) # Try current and previous season
+    seasons_to_try_for_index = get_available_seasons_util(num_seasons=2)
     
     for season_str in seasons_to_try_for_index:
         end_year = int(season_str.split('–')[1])
@@ -669,7 +760,6 @@ def _scrape_player_index_brscraper():
             
             if not df.empty and 'Player' in df.columns:
                 player_names = df['Player'].dropna().unique().tolist()
-                # Normalize player names before returning
                 player_names = [normalize_string(name) for name in player_names]
                 logging.info(f"Successfully retrieved {len(player_names)} players for index from {season_str}.")
                 return pd.DataFrame({'name': player_names})
@@ -678,12 +768,11 @@ def _scrape_player_index_brscraper():
         except Exception as e:
             logging.warning(f"Error fetching player index with BRScraper for {season_str}: {e}. Trying next season.")
 
-    # Fallback to a curated list if recent seasons fail
     logging.error("Failed to fetch player index from recent seasons. Falling back to curated common players list.")
     common_players = [
         'LeBron James', 'Stephen Curry', 'Kevin Durant', 'Giannis Antetokounmpo',
-        'Nikola Jokic', # No accent here, as it will be normalized
-        'Joel Embiid', 'Jayson Tatum', 'Luka Doncic', # No accent here, as it will be normalized
+        'Nikola Jokic',
+        'Joel Embiid', 'Jayson Tatum', 'Luka Doncic',
         'Damian Lillard', 'Jimmy Butler', 'Kawhi Leonard', 'Paul George',
         'Anthony Davis', 'Rudy Gobert', 'Donovan Mitchell', 'Trae Young',
         'Devin Booker', 'Karl-Anthony Towns', 'Zion Williamson', 'Ja Morant',
@@ -692,22 +781,30 @@ def _scrape_player_index_brscraper():
     ]
     return pd.DataFrame({'name': common_players})
 
-def get_player_career_stats_brscraper(player_name, seasons_to_check=10, playoffs=False):
+def get_player_career_stats_brscraper(player_name, seasons_to_fetch: list[str], playoffs=False):
     if not BRSCRAPER_AVAILABLE:
         logging.error("BRScraper is not available. Cannot fetch player career stats.")
         return pd.DataFrame()
-    all_rows = []
     
-    # Normalize the input player name for consistent lookup
     normalized_player_name = normalize_string(player_name)
+    all_rows = []
 
-    seasons_to_try = get_available_seasons_util(seasons_to_check)
-    
-    for season_str in seasons_to_try:
+    for season_str in seasons_to_fetch:
         end_year = int(season_str.split('–')[1])
         
-        # Implement retry logic for each season fetch
-        for attempt in range(3): # Try up to 3 times
+        cache_key = f"{normalized_player_name}_{end_year}_{'playoffs' if playoffs else 'regular'}"
+        db_ref = db.reference(f'scraped_data/player_season_stats/{cache_key}')
+
+        if FIREBASE_INITIALIZED:
+            cached_data = db_ref.get()
+            if cached_data and not is_data_stale(cached_data.get('last_updated'), max_age_hours=24*7):
+                logging.info(f"Loading stats for {player_name} in {season_str} (playoffs: {playoffs}) from Firebase cache.")
+                all_rows.append(pd.DataFrame.from_records(cached_data['data']))
+                continue # Skip scraping for this season if found in cache
+            else:
+                logging.info(f"Stats for {player_name} in {season_str} cache stale or not found. Scraping...")
+
+        for attempt in range(3):
             try:
                 logging.info(f"DEBUG: Attempt {attempt+1} for nba.get_stats for player '{player_name}' in season {season_str} (year: {end_year}, playoffs: {playoffs})...")
                 
@@ -715,41 +812,49 @@ def get_player_career_stats_brscraper(player_name, seasons_to_check=10, playoffs
                 
                 if df_season.empty:
                     logging.warning(f"DEBUG: nba.get_stats returned empty DataFrame for {player_name} in {season_str} on attempt {attempt+1}. Retrying...")
-                    time.sleep(1) # Wait a bit before retrying
-                    continue # Go to next attempt
+                    time.sleep(1)
+                    continue 
                 
                 if 'Player' not in df_season.columns:
                     logging.warning(f"DEBUG: DataFrame for {player_name} in {season_str} has no 'Player' column on attempt {attempt+1}. Columns: {df_season.columns.tolist()}. Retrying...")
                     time.sleep(1)
                     continue
 
-                # Normalize player names in the DataFrame for comparison
                 df_season['Player_Normalized'] = df_season['Player'].apply(normalize_string)
-                
                 row = df_season[df_season['Player_Normalized'] == normalized_player_name]
                 
                 if not row.empty:
                     row = row.copy()
                     row['Season'] = season_str
-                    # Remove the temporary normalized column before appending
                     row = row.drop(columns=['Player_Normalized'], errors='ignore')
+                    
+                    if FIREBASE_INITIALIZED:
+                        df_cleaned_for_firebase = clean_df_for_firebase(row.copy())
+                        db_ref.set({
+                            'last_updated': datetime.utcnow().isoformat(),
+                            'data': df_cleaned_for_firebase.to_dict(orient='records')
+                        })
+                        logging.info(f"Stats for {player_name} in {season_str} saved to Firebase cache.")
+                    
                     all_rows.append(row)
                     logging.info(f"DEBUG: Found stats for {player_name} in {season_str} on attempt {attempt+1}. Appending row.")
-                    break # Break retry loop if successful
+                    break
                 else:
                     logging.info(f"DEBUG: Player {player_name} not found in {season_str} stats (after getting season data) on attempt {attempt+1}. Retrying...")
                     time.sleep(1)
-                    continue # Go to next attempt
+                    continue
 
             except Exception as e:
                 logging.warning(f"DEBUG: Exception on attempt {attempt+1} when fetching {season_str} {'playoff' if playoffs else 'regular season'} stats for {player_name}: {e}")
-                time.sleep(1) # Wait before next retry
-                if attempt == 2: # If last attempt failed
+                time.sleep(1)
+                if attempt == 2:
                     logging.error(f"DEBUG: All 3 attempts failed for {player_name} in {season_str}. Giving up on this season.")
-                continue # Go to next attempt
+                continue
 
+        time.sleep(0.5) # Delay between seasons
+        
     if not all_rows:
-        logging.warning(f"DEBUG: No stats found for {player_name} across all attempted seasons. Returning empty DataFrame.")
+        logging.warning(f"DEBUG: No stats found for {player_name} in the requested seasons: {seasons_to_fetch}. Returning empty DataFrame.")
         return pd.DataFrame()
     
     df = pd.concat(all_rows, ignore_index=True)
@@ -769,13 +874,13 @@ def get_player_career_stats_brscraper(player_name, seasons_to_check=10, playoffs
         if col not in non_num:
             df[col] = pd.to_numeric(df[col], errors='coerce')
 
-    df['Player'] = player_name # Ensure original player name is kept
+    df['Player'] = player_name
     df = df.replace({np.nan: None})
     return df
 
 def get_dashboard_info_brscraper():
-    if not BRSCRAPER_AVAILABLE:
-        logging.error("BRScraper not available for dashboard info.")
+    if not FIREBASE_INITIALIZED:
+        logging.error("Firebase not initialized. Dashboard info skipped.")
         return {}
 
     if not FIREBASE_INITIALIZED:
@@ -947,22 +1052,47 @@ def get_player_stats():
         all_player_season_data = []
         players_with_no_data = []
 
-        for player_name in selected_players:
-            df_player_career = get_player_career_stats_brscraper(player_name, playoffs=False)
+        # Handle individual player stats (1 player, 1 season)
+        if len(selected_players) == 1 and len(selected_seasons) == 1:
+            player_name = selected_players[0]
+            season_str = selected_seasons[0]
+            df_player_data = get_player_career_stats_brscraper(player_name, seasons_to_fetch=[season_str], playoffs=False)
             
-            if df_player_career.empty:
-                logging.info(f"No career data found for {player_name}. Adding to no_data list.")
+            if not df_player_data.empty:
+                all_player_season_data.append(df_player_data)
+                logging.info(f"Successfully retrieved data for {player_name} in {season_str}.")
+            else:
                 players_with_no_data.append(player_name)
-                continue
+                logging.info(f"No data found for {player_name} in {season_str}.")
+
+        # Handle comparison (2 players, 2 seasons)
+        elif len(selected_players) == 2 and len(selected_seasons) == 2:
+            player1_name = selected_players[0]
+            player1_season = selected_seasons[0]
+            player2_name = selected_players[1]
+            player2_season = selected_seasons[1]
+
+            df_player1_data = get_player_career_stats_brscraper(player1_name, seasons_to_fetch=[player1_season], playoffs=False)
+            if not df_player1_data.empty:
+                all_player_season_data.append(df_player1_data)
+                logging.info(f"Successfully retrieved data for {player1_name} in {player1_season}.")
+            else:
+                players_with_no_data.append(player1_name)
+                logging.info(f"No data found for {player1_name} in {player1_season}.")
 
-            filtered_df = df_player_career[df_player_career['Season'].isin(selected_seasons)].copy()
-            
-            if not filtered_df.empty:
-                all_player_season_data.append(filtered_df)
-                logging.info(f"Successfully filtered data for {player_name} in requested seasons.")
+            # Add a delay between fetching data for player 1 and player 2
+            time.sleep(2) # Introduce a 2-second delay
+
+            df_player2_data = get_player_career_stats_brscraper(player2_name, seasons_to_fetch=[player2_season], playoffs=False)
+            if not df_player2_data.empty:
+                all_player_season_data.append(df_player2_data)
+                logging.info(f"Successfully retrieved data for {player2_name} in {player2_season}.")
             else:
-                logging.info(f"No data found for {player_name} in the specific requested seasons: {selected_seasons}. Adding to no_data list.")
-                players_with_no_data.append(player_name)
+                players_with_no_data.append(player2_name)
+                logging.info(f"No data found for {player2_name} in {player2_season}.")
+        else:
+            return jsonify({'error': 'Invalid combination of players and seasons. Expected 1 player/1 season or 2 players/2 seasons.'}), 400
+
 
         if not all_player_season_data:
             logging.warning("After processing all players, 'all_player_season_data' is empty. Returning 404.")
@@ -973,11 +1103,7 @@ def get_player_stats():
 
         comparison_df_raw = pd.concat(all_player_season_data, ignore_index=True)
 
-        if len(selected_seasons) > 1:
-            basic_display_df = comparison_df_raw.groupby('Player').mean(numeric_only=True).reset_index()
-        else:
-            basic_display_df = comparison_df_raw.copy()
-        
+        basic_display_df = comparison_df_raw.copy()
         basic_cols = ['Player', 'Season', 'GP', 'MIN', 'PTS', 'REB', 'AST', 'STL', 'BLK', 'FG_PCT', 'FT_PCT', 'FG3_PCT']
         basic_display_df = basic_display_df[[c for c in basic_cols if c in basic_display_df.columns]].round(2)
 
@@ -989,13 +1115,8 @@ def get_player_stats():
             lambda r: r['PTS'] / (2 * (r['FGA'] + 0.44 * r['FTA'])) if (r['FGA'] + 0.44 * r['FTA']) else 0,
             axis=1
         )
-        if len(selected_seasons) > 1:
-            advanced_display_df = advanced_df.groupby('Player').mean(numeric_only=True).reset_index()
-        else:
-            advanced_display_df = advanced_df.copy()
-        
         advanced_cols = ['Player', 'Season', 'PTS', 'REB', 'AST', 'FG_PCT', 'TS_PCT']
-        advanced_display_df = advanced_display_df[[c for c in advanced_cols if c in advanced_display_df.columns]].round(3)
+        advanced_display_df = advanced_df[[c for c in advanced_cols if c in advanced_df.columns]].round(3)
 
         return jsonify({
             'basic_stats': basic_display_df.to_dict(orient='records'),
@@ -1020,21 +1141,44 @@ def get_player_playoff_stats():
         all_player_season_data = []
         players_with_no_data = []
 
-        for player_name in selected_players:
-            df_player_career = get_player_career_stats_brscraper(player_name, playoffs=True)
-            if df_player_career.empty:
-                logging.info(f"No career playoff data found for {player_name}. Adding to no_data list.")
-                players_with_no_data.append(player_name)
-                continue
-
-            filtered_df = df_player_career[df_player_career['Season'].isin(selected_seasons)].copy()
+        if len(selected_players) == 1 and len(selected_seasons) == 1:
+            player_name = selected_players[0]
+            season_str = selected_seasons[0]
+            df_player_data = get_player_career_stats_brscraper(player_name, seasons_to_fetch=[season_str], playoffs=True)
             
-            if not filtered_df.empty:
-                all_player_season_data.append(filtered_df)
-                logging.info(f"Successfully filtered playoff data for {player_name} in requested seasons.")
+            if not df_player_data.empty:
+                all_player_season_data.append(df_player_data)
+                logging.info(f"Successfully retrieved playoff data for {player_name} in {season_str}.")
             else:
-                logging.info(f"No playoff data found for {player_name} in the specific requested seasons: {selected_seasons}. Adding to no_data list.")
                 players_with_no_data.append(player_name)
+                logging.info(f"No playoff data found for {player_name} in {season_str}.")
+
+        elif len(selected_players) == 2 and len(selected_seasons) == 2:
+            player1_name = selected_players[0]
+            player1_season = selected_seasons[0]
+            player2_name = selected_players[1]
+            player2_season = selected_seasons[1]
+
+            df_player1_data = get_player_career_stats_brscraper(player1_name, seasons_to_fetch=[player1_season], playoffs=True)
+            if not df_player1_data.empty:
+                all_player_season_data.append(df_player1_data)
+                logging.info(f"Successfully retrieved playoff data for {player1_name} in {player1_season}.")
+            else:
+                players_with_no_data.append(player1_name)
+                logging.info(f"No playoff data found for {player1_name} in {player1_season}.")
+
+            time.sleep(2) # Introduce a 2-second delay
+
+            df_player2_data = get_player_career_stats_brscraper(player2_name, seasons_to_fetch=[player2_season], playoffs=True)
+            if not df_player2_data.empty:
+                all_player_season_data.append(df_player2_data)
+                logging.info(f"Successfully retrieved playoff data for {player2_name} in {player2_season}.")
+            else:
+                players_with_no_data.append(player2_name)
+                logging.info(f"No playoff data found for {player2_name} in {player2_season}.")
+        else:
+            return jsonify({'error': 'Invalid combination of players and seasons. Expected 1 player/1 season or 2 players/2 seasons.'}), 400
+
 
         if not all_player_season_data:
             logging.warning("After processing all players, 'all_player_season_data' is empty for playoffs. Returning 404.")
@@ -1045,11 +1189,7 @@ def get_player_playoff_stats():
 
         comparison_df_raw = pd.concat(all_player_season_data, ignore_index=True)
 
-        if len(selected_seasons) > 1:
-            basic_display_df = comparison_df_raw.groupby('Player').mean(numeric_only=True).reset_index()
-        else:
-            basic_display_df = comparison_df_raw.copy()
-        
+        basic_display_df = comparison_df_raw.copy()
         basic_cols = ['Player', 'Season', 'GP', 'MIN', 'PTS', 'REB', 'AST', 'STL', 'BLK', 'FG_PCT', 'FT_PCT', 'FG3_PCT']
         basic_display_df = basic_display_df[[c for c in basic_cols if c in basic_display_df.columns]].round(2)
 
@@ -1061,13 +1201,8 @@ def get_player_playoff_stats():
             lambda r: r['PTS'] / (2 * (r['FGA'] + 0.44 * r['FTA'])) if (r['FGA'] + 0.44 * r['FTA']) else 0,
             axis=1
         )
-        if len(selected_seasons) > 1:
-            advanced_display_df = advanced_df.groupby('Player').mean(numeric_only=True).reset_index()
-        else:
-            advanced_display_df = advanced_df.copy()
-        
         advanced_cols = ['Player', 'Season', 'PTS', 'REB', 'AST', 'FG_PCT', 'TS_PCT']
-        advanced_display_df = advanced_display_df[[c for c in advanced_cols if c in advanced_display_df.columns]].round(3)
+        advanced_display_df = advanced_df[[c for c in advanced_cols if c in advanced_df.columns]].round(3)
 
         return jsonify({
             'basic_stats': basic_display_df.to_dict(orient='records'),
@@ -1147,6 +1282,10 @@ def get_team_stats():
 @credit_required(cost=0)
 @cross_origin()
 def dashboard_info():
+    if not FIREBASE_INITIALIZED:
+        logging.error("Firebase not initialized. Dashboard info skipped.")
+        return jsonify({'error': 'Server configuration error: Firebase not ready.'}), 500
+
     try:
         dashboard_data = get_dashboard_info_brscraper()
         if not dashboard_data:
@@ -1160,6 +1299,10 @@ def dashboard_info():
 @credit_required(cost=1)
 @cross_origin()
 def perplexity_explain():
+    if not FIREBASE_INITIALIZED:
+        logging.error("Firebase not initialized. Perplexity explain skipped.")
+        return jsonify({'error': 'Server configuration error: Firebase not ready.'}), 500
+
     try:
         data = request.get_json()
         prompt = data.get('prompt')
@@ -1197,6 +1340,10 @@ def perplexity_explain():
 @credit_required(cost=0)
 @cross_origin()
 def get_user_analyses():
+    if not FIREBASE_INITIALIZED:
+        logging.error("Firebase not initialized. Get user analyses skipped.")
+        return jsonify({'error': 'Server configuration error: Firebase not ready.'}), 500
+
     try:
         auth_header = request.headers.get('Authorization', '')
         token = auth_header.split(' ')[1]
@@ -1228,6 +1375,10 @@ def get_user_analyses():
 @credit_required(cost=0)
 @cross_origin()
 def delete_user_analysis(analysis_id):
+    if not FIREBASE_INITIALIZED:
+        logging.error("Firebase not initialized. Delete user analysis skipped.")
+        return jsonify({'error': 'Server configuration error: Firebase not ready.'}), 500
+
     try:
         auth_header = request.headers.get('Authorization', '')
         token = auth_header.split(' ')[1]
@@ -1254,6 +1405,10 @@ def delete_user_analysis(analysis_id):
 @credit_required(cost=1)
 @cross_origin()
 def perplexity_chat():
+    if not FIREBASE_INITIALIZED:
+        logging.error("Firebase not initialized. Perplexity chat skipped.")
+        return jsonify({'error': 'Server configuration error: Firebase not ready.'}), 500
+
     try:
         data = request.get_json()
         prompt = data.get('prompt')
@@ -1294,6 +1449,10 @@ def perplexity_chat():
 @credit_required(cost=1)
 @cross_origin()
 def awards_predictor():
+    if not FIREBASE_INITIALIZED:
+        logging.error("Firebase not initialized. Awards predictor skipped.")
+        return jsonify({'error': 'Server configuration error: Firebase not ready.'}), 500
+
     try:
         data = request.get_json()
         award_type = data.get('award_type')
@@ -1316,6 +1475,10 @@ def awards_predictor():
 @credit_required(cost=1)
 @cross_origin()
 def young_player_projection():
+    if not FIREBASE_INITIALIZED:
+        logging.error("Firebase not initialized. Young player projection skipped.")
+        return jsonify({'error': 'Server configuration error: Firebase not ready.'}), 500
+
     try:
         data = request.get_json()
         player_name = data.get('player_name')
@@ -1349,6 +1512,10 @@ def young_player_projection():
 @credit_required(cost=1)
 @cross_origin()
 def similar_players():
+    if not FIREBASE_INITIALIZED:
+        logging.error("Firebase not initialized. Similar players skipped.")
+        return jsonify({'error': 'Server configuration error: Firebase not ready.'}), 500
+
     try:
         data = request.get_json()
         target_player = data.get('target_player')
@@ -1393,6 +1560,10 @@ def similar_players():
 @credit_required(cost=1)
 @cross_origin()
 def manual_player_compare():
+    if not FIREBASE_INITIALIZED:
+        logging.error("Firebase not initialized. Manual player compare skipped.")
+        return jsonify({'error': 'Server configuration error: Firebase not ready.'}), 500
+
     try:
         data = request.get_json()
         player1_name = data.get('player1_name')
@@ -1435,4 +1606,4 @@ def manual_player_compare():
 
 
 if __name__ == '__main__':
-    app.run(debug=True, host="0.0.0.0", port=7860)
+    app.run(debug=True, host="0.0.0.0", port=7860)