Update src/streamlit_app.py

src/streamlit_app.py

@@ -1,413 +1,750 @@
 import streamlit as st
 import requests
-import pandas as pd
-from together import Together
-import os
+import hashlib
+import datetime
+import uuid
+from datetime import timedelta
 
-# =============================================================================
-# CONFIGURATION - Using Secrets Management
-# =============================================================================
-NOCODB_URL = "https://app.nocodb.com"  # Base URL
+# --- Configuration (Replace with your NocoDB details) ---
+NOCODB_API_URL = "https://mtoft20-potm.hf.space/api/v1/db/data/noco/pt374k79jaxk7jr"  # API endpoint URL
+NOCODB_API_TOKEN = "-4o0sHFbhvIOZT356Wgtgfb0-JpQc8fz_w_rHUji"  # Your NocoDB API token
 
-# Get sensitive data from Streamlit secrets or environment variables
-def get_api_credentials():
-    """Get API credentials from secrets or environment"""
-    try:
-        # Try Streamlit secrets first (for Hugging Face Spaces)
-        api_token = st.secrets.get("NOCODB_API_TOKEN", os.environ.get("NOCODB_API_TOKEN", ""))
-        together_key = st.secrets.get("TOGETHER_API_KEY", os.environ.get("TOGETHER_API_KEY", ""))
-        endpoint_path = st.secrets.get("NOCODB_ENDPOINT_PATH", os.environ.get("NOCODB_ENDPOINT_PATH", ""))
-        
-        return api_token, together_key, endpoint_path
-    except:
-        # Fallback to environment variables
-        api_token = os.environ.get("NOCODB_API_TOKEN", "")
-        together_key = os.environ.get("TOGETHER_API_KEY", "")
-        endpoint_path = os.environ.get("NOCODB_ENDPOINT_PATH", "")
-        
-        return api_token, together_key, endpoint_path
+# --- Helper Functions for NocoDB Interaction ---
+def get_nocodb_headers():
+    return {
+        "xc-token": NOCODB_API_TOKEN,
+        "Content-Type": "application/json",
+        "Accept": "application/json"
+    }
 
-# Initialize Together AI client
-@st.cache_resource
-def get_ai_client():
-    """Initialize Together AI client"""
-    _, together_key, _ = get_api_credentials()
-    if not together_key:
-        st.error("Together AI API key not found. Please configure it in the secrets.")
+def get_active_match():
+    """Get the currently active match"""
+    try:
+        response = requests.get(
+            f"{NOCODB_API_URL}/matches?where=(status,eq,active)",
+            headers=get_nocodb_headers()
+        )
+        response.raise_for_status()
+        matches = response.json().get("list", [])
+        
+        if matches and matches[0].get('Id'):
+            try:
+                # Verify that the match has a valid integer ID
+                match = matches[0]
+                match['Id'] = int(match['Id'])
+                return match
+            except (ValueError, TypeError):
+                return None
+        return None
+    except requests.exceptions.RequestException as e:
+        st.error(f"Error fetching active match: {e}")
         return None
-    return Together(api_key=together_key)
 
-# =============================================================================
-# HELPER FUNCTIONS
-# =============================================================================
-@st.cache_data(ttl=300)  # Cache for 5 minutes
-def get_netflix_content():
-    """Fetch Netflix content from NocoDB"""
-    api_token, _, endpoint_path = get_api_credentials()
-    
-    if not api_token or not endpoint_path:
-        st.error("NocoDB credentials not configured. Please set up your secrets.")
+def get_all_players():
+    """Get all players from the players table"""
+    try:
+        response = requests.get(f"{NOCODB_API_URL}/players", headers=get_nocodb_headers())
+        response.raise_for_status()
+        return response.json().get("list", [])
+    except requests.exceptions.RequestException as e:
+        st.error(f"Error fetching players: {e}")
         return []
-    
-    headers = {"xc-token": api_token}
-    
+
+def get_players_for_match(match_id, debug_mode=True):
+    """Fetch players assigned to a specific match via match_players table, with error handling and debug info."""
     try:
-        response = requests.get(
-            f"{NOCODB_URL}{endpoint_path}?limit=10000",
-            headers=headers
-        )
+        if debug_mode:
+            st.write(f"Fetching players for match_id: {match_id}")
         
-        if response.status_code == 200:
-            data = response.json()
-            return data.get('list', [])
-        else:
-            st.error(f"Failed to fetch data: {response.status_code}")
-            return []
+        # Get match_players records
+        url = f"{NOCODB_API_URL}/match_players?where=(match_id,eq,{match_id})"
+        if debug_mode:
+            st.write(f"Querying match_players with URL: {url}")
+        
+        resp = requests.get(url, headers=get_nocodb_headers())
+        resp.raise_for_status()
+        match_players = resp.json().get("list", [])
+        
+        if debug_mode:
+            st.write(f"Raw match_players response: {match_players}")
+            # Print each match_player record structure
+            for idx, mp in enumerate(match_players):
+                st.write(f"Match player {idx} structure:")
+                st.write(mp)
+        
+        # Extract player IDs, handling various possible field names
+        player_ids = []
+        for mp in match_players:
+            # Try all possible field variations
+            player_id = None
+            # Direct fields
+            if mp.get('player_id'):
+                player_id = mp['player_id']
+            elif mp.get('Id'):
+                player_id = mp['Id']
+            elif mp.get('id'):
+                player_id = mp['id']
+            # Nested fields (in case it's a relation)
+            elif isinstance(mp.get('player'), dict):
+                player_id = mp['player'].get('id') or mp['player'].get('Id')
+            
+            if debug_mode:
+                st.write(f"Extracted player_id from record: {player_id}")
             
