server.py

import http.server
import socketserver
import json
import urllib.parse
from datetime import datetime
import webbrowser
import os

# File de commandes globale
pending_commands = []

# Chemin vers le fichier de données
DATA_FILE = os.path.join(os.path.dirname(__file__), 'leaderboard_data.json')

def load_leaderboard_data():
    """Charger les données du classement depuis le fichier JSON"""
    try:
        if os.path.exists(DATA_FILE):
            with open(DATA_FILE, 'r', encoding='utf-8') as f:
                data = json.load(f)
            
            # Migration : ajouter les timestamps manquants
            migrated = False
            for user in data.get("leaderboard", []):
                if "lastFirstTimestamp" not in user:
                    user["lastFirstTimestamp"] = datetime.now().isoformat()
                    migrated = True
            
            if migrated:
                save_leaderboard_data(data)
                print("[Info] Migration des données terminée - timestamps ajoutés")
            
            return data
        else:
            # Créer un fichier vide si il n'existe pas
            default_data = {
                "leaderboard": [],
                "metadata": {
                    "lastUpdated": datetime.now().isoformat(),
                    "totalUsers": 0,
                    "totalFirsts": 0
                }
            }
            save_leaderboard_data(default_data)
            return default_data
    except Exception as e:
        print(f"[Erreur] Erreur lors du chargement des données: {e}")
        return {
            "leaderboard": [],
            "metadata": {
                "lastUpdated": datetime.now().isoformat(),
                "totalUsers": 0,
                "totalFirsts": 0
            }
        }

def save_leaderboard_data(data):
    """Sauvegarder les données du classement dans le fichier JSON"""
    try:
        # Mettre à jour les métadonnées
        data["metadata"]["lastUpdated"] = datetime.now().isoformat()
        data["metadata"]["totalUsers"] = len(data["leaderboard"])
        data["metadata"]["totalFirsts"] = sum(user["firsts"] for user in data["leaderboard"])
        
        with open(DATA_FILE, 'w', encoding='utf-8') as f:
            json.dump(data, f, indent=2, ensure_ascii=False)
        print(f"[Info] Données sauvegardées dans {DATA_FILE}")
    except Exception as e:
        print(f"[Erreur] Erreur lors de la sauvegarde: {e}")

def add_first_to_user(username):
    """Ajouter un first à un utilisateur dans les données"""
    data = load_leaderboard_data()
    username_key = username.lower()
    current_timestamp = datetime.now().isoformat()
    
    # Chercher l'utilisateur existant
    user_found = False
    for user in data["leaderboard"]:
        if user["username"].lower() == username_key:
            user["firsts"] += 1
            user["lastFirstTimestamp"] = current_timestamp
            user_found = True
            break
    
    # Si l'utilisateur n'existe pas, l'ajouter
    if not user_found:
        data["leaderboard"].append({
            "username": username_key,
            "displayName": username.strip(),
            "firsts": 1,
            "lastFirstTimestamp": current_timestamp
        })
    
    save_leaderboard_data(data)
    return data

