#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Модуль аналитики для AI-Иллюстратор бота
"""

import sqlite3
import json
import logging
from datetime import datetime, timedelta
from typing import Dict, List, Any, Optional

logger = logging.getLogger(__name__)


class BotAnalytics:
    """Класс для работы с аналитикой бота"""
    
    def __init__(self, db_path: str = "bot_illustrator.db"):
        """Инициализация модуля аналитики"""
        self.db_path = db_path
        self.init_database()
        logger.info(f"📊 Инициализирована аналитика бота, БД: {db_path}")
    
    def init_database(self):
        """Создание таблиц базы данных"""
        try:
            conn = sqlite3.connect(self.db_path)
            cursor = conn.cursor()
            
            # Таблица пользователей
            cursor.execute("""
                CREATE TABLE IF NOT EXISTS users (
                    user_id INTEGER PRIMARY KEY,
                    username TEXT,
                    first_name TEXT,
                    last_name TEXT,
                    first_seen TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
                    last_activity TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
                    is_subscribed INTEGER DEFAULT 1,
                    total_generations INTEGER DEFAULT 0
                )
            """)
            
            # Таблица генераций изображений
            cursor.execute("""
                CREATE TABLE IF NOT EXISTS generations (
                    id INTEGER PRIMARY KEY AUTOINCREMENT,
                    user_id INTEGER,
                    generation_type TEXT,
                    prompt TEXT,
                    success INTEGER DEFAULT 1,
                    timestamp TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
                    FOREIGN KEY (user_id) REFERENCES users (user_id)
                )
            """)
            
            # Таблица активности по часам
            cursor.execute("""
                CREATE TABLE IF NOT EXISTS hourly_activity (
                    id INTEGER PRIMARY KEY AUTOINCREMENT,
                    user_id INTEGER,
                    activity_hour INTEGER,
                    activity_date DATE,
                    count INTEGER DEFAULT 1,
                    FOREIGN KEY (user_id) REFERENCES users (user_id)
                )
            """)
            
            # Индексы для быстрого поиска
            cursor.execute("CREATE INDEX IF NOT EXISTS idx_generations_user_id ON generations(user_id)")
            cursor.execute("CREATE INDEX IF NOT EXISTS idx_generations_timestamp ON generations(timestamp)")
            cursor.execute("CREATE INDEX IF NOT EXISTS idx_hourly_activity_date ON hourly_activity(activity_date)")
            
            conn.commit()
            conn.close()
            logger.info("✅ База данных инициализирована успешно")
            
        except Exception as e:
            logger.error(f"❌ Ошибка инициализации базы данных: {e}")
            raise
    
    def register_user(self, user_id: int, username: str = None, 
                     first_name: str = None, last_name: str = None):
        """Регистрация или обновление пользователя"""
        try:
            conn = sqlite3.connect(self.db_path)
            cursor = conn.cursor()
            
            # Проверяем, существует ли пользователь
            cursor.execute("SELECT user_id FROM users WHERE user_id = ?", (user_id,))
            exists = cursor.fetchone()
            
            if exists:
                # Обновляем данные существующего пользователя
                cursor.execute("""
                    UPDATE users 
                    SET username = ?, first_name = ?, last_name = ?, 
                        last_activity = CURRENT_TIMESTAMP
                    WHERE user_id = ?
                """, (username, first_name, last_name, user_id))
                logger.debug(f"Обновлен пользователь {user_id}")
            else:
                # Добавляем нового пользователя
                cursor.execute("""
                    INSERT INTO users (user_id, username, first_name, last_name)
                    VALUES (?, ?, ?, ?)
                """, (user_id, username, first_name, last_name))
                logger.info(f"✅ Зарегистрирован новый пользователь {user_id} (@{username})")
            
            conn.commit()
            conn.close()
            
        except Exception as e:
            logger.error(f"❌ Ошибка регистрации пользователя {user_id}: {e}")
    
    def log_generation(self, user_id: int, generation_type: str, 
                       prompt: str = "", success: bool = True):
        """Логирование генерации изображения"""
        try:
            conn = sqlite3.connect(self.db_path)
            cursor = conn.cursor()
            
            # Добавляем запись о генерации
            cursor.execute("""
                INSERT INTO generations (user_id, generation_type, prompt, success)
                VALUES (?, ?, ?, ?)
            """, (user_id, generation_type, prompt, 1 if success else 0))
            
            # Обновляем счетчик генераций пользователя
            if success:
                cursor.execute("""
                    UPDATE users 
                    SET total_generations = total_generations + 1,
                        last_activity = CURRENT_TIMESTAMP
                    WHERE user_id = ?
                """, (user_id,))
            
            # Логируем почасовую активность
            now = datetime.now()
            cursor.execute("""
                INSERT INTO hourly_activity (user_id, activity_hour, activity_date)
                VALUES (?, ?, ?)
                ON CONFLICT DO NOTHING
            """, (user_id, now.hour, now.date()))
            
            conn.commit()
            conn.close()
            
            logger.info(f"📊 Логирование: user={user_id}, type={generation_type}, success={success}")
            
        except Exception as e:
            logger.error(f"❌ Ошибка логирования генерации: {e}")
    
    def get_general_stats(self) -> Dict[str, Any]:
        """Получение общей статистики"""
        try:
            conn = sqlite3.connect(self.db_path)
            cursor = conn.cursor()
            
            # Общее количество пользователей
            cursor.execute("SELECT COUNT(*) FROM users")
            total_users = cursor.fetchone()[0]
            
            # Общее количество генераций
            cursor.execute("SELECT COUNT(*) FROM generations WHERE success = 1")
            total_generations = cursor.fetchone()[0]
            
            # Активные пользователи за последние 24 часа
            cursor.execute("""
                SELECT COUNT(DISTINCT user_id) FROM generations 
                WHERE timestamp >= datetime('now', '-1 day')
            """)
            active_users_24h = cursor.fetchone()[0]
            
            # Активные пользователи за последние 7 дней
            cursor.execute("""
                SELECT COUNT(DISTINCT user_id) FROM generations 
                WHERE timestamp >= datetime('now', '-7 days')
            """)
            active_users_7d = cursor.fetchone()[0]
            
            # Средняя генерация на пользователя
            avg_generations = total_generations / total_users if total_users > 0 else 0
            
            # Дата первой регистрации
            cursor.execute("SELECT MIN(first_seen) FROM users")
            first_registration = cursor.fetchone()[0]
            
            # Последняя активность
            cursor.execute("SELECT MAX(timestamp) FROM generations")
            last_activity = cursor.fetchone()[0]
            
            conn.close()
            
            return {
                'total_users': total_users,
                'total_generations': total_generations,
                'active_users_24h': active_users_24h,
                'active_users_7d': active_users_7d,
                'avg_generations_per_user': round(avg_generations, 2),
                'first_registration': first_registration,
                'last_activity': last_activity
            }
            
        except Exception as e:
            logger.error(f"❌ Ошибка получения общей статистики: {e}")
            return {}
    
    def get_top_users(self, limit: int = 10) -> List[Dict[str, Any]]:
        """Получение топ пользователей по количеству генераций"""
        try:
            conn = sqlite3.connect(self.db_path)
            cursor = conn.cursor()
            
            cursor.execute("""
                SELECT 
                    u.user_id,
                    u.username,
                    u.first_name,
                    u.total_generations,
                    u.first_seen,
                    u.last_activity
                FROM users u
                ORDER BY u.total_generations DESC
                LIMIT ?
            """, (limit,))
            
            results = cursor.fetchall()
            conn.close()
            
            top_users = []
            for row in results:
                top_users.append({
                    'user_id': row[0],
                    'username': row[1] or 'Неизвестно',
                    'first_name': row[2] or 'Пользователь',
                    'total_generations': row[3],
                    'first_seen': row[4],
                    'last_activity': row[5]
                })
            
            return top_users
            
        except Exception as e:
            logger.error(f"❌ Ошибка получения топ пользователей: {e}")
            return []
    
    def get_generation_types_stats(self) -> Dict[str, int]:
        """Получение статистики по типам генераций"""
        try:
            conn = sqlite3.connect(self.db_path)
            cursor = conn.cursor()
            
            cursor.execute("""
                SELECT generation_type, COUNT(*) as count
                FROM generations
                WHERE success = 1
                GROUP BY generation_type
                ORDER BY count DESC
            """)
            
            results = cursor.fetchall()
            conn.close()
            
            stats = {}
            for row in results:
                stats[row[0]] = row[1]
            
            return stats
            
        except Exception as e:
            logger.error(f"❌ Ошибка получения статистики типов генераций: {e}")
            return {}
    
    def get_daily_activity(self, days: int = 7) -> List[Dict[str, Any]]:
        """Получение активности по дням"""
        try:
            conn = sqlite3.connect(self.db_path)
            cursor = conn.cursor()
            
            cursor.execute("""
                SELECT 
                    DATE(timestamp) as date,
                    COUNT(*) as generations_count,
                    COUNT(DISTINCT user_id) as active_users
                FROM generations
                WHERE timestamp >= datetime('now', '-' || ? || ' days')
                  AND success = 1
                GROUP BY DATE(timestamp)
                ORDER BY date DESC
            """, (days,))
            
            results = cursor.fetchall()
            conn.close()
            
            activity = []
            for row in results:
                activity.append({
                    'date': row[0],
                    'generations_count': row[1],
                    'active_users': row[2]
                })
            
            return activity
            
        except Exception as e:
            logger.error(f"❌ Ошибка получения дневной активности: {e}")
            return []
    
    def get_hourly_activity(self) -> List[Dict[str, Any]]:
        """Получение активности по часам"""
        try:
            conn = sqlite3.connect(self.db_path)
            cursor = conn.cursor()
            
            cursor.execute("""
                SELECT 
                    CAST(strftime('%H', timestamp) AS INTEGER) as hour,
                    COUNT(*) as count
                FROM generations
                WHERE success = 1
                GROUP BY hour
                ORDER BY hour
            """)
            
            results = cursor.fetchall()
            conn.close()
            
            # Создаем массив на все 24 часа
            hourly_stats = [{'hour': i, 'count': 0} for i in range(24)]
            
            for row in results:
                hour = row[0]
                count = row[1]
                if 0 <= hour < 24:
                    hourly_stats[hour]['count'] = count
            
            return hourly_stats
            
        except Exception as e:
            logger.error(f"❌ Ошибка получения почасовой активности: {e}")
            return []
    
    def get_popular_prompts(self, limit: int = 10) -> List[Dict[str, Any]]:
        """Получение популярных промптов"""
        try:
            conn = sqlite3.connect(self.db_path)
            cursor = conn.cursor()
            
            cursor.execute("""
                SELECT 
                    prompt,
                    COUNT(*) as count,
                    generation_type
                FROM generations
                WHERE success = 1 AND prompt != ''
                GROUP BY prompt
                ORDER BY count DESC
                LIMIT ?
            """, (limit,))
            
            results = cursor.fetchall()
            conn.close()
            
            prompts = []
            for row in results:
                prompts.append({
                    'prompt': row[0][:100] + '...' if len(row[0]) > 100 else row[0],
                    'count': row[1],
                    'type': row[2]
                })
            
            return prompts
            
        except Exception as e:
            logger.error(f"❌ Ошибка получения популярных промптов: {e}")
            return []
    
    def format_analytics_message(self) -> str:
        """Форматирование аналитики для отправки в Telegram"""
        try:
            # Получаем все данные
            general_stats = self.get_general_stats()
            top_users = self.get_top_users(5)
            generation_types = self.get_generation_types_stats()
            daily_activity = self.get_daily_activity(7)
            hourly_activity = self.get_hourly_activity()
            popular_prompts = self.get_popular_prompts(5)
            
            # Форматируем сообщение
            message = "📊 <b>АНАЛИТИКА AI-ИЛЛЮСТРАТОР БОТА</b>\n\n"
            
            # Общая статистика
            message += "📈 <b>ОБЩАЯ СТАТИСТИКА:</b>\n"
            message += f"👥 Всего пользователей: <b>{general_stats.get('total_users', 0)}</b>\n"
            message += f"🎨 Всего генераций: <b>{general_stats.get('total_generations', 0)}</b>\n"
            message += f"📊 Среднее на пользователя: <b>{general_stats.get('avg_generations_per_user', 0)}</b>\n"
            message += f"🔥 Активных за 24ч: <b>{general_stats.get('active_users_24h', 0)}</b>\n"
            message += f"📅 Активных за 7 дней: <b>{general_stats.get('active_users_7d', 0)}</b>\n\n"
            
            # Типы генераций
            if generation_types:
                message += "🎯 <b>ТИПЫ ГЕНЕРАЦИЙ:</b>\n"
                type_names = {
                    'text': '📝 Текст',
                    'photo': '📸 Одно фото',
                    'album': '🖼 Альбом',
                    'voice': '🎤 Голос',
                    'modification': '🔄 Модификация'
                }
                for gen_type, count in generation_types.items():
                    type_display = type_names.get(gen_type, gen_type)
                    message += f"  {type_display}: <b>{count}</b>\n"
                message += "\n"
            
            # Топ пользователей
            if top_users:
                message += "🏆 <b>ТОП-5 ПОЛЬЗОВАТЕЛЕЙ:</b>\n"
                for i, user in enumerate(top_users, 1):
                    username = f"@{user['username']}" if user['username'] != 'Неизвестно' else user['first_name']
                    message += f"{i}. {username}: <b>{user['total_generations']}</b> генераций\n"
                message += "\n"
            
            # Активность за последние 7 дней
            if daily_activity:
                message += "📅 <b>АКТИВНОСТЬ ЗА 7 ДНЕЙ:</b>\n"
                for day in daily_activity[:5]:  # Показываем последние 5 дней
                    date = datetime.strptime(day['date'], '%Y-%m-%d').strftime('%d.%m.%Y')
                    message += f"{date}: <b>{day['generations_count']}</b> генераций ({day['active_users']} польз.)\n"
                message += "\n"
            
            # Пиковые часы активности
            if hourly_activity:
                peak_hours = sorted(hourly_activity, key=lambda x: x['count'], reverse=True)[:3]
                message += "⏰ <b>ПИКОВЫЕ ЧАСЫ:</b>\n"
                for hour_data in peak_hours:
                    if hour_data['count'] > 0:
                        message += f"{hour_data['hour']:02d}:00 - <b>{hour_data['count']}</b> генераций\n"
                message += "\n"
            
            # Популярные промпты
            if popular_prompts:
                message += "✨ <b>ПОПУЛЯРНЫЕ ПРОМПТЫ:</b>\n"
                for i, prompt_data in enumerate(popular_prompts[:3], 1):
                    message += f"{i}. \"{prompt_data['prompt']}\" - <b>{prompt_data['count']}x</b>\n"
            
            # Дата обновления
            message += f"\n🕐 Обновлено: {datetime.now().strftime('%d.%m.%Y %H:%M:%S')}"
            
            return message
            
        except Exception as e:
            logger.error(f"❌ Ошибка форматирования аналитики: {e}")
            return "❌ Ошибка формирования аналитики"