+            if player_id and str(player_id).isdigit() and int(player_id) > 0:
+                player_ids.append(int(player_id))
+        
+        if debug_mode:
+            st.write(f"Final extracted player_ids: {player_ids}")
+        
+        if not player_ids:
+            if debug_mode:
+                st.warning(f"No valid player IDs found for match {match_id}")
+                # Get all match_players for debugging
+                all_mp_url = f"{NOCODB_API_URL}/match_players"
+                all_mp_resp = requests.get(all_mp_url, headers=get_nocodb_headers())
+                if all_mp_resp.ok:
+                    all_mp_data = all_mp_resp.json().get("list", [])
+                    st.write("All match_players records:", all_mp_data)
+                    # Analyze each record's structure
+                    for mp in all_mp_data:
+                        st.write("Record structure:", {k: type(v).__name__ for k, v in mp.items()})
+            return []
+        
+        # Get player details
+        ids_str = ",".join(str(pid) for pid in player_ids)
+        players_url = f"{NOCODB_API_URL}/players?where=(Id,in,[{ids_str}])"
+        
+        if debug_mode:
+            st.write(f"Querying players with URL: {players_url}")
+        
+        resp = requests.get(players_url, headers=get_nocodb_headers())
+        resp.raise_for_status()
+        players = resp.json().get("list", [])
+        
+        if debug_mode:
+            st.write(f"Retrieved players: {players}")
+        
+        # Normalize player IDs
+        for player in players:
+            if 'id' in player and 'Id' not in player:
+                player['Id'] = player['id']
+            elif 'Id' in player and 'id' not in player:
+                player['id'] = player['Id']
+        
+        return players
     except Exception as e:
-        st.error(f"Error connecting to database: {e}")
+        if debug_mode:
+            st.error(f"Error in get_players_for_match: {str(e)}")
+            st.exception(e)
         return []
 
-def filter_content(content_list, filters):
-    """Apply filters to Netflix content list"""
-    filtered = []
-    
-    for content in content_list:
-        # Type filter
-        if filters['content_type'] and content.get('type') != filters['content_type']:
-            continue
+def has_user_voted(match_id, user_ip_hash):
+    """Check if user has already voted for this match"""
+    try:
+        # Ensure match_id is an integer
+        match_id = int(match_id) if match_id else None
+        if not match_id:
+            return False
             
-        # Rating filter
-        if filters['ratings'] and content.get('rating') not in filters['ratings']:
-            continue
+        response = requests.get(
+            f"{NOCODB_API_URL}/votes?where=(match_id,eq,{match_id})~and(user_ip_hash,eq,{user_ip_hash})",
+            headers=get_nocodb_headers()
+        )
+        response.raise_for_status()
+        votes = response.json().get("list", [])
+        return len(votes) > 0
+    except requests.exceptions.RequestException as e:
+        st.error(f"Error checking if user voted: {e}")
+        return False
+
+def record_vote(match_id, player_id, user_ip_hash):
+    """Record a vote for a player in a match"""
+    try:
+        # Ensure match_id and player_id are integers
+        match_id = int(match_id) if match_id else None
+        player_id = int(player_id) if player_id else None
+        
+        if not match_id or not player_id:
+            return False
             
-        # Genre filter
-        if filters['genres'] and not any(genre in content.get('listed_in', '') for genre in filters['genres']):
-            continue
+        vote_payload = {
+            "match_id": match_id,
+            "player_id": player_id,
+            "user_ip_hash": user_ip_hash,
+            "vote_time": datetime.datetime.now().isoformat()
+        }
+        
+        response = requests.post(
+            f"{NOCODB_API_URL}/votes",
+            headers=get_nocodb_headers(),
+            json=vote_payload
+        )
+        response.raise_for_status()
+        return True
+    except requests.exceptions.RequestException as e:
+        st.error(f"Error recording vote: {e}")
+        return False
+
+def get_historical_potms():
+    """Get historical Player of the Match winners"""
+    try:
+        # Get completed matches
+        matches_response = requests.get(
+            f"{NOCODB_API_URL}/matches?where=(status,eq,completed)&sort=-match_date",
+            headers=get_nocodb_headers()
+        )
+        matches_response.raise_for_status()
+        completed_matches = matches_response.json().get("list", [])
+        
+        historical_data = []
+        all_players = get_all_players()
+        
+        for match in completed_matches:
+            match_id = match.get('Id')
+            if not match_id:
+                continue
+                
+            # Get all votes for this match
+            votes_response = requests.get(
+                f"{NOCODB_API_URL}/votes?where=(match_id,eq,{match_id})",
+                headers=get_nocodb_headers()
+            )
+            votes_response.raise_for_status()
+            votes = votes_response.json().get("list", [])
             
