import asyncio
import logging
from telegram import Update
from telegram.ext import Application, CommandHandler, MessageHandler, filters, ContextTypes
from openai import AsyncOpenAI
import sqlite3
import json
from datetime import datetime
import hashlib
import redis

# Настройка логирования
logging.basicConfig(
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
    level=logging.INFO
)
logger = logging.getLogger(__name__)

class SmartTelegramBot:
    def __init__(self, telegram_token: str, openai_api_key: str):
        self.telegram_token = telegram_token
        self.openai_client = AsyncOpenAI(api_key=openai_api_key)
        self.app = Application.builder().token(telegram_token).build()
        
        # Redis для кэширования
        self.redis_client = redis.Redis(host='localhost', port=6379, db=0)
        
        # Инициализация базы данных
        self.init_database()
        
        # Регистрация обработчиков
        self.setup_handlers()
        
        # Статистика
        self.stats = {
            'total_messages': 0,
            'api_calls': 0,
            'cache_hits': 0,
            'errors': 0,
            'total_cost': 0.0
        }

async def handle_message(self, update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Обработка обычных сообщений"""
    user_id = update.effective_user.id
    message_text = update.message.text
    
    # Показываем, что бот печатает
    await context.bot.send_chat_action(chat_id=update.effective_chat.id, action="typing")
    
    try:
        # Проверяем кэш
        cache_key = f"response:{hashlib.md5(f'{user_id}:{message_text}'.encode()).hexdigest()}"
        cached_response = self.redis_client.get(cache_key)
        
        if cached_response:
            self.stats['cache_hits'] += 1
            await update.message.reply_text(cached_response.decode())
            return
        
        # Получаем контекст пользователя
        user_context = self.get_user_context(user_id)
        
        # Генерируем ответ через OpenAI
        response = await self.generate_response(message_text, user_context, user_id)
        
        # Отправляем ответ
        await update.message.reply_text(response)
        
        # Сохраняем в кэш на 1 час
        self.redis_client.setex(cache_key, 3600, response)
        
        # Сохраняем в базу данных
        self.save_conversation(user_id, message_text, response, user_context)
        
        self.stats['total_messages'] += 1
        
    except Exception as e:
        self.stats['errors'] += 1
        logger.error(f"Ошибка при обработке сообщения: {e}")
        await update.message.reply_text(
            "Извините, произошла ошибка. Попробуйте еще раз или обратитесь к администратору."
        )

async def generate_response(self, message: str, context: str, user_id: int) -> str:
    """Генерация ответа через OpenAI с оптимизацией затрат"""
    
    # Определяем модель в зависимости от сложности запроса
    model = self.select_model(message)
    
    # Системный промпт для настройки поведения бота
    system_prompt = f"""
Ты - умный помощник для Telegram-бота. 

Твоя роль:
Отвечай дружелюбно и профессионально на русском языке

Помни контекст разговора

Предлагай конкретные решения

Если не знаешь ответа, честно говори об этом

Используй эмодзи для лучшего восприятия

Будь кратким, но информативным


Контекст пользователя: {context}

Правила:
Отвечай на русском языке

Не создавай контент, который может навредить

Если вопрос не по теме, вежливо перенаправь

"""
    
    try:
        # Подсчитываем токены для контроля затрат
        estimated_tokens = len(message.split()) * 1.3  # Примерная оценка
        
        response = await self.openai_client.chat.completions.create(
            model=model,
            messages=[
                {"role": "system", "content": system_prompt},
                {"role": "user", "content": message}
            ],
            max_tokens=self.calculate_max_tokens(model, estimated_tokens),
            temperature=0.7,
            timeout=30
        )
        
        # Подсчитываем стоимость
        cost = self.calculate_cost(model, response.usage.total_tokens)
        self.stats['total_cost'] += cost
        self.stats['api_calls'] += 1
        
        logger.info(f"API вызов: {model}, токены: {response.usage.total_tokens}, стоимость: ${cost:.4f}")
        
        return response.choices[0].message.content
        
    except Exception as e:
        logger.error(f"Ошибка OpenAI API: {e}")
        return "Извините, сервис временно недоступен. Попробуйте позже."

def select_model(self, message: str) -> str:
    """Выбор модели в зависимости от сложности запроса"""
    
    # Простые вопросы - используем дешевую модель
    simple_keywords = ['привет', 'как дела', 'спасибо', 'пока']
    if any(keyword in message.lower() for keyword in simple_keywords):
        return "gpt-3.5-turbo"
    
    # Сложные вопросы - используем GPT-4
    complex_keywords = ['объясни', 'расскажи подробно', 'анализ', 'сравни']
    if any(keyword in message.lower() for keyword in complex_keywords):
        return "gpt-4"
    
    # По умолчанию - GPT-3.5-turbo
    return "gpt-3.5-turbo"

def calculate_max_tokens(self, model: str, estimated_input_tokens: int) -> int:
    """Расчет максимального количества токенов для ответа"""
    
    if model == "gpt-4":
        return min(500, 4000 - int(estimated_input_tokens))
    else:
        return min(300, 4000 - int(estimated_input_tokens))

def calculate_cost(self, model: str, tokens: int) -> float:
    """Расчет стоимости запроса"""
    
    # Цены на момент написания статьи (могут измениться)
    prices = {
        "gpt-3.5-turbo": 0.002,  # $0.002 за 1K токенов
        "gpt-4": 0.03,           # $0.03 за 1K токенов
    }
    
    return (tokens / 1000) * prices.get(model, 0.002)

def setup_caching(self):
    """Настройка системы кэширования"""
    
    # Кэшируем частые вопросы
    common_questions = {
        "как дела": "У меня все отлично! Готов помочь вам с любыми вопросами 😊",
        "что ты умеешь": "Я умею отвечать на вопросы, помогать с задачами, поддерживать беседу и многое другое!",
        "спасибо": "Пожалуйста! Рад был помочь 😊"
    }
    
    for question, answer in common_questions.items():
        cache_key = f"common:{hashlib.md5(question.encode()).hexdigest()}"
        self.redis_client.setex(cache_key, 86400, answer)  # Кэш на сутки

async def batch_process_messages(self, messages: list):
    """Обработка нескольких сообщений одним запросом"""
    
    if len(messages) < 2:
        return await self.process_single_message(messages[0])
    
    # Группируем похожие сообщения
    batched_messages = self.group_similar_messages(messages)
    
    responses = []
    for batch in batched_messages:
        response = await self.openai_client.chat.completions.create(
            model="gpt-3.5-turbo",
            messages=[
                {"role": "system", "content": "Ответь на все вопросы кратко и по делу"},
                {"role": "user", "content": "\n".join(batch)}
            ],
            max_tokens=200
        )
        responses.extend(response.choices[0].message.content.split('\n'))
    
    return responses

async def check_daily_spending(self):
    """Проверка дневных трат"""
    
    today = datetime.now().strftime('%Y-%m-%d')
    daily_spending = self.redis_client.get(f"spending:{today}")
    
    if daily_spending:
        spending = float(daily_spending)
        if spending > 10:  # Лимит $10 в день
            logger.warning(f"Превышен дневной лимит: ${spending}")
            await self.notify_admin(f"Превышен дневной лимит трат: ${spending}")
    
    # Сохраняем текущие траты
    self.redis_client.setex(f"spending:{today}", 86400, str(self.stats['total_cost']))

def get_user_context(self, user_id: int) -> str:
    """Получение контекста пользователя"""
    
    # Получаем последние сообщения из Redis
    context_key = f"context:{user_id}"
    context_data = self.redis_client.get(context_key)
    
    if context_data:
        messages = json.loads(context_data)
        return "\n".join([f"{msg['role']}: {msg['content']}" for msg in messages[-10:]])
    
    return "Новый пользователь"

def save_user_context(self, user_id: int, role: str, content: str):
    """Сохранение контекста пользователя"""
    
    context_key = f"context:{user_id}"
    context_data = self.redis_client.get(context_key)
    
    if context_data:
        messages = json.loads(context_data)
    else:
        messages = []
    
    messages.append({
        "role": role,
        "content": content,
        "timestamp": datetime.now().isoformat()
    })
    
    # Оставляем только последние 20 сообщений
    messages = messages[-20:]
    
    self.redis_client.setex(context_key, 3600, json.dumps(messages))  # Кэш на час

async def moderate_message(self, message: str) -> bool:
    """Проверка сообщения на токсичность"""
    
    try:
        response = await self.openai_client.moderations.create(input=message)
        return not response.results[0].flagged
    except Exception as e:
        logger.error(f"Ошибка модерации: {e}")
        return True  # В случае ошибки пропускаем сообщение

import asyncio
from asyncio import Queue

class RateLimiter:
    def __init__(self, max_requests_per_minute: int = 60):
        self.max_requests = max_requests_per_minute
        self.requests = Queue()
        self.semaphore = asyncio.Semaphore(max_requests_per_minute)
    
    async def acquire(self):
        await self.semaphore.acquire()
        self.requests.put_nowait(datetime.now())
    
    def release(self):
        self.semaphore.release()
    
    async def wait_if_needed(self):
        """Ждем, если нужно соблюсти лимит"""
        
        now = datetime.now()
        
        # Удаляем старые запросы (старше минуты)
        while not self.requests.empty():
            try:
                old_request = self.requests.get_nowait()
                if (now - old_request).seconds < 60:
                    self.requests.put_nowait(old_request)
                    break
            except:
                break
        
        # Если достигли лимита, ждем
        if self.requests.qsize() >= self.max_requests:
            await asyncio.sleep(60)

class BotLogger:
    def __init__(self):
        self.logger = logging.getLogger('telegram_bot')
        self.setup_logging()
    
    def setup_logging(self):
        """Настройка системы логирования"""
        
        # Логи в файл
        file_handler = logging.FileHandler('bot.log')
        file_handler.setLevel(logging.INFO)
        
        # Логи в консоль
        console_handler = logging.StreamHandler()
        console_handler.setLevel(logging.WARNING)
        
        # Формат логов
        formatter = logging.Formatter(
            '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
        )
        
        file_handler.setFormatter(formatter)
        console_handler.setFormatter(formatter)
        
        self.logger.addHandler(file_handler)
        self.logger.addHandler(console_handler)
    
    def log_user_interaction(self, user_id: int, message: str, response: str, cost: float):
        """Логирование взаимодействия с пользователем"""
        
        log_entry = {
            'user_id': user_id,
            'message': message,
            'response': response,
            'cost': cost,
            'timestamp': datetime.now().isoformat()
        }
        
        self.logger.info(json.dumps(log_entry))

async def get_bot_statistics(self) -> dict:
    """Получение статистики бота"""
    
    # Статистика из базы данных
    cursor = self.conn.cursor()
    
    # Общее количество пользователей
    cursor.execute("SELECT COUNT(DISTINCT user_id) FROM conversations")
    total_users = cursor.fetchone()[0]
    
    # Сообщения за последние 24 часа
    cursor.execute("""
        SELECT COUNT(*) FROM conversations 
        WHERE timestamp > datetime('now', '-1 day')
    """)
    messages_24h = cursor.fetchone()[0]
    
    # Топ активных пользователей
    cursor.execute("""
        SELECT user_id, COUNT(*) as message_count 
        FROM conversations 
        WHERE timestamp > datetime('now', '-7 days')
        GROUP BY user_id 
        ORDER BY message_count DESC 
        LIMIT 10
    """)
    top_users = cursor.fetchall()
    
    return {
        'total_users': total_users,
        'messages_24h': messages_24h,
        'total_messages': self.stats['total_messages'],
        'api_calls': self.stats['api_calls'],
        'cache_hits': self.stats['cache_hits'],
        'total_cost': self.stats['total_cost'],
        'top_users': top_users,
        'uptime': self.get_uptime()
    }

# docker-compose.yml
version: '3.8'
services:
  telegram-bot:
    build: .
    environment:
      - TELEGRAM_TOKEN=${TELEGRAM_TOKEN}
      - OPENAI_API_KEY=${OPENAI_API_KEY}
      - REDIS_URL=redis://redis:6379
      - DATABASE_URL=postgresql://user:password@postgres:5432/bot_db
    depends_on:
      - redis
      - postgres
    restart: unless-stopped
    
  redis:
    image: redis:7-alpine
    volumes:
      - redis_data:/data
    restart: unless-stopped
    
  postgres:
    image: postgres:15
    environment:
      - POSTGRES_DB=bot_db
      - POSTGRES_USER=user
      - POSTGRES_PASSWORD=password
    volumes:
      - postgres_data:/var/lib/postgresql/data
    restart: unless-stopped
    
  nginx:
    image: nginx:alpine
    ports:
      - "80:80"
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf
    depends_on:
      - telegram-bot
    restart: unless-stopped

volumes:
  redis_data:
  postgres_data:

class HealthChecker:
    def __init__(self):
        self.checks = {
            'openai_api': self.check_openai_api,
            'telegram_api': self.check_telegram_api,
            'redis': self.check_redis,
            'database': self.check_database
        }
    
    async def check_openai_api(self) -> dict:
        """Проверка доступности OpenAI API"""
        try:
            response = await self.openai_client.chat.completions.create(
                model="gpt-3.5-turbo",
                messages=[{"role": "user", "content": "test"}],
                max_tokens=1
            )
            return {"status": "healthy", "response_time": "< 1s"}
        except Exception as e:
            return {"status": "unhealthy", "error": str(e)}
    
    async def check_telegram_api(self) -> dict:
        """Проверка доступности Telegram API"""
        try:
            response = await self.app.bot.get_me()
            return {"status": "healthy", "bot_name": response.first_name}
        except Exception as e:
            return {"status": "unhealthy", "error": str(e)}
    
    async def run_health_checks(self) -> dict:
        """Запуск всех проверок"""
        results = {}
        
        for check_name, check_func in self.checks.items():
            try:
                results[check_name] = await check_func()
            except Exception as e:
                results[check_name] = {"status": "error", "error": str(e)}
        
        return results