import sqlite3
import logging
from datetime import datetime
import os

logger = logging.getLogger(__name__)

class Database:
    def __init__(self, db_path="data/scambot.db"):
        self.db_path = db_path
        # Créer le dossier data s'il n'existe pas (sauf si db_path est un nom de fichier simple)
        if "/" in db_path:
            os.makedirs(os.path.dirname(self.db_path), exist_ok=True)
        self.init_database()
    
    def init_database(self):
        """Initialise la base de données avec les tables nécessaires"""
        try:
            # Créer le dossier data s'il n'existe pas
            os.makedirs(os.path.dirname(self.db_path), exist_ok=True)
            
            conn = sqlite3.connect(self.db_path)
            cursor = conn.cursor()
            
            # Table des créateurs
            cursor.execute('''
                CREATE TABLE IF NOT EXISTS creators (
                    id INTEGER PRIMARY KEY AUTOINCREMENT,
                    pseudo TEXT UNIQUE NOT NULL,
                    platform TEXT NOT NULL,
                    profile_url TEXT NOT NULL,
                    discord_channel_id INTEGER NOT NULL,
                    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
                )
            ''')
            
            # Table des vidéos traitées
            cursor.execute('''
                CREATE TABLE IF NOT EXISTS processed_videos (
                    id INTEGER PRIMARY KEY AUTOINCREMENT,
                    creator_id INTEGER NOT NULL,
                    video_url TEXT UNIQUE NOT NULL,
                    video_title TEXT,
                    video_duration TEXT,
                    video_published_date TEXT,
                    game_name TEXT,
                    form_data TEXT,
                    full_form_data TEXT,
                    processed_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
                    FOREIGN KEY (creator_id) REFERENCES creators (id)
                )
            ''')
            
            # Ajouter les colonnes manquantes si elles n'existent pas (migration)
            try:
                cursor.execute('ALTER TABLE processed_videos ADD COLUMN video_published_date TEXT')
            except sqlite3.OperationalError:
                pass  # La colonne existe déjà
            
            try:
                cursor.execute('ALTER TABLE processed_videos ADD COLUMN full_form_data TEXT')
            except sqlite3.OperationalError:
                pass  # La colonne existe déjà
            
            conn.commit()
            conn.close()
            logger.info("✅ Base de données initialisée avec succès")
            
        except Exception as e:
            logger.error(f"❌ Erreur initialisation base de données: {e}")
    
    def add_creator(self, pseudo, platform, profile_url, discord_channel_id):
        """Ajoute un créateur à la base de données"""
        try:
            conn = sqlite3.connect(self.db_path)
            cursor = conn.cursor()
            
            cursor.execute('''
                INSERT OR REPLACE INTO creators (pseudo, platform, profile_url, discord_channel_id)
                VALUES (?, ?, ?, ?)
            ''', (pseudo, platform, profile_url, discord_channel_id))
            
            conn.commit()
            conn.close()
            
            logger.info(f"✅ Créateur ajouté: {pseudo} ({platform})")
            return True
            
        except Exception as e:
            logger.error(f"❌ Erreur ajout créateur: {e}")
            return False
    
    def remove_creator(self, pseudo):
        """Supprime un créateur de la base de données"""
        try:
            conn = sqlite3.connect(self.db_path)
            cursor = conn.cursor()
            
            # Supprimer d'abord les vidéos traitées
            cursor.execute('''
                DELETE FROM processed_videos 
                WHERE creator_id IN (SELECT id FROM creators WHERE pseudo = ?)
            ''', (pseudo,))
            
            # Puis supprimer le créateur
            cursor.execute('DELETE FROM creators WHERE pseudo = ?', (pseudo,))
            
            conn.commit()
            conn.close()
            
            logger.info(f"✅ Créateur supprimé: {pseudo}")
            return True
            
        except Exception as e:
            logger.error(f"❌ Erreur suppression créateur: {e}")
            return False
    
    def list_creators(self):
        """Liste tous les créateurs"""
        try:
            conn = sqlite3.connect(self.db_path)
            cursor = conn.cursor()
            
            cursor.execute('''
                SELECT id, pseudo, platform, profile_url, discord_channel_id, created_at
                FROM creators
                ORDER BY pseudo
            ''')
            
            creators = cursor.fetchall()
            conn.close()
            
            return creators
            
        except Exception as e:
            logger.error(f"❌ Erreur liste créateurs: {e}")
            return []
    
    def get_creator_by_id(self, creator_id):
        """Récupère un créateur par son ID"""
        try:
            conn = sqlite3.connect(self.db_path)
            cursor = conn.cursor()
            
            cursor.execute('''
                SELECT id, pseudo, platform, profile_url, discord_channel_id
                FROM creators
                WHERE id = ?
            ''', (creator_id,))
            
            creator = cursor.fetchone()
            conn.close()
            
            return creator
            
        except Exception as e:
            logger.error(f"❌ Erreur récupération créateur: {e}")
            return None
    
    def get_creator_by_pseudo(self, pseudo):
        """Récupère un créateur par son pseudo"""
        try:
            conn = sqlite3.connect(self.db_path)
            cursor = conn.cursor()
            
            cursor.execute('''
                SELECT id, pseudo, platform, profile_url, discord_channel_id
                FROM creators
                WHERE pseudo = ?
            ''', (pseudo,))
            
            creator = cursor.fetchone()
            conn.close()
            
            return creator
            
        except Exception as e:
            logger.error(f"❌ Erreur récupération créateur: {e}")
            return None
    
    def is_video_processed(self, video_url):
        """Vérifie si une vidéo a déjà été traitée"""
        try:
            conn = sqlite3.connect(self.db_path)
            cursor = conn.cursor()
            
            cursor.execute('''
                SELECT id FROM processed_videos WHERE video_url = ?
            ''', (video_url,))
            
            result = cursor.fetchone()
            conn.close()
            
            return result is not None
            
        except Exception as e:
            logger.error(f"❌ Erreur vérification vidéo: {e}")
            return False
    
    def add_processed_video(self, creator_id, video_url, video_title="", video_duration="", video_published_date="", game_name="", form_data="", full_form_data=""):
        """Ajoute une vidéo traitée à la base de données"""
        try:
            conn = sqlite3.connect(self.db_path)
            cursor = conn.cursor()
            
            cursor.execute('''
                INSERT INTO processed_videos (creator_id, video_url, video_title, video_duration, video_published_date, game_name, form_data, full_form_data)
                VALUES (?, ?, ?, ?, ?, ?, ?, ?)
            ''', (creator_id, video_url, video_title, video_duration, video_published_date, game_name, form_data, full_form_data))
            
            conn.commit()
            conn.close()
            
            logger.info(f"✅ Vidéo traitée ajoutée: {video_url}")
            return True
            
        except Exception as e:
            logger.error(f"❌ Erreur ajout vidéo traitée: {e}")
            return False
    
    def get_recent_videos(self, creator_id, limit=10):
        """Récupère les vidéos récentes d'un créateur"""
        try:
            conn = sqlite3.connect(self.db_path)
            cursor = conn.cursor()
            
            cursor.execute('''
                SELECT video_url, video_title, processed_at
                FROM processed_videos
                WHERE creator_id = ?
                ORDER BY processed_at DESC
                LIMIT ?
            ''', (creator_id, limit))
            
            videos = cursor.fetchall()
            conn.close()
            
            return videos
            
        except Exception as e:
            logger.error(f"❌ Erreur récupération vidéos récentes: {e}")
            return []
    
    def get_processed_form(self, video_url):
        """Récupère le formulaire d'une vidéo déjà traitée"""
        try:
            conn = sqlite3.connect(self.db_path)
            cursor = conn.cursor()
            
            cursor.execute('''
                SELECT form_data, game_name, video_title, video_duration, video_published_date, full_form_data
                FROM processed_videos
                WHERE video_url = ?
            ''', (video_url,))
            
            result = cursor.fetchone()
            conn.close()
            
            if result:
                return {
                    'form_data': result[0],
                    'game_name': result[1],
                    'video_title': result[2],
                    'video_duration': result[3],
                    'video_published_date': result[4] or 'Non trouvée',
                    'full_form_data': result[5] or result[0]  # Fallback sur form_data si full_form_data n'existe pas
                }
            return None
            
        except Exception as e:
            logger.error(f"❌ Erreur récupération formulaire: {e}")
            return None
    
    def update_processed_video(self, video_url, form_data, game_name="", full_form_data=""):
        """Met à jour une vidéo déjà traitée"""
        try:
            conn = sqlite3.connect(self.db_path)
            cursor = conn.cursor()
            
            if full_form_data:
                cursor.execute('''
                    UPDATE processed_videos
                    SET form_data = ?, game_name = ?, full_form_data = ?, processed_at = CURRENT_TIMESTAMP
                    WHERE video_url = ?
                ''', (form_data, game_name, full_form_data, video_url))
            else:
                cursor.execute('''
                    UPDATE processed_videos
                    SET form_data = ?, game_name = ?, processed_at = CURRENT_TIMESTAMP
                    WHERE video_url = ?
                ''', (form_data, game_name, video_url))
            
            conn.commit()
            conn.close()
            
            logger.info(f"✅ Vidéo mise à jour: {video_url}")
            return True
            
        except Exception as e:
            logger.error(f"❌ Erreur mise à jour vidéo: {e}")
            return False

    def clear_all_processed_videos(self):
        """Vide toutes les vidéos traitées de la base de données"""
        try:
            conn = sqlite3.connect(self.db_path)
            cursor = conn.cursor()
            
            cursor.execute('DELETE FROM processed_videos')
            
            conn.commit()
            count = cursor.rowcount
            conn.close()
            
            logger.info(f"✅ {count} vidéo(s) supprimée(s) de l'historique")
            return count
            
        except Exception as e:
            logger.error(f"❌ Erreur suppression historique: {e}")
            return -1
    
    def clear_processed_videos_by_creator(self, creator_id):
        """Vide les vidéos traitées d'un créateur spécifique"""
        try:
            conn = sqlite3.connect(self.db_path)
            cursor = conn.cursor()
            
            cursor.execute('DELETE FROM processed_videos WHERE creator_id = ?', (creator_id,))
            
            conn.commit()
            count = cursor.rowcount
            conn.close()
            
            logger.info(f"✅ {count} vidéo(s) supprimée(s) pour le créateur {creator_id}")
            return count
            
        except Exception as e:
            logger.error(f"❌ Erreur suppression historique créateur: {e}")
            return -1

    def get_stats(self):
        """Récupère les statistiques de la base de données"""
        try:
            conn = sqlite3.connect(self.db_path)
            cursor = conn.cursor()
            
            # Nombre de créateurs
            cursor.execute('SELECT COUNT(*) FROM creators')
            creators_count = cursor.fetchone()[0]
            
            # Nombre de vidéos traitées
            cursor.execute('SELECT COUNT(*) FROM processed_videos')
            videos_count = cursor.fetchone()[0]
            
            # Vidéos par plateforme
            cursor.execute('''
                SELECT c.platform, COUNT(pv.id) as count
                FROM creators c
                LEFT JOIN processed_videos pv ON c.id = pv.creator_id
                GROUP BY c.platform
            ''')
            platform_stats = cursor.fetchall()
            
            conn.close()
            
            return {
                'creators_count': creators_count,
                'videos_count': videos_count,
                'platform_stats': platform_stats
            }
            
        except Exception as e:
            logger.error(f"❌ Erreur récupération stats: {e}")
            return {
                'creators_count': 0,
                'videos_count': 0,
                'platform_stats': []
            }