-        # Release year filter
-        try:
-            release_year = int(content.get('release_year', 0))
-            if release_year < filters['year_range'][0] or release_year > filters['year_range'][1]:
+            if not votes:
                 continue
-        except (ValueError, TypeError):
-            continue
+                
+            # Count votes by player
+            vote_counts = {}
+            for vote in votes:
+                player_id = vote.get('player_id')
+                if player_id:
+                    vote_counts[player_id] = vote_counts.get(player_id, 0) + 1
+            
+            if not vote_counts:
+                continue
+                
+            # Find player with most votes
+            winner_id = max(vote_counts.items(), key=lambda x: x[1])[0]
+            winner_votes = vote_counts[winner_id]
             
-        # Duration filter (different handling for movies and shows)
-        duration = content.get('duration', '')
-        if filters['content_type'] == 'Movie' and 'min' in duration:
+            # Get player name
+            winner = next((p for p in all_players if p.get('id') == winner_id), None)
+            
+            if winner:
+                historical_data.append({
+                    'match_name': match.get('name', f'Match vs {match.get("opponent", "Unknown")}'),
+                    'match_date': match.get('match_date'),
+                    'player_name': winner.get('name'),
+                    'votes': winner_votes,
+                    'total_votes': sum(vote_counts.values())
+                })
+        
+        return historical_data
+    except requests.exceptions.RequestException as e:
+        st.error(f"Error fetching historical POTM data: {e}")
+        return []
+
+def add_player(name):
+    """Add a new player to the database"""
+    try:
+        # Check if player already exists
+        existing_players = get_all_players()
+        if any(p.get('name', '').lower() == name.lower() for p in existing_players):
+            return False, "Player already exists"
+        
+        player_payload = {"name": name}
+        response = requests.post(
+            f"{NOCODB_API_URL}/players",
+            headers=get_nocodb_headers(),
+            json=player_payload
+        )
+        response.raise_for_status()
+        return True, "Player added successfully"
+    except requests.exceptions.RequestException as e:
+        return False, f"Error adding player: {e}"
+
+def add_match(name, opponent, match_date, selected_player_ids):
+    """Add a new match with selected players"""
+    try:
+        # Create match
+        match_payload = {
+            "name": name,
+            "opponent": opponent,
+            "match_date": match_date.isoformat(),
+            "status": "upcoming"
+        }
+        
+        match_response = requests.post(
+            f"{NOCODB_API_URL}/matches",
+            headers=get_nocodb_headers(),
+            json=match_payload
+        )
+        match_response.raise_for_status()
+        match_data = match_response.json()
+        
+        try:
+            match_id = int(match_data.get('Id'))
+        except (ValueError, TypeError):
+            return False, "Could not create match: Invalid match ID"
+        
+        if not match_id:
+            return False, "Could not create match: No match ID returned"
+        
+        # Add players to match
+        success_count = 0
+        for player_id in selected_player_ids:
             try:
-                minutes = int(duration.split()[0])
-                if minutes < filters['duration_range'][0] or minutes > filters['duration_range'][1]:
+                # Ensure player_id is an integer
+                player_id = int(player_id) if player_id else None
+                if not player_id:
                     continue
-            except (ValueError, IndexError):
+                    
+                match_player_payload = {
+                    "match_id": match_id,
+                    "player_id": player_id
+                }
+                mp_response = requests.post(
+                    f"{NOCODB_API_URL}/match_players",
+                    headers=get_nocodb_headers(),
+                    json=match_player_payload
+                )
+                mp_response.raise_for_status()
+                success_count += 1
+            except (ValueError, TypeError, requests.exceptions.RequestException):
                 continue
         
-        filtered.append(content)
-    
-    return filtered
+        return True, f"Match created with {success_count} players"
+    except requests.exceptions.RequestException as e:
+        return False, f"Error creating match: {e}"
 
-def create_content_context(content_list):
-    """Create context string about current content for AI"""
-    if not content_list:
-        return "No content matches the current filters."
-    
-    total = len(content_list)
-    movies = sum(1 for c in content_list if c.get('type') == 'Movie')
-    shows = sum(1 for c in content_list if c.get('type') == 'TV Show')
-    
-    context = f"""Currently showing {total} Netflix titles ({movies} movies and {shows} TV shows). """
-    
-    # Add some genre info
-    all_genres = []
-    for content in content_list[:20]:  # Sample from first 20 items
-        genres = content.get('listed_in', '').split(', ')
-        all_genres.extend(genres)
-    
-    if all_genres:
-        genre_counts = pd.Series(all_genres).value_counts()
-        top_genres = genre_counts.head(5).index.tolist()
-        context += f"Top genres include: {', '.join(top_genres)}. "
-    
-    # Add year range
-    years = [int(c.get('release_year', 0)) for c in content_list if c.get('release_year')]
-    if years:
-        context += f"Release years range from {min(years)} to {max(years)}."
-    
-    return context
+def update_match_status(match_id, status):
+    """Update match status"""
+    try:
+        payload = {"status": status}
+        response = requests.patch(
+            f"{NOCODB_API_URL}/matches/{match_id}",
+            headers=get_nocodb_headers(),
+            json=payload
+        )
+        response.raise_for_status()
+        return True
+    except requests.exceptions.RequestException:
+        return False
 