class FirstsHTTPRequestHandler(http.server.SimpleHTTPRequestHandler):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, directory=os.path.dirname(os.path.abspath(__file__)), **kwargs)
    
    def do_POST(self):
        """Gérer les requêtes POST pour ajouter des firsts"""
        global pending_commands
        
        if self.path.startswith('/add-first'):
            try:
                # Lire les données POST
                content_length = int(self.headers['Content-Length'])
                post_data = self.rfile.read(content_length)
                data = json.loads(post_data.decode('utf-8'))
                
                username = data.get('username', '').strip()
                
                if not username:
                    self.send_error(400, "Username requis")
                    return
                
                # Ajouter le first dans les données
                updated_data = add_first_to_user(username)
                
                # Ajouter la commande à la file pour le widget
                command = {
                    'action': 'add_first',
                    'username': username,
                    'timestamp': datetime.now().isoformat()
                }
                
                pending_commands.append(command)
                
                # Répondre avec succès
                response = {
                    'success': True,
                    'message': f'First ajouté pour {username}',
                    'username': username,
                    'timestamp': datetime.now().isoformat(),
                    'data': updated_data
                }
                
                self.send_response(200)
                self.send_header('Content-type', 'application/json')
                self.send_header('Access-Control-Allow-Origin', '*')
                self.send_header('Access-Control-Allow-Methods', 'POST, GET, OPTIONS')
                self.send_header('Access-Control-Allow-Headers', 'Content-Type')
                self.end_headers()
                self.wfile.write(json.dumps(response).encode())
                
                print(f"[{datetime.now().strftime('%H:%M:%S')}] First ajouté: {username}")
                
            except Exception as e:
                print(f"Erreur: {e}")
                self.send_error(500, str(e))
        else:
            self.send_error(404, "Endpoint non trouvé")
    
    def do_GET(self):
        """Gérer les requêtes GET"""
        global pending_commands
        
        if self.path == '/':
            self.path = '/index.html'
        elif self.path.startswith('/add-first-simple'):
            try:
                query_params = urllib.parse.parse_qs(urllib.parse.urlparse(self.path).query)
                username = query_params.get('username', [''])[0].strip()
                
                if not username:
                    self.send_error(400, "Paramètre username requis")
                    return
                
                # Ajouter le first dans les données
                updated_data = add_first_to_user(username)
                
                # Ajouter la commande à la file pour le widget
                command = {
                    'action': 'add_first',
                    'username': username,
                    'timestamp': datetime.now().isoformat()
                }
                
                pending_commands.append(command)
                
                response = {
                    'success': True,
                    'message': f'First ajouté pour {username}',
                    'username': username,
                    'timestamp': datetime.now().isoformat(),
                    'data': updated_data
                }
                
                self.send_response(200)
                self.send_header('Content-type', 'application/json')
                self.send_header('Access-Control-Allow-Origin', '*')
                self.end_headers()
                self.wfile.write(json.dumps(response).encode())
                
                print(f"[{datetime.now().strftime('%H:%M:%S')}] First ajouté: {username}")
                return
                
            except Exception as e:
                print(f"Erreur: {e}")
                self.send_error(500, str(e))
                return
        elif self.path == '/get-pending-commands':
            try:
                commands_to_send = pending_commands.copy()
                pending_commands.clear()  # Vider la file après lecture
                
                self.send_response(200)
                self.send_header('Content-type', 'application/json')
                self.send_header('Access-Control-Allow-Origin', '*')
                self.end_headers()
                self.wfile.write(json.dumps(commands_to_send).encode())
                return
                
            except Exception as e:
                print(f"Erreur: {e}")
                self.send_error(500, str(e))
                return
        elif self.path == '/get-leaderboard-data':
            try:
                # Endpoint pour récupérer toutes les données du classement
                data = load_leaderboard_data()
                
                self.send_response(200)
                self.send_header('Content-type', 'application/json')
                self.send_header('Access-Control-Allow-Origin', '*')
                self.end_headers()
                self.wfile.write(json.dumps(data).encode())
                return
                
            except Exception as e:
                print(f"Erreur: {e}")
                self.send_error(500, str(e))
                return
        
        # Pour tous les autres fichiers, utiliser le comportement par défaut
        return super().do_GET()
    
    def do_OPTIONS(self):
        """Gérer les requêtes OPTIONS pour CORS"""
        self.send_response(200)
        self.send_header('Access-Control-Allow-Origin', '*')
        self.send_header('Access-Control-Allow-Methods', 'POST, GET, OPTIONS')
        self.send_header('Access-Control-Allow-Headers', 'Content-Type')
        self.end_headers()

def start_server(port=8080):
    """Démarrer le serveur HTTP"""
    try:
        with socketserver.TCPServer(("", port), FirstsHTTPRequestHandler) as httpd:
            print(f"""
[Info] SERVEUR FIRSTS LEADERBOARD DÉMARRÉ

[Info] Serveur actif sur: http://localhost:{port}
[Info] Widget accessible: http://localhost:{port}/


[Info] Pour utiliser dans Streamlabs OBS:
   1. Copiez l'URL: http://localhost:{port}
   2. Ajoutez-la comme source Browser dans OBS
   3. Taille recommandée: 400x600

[Info] Appuyez sur Ctrl+C pour arrêter le serveur

""")
            
            # Ouvrir automatiquement le navigateur
            webbrowser.open(f'http://localhost:{port}')
            
            print(f"[{datetime.now().strftime('%H:%M:%S')}] En attente de connexions...")
            httpd.serve_forever()
            
    except KeyboardInterrupt:
        print("\n[Info] Serveur arrêté par l'utilisateur")
    except OSError as e:
        if "Address already in use" in str(e):
            print(f"[Erreur] Erreur: Le port {port} est déjà utilisé")
            print(f"[Info] Essayez avec un autre port: python server.py --port {port+1}")
        else:
            print(f"[Erreur] Erreur: {e}")

if __name__ == "__main__":
    import sys
    
    port = 8080
    if len(sys.argv) > 1:
        try:
            if '--port' in sys.argv:
                port_index = sys.argv.index('--port') + 1
                port = int(sys.argv[port_index])
        except (ValueError, IndexError):
            print("Usage: python server.py [--port PORT_NUMBER]")
            sys.exit(1)
    
    start_server(port)