import sqlite3
import logging
from datetime import datetime
import os

logger = logging.getLogger(__name__)

class UserManager:
    def __init__(self, db_path="data/scambot.db"):
        self.db_path = db_path
        self.init_user_tables()
    
    def init_user_tables(self):
        """Initialise les tables pour les utilisateurs Discord"""
        try:
            conn = sqlite3.connect(self.db_path)
            cursor = conn.cursor()
            
            # Table des utilisateurs Discord avec leurs données personnelles
            cursor.execute('''
                CREATE TABLE IF NOT EXISTS discord_users (
                    id INTEGER PRIMARY KEY AUTOINCREMENT,
                    discord_id TEXT UNIQUE NOT NULL,
                    prenom TEXT NOT NULL,
                    nom TEXT NOT NULL,
                    email TEXT NOT NULL,
                    telephone TEXT NOT NULL,
                    rue TEXT NOT NULL,
                    code_postal TEXT NOT NULL,
                    ville TEXT NOT NULL,
                    instagram TEXT,
                    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
                    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
                )
            ''')
            
            # Ajouter la colonne instagram si elle n'existe pas (migration)
            try:
                cursor.execute('ALTER TABLE discord_users ADD COLUMN instagram TEXT')
                logger.info("✅ Colonne instagram ajoutée à la table")
            except sqlite3.OperationalError:
                # La colonne existe déjà
                pass
            
            conn.commit()
            conn.close()
            logger.info("✅ Tables utilisateurs initialisées avec succès")
            
        except Exception as e:
            logger.error(f"❌ Erreur initialisation tables utilisateurs: {e}")
    
    def add_user(self, discord_id, prenom, nom, email, telephone, rue, code_postal, ville, instagram=None):
        """Ajoute ou met à jour un utilisateur Discord"""
        try:
            conn = sqlite3.connect(self.db_path)
            cursor = conn.cursor()
            
            cursor.execute('''
                INSERT OR REPLACE INTO discord_users 
                (discord_id, prenom, nom, email, telephone, rue, code_postal, ville, instagram, updated_at)
                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP)
            ''', (discord_id, prenom, nom, email, telephone, rue, code_postal, ville, instagram))
            
            conn.commit()
            conn.close()
            
            logger.info(f"✅ Utilisateur ajouté/mis à jour: {prenom} {nom} ({discord_id})")
            return True
            
        except Exception as e:
            logger.error(f"❌ Erreur ajout utilisateur: {e}")
            return False
    
    def get_user(self, discord_id):
        """Récupère les données d'un utilisateur Discord"""
        try:
            conn = sqlite3.connect(self.db_path)
            cursor = conn.cursor()
            
            cursor.execute('''
                SELECT prenom, nom, email, telephone, rue, code_postal, ville, created_at, instagram
                FROM discord_users
                WHERE discord_id = ?
            ''', (discord_id,))
            
            result = cursor.fetchone()
            conn.close()
            
            if result:
                return {
                    'prenom': result[0],
                    'nom': result[1],
                    'email': result[2],
                    'telephone': result[3],
                    'rue': result[4],
                    'code_postal': result[5],
                    'ville': result[6],
                    'created_at': result[7],
                    'instagram': result[8]
                }
            return None
            
        except Exception as e:
            logger.error(f"❌ Erreur récupération utilisateur: {e}")
            return None
    
    def user_exists(self, discord_id):
        """Vérifie si un utilisateur Discord existe"""
        try:
            conn = sqlite3.connect(self.db_path)
            cursor = conn.cursor()
            
            cursor.execute('SELECT id FROM discord_users WHERE discord_id = ?', (discord_id,))
            result = cursor.fetchone()
            conn.close()
            
            return result is not None
            
        except Exception as e:
            logger.error(f"❌ Erreur vérification utilisateur: {e}")
            return False
    
    def delete_user(self, discord_id):
        """Supprime un utilisateur Discord"""
        try:
            conn = sqlite3.connect(self.db_path)
            cursor = conn.cursor()
            
            cursor.execute('DELETE FROM discord_users WHERE discord_id = ?', (discord_id,))
            
            conn.commit()
            rows_affected = cursor.rowcount
            conn.close()
            
            if rows_affected > 0:
                logger.info(f"✅ Utilisateur supprimé: {discord_id}")
                return True
            else:
                logger.warning(f"⚠️ Aucun utilisateur trouvé pour suppression: {discord_id}")
                return False
                
        except Exception as e:
            logger.error(f"❌ Erreur suppression utilisateur: {e}")
            return False
    
    def list_users(self):
        """Liste tous les utilisateurs Discord enregistrés"""
        try:
            conn = sqlite3.connect(self.db_path)
            cursor = conn.cursor()
            
            cursor.execute('''
                SELECT discord_id, prenom, nom, email, created_at
                FROM discord_users
                ORDER BY created_at DESC
            ''')
            
            users = cursor.fetchall()
            conn.close()
            
            return users
            
        except Exception as e:
            logger.error(f"❌ Erreur liste utilisateurs: {e}")
            return []
    
    def get_user_stats(self):
        """Récupère les statistiques des utilisateurs"""
        try:
            conn = sqlite3.connect(self.db_path)
            cursor = conn.cursor()
            
            cursor.execute('SELECT COUNT(*) FROM discord_users')
            total_users = cursor.fetchone()[0]
            
            conn.close()
            
            return {
                'total_users': total_users
            }
            
        except Exception as e:
            logger.error(f"❌ Erreur stats utilisateurs: {e}")
            return {'total_users': 0}