-def get_ai_response(client, question, context, model_name):
-    """Get response from Together AI"""
+def cleanup_invalid_match_players():
+    """Remove invalid match_players records with match_id=0 or player_id=0"""
     try:
-        prompt = f"""You are a helpful Netflix content expert. Based on the current content data, please answer the user's question accurately and helpfully.
+        # Get all invalid records
+        response = requests.get(
+            f"{NOCODB_API_URL}/match_players?where=(match_id,eq,0)~or(player_id,eq,0)",
+            headers=get_nocodb_headers()
+        )
+        response.raise_for_status()
+        invalid_records = response.json().get("list", [])
+        
+        deleted_count = 0
+        for record in invalid_records:
+            try:
+                delete_response = requests.delete(
+                    f"{NOCODB_API_URL}/match_players/{record['Id']}",
+                    headers=get_nocodb_headers()
+                )
+                delete_response.raise_for_status()
+                deleted_count += 1
+            except requests.exceptions.RequestException:
+                continue
+        return True, f"Deleted {deleted_count} invalid match_players records"
+    except requests.exceptions.RequestException as e:
+        return False, f"Error cleaning up invalid records: {e}"
 
-Current Content Data Context:
-{context}
+# --- Main App Logic ---
+st.set_page_config(page_title="Player of the Match Voting", page_icon="⚽", layout="wide")
+st.title("⚽ Player of the Match Voting App")
 
-User Question: {question}
+# Generate user identifier for voting uniqueness
+if 'user_id' not in st.session_state:
+    st.session_state.user_id = str(uuid.uuid4())
+user_identifier = st.session_state.user_id
+user_ip_hash = hashlib.sha256(user_identifier.encode()).hexdigest()
 
-Please provide a helpful, accurate response based on the data provided. Keep your answer concise but informative."""
+# Check configuration
+if NOCODB_API_URL == "YOUR_NOCODB_API_URL" or NOCODB_API_TOKEN == "YOUR_NOCODB_API_TOKEN":
+    st.error("⚠️ **Configuration Required**: Please update the NocoDB API URL and Token in the code.")
+    st.info("""
+    **Setup Instructions:**
+    1. Replace `YOUR_NOCODB_API_URL` with your NocoDB API URL
+    2. Replace `YOUR_NOCODB_API_TOKEN` with your NocoDB API token
+    3. Set up the database structure as described in the documentation
+    """)
+    st.stop()
 
-        response = client.chat.completions.create(
-            model=model_name,
-            messages=[
-                {"role": "system", "content": "You are a helpful Netflix content expert with deep knowledge of movies and TV shows."},
-                {"role": "user", "content": prompt}
-            ],
-            max_tokens=300,
-            temperature=0.7,
-        )
-        
-        return response.choices[0].message.content
-        
-    except Exception as e:
-        raise Exception(f"Together AI Error: {str(e)}")
+# Sidebar navigation
+st.sidebar.header("Navigation")
+view_mode = st.sidebar.radio(
+    "Select Mode:",
+    ["🗳️ Vote for POTM", "📊 View Past POTMs", "⚙️ Developer Mode"]
+)
 
-# =============================================================================
-# MAIN APP
-# =============================================================================
-def main():
-    # Page config
-    st.set_page_config(
-        page_title="Netflix Content Explorer",
-        page_icon="🎬",
-        layout="wide"
-    )
-    
-    # Header
-    st.title("🎬 Netflix Content Explorer")
-    st.write("Explore Netflix movies and TV shows with AI-powered insights!")
-    
-    # Check API credentials
-    api_token, together_key, endpoint_path = get_api_credentials()
-    
-    if not together_key:
-        st.error("⚠️ Together AI API key not configured!")
-        st.info("Please set your TOGETHER_API_KEY in the Hugging Face Spaces secrets.")
-        st.stop()
-    
-    if not api_token or not endpoint_path:
-        st.error("⚠️ NocoDB credentials not configured!")
-        st.info("Please set NOCODB_API_TOKEN and NOCODB_ENDPOINT_PATH in the Hugging Face Spaces secrets.")
-        st.stop()
-    
-    # Initialize AI client
-    try:
-        client = get_ai_client()
-        if not client:
-            st.stop()
-    except Exception as e:
-        st.error(f"Failed to initialize Together AI client: {e}")
-        st.stop()
-    
-    # Load all content first
-    with st.spinner("Loading Netflix content..."):
-        all_content = get_netflix_content()
+# Developer Mode
+if view_mode == "⚙️ Developer Mode":
+    st.header("🔧 Developer Mode")
     
-    if not all_content:
-        st.error("Could not load Netflix content. Please check your NocoDB connection.")
-        st.stop()
+    # Password protection
+    dev_password = st.text_input("Enter Developer Password:", type="password")
     
