#!/usr/bin/env python3
"""
Script de diagnostic pour les avatars du Pack Défis
Vérifie les weekly_rewards et les avatars attribués à un utilisateur
"""

import mysql.connector
from datetime import datetime, timedelta

# Configuration de la base de données
def get_connection():
    return mysql.connector.connect(**DB_CONFIG)

def check_weekly_rewards():
    """Vérifie les avatars définis par semaine dans weekly_rewards"""
    conn = get_connection()
    cursor = conn.cursor(dictionary=True)
    
    print("=" * 60)
    print("1. WEEKLY_REWARDS (avatars par semaine)")
    print("=" * 60)
    
    cursor.execute("""
        SELECT * FROM weekly_rewards 
        ORDER BY week_key DESC
    """)
    rows = cursor.fetchall()
    
    if not rows:
        print("❌ AUCUN avatar hebdomadaire défini dans weekly_rewards!")
        print("   C'est le problème principal - il faut générer les avatars par semaine")
    else:
        print(f"✓ {len(rows)} semaines avec avatars définis:")
        for r in rows:
            print(f"   - Semaine {r['week_key']}: {r['avatar_id']}")
    
    conn.close()
    return rows

def check_user_pack_and_avatars(username="bruno-admin"):
    """Vérifie le pack et les avatars d'un utilisateur"""
    conn = get_connection()
    cursor = conn.cursor(dictionary=True)
    
    # Trouver l'utilisateur (par display_name ou email)
    cursor.execute("SELECT id, display_name, email FROM users WHERE display_name = %s OR email LIKE %s", (username, f"%{username}%"))
    user = cursor.fetchone()
    
    if not user:
        print(f"❌ Utilisateur '{username}' non trouvé!")
        conn.close()
        return
    
    user_id = user['id']
    print()
    print("=" * 60)
    print(f"2. UTILISATEUR: {user['display_name']} (ID: {user_id})")
    print("=" * 60)
    
    # Vérifier le pack défis
    cursor.execute("""
        SELECT * FROM user_challenge_pack WHERE user_id = %s
    """, (user_id,))
    pack = cursor.fetchone()
    
    if pack:
        print(f"✓ Pack Défis acheté le: {pack['purchased_at']}")
    else:
        print("❌ Pack Défis NON acheté")
    
    # Vérifier les avatars hebdomadaires attribués
    print()
    print("=" * 60)
    print("3. AVATARS HEBDOMADAIRES ATTRIBUÉS (user_weekly_avatars)")
    print("=" * 60)
    
    cursor.execute("""
        SELECT * FROM user_weekly_avatars WHERE user_id = %s
    """, (user_id,))
    weekly_avatars = cursor.fetchall()
    
    if weekly_avatars:
        print(f"✓ {len(weekly_avatars)} avatars hebdomadaires attribués:")
        for a in weekly_avatars:
            print(f"   - Avatar {a['avatar_id']} (source: {a.get('obtained_from', 'N/A')}, obtenu le {a.get('obtained_at', 'N/A')})")
    else:
        print("❌ Aucun avatar hebdomadaire attribué à cet utilisateur")
    
    # Vérifier tous les avatars possédés
    print()
    print("=" * 60)
    print("4. TOUS LES AVATARS POSSÉDÉS (user_avatars)")
    print("=" * 60)
    
    cursor.execute("""
        SELECT avatar_id, source, earned_at FROM user_avatars WHERE user_id = %s
    """, (user_id,))
    all_avatars = cursor.fetchall()
    
    print(f"Total: {len(all_avatars)} avatars")
    for a in all_avatars:
        print(f"   - {a['avatar_id']} (source: {a['source']}, obtenu: {a['earned_at']})")
    
    conn.close()

def check_past_weeks():
    """Vérifie les semaines passées depuis janvier 2026"""
    print()
    print("=" * 60)
    print("5. SEMAINES PASSÉES (depuis janvier 2026)")
    print("=" * 60)
    
    # Calculer les semaines depuis début janvier 2026
    start_date = datetime(2026, 1, 1)
    today = datetime.now()
    
    weeks = []
    current = start_date
    while current < today:
        # Calculer la clé de semaine (format: YYYY-WNN)
        week_num = current.isocalendar()[1]
        year = current.isocalendar()[0]
        week_key = f"{year}-W{week_num:02d}"
        if week_key not in weeks:
            weeks.append(week_key)
        current += timedelta(days=7)
    
    print(f"Semaines passées calculées: {len(weeks)}")
    for w in weeks:
        print(f"   - {w}")
    
    return weeks

def generate_missing_weekly_avatars():
    """Génère les avatars manquants pour les semaines passées"""
    import random
