"""
Examples of how to use metrics decorators in your bot handlers.
These examples show how to integrate metrics without modifying existing logic.
"""

from aiogram import Router, F
from aiogram.types import Message, CallbackQuery
from aiogram.filters import Command
from aiogram.fsm.context import FSMContext

# Import metrics decorators
from ..utils.metrics import track_time, track_errors, db_query_time, metrics

router = Router()


# Example 1: Basic command handler with timing and error tracking
@router.message(Command("start"))
@track_time("start_command", "private_handler")
@track_errors("private_handler", "start_command")
async def start_command(message: Message, state: FSMContext):
    """Start command handler with metrics."""
    # Your existing logic here
    await message.answer("Welcome! Bot started.")
    
    # Optionally record custom metrics
    metrics.record_command("start", "private_handler", "user")


# Example 2: Group command handler with custom labels
@router.message(Command("help"), F.chat.type.in_({"group", "supergroup"}))
@track_time("help_command", "group_handler")
@track_errors("group_handler", "help_command")
async def help_command(message: Message):
    """Help command handler for groups."""
    await message.answer("Group help information.")
    
    # Record command with group context
    metrics.record_command("help", "group_handler", "group_user")


# Example 3: Callback handler with timing
@router.callback_query(F.data.startswith("menu:"))
@track_time("menu_callback", "callback_handler")
@track_errors("callback_handler", "menu_callback")
async def menu_callback(callback: CallbackQuery):
    """Menu callback handler."""
    data = callback.data
    await callback.answer(f"Menu: {data}")
    
    # Record callback processing
    metrics.record_message("callback_query", "callback", "callback_handler")


# Example 4: Database operation with query timing
@db_query_time("user_lookup", "users", "select")
async def get_user_info(user_id: int):
    """Example database function with timing."""
    # Your database query here
    # result = await db.fetch_one("SELECT * FROM users WHERE id = ?", user_id)
    return {"user_id": user_id, "status": "active"}


# Example 5: Complex handler with multiple metrics
@router.message(Command("stats"))
@track_time("stats_command", "admin_handler")
@track_errors("admin_handler", "stats_command")
async def stats_command(message: Message):
    """Stats command with detailed metrics."""
    try:
        # Record command execution
        metrics.record_command("stats", "admin_handler", "admin_user")
        
        # Your stats logic here
        stats = await get_bot_stats()
        
        # Record successful execution
        await message.answer(f"Bot stats: {stats}")
        
    except Exception as e:
        # Error is automatically tracked by decorator
        await message.answer("Error getting stats")
        raise


# Example 6: Message handler with message type tracking
@router.message()
@track_time("message_processing", "general_handler")
async def handle_message(message: Message):
    """General message handler."""
    # Message type is automatically detected by middleware
    # But you can add custom tracking
    
    if message.photo:
        # Custom metric for photo processing
        metrics.record_message("photo", "general", "photo_handler")
    
    # Your message handling logic
    await message.answer("Message received")


# Example 7: Error-prone operation with custom error tracking
@track_errors("file_handler", "file_upload")
async def upload_file(file_data: bytes, filename: str):
    """File upload with error tracking."""
    try:
        # Your file upload logic
        # result = await upload_service.upload(file_data, filename)
        return {"status": "success", "filename": filename}
        
    except Exception as e:
        # Custom error metric
        metrics.record_error(
            type(e).__name__,
            "file_handler",
            "file_upload"
        )
        raise


# Example 8: Background task with metrics
async def background_metrics_collection():
    """Background task for collecting periodic metrics."""
    while True:
        try:
            # Collect custom metrics
            active_users = await count_active_users()
            metrics.set_active_users(active_users, "current")
            
            # Wait before next collection
            await asyncio.sleep(300)  # 5 minutes
            
        except Exception as e:
            metrics.record_error(
                type(e).__name__,
                "background_task",
                "metrics_collection"
            )
            await asyncio.sleep(60)  # Wait 1 minute on error


# Example 9: Custom metric collection in service
class UserService:
    """Example service with integrated metrics."""
    
    @db_query_time("user_creation", "users", "insert")
    async def create_user(self, user_data: dict):
        """Create user with database timing."""
        # Your user creation logic
        # user_id = await self.db.execute("INSERT INTO users ...")
        return {"user_id": 123, "status": "created"}
    
    @track_time("user_update", "user_service")
    async def update_user(self, user_id: int, updates: dict):
        """Update user with timing."""
        # Your update logic
        # await self.db.execute("UPDATE users SET ...")
        return {"user_id": user_id, "status": "updated"}


# Example 10: Middleware integration example
async def custom_middleware(handler, event, data):
    """Custom middleware that works with metrics system."""
    from ..utils.metrics import track_middleware
    
    async with track_middleware("custom_middleware"):
        # Your middleware logic
        result = await handler(event, data)
        return result


# Helper function for stats (placeholder)
async def get_bot_stats():
    """Get bot statistics."""
    return {
        "total_users": 1000,
        "active_today": 150,
        "commands_processed": 5000
    }


# Helper function for user counting (placeholder)
async def count_active_users():
    """Count active users."""
    return 150


# Import asyncio for background task
import asyncio