-    # Extract unique values for filters
-    all_ratings = sorted(list(set([c.get('rating') for c in all_content if c.get('rating')])))
-    all_genres = sorted(list(set(
-        genre.strip()
-        for c in all_content
-        for genre in c.get('listed_in', '').split(',')
-        if genre.strip()
-    )))
-    
-    # Sidebar filters
-    st.sidebar.header("🔍 Filter Content")
-    
-    content_type = st.sidebar.selectbox(
-        "Content Type",
-        options=["All", "Movie", "TV Show"],
-        index=0
-    )
-    
-    selected_ratings = st.sidebar.multiselect(
-        "Ratings",
-        options=all_ratings,
-        default=[]
-    )
-    
-    selected_genres = st.sidebar.multiselect(
-        "Genres",
-        options=all_genres,
-        default=[]
-    )
-    
-    # Year range slider
-    years = [int(c.get('release_year', 0)) for c in all_content if c.get('release_year')]
-    min_year, max_year = min(years), max(years)
-    year_range = st.sidebar.slider(
-        "Release Year",
-        min_value=min_year,
-        max_value=max_year,
-        value=(min_year, max_year)
-    )
-    
-    # Duration range slider (for movies only)
-    movie_durations = [
-        int(c.get('duration', '0 min').split()[0])
-        for c in all_content
-        if c.get('type') == 'Movie' and 'min' in c.get('duration', '')
-    ]
-    if movie_durations:
-        min_duration, max_duration = min(movie_durations), max(movie_durations)
-        duration_range = st.sidebar.slider(
-            "Movie Duration (minutes)",
-            min_value=min_duration,
-            max_value=max_duration,
-            value=(min_duration, max_duration),
-            help="This filter only applies to movies"
-        )
-    else:
-        duration_range = (0, 1000)  # Fallback values
-    
-    # Create filter dictionary
-    filters = {
-        'content_type': content_type if content_type != "All" else None,
-        'ratings': selected_ratings,
-        'genres': selected_genres,
-        'year_range': year_range,
-        'duration_range': duration_range
-    }
-    
-    # Apply filters
-    filtered_content = filter_content(all_content, filters)
+    if dev_password == "dev123":  # Change this password as needed
+        st.success("✅ Developer access granted")
+        
+        # Tabs for different admin functions
+        tab1, tab2, tab3 = st.tabs(["👥 Manage Players", "⚽ Manage Matches", "📊 Database Status"])
+        
+        with tab1:
+            st.subheader("Add New Player")
+            new_player_name = st.text_input("Player Name:")
+            if st.button("Add Player", type="primary"):
+                if new_player_name.strip():
+                    success, message = add_player(new_player_name.strip())
+                    if success:
+                        st.success(message)
+                        st.rerun()
+                    else:
+                        st.error(message)
+                else:
+                    st.warning("Please enter a player name")
+            
+            # Show existing players
+            st.subheader("Existing Players")
+            players = get_all_players()
+            if players:
+                for i, player in enumerate(players, 1):
+                    player_id = player.get('Id') or 'Unknown'
+                    st.write(f"{i}. {player.get('name')} (ID: {player_id})")
+            else:
+                st.info("No players found")
+        
+        with tab2:
+            st.subheader("Add New Match")
+            
+            col1, col2 = st.columns(2)
+            with col1:
+                match_name = st.text_input("Match Name:")
+                opponent = st.text_input("Opponent:")
+            with col2:
+                match_date = st.date_input("Match Date:", datetime.date.today())
+                match_time = st.time_input("Match Time:", datetime.time(19, 0))
+            
+            # Player selection
+            players = get_all_players()
+            if players:
+                player_options = {f"{p.get('name')} (ID: {p.get('Id') or 'Unknown'})": p.get('Id') for p in players}
+                selected_players = st.multiselect(
+                    "Select Players for this Match:",
+                    options=list(player_options.keys())
+                )
+                selected_player_ids = [player_options[p] for p in selected_players if player_options[p] is not None]
+                
+                if st.button("Create Match", type="primary"):
+                    if match_name and opponent and selected_player_ids:
+                        match_datetime = datetime.datetime.combine(match_date, match_time)
+                        success, message = add_match(match_name, opponent, match_datetime, selected_player_ids)
+                        if success:
+                            st.success(message)
+                            st.rerun()
+                        else:
+                            st.error(message)
+                    else:
+                        st.warning("Please fill all fields and select players")
+            else:
+                st.warning("No players available. Add players first.")
+            
+            # Show existing matches
+            st.subheader("Existing Matches")
+            try:
+                matches_response = requests.get(
+                    f"{NOCODB_API_URL}/matches?sort=-match_date",
+                    headers=get_nocodb_headers()
+                )
+                matches_response.raise_for_status()
+                matches = matches_response.json().get("list", [])
+                if matches:
+                    for match in matches:
+                        status_emoji = {"upcoming": "🔜", "active": "🔴", "completed": "✅"}
+                        emoji = status_emoji.get(match.get('status'), "❓")
+                        col1, col2, col3 = st.columns([3, 1, 1])
+                        with col1:
+                            st.write(f"{emoji} **{match.get('name')}** vs {match.get('opponent')}")
+                            match_date = match.get('match_date', 'N/A')
+                            if match_date is not None:
+                                match_date = match_date[:10]
+                            st.caption(f"Date: {match_date} | Status: {match.get('status')}")
+                            # --- EDIT MATCH PLAYERS ---
+                            # Only allow editing for upcoming or active matches
+                            if match.get('status') in ['upcoming', 'active']:
+                                with st.expander("Edit Players", expanded=False):
+                                    try:
+                                        # Get all players
+                                        all_players = get_all_players()
+                                        # Get current players for this match
+                                        current_players = get_players_for_match(match.get('Id'), debug_mode=False)
+                                        
+                                        # Create options dictionary with normalized IDs
+                                        player_options = {}
+                                        for p in all_players:
+                                            player_id = p.get('Id') or p.get('id')
+                                            if player_id:
+                                                player_options[f"{p.get('name')} (ID: {player_id})"] = int(player_id)
+                                        
+                                        # Get current player display names
+                                        current_player_displays = []
+                                        for p in current_players:
+                                            player_id = p.get('Id') or p.get('id')
+                                            if player_id:
+                                                display = f"{p.get('name')} (ID: {player_id})"
+                                                if display in player_options:
+                                                    current_player_displays.append(display)
+                                        
+                                        selected_players = st.multiselect(
+                                            f"Select Players for {match.get('name')}",
+                                            options=list(player_options.keys()),
+                                            default=current_player_displays,
+                                            key=f"edit_players_{match.get('Id')}"
+                                        )
+                                        
+                                        if st.button("Update Players", key=f"update_players_{match.get('Id')}"):
+                                            try:
+                                                # Delete existing match_players
+                                                mp_response = requests.get(
+                                                    f"{NOCODB_API_URL}/match_players?where=(match_id,eq,{match.get('Id')})",
+                                                    headers=get_nocodb_headers()
+                                                )
+                                                mp_response.raise_for_status()
+                                                match_players = mp_response.json().get("list", [])
+                                                
+                                                for mp in match_players:
+                                                    mp_id = mp.get('Id') or mp.get('id')
+                                                    if mp_id:
+                                                        delete_response = requests.delete(
+                                                            f"{NOCODB_API_URL}/match_players/{mp_id}",
+                                                            headers=get_nocodb_headers()
+                                                        )
+                                                        delete_response.raise_for_status()
+                                                
+                                                # Add new match_players
+                                                selected_player_ids = [player_options[p] for p in selected_players]
+                                                success_count = 0
+                                                
+                                                for player_id in selected_player_ids:
+                                                    add_response = requests.post(
+                                                        f"{NOCODB_API_URL}/match_players",
+                                                        headers=get_nocodb_headers(),
+                                                        json={
+                                                            "match_id": int(match.get('Id')),
+                                                            "player_id": int(player_id)
+                                                        }
+                                                    )
+                                                    add_response.raise_for_status()
+                                                    success_count += 1
+                                                
+                                                st.success(f"✅ Successfully updated {success_count} players!")
+                                                st.rerun()
+                                                
+                                            except requests.exceptions.RequestException as e:
+                                                st.error(f"API Error: {str(e)}")
+                                            except Exception as e:
+                                                st.error(f"Unexpected error: {str(e)}")
+                                    except Exception as e:
+                                        st.error(f"Error loading player data: {str(e)}")
+                        with col2:
+                            if match.get('status') == 'upcoming':
+                                if st.button("Activate", key=f"activate_{match.get('Id')}"):
+                                    if update_match_status(match.get('Id'), 'active'):
+                                        st.success("Match activated!")
+                                        st.rerun()
+                        with col3:
+                            if match.get('status') == 'active':
+                                if st.button("Complete", key=f"complete_{match.get('Id')}"):
+                                    if update_match_status(match.get('Id'), 'completed'):
+                                        st.success("Match completed!")
+                                        st.rerun()
+                else:
+                    st.info("No matches found")
+            except requests.exceptions.RequestException as e:
+                st.error(f"Error fetching matches: {e}")
+        
+        with tab3:
+            st.subheader("Database Connection Status")
+            try:
+                # Test connection
+                test_response = requests.get(
+                    f"{NOCODB_API_URL}/players?limit=1",
+                    headers=get_nocodb_headers()
+                )
+                test_response.raise_for_status()
+                st.success("✅ Database connection successful")
+                
+                # Show stats
+                players_count = len(get_all_players())
+                st.metric("Total Players", players_count)
+                
+            except requests.exceptions.RequestException as e:
+                st.error(f"❌ Database connection failed: {e}")
     
