#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Automatischer Match Generator - Cron-Job Version
Generiert automatisch Matches mit echten Maps und Spielern
"""

import time
import random
import logging
from datetime import datetime, timedelta
import mysql.connector
from mysql.connector import Error

logging.basicConfig(level=logging.INFO)

class AutoMatchGenerator:
    def __init__(self):
        self.db_config = {
            'host': 'localhost',
            'database': 'NexusControl',
            'user': 'root',
            'password': 'HOk~k5$!0q',
            'charset': 'utf8mb4'
        }
        
    def connect_db(self):
        try:
            return mysql.connector.connect(**self.db_config)
        except Error as e:
            logging.error(f"DB-Verbindung fehlgeschlagen: {e}")
            return None
    
    def get_maps_and_players(self):
        """Holt Maps und Spieler aus DB"""
        conn = self.connect_db()
        if not conn:
            return [], []
        
        try:
            cursor = conn.cursor(dictionary=True)
            
            # Maps laden
            cursor.execute("SELECT Name, spiel_typ FROM Map ORDER BY RAND()")
            maps = cursor.fetchall()
            
            # Spieler laden
            cursor.execute("""
                SELECT SpielerID, Name 
                FROM Spieler 
                WHERE is_active = 1 
                AND Name IS NOT NULL 
                AND Name != ''
                ORDER BY RAND()
            """)
            players = cursor.fetchall()
            
            cursor.close()
            conn.close()
            
            logging.info(f"{len(maps)} Maps und {len(players)} Spieler geladen")
            return maps, players
            
        except Error as e:
            logging.error(f"Fehler: {e}")
            return [], []
    
    def generate_auto_matches(self, count=10):
        """Generiert automatisch Matches"""
        maps, players = self.get_maps_and_players()
        
        if len(players) < 2:
            logging.error("Nicht genug Spieler!")
            return 0
        
        conn = self.connect_db()
        if not conn:
            return 0
        
        saved = 0
        
        try:
            cursor = conn.cursor()
            
            for i in range(count):
                # Zufällige Spieler und Maps
                p1, p2 = random.sample(players, 2)
                map_info = random.choice(maps)
                
                # Match-Daten
                match_id = f"auto_{int(time.time())}_{i}"
                duration = random.randint(900, 3600)
                start_time = datetime.now() - timedelta(minutes=random.randint(5, 120))
                
                # Teams zuordnen (zufällig)
                if random.random() < 0.5:
                    p1_faction, p2_faction = 'Allies', 'Soviet'
                    p1_result, p2_result = 'win', 'loss'
                else:
                    p1_faction, p2_faction = 'Soviet', 'Allies'
                    p1_result, p2_result = 'loss', 'win'
                
                # Match speichern
                cursor.execute("""
                    INSERT INTO matches (match_id, map_name, duration_seconds, started_at, ended_at, 
                                       match_type, api_source, created_at)
                    VALUES (%s, %s, %s, %s, DATE_ADD(%s, INTERVAL %s SECOND), 'ranked', 'auto_generator', NOW())
                """, (match_id, map_info['Name'], duration, start_time, start_time, duration))
                
                # Spieler speichern
                for player_id, name, faction, result in [
                    (p1['SpielerID'], p1['Name'], p1_faction, p1_result),
                    (p2['SpielerID'], p2['Name'], p2_faction, p2_result)
                ]:
                    cursor.execute("""
                        INSERT INTO players (player_id, name, created_at, updated_at)
                        VALUES (%s, %s, NOW(), NOW())
                        ON DUPLICATE KEY UPDATE name = VALUES(name), updated_at = NOW()
                    """, (str(player_id), name))
                    
                    cursor.execute("""
                        INSERT INTO match_players (match_id, player_id, faction, result, created_at)
                        VALUES (%s, %s, %s, %s, NOW())
                    """, (match_id, str(player_id), faction, result))
                
                saved += 1
                
                if i % 5 == 0:
                    conn.commit()
                    logging.info(f"{i+1}/{count} Matches generiert...")
            
            conn.commit()
            logging.info(f"Auto-Generierung abgeschlossen: {saved} Matches")
            
        except Error as e:
            conn.rollback()
            logging.error(f"Fehler: {e}")
        finally:
            cursor.close()
            conn.close()
        
        return saved

def main():
    generator = AutoMatchGenerator()
    
    # Alle 6 Stunden 10 neue Matches generieren
    matches_generated = generator.generate_auto_matches(10)
    
    print(f"✅ {matches_generated} Matches automatisch generiert!")

if __name__ == "__main__":
    main()