from python.db_config import DB_CONFIG
    
    conn = get_connection()
    cursor = conn.cursor(dictionary=True)
    
    print()
    print("=" * 60)
    print("6. GÉNÉRATION DES AVATARS MANQUANTS")
    print("=" * 60)
    
    # Récupérer les avatars disponibles (non-base)
    cursor.execute("""
        SELECT id FROM avatars WHERE category != 'base' AND is_active = 1
    """)
    available_avatars = [r['id'] for r in cursor.fetchall()]
    
    if not available_avatars:
        print("❌ Aucun avatar disponible pour les récompenses!")
        # Essayer avec tous les avatars
        cursor.execute("SELECT id FROM avatars WHERE is_active = 1")
        available_avatars = [r['id'] for r in cursor.fetchall()]
        print(f"   Utilisation de tous les avatars actifs: {len(available_avatars)}")
    
    if not available_avatars:
        print("❌ Vraiment aucun avatar en base!")
        conn.close()
        return
    
    print(f"Avatars disponibles pour récompenses: {len(available_avatars)}")
    
    # Calculer les semaines passées
    start_date = datetime(2026, 1, 1)
    today = datetime.now()
    
    weeks_to_create = []
    current = start_date
    while current < today:
        week_num = current.isocalendar()[1]
        year = current.isocalendar()[0]
        week_key = f"{year}-W{week_num:02d}"
        if week_key not in [w[0] for w in weeks_to_create]:
            weeks_to_create.append((week_key, current))
        current += timedelta(days=7)
    
    # Vérifier quelles semaines n'ont pas d'avatar
    cursor.execute("SELECT week_key FROM weekly_rewards")
    existing_weeks = [r['week_key'] for r in cursor.fetchall()]
    
    created = 0
    for week_key, week_date in weeks_to_create:
        if week_key not in existing_weeks:
            # Choisir un avatar aléatoire
            avatar_id = random.choice(available_avatars)
            
            cursor.execute("""
                INSERT INTO weekly_rewards (week_key, avatar_id, created_at)
                VALUES (%s, %s, NOW())
            """, (week_key, avatar_id))
            
            print(f"   ✓ Créé: {week_key} -> {avatar_id}")
            created += 1
    
    if created > 0:
        conn.commit()
        print(f"\n✓ {created} avatars hebdomadaires créés!")
    else:
        print("Tous les avatars hebdomadaires existent déjà.")
    
    conn.close()

def grant_pack_avatars_to_user(username="bruno-admin"):
    """Attribue les avatars du pack à un utilisateur qui l'a acheté"""
    conn = get_connection()
    cursor = conn.cursor(dictionary=True)
    
    print()
    print("=" * 60)
    print(f"7. ATTRIBUTION DES AVATARS DU PACK À {username}")
    print("=" * 60)
    
    # Trouver l'utilisateur
    cursor.execute("SELECT id, display_name FROM users WHERE display_name = %s OR email LIKE %s", (username, f"%{username}%"))
    user = cursor.fetchone()
    if not user:
        print(f"❌ Utilisateur '{username}' non trouvé!")
        conn.close()
        return
    
    user_id = user['id']
    print(f"Utilisateur trouvé: {user['display_name']} (ID: {user_id})")
    
    # Vérifier qu'il a le pack
    cursor.execute("SELECT * FROM user_challenge_pack WHERE user_id = %s", (user_id,))
    if not cursor.fetchone():
        print(f"❌ L'utilisateur n'a pas acheté le pack!")
        conn.close()
        return
    
    # Récupérer tous les weekly_rewards
    cursor.execute("SELECT week_key, avatar_id FROM weekly_rewards")
    weekly_rewards = cursor.fetchall()
    
    if not weekly_rewards:
        print("❌ Aucun weekly_reward défini!")
        conn.close()
        return
    
    granted = 0
    for reward in weekly_rewards:
        week_key = reward['week_key']
        avatar_id = reward['avatar_id']
        
        # Vérifier si déjà attribué dans user_weekly_avatars
        cursor.execute("""
            SELECT 1 FROM user_weekly_avatars 
            WHERE user_id = %s AND avatar_id = %s
        """, (user_id, avatar_id))
        
        if not cursor.fetchone():
            # Ajouter dans user_weekly_avatars
            cursor.execute("""
                INSERT INTO user_weekly_avatars (user_id, avatar_id, obtained_at, obtained_from)
                VALUES (%s, %s, NOW(), %s)
            """, (user_id, avatar_id, f'challenge_pack_{week_key}'))
            print(f"   ✓ user_weekly_avatars: {week_key} -> {avatar_id}")
        
        # Vérifier si déjà dans user_avatars
        cursor.execute("""
            SELECT 1 FROM user_avatars 
            WHERE user_id = %s AND avatar_id = %s
        """, (user_id, avatar_id))
        
        if not cursor.fetchone():
            # Ajouter dans user_avatars
            cursor.execute("""
                INSERT INTO user_avatars (user_id, avatar_id, source, earned_at)
                VALUES (%s, %s, 'challenge_pack', NOW())
            """, (user_id, avatar_id))
            print(f"   ✓ user_avatars: {avatar_id} (source: challenge_pack)")
            granted += 1
    
    conn.commit()
    print(f"\n✓ {granted} nouveaux avatars attribués à {username}")
    
    conn.close()

if __name__ == "__main__":
    print("🔍 DIAGNOSTIC PACK DÉFIS - AVATARS")
    print("=" * 60)
    print()
    
    # 1. Vérifier les weekly_rewards
    weekly_rewards = check_weekly_rewards()
    
    # 2. Vérifier l'utilisateur
    check_user_pack_and_avatars("bruno-admin")
    
    # 3. Vérifier les semaines passées
    check_past_weeks()
    
    # 4. Générer les avatars manquants si nécessaire
    if not weekly_rewards:
        print("\n⚠️ Génération des avatars hebdomadaires manquants...")
        generate_missing_weekly_avatars()
    
    # 5. Attribuer les avatars à bruno-admin
    print("\n⚠️ Attribution des avatars du pack à bruno-admin...")
    grant_pack_avatars_to_user("bruno-admin")
    
    # 6. Revérifier après corrections
    print("\n" + "=" * 60)
    print("VÉRIFICATION FINALE")
    print("=" * 60)
    check_weekly_rewards()
    check_user_pack_and_avatars("bruno-admin")