-    # Main content area
-    col1, col2 = st.columns([2, 1])
+    elif dev_password:
+        st.error("❌ Incorrect password")
+
+# Voting Mode
+elif view_mode == "🗳️ Vote for POTM":
+    st.header("🗳️ Vote for Player of the Match")
     
-    with col1:
-        # Content listings
-        st.subheader(f"📋 Found {len(filtered_content)} Titles")
-        
-        if filtered_content:
-            # Show first 10 items
-            for i, content in enumerate(filtered_content[:10]):
-                with st.expander(f"{content.get('title', 'N/A')} ({content.get('release_year', 'N/A')})"):
-                    # Content details in columns
-                    detail_col1, detail_col2 = st.columns(2)
-                    
-                    with detail_col1:
-                        st.write(f"**🎭 Type:** {content.get('type', 'N/A')}")
-                        st.write(f"**⭐ Rating:** {content.get('rating', 'N/A')}")
-                        st.write(f"**⏱️ Duration:** {content.get('duration', 'N/A')}")
-                    
-                    with detail_col2:
-                        st.write(f"**🎬 Genre:** {content.get('listed_in', 'N/A')}")
-                        # Fix cast handling to prevent NoneType error
-                        cast = content.get('cast')
-                        cast_display = cast[:100] + "..." if cast else "N/A"
-                        st.write(f"**👥 Cast:** {cast_display}")
-                        st.write(f"**📝 Director:** {content.get('director', 'N/A')}")
-                    
-                    # Description
-                    st.write(f"**📖 Description:**")
-                    st.write(content.get('description', 'N/A'))
-            
-            if len(filtered_content) > 10:
-                st.info(f"Showing first 10 of {len(filtered_content)} titles. Adjust filters to narrow results.")
-        else:
-            st.info("No content matches your current filters. Try adjusting the criteria.")
+    active_match = get_active_match()
     
-    with col2:
-        # AI Chat Section
-        st.subheader("🤖 Ask AI Assistant")
-        st.write("Ask questions about the Netflix content!")
-        
-        # Model selection for Together AI
-        model_choice = st.selectbox(
-            "Select AI Model:",
-            [
-                "google/gemma-2b-it",
-                "google/gemma-2-27b-it",
-                "mistralai/Mistral-7B-Instruct-v0.1",
-                "NousResearch/Nous-Hermes-2-Mixtral-8x7B-DPO",
-                "mistralai/Mixtral-8x7B-Instruct-v0.1"
-            ],
-            help="Select an AI model to answer your questions"
-        )
+    if active_match:
+        match_id = active_match.get('Id')
+        match_name = active_match.get('name', 'Current Match')
+        opponent = active_match.get('opponent', 'Unknown')
         
-        # Example questions
-        with st.expander("💡 Example Questions"):
-            st.write("• What are the most common genres?")
-            st.write("• What's the average movie duration?")
-            st.write("• Which directors have the most content?")
-            st.write("• What are the trends in content ratings?")
-            st.write("• Tell me about the release year distribution")
-        
-        user_question = st.text_area(
-            "Your Question:",
-            placeholder="Ask about genres, ratings, directors, trends...",
-            height=100
-        )
+        st.success(f"**Current Active Match:** {match_name} vs {opponent}")
+        
+        # Fetch players for the active match
+        match_players = get_players_for_match(match_id)
         
-        if st.button("🔍 Ask AI", type="primary"):
-            if user_question:
-                with st.spinner("AI is analyzing the content..."):
-                    # Create context from current filtered data
-                    context = create_content_context(filtered_content)
+        if match_players:
+            st.subheader("Vote for your Player of the Match:")
+            # Display players for voting (e.g., using radio buttons)
+            player_options = {p.get('name'): p.get('Id') for p in match_players}
+            selected_player_name = st.radio(
+                "Select a player:",
+                list(player_options.keys()),
+                key=f"vote_player_{match_id}"
+            )
+            
+            if st.button("Submit Vote", key=f"submit_vote_{match_id}"):
+                selected_player_id = player_options.get(selected_player_name)
+                if selected_player_id:
+                    # Check if user has already voted
+                    if has_user_voted(match_id, user_ip_hash):
+                        st.info("✅ You have already voted for this match. Thank you for your participation!")
+                    else:
+                        # Record the vote
+                        if record_vote(match_id, int(selected_player_id), user_ip_hash):
+                            st.success("🗳️ Vote submitted successfully!")
+                            st.rerun()
+                        else:
+                            st.error("❌ Failed to submit vote.")
+                else:
+                    st.warning("Please select a player to vote.")
+
+        else:
+            st.warning("⚠️ No players found for this match. Please contact the administrator.")
+
+        # Check if user has already voted
+        if has_user_voted(match_id, user_ip_hash):
+            st.info("✅ You have already voted for this match. Thank you for your participation!")
+            
+            # Show current vote counts (optional)
+            with st.expander("View Current Results"):
+                try:
+                    votes_response = requests.get(
+                        f"{NOCODB_API_URL}/votes?where=(match_id,eq,{match_id})",
+                        headers=get_nocodb_headers()
+                    )
+                    votes_response.raise_for_status()
+                    votes = votes_response.json().get("list", [])
                     
-                    try:
-                        # Get AI response
-                        ai_response = get_ai_response(client, user_question, context, model_choice)
-                        
-                        st.success("**AI Assistant Response:**")
-                        st.write(ai_response)
-                        
-                        # Show debug info
-                        with st.expander("Debug Info"):
-                            st.write(f"Model used: {model_choice}")
-                            st.write(f"Content items analyzed: {len(filtered_content)}")
-                            st.write(f"Context: {context[:150]}...")
+                    if votes:
+                        vote_counts = {}
+                        all_players = get_all_players()
                         
-                    except Exception as e:
-                        st.error(f"AI Error: {str(e)}")
+                        for vote in votes:
+                            player_id = vote.get('player_id')
+                            if player_id:
+                                vote_counts[player_id] = vote_counts.get(player_id, 0) + 1
                         
-                        # Fallback response with data analysis
-                        st.info("**Fallback Analysis:**")
-                        if filtered_content:
-                            movies = sum(1 for c in filtered_content if c.get('type') == 'Movie')
-                            shows = sum(1 for c in filtered_content if c.get('type') == 'TV Show')
-                            st.write(f"• Found {len(filtered_content)} titles ({movies} movies, {shows} TV shows)")
-                            
-                            # Show top genres
-                            genres = [g.strip() for c in filtered_content for g in c.get('listed_in', '').split(',')]
-                            genre_counts = pd.Series(genres).value_counts()
-                            st.write(f"• Top genres: {', '.join(genre_counts.head(3).index)}")
-                            
-                            # Show year range
-                            years = [int(c.get('release_year', 0)) for c in filtered_content if c.get('release_year')]
-                            if years:
-                                st.write(f"• Release years: {min(years)} - {max(years)}")
+                        st.write("**Current Vote Counts:**")
+                        for player_id, count in sorted(vote_counts.items(), key=lambda x: x[1], reverse=True):
+                            player = next((p for p in all_players if p.get('Id') == player_id), None)
+                            if player:
+                                st.write(f"• {player.get('name')}: {count} votes")
+                    else:
+                        st.write("No votes yet.")
+                except:
+                    st.write("Could not load current results.")
+        
+        else:
+            # Show voting interface
+            players = get_players_for_match(match_id, debug_mode=True)
+            
+            if players:
+                st.write("**Select the Player of the Match:**")
+                
+                # Create voting form
+                with st.form("voting_form"):
+                    selected_player = st.radio(
+                        "Players:",
+                        options=[p.get('name') for p in players],
+                        key="player_selection"
+                    )
+                    
+                    submit_vote = st.form_submit_button("🗳️ Submit Vote", type="primary")
+                
+                if submit_vote and selected_player:
+                    # Find selected player ID
+                    selected_player_obj = next((p for p in players if p.get('name') == selected_player), None)
+                    
+                    if selected_player_obj:
+                        if record_vote(match_id, int(selected_player_obj.get('Id')), user_ip_hash):
+                            st.balloons()
+                            st.success(f"🎉 Vote recorded for {selected_player}! Thank you!")
+                            st.rerun()
+                        else:
+                            st.error("Failed to record vote. Please try again.")
             else:
-                st.warning("Please enter a question first!")
+                st.warning("⚠️ No players found for this match. Please contact the administrator.")
     
-    # Footer stats
-    st.markdown("---")
-    if all_content:
-        total_items = len(all_content)
-        filtered_items = len(filtered_content)
-        
-        stat_col1, stat_col2, stat_col3, stat_col4 = st.columns(4)
-        
-        with stat_col1:
-            st.metric("Total Titles", total_items)
-        
-        with stat_col2:
-            st.metric("Filtered Results", filtered_items)
-        
-        with stat_col3:
-            movies = sum(1 for c in filtered_content if c.get('type') == 'Movie')
-            st.metric("Movies", movies)
+    else:
+        st.info("📅 There is no active match currently. Please check back later!")
+
+# Historical POTMs Mode
+elif view_mode == "📊 View Past POTMs":
+    st.header("📊 Historical Player of the Match Winners")
+    
+    historical_data = get_historical_potms()
+    
+    if historical_data:
+        st.write(f"**Total Completed Matches:** {len(historical_data)}")
         
-        with stat_col4:
-            shows = sum(1 for c in filtered_content if c.get('type') == 'TV Show')
-            st.metric("TV Shows", shows)
+        for i, data in enumerate(historical_data, 1):
+            with st.container():
+                col1, col2, col3 = st.columns([3, 2, 1])
+                
+                with col1:
+                    st.subheader(f"🏆 {data['match_name']}")
+                    st.write(f"**Winner:** {data['player_name']}")
+                
+                with col2:
+                    st.metric("Votes Received", f"{data['votes']}/{data['total_votes']}")
+                    percentage = (data['votes'] / data['total_votes']) * 100 if data['total_votes'] > 0 else 0
+                    st.write(f"({percentage:.1f}% of votes)")
+                
+                with col3:
+                    if data['match_date']:
+                        st.write(f"📅 {data['match_date'][:10]}")
+                
+                st.divider()
+    
+    else:
+        st.info("📝 No historical data available yet. Complete some matches to see results here!")
 
-if __name__ == "__main__":
-    main() 
+# Footer
+st.markdown("---")
+st.markdown(
+    """
+    <div style='text-align: center; color: #666;'>
+        Player of the Match Voting System | Powered by Streamlit & NocoDB
+    </div>
+    """,
+    unsafe_allow_html=True
+)