import logging
import os
import asyncio
from typing import Dict, Any

from aiogram import Bot, Dispatcher, types, F
from aiogram.filters import Command, StateFilter
from aiogram.fsm.context import FSMContext
from aiogram.fsm.state import State, StatesGroup
from aiogram.types import Message, CallbackQuery, FSInputFile

from config import Config
from database.db_manager import DatabaseManager
from services.shazam_service import ShazamService
from keyboards.inline_keyboards import InlineKeyboards

# Bot state'lari
class BotStates(StatesGroup):
    waiting_search_text = State()
    waiting_audio_file = State()

class BotHandlers:
    """
    Bot handler'lari uchun asosiy klass
    """
    
    def __init__(self, bot: Bot, dp: Dispatcher):
        self.bot = bot
        self.dp = dp
        self.db = DatabaseManager()
        self.shazam = ShazamService()
        self.register_handlers()
    
    def register_handlers(self):
        """
        Handler'larni ro'yxatdan o'tkazish
        """
        # Asosiy komandalar
        self.dp.message.register(self.start_command, Command("start"))
        self.dp.message.register(self.help_command, Command("help"))
        
        # Callback query handler'lari
        self.dp.callback_query.register(self.main_menu_handler, F.data == "main_menu")
        self.dp.callback_query.register(self.search_handler, F.data == "search")
        self.dp.callback_query.register(self.search_text_handler, F.data == "search_text")
        self.dp.callback_query.register(self.search_audio_handler, F.data == "search_audio")
        self.dp.callback_query.register(self.top_songs_handler, F.data == "top_songs")
        self.dp.callback_query.register(self.history_handler, F.data == "history")
        self.dp.callback_query.register(self.favorites_handler, F.data == "favorites")
        self.dp.callback_query.register(self.settings_handler, F.data == "settings")
        
        # Sozlamalar callback'lari
        self.dp.callback_query.register(self.settings_language_handler, F.data == "settings_language")
        self.dp.callback_query.register(self.settings_quality_handler, F.data == "settings_quality")
        self.dp.callback_query.register(self.set_language_handler, F.data.startswith("set_language:"))
        self.dp.callback_query.register(self.set_quality_handler, F.data.startswith("set_quality:"))
        
        # Qo'shiq handler'lari
        self.dp.callback_query.register(self.song_details_handler, F.data.startswith("song_details:"))
        self.dp.callback_query.register(self.download_handler, F.data.startswith("download:"))
        self.dp.callback_query.register(self.download_quality_handler, F.data.startswith("dl_quality:"))
        self.dp.callback_query.register(self.add_favorite_handler, F.data.startswith("add_favorite:"))
        self.dp.callback_query.register(self.remove_favorite_handler, F.data.startswith("remove_favorite:"))
        
        # Matn va audio handler'lari
        self.dp.message.register(self.text_search_handler, StateFilter(BotStates.waiting_search_text))
        self.dp.message.register(self.audio_search_handler, StateFilter(BotStates.waiting_audio_file))
    
    async def get_user_language(self, user_id: int) -> str:
        """
        Foydalanuvchi tilini olish
        """
        user = self.db.get_user(user_id)
        return user['language'] if user else 'uz'
    
    async def get_or_create_user(self, telegram_user: types.User) -> Dict[str, Any]:
        """
        Foydalanuvchini olish yoki yaratish
        """
        user = self.db.get_user(telegram_user.id)
        if not user:
            self.db.create_user(
                telegram_user.id,
                telegram_user.username,
                telegram_user.first_name,
                telegram_user.last_name
            )
            user = self.db.get_user(telegram_user.id)
        return user
    
    async def start_command(self, message: Message, state: FSMContext):
        """
        /start komandasi
        """
        await state.clear()
        user = await self.get_or_create_user(message.from_user)
        language = user['language']
        
        welcome_texts = {
            'uz': f"Assalomu alaykum, {message.from_user.first_name}! 🎵\n\nMuzlar botiga xush kelibsiz!\n\nBu bot orqali siz:\n🔍 Qo'shiqlarni qidirishingiz\n⬇️ Yuklab olishingiz\n❤️ Sevimlilaringizga qo'shishingiz mumkin",
            'ru': f"Добро пожаловать, {message.from_user.first_name}! 🎵\n\nДобро пожаловать в Muzlar бот!\n\nС помощью этого бота вы можете:\n🔍 Искать песни\n⬇️ Скачивать их\n❤️ Добавлять в избранное",
            'en': f"Welcome, {message.from_user.first_name}! 🎵\n\nWelcome to Muzlar bot!\n\nWith this bot you can:\n🔍 Search for songs\n⬇️ Download them\n❤️ Add to favorites"
        }
        
        text = welcome_texts.get(language, welcome_texts['uz'])
        keyboard = InlineKeyboards.main_menu(language)
        
        await message.answer(text, reply_markup=keyboard)
        logging.info(f"Yangi foydalanuvchi: {message.from_user.id}")
    
    async def help_command(self, message: Message):
        """
        /help komandasi
        """
        language = await self.get_user_language(message.from_user.id)
        
        help_texts = {
            'uz': "🤖 Muzlar Bot yordam\n\n🔍 Qidiruv - qo'shiqlarni matn yoki audio orqali qidiring\n🔥 TOP - eng mashhur qo'shiqlar\n📝 Tarix - qidiruv tarixingiz\n❤️ Sevimlilar - sevimli qo'shiqlaringiz\n⚙️ Sozlamalar - til va sifat sozlamalari",
            'ru': "🤖 Muzlar Bot помощь\n\n🔍 Поиск - ищите песни по тексту или аудио\n🔥 ТОП - самые популярные песни\n📝 История - ваша история поиска\n❤️ Избранное - ваши избранные песни\n⚙️ Настройки - настройки языка и качества",
            'en': "🤖 Muzlar Bot help\n\n🔍 Search - search for songs by text or audio\n🔥 TOP - most popular songs\n📝 History - your search history\n❤️ Favorites - your favorite songs\n⚙️ Settings - language and quality settings"
        }
        
        text = help_texts.get(language, help_texts['uz'])
        keyboard = InlineKeyboards.main_menu(language)
        
        await message.answer(text, reply_markup=keyboard)
    
    async def main_menu_handler(self, callback: CallbackQuery):
        """
        Asosiy menyuga qaytish
        """
        language = await self.get_user_language(callback.from_user.id)
        
        main_menu_texts = {
            'uz': "🎵 Asosiy menyu",
            'ru': "🎵 Главное меню",
            'en': "🎵 Main menu"
        }
        
        text = main_menu_texts.get(language, main_menu_texts['uz'])
        keyboard = InlineKeyboards.main_menu(language)
        
        await callback.message.edit_text(text, reply_markup=keyboard)
        await callback.answer()
    
    async def search_handler(self, callback: CallbackQuery):
        """
        Qidiruv menyusi
        """
        language = await self.get_user_language(callback.from_user.id)
        
        search_texts = {
            'uz': "🔍 Qidiruv turini tanlang:",
            'ru': "🔍 Выберите тип поиска:",
            'en': "🔍 Choose search type:"
        }
        
        text = search_texts.get(language, search_texts['uz'])
        keyboard = InlineKeyboards.search_menu(language)
        
        await callback.message.edit_text(text, reply_markup=keyboard)
        await callback.answer()
    
    async def search_text_handler(self, callback: CallbackQuery, state: FSMContext):
        """
        Matn orqali qidiruv
        """
        language = await self.get_user_language(callback.from_user.id)
        
        search_prompt_texts = {
            'uz': "✍️ Qo'shiq yoki ijrochi nomini yozing:",
            'ru': "✍️ Напишите название песни или исполнителя:",
            'en': "✍️ Write song or artist name:"
        }
        
        text = search_prompt_texts.get(language, search_prompt_texts['uz'])
        
        await callback.message.edit_text(text)
        await state.set_state(BotStates.waiting_search_text)
        await callback.answer()
    
    async def search_audio_handler(self, callback: CallbackQuery, state: FSMContext):
        """
        Audio orqali qidiruv
        """
        language = await self.get_user_language(callback.from_user.id)
        
        audio_prompt_texts = {
            'uz': "🎵 Audio faylni yuboring (maksimal 20 soniya):",
            'ru': "🎵 Отправьте аудио файл (максимум 20 секунд):",
            'en': "🎵 Send audio file (maximum 20 seconds):"
        }
        
        text = audio_prompt_texts.get(language, audio_prompt_texts['uz'])
        
        await callback.message.edit_text(text)
        await state.set_state(BotStates.waiting_audio_file)
        await callback.answer()
    
    async def text_search_handler(self, message: Message, state: FSMContext):
        """
        Matn qidiruvi javobi
        """
        await state.clear()
        query = message.text
        language = await self.get_user_language(message.from_user.id)
        
        # Loading xabari
        loading_texts = {
            'uz': "🔍 Qidiruv... Iltimos kuting...",
            'ru': "🔍 Поиск... Пожалуйста подождите...",
            'en': "🔍 Searching... Please wait..."
        }
        
        loading_msg = await message.answer(loading_texts.get(language, loading_texts['uz']))
        
        try:
            # Qidiruv bajarish
            songs = await self.shazam.search_songs(query, 10)
            
            if songs:
                # Qidiruv tarixiga qo'shish
                user = await self.get_or_create_user(message.from_user)
                self.db.add_search_history(user['id'], query, len(songs), 'text')
                
                # Natijalarni ko'rsatish
                results_texts = {
                    'uz': f"🔍 '{query}' uchun {len(songs)} ta natija:",
                    'ru': f"🔍 {len(songs)} результатов для '{query}':",
                    'en': f"🔍 {len(songs)} results for '{query}':"
                }
                
                text = results_texts.get(language, results_texts['uz'])
                keyboard = InlineKeyboards.songs_list(songs, 0, language)
                
                await loading_msg.edit_text(text, reply_markup=keyboard)
                
                # Qo'shiqlarni database'ga saqlash
                for song in songs:
                    self.db.add_song(
                        song['id'], song['title'], song['artist'],
                        song.get('album'), song.get('duration'),
                        song.get('cover_url'), song.get('preview_url'),
                        song.get('download_url'), song.get('file_size')
                    )
            else:
                no_results_texts = {
                    'uz': f"❌ '{query}' uchun hech narsa topilmadi.",
                    'ru': f"❌ Ничего не найдено для '{query}'.",
                    'en': f"❌ Nothing found for '{query}'."
                }
                
                text = no_results_texts.get(language, no_results_texts['uz'])
                keyboard = InlineKeyboards.main_menu(language)
                
                await loading_msg.edit_text(text, reply_markup=keyboard)
                
        except Exception as e:
            logging.error(f"Qidiruv xatosi: {e}")
            
            error_texts = {
                'uz': "❌ Qidiruv vaqtida xatolik yuz berdi. Qaytadan urinib ko'ring.",
                'ru': "❌ Произошла ошибка при поиске. Попробуйте еще раз.",
                'en': "❌ An error occurred during search. Try again."
            }
            
            text = error_texts.get(language, error_texts['uz'])
            keyboard = InlineKeyboards.main_menu(language)
            
            await loading_msg.edit_text(text, reply_markup=keyboard)
    
    async def audio_search_handler(self, message: Message, state: FSMContext):
        """
        Audio qidiruvi javobi
        """
        await state.clear()
        
        if not message.audio and not message.voice:
            language = await self.get_user_language(message.from_user.id)
            
            invalid_texts = {
                'uz': "❌ Iltimos, audio fayl yuboring!",
                'ru': "❌ Пожалуйста, отправьте аудио файл!",
                'en': "❌ Please send an audio file!"
            }
            
            text = invalid_texts.get(language, invalid_texts['uz'])
            await message.answer(text)
            return
        
        language = await self.get_user_language(message.from_user.id)
        
        # Loading xabari
        loading_texts = {
            'uz': "🎵 Audio tanib olinmoqda... Iltimos kuting...",
            'ru': "🎵 Распознаем аудио... Пожалуйста подождите...",
            'en': "🎵 Recognizing audio... Please wait..."
        }
        
        loading_msg = await message.answer(loading_texts.get(language, loading_texts['uz']))
        
        try:
            # Audio faylni yuklash
            audio_file = message.audio or message.voice
            file_info = await self.bot.get_file(audio_file.file_id)
            
            # Temp papkani yaratish
            os.makedirs(Config.TEMP_DIR, exist_ok=True)
            
            # Audio faylni saqlash
            audio_path = f"{Config.TEMP_DIR}audio_{message.from_user.id}.ogg"
            await self.bot.download_file(file_info.file_path, audio_path)
            
            # Audio tanib olish
            song_info = await self.shazam.recognize_audio(audio_path)
            
            # Temp faylni o'chirish
            try:
                os.remove(audio_path)
            except:
                pass
            
            if song_info:
                # Qidiruv tarixiga qo'shish
                user = await self.get_or_create_user(message.from_user)
                self.db.add_search_history(user['id'], f"Audio: {song_info['title']}", 1, 'audio')
                
                # Natijani ko'rsatish
                result_text = f"🎵 *{song_info['title']}*\n👤 *{song_info['artist']}*"
                if song_info.get('album'):
                    result_text += f"\n💿 {song_info['album']}"
                
                keyboard = InlineKeyboards.song_details(song_info['id'], False, language)
                
                await loading_msg.edit_text(result_text, reply_markup=keyboard, parse_mode='Markdown')
                
                # Qo'shiqni database'ga saqlash
                self.db.add_song(
                    song_info['id'], song_info['title'], song_info['artist'],
                    song_info.get('album'), song_info.get('duration'),
                    song_info.get('cover_url'), song_info.get('preview_url'),
                    song_info.get('download_url'), song_info.get('file_size')
                )
            else:
                no_recognition_texts = {
                    'uz': "❌ Audio tanib olinmadi. Boshqa audio bilan urinib ko'ring.",
                    'ru': "❌ Аудио не распознано. Попробуйте другое аудио.",
                    'en': "❌ Audio not recognized. Try another audio."
                }
                
                text = no_recognition_texts.get(language, no_recognition_texts['uz'])
                keyboard = InlineKeyboards.main_menu(language)
                
                await loading_msg.edit_text(text, reply_markup=keyboard)
                
        except Exception as e:
            logging.error(f"Audio tanib olish xatosi: {e}")
            
            error_texts = {
                'uz': "❌ Audio qayta ishlashda xatolik. Qaytadan urinib ko'ring.",
                'ru': "❌ Ошибка обработки аудио. Попробуйте еще раз.",
                'en': "❌ Audio processing error. Try again."
            }
            
            text = error_texts.get(language, error_texts['uz'])
            keyboard = InlineKeyboards.main_menu(language)
            
            await loading_msg.edit_text(text, reply_markup=keyboard)
    
    async def top_songs_handler(self, callback: CallbackQuery):
        """
        TOP qo'shiqlar
        """
        language = await self.get_user_language(callback.from_user.id)
        
        loading_texts = {
            'uz': "🔥 TOP qo'shiqlar yuklanmoqda...",
            'ru': "🔥 Загружаем ТОП песни...",
            'en': "🔥 Loading TOP songs..."
        }
        
        await callback.message.edit_text(loading_texts.get(language, loading_texts['uz']))
        
        try:
            songs = await self.shazam.get_top_tracks(limit=10)
            
            if songs:
                top_texts = {
                    'uz': f"🔥 TOP {len(songs)} ta qo'shiq:",
                    'ru': f"🔥 ТОП {len(songs)} песен:",
                    'en': f"🔥 TOP {len(songs)} songs:"
                }
                
                text = top_texts.get(language, top_texts['uz'])
                keyboard = InlineKeyboards.songs_list(songs, 0, language)
                
                await callback.message.edit_text(text, reply_markup=keyboard)
                
                # Qo'shiqlarni database'ga saqlash
                for song in songs:
                    self.db.add_song(
                        song['id'], song['title'], song['artist'],
                        song.get('album'), song.get('duration'),
                        song.get('cover_url'), song.get('preview_url'),
                        song.get('download_url'), song.get('file_size')
                    )
            else:
                error_texts = {
                    'uz': "❌ TOP qo'shiqlar yuklanmadi. Qaytadan urinib ko'ring.",
                    'ru': "❌ ТОП песни не загрузились. Попробуйте еще раз.",
                    'en': "❌ TOP songs not loaded. Try again."
                }
                
                text = error_texts.get(language, error_texts['uz'])
                keyboard = InlineKeyboards.main_menu(language)
                
                await callback.message.edit_text(text, reply_markup=keyboard)
                
        except Exception as e:
            logging.error(f"TOP qo'shiqlar xatosi: {e}")
            
            error_callback_texts = {
                'uz': "❌ Xatolik yuz berdi!",
                'ru': "❌ Произошла ошибка!",
                'en': "❌ An error occurred!"
            }
            
            await callback.answer(error_callback_texts.get(language, error_callback_texts['uz']))
        
        await callback.answer()
    
    async def settings_handler(self, callback: CallbackQuery):
        """
        Sozlamalar menyusi
        """
        language = await self.get_user_language(callback.from_user.id)
        
        settings_texts = {
            'uz': "⚙️ Sozlamalar:",
            'ru': "⚙️ Настройки:",
            'en': "⚙️ Settings:"
        }
        
        text = settings_texts.get(language, settings_texts['uz'])
        keyboard = InlineKeyboards.settings_menu(language)
        
        await callback.message.edit_text(text, reply_markup=keyboard)
        await callback.answer()
    
    async def settings_language_handler(self, callback: CallbackQuery):
        """
        Til sozlamalari
        """
        current_lang = await self.get_user_language(callback.from_user.id)
        
        lang_texts = {
            'uz': "🌐 Tilni tanlang:",
            'ru': "🌐 Выберите язык:",
            'en': "🌐 Choose language:"
        }
        
        text = lang_texts.get(current_lang, lang_texts['uz'])
        keyboard = InlineKeyboards.language_settings(current_lang)
        
        await callback.message.edit_text(text, reply_markup=keyboard)
        await callback.answer()
    
    async def set_language_handler(self, callback: CallbackQuery):
        """
        Tilni o'rnatish
        """
        lang_code = callback.data.split(':')[1]
        
        # Tilni yangilash
        self.db.update_user_settings(callback.from_user.id, language=lang_code)
        
        success_texts = {
            'uz': "✅ Til muvaffaqiyatli o'zgartirildi!",
            'ru': "✅ Язык успешно изменен!",
            'en': "✅ Language successfully changed!"
        }
        
        text = success_texts.get(lang_code, success_texts['uz'])
        keyboard = InlineKeyboards.main_menu(lang_code)
        
        await callback.message.edit_text(text, reply_markup=keyboard)
        await callback.answer()
    
    async def settings_quality_handler(self, callback: CallbackQuery):
        """
        Sifat sozlamalari menyusi
        """
        language = await self.get_user_language(callback.from_user.id)
        
        quality_texts = {
            'uz': "🎵 Audio sifatini tanlang:",
            'ru': "🎵 Выберите качество аудио:",
            'en': "🎵 Choose audio quality:"
        }
        
        text = quality_texts.get(language, quality_texts['uz'])
        keyboard = InlineKeyboards.quality_settings(language)
        
        await callback.message.edit_text(text, reply_markup=keyboard)
        await callback.answer()
    
    async def set_quality_handler(self, callback: CallbackQuery):
        """
        Sifatni o'rnatish
        """
        quality = callback.data.split(':')[1]
        language = await self.get_user_language(callback.from_user.id)
        
        # Sifatni yangilash
        self.db.update_user_settings(callback.from_user.id, audio_quality=quality)
        
        success_texts = {
            'uz': f"✅ Audio sifat {quality} kbps ga o'zgartirildi!",
            'ru': f"✅ Качество аудио изменено на {quality} kbps!",
            'en': f"✅ Audio quality changed to {quality} kbps!"
        }
        
        text = success_texts.get(language, success_texts['uz'])
        keyboard = InlineKeyboards.main_menu(language)
        
        await callback.message.edit_text(text, reply_markup=keyboard)
        await callback.answer()
    
    async def download_handler(self, callback: CallbackQuery):
        """
        Qo'shiqni yuklash
        """
        song_id = callback.data.split(':')[1]
        language = await self.get_user_language(callback.from_user.id)
        user = await self.get_or_create_user(callback.from_user)
        
        # Kunlik limitni tekshirish
        if not self.db.check_daily_limit(user['id']):
            limit_texts = {
                'uz': f"❌ Kunlik yuklash limitingiz tugadi ({Config.FREE_DOWNLOAD_LIMIT} ta).\n💎 Premium sotib oling cheksiz yuklash uchun!",
                'ru': f"❌ Ваш дневной лимит загрузок исчерпан ({Config.FREE_DOWNLOAD_LIMIT} шт).\n💎 Купите Premium для безлимитной загрузки!",
                'en': f"❌ Your daily download limit exceeded ({Config.FREE_DOWNLOAD_LIMIT} pcs).\n💎 Buy Premium for unlimited download!"
            }
            
            text = limit_texts.get(language, limit_texts['uz'])
            await callback.answer(text, show_alert=True)
            return
        
        # Sifat tanlash menyusi
        quality_texts = {
            'uz': "🎵 Yuklash sifatini tanlang:",
            'ru': "🎵 Выберите качество загрузки:",
            'en': "🎵 Choose download quality:"
        }
        
        text = quality_texts.get(language, quality_texts['uz'])
        keyboard = InlineKeyboards.download_quality(song_id, language)
        
        await callback.message.edit_text(text, reply_markup=keyboard)
        await callback.answer()
    
    async def download_quality_handler(self, callback: CallbackQuery):
        """
        Sifat tanlangandan keyin yuklash
        """
        parts = callback.data.split(':')
        song_id = parts[1]
        quality = parts[2]
        
        language = await self.get_user_language(callback.from_user.id)
        user = await self.get_or_create_user(callback.from_user)
        
        downloading_texts = {
            'uz': f"⬇️ Yuklanyapti ({quality} kbps)...",
            'ru': f"⬇️ Загружается ({quality} kbps)...",
            'en': f"⬇️ Downloading ({quality} kbps)..."
        }
        
        await callback.message.edit_text(downloading_texts.get(language, downloading_texts['uz']))
        
        try:
            # Qo'shiq ma'lumotlarini olish
            song = self.db.get_song(song_id)
            if not song:
                not_found_texts = {
                    'uz': "❌ Qo'shiq topilmadi!",
                    'ru': "❌ Песня не найдена!",
                    'en': "❌ Song not found!"
                }
                await callback.answer(not_found_texts.get(language, not_found_texts['uz']))
                return
            
            # Qo'shiqni yuklash
            song_info = {
                'id': song['shazam_id'],
                'title': song['title'],
                'artist': song['artist']
            }
            
            file_path = await self.shazam.download_song(song_info, quality)
            
            if file_path and os.path.exists(file_path):
                # Telegram'ga yuklash
                audio_file = FSInputFile(file_path)
                
                caption_texts = {
                    'uz': f"🎵 *{song['artist']}* - *{song['title']}*\n💿 Sifat: {quality} kbps",
                    'ru': f"🎵 *{song['artist']}* - *{song['title']}*\n💿 Качество: {quality} kbps",
                    'en': f"🎵 *{song['artist']}* - *{song['title']}*\n💿 Quality: {quality} kbps"
                }
                
                sent_message = await self.bot.send_audio(
                    callback.from_user.id,
                    audio_file,
                    title=song['title'],
                    performer=song['artist'],
                    caption=caption_texts.get(language, caption_texts['uz']),
                    parse_mode='Markdown'
                )
                
                # Yuklash tarixiga qo'shish
                self.db.add_download(user['id'], song['id'], quality, sent_message.audio.file_id)
                self.db.increment_daily_downloads(user['id'])
                
                # Temp faylni o'chirish
                try:
                    os.remove(file_path)
                except:
                    pass
                
                success_texts = {
                    'uz': "✅ Muvaffaqiyatli yuklandi!",
                    'ru': "✅ Успешно загружено!",
                    'en': "✅ Successfully downloaded!"
                }
                
                text = success_texts.get(language, success_texts['uz'])
                keyboard = InlineKeyboards.main_menu(language)
                
                await callback.message.edit_text(text, reply_markup=keyboard)
                
            else:
                error_texts = {
                    'uz': "❌ Yuklashda xatolik yuz berdi.",
                    'ru': "❌ Ошибка при загрузке.",
                    'en': "❌ Download error occurred."
                }
                
                text = error_texts.get(language, error_texts['uz'])
                keyboard = InlineKeyboards.main_menu(language)
                
                await callback.message.edit_text(text, reply_markup=keyboard)
                
        except Exception as e:
            logging.error(f"Yuklash xatosi: {e}")
            
            download_error_texts = {
                'uz': "❌ Yuklashda xatolik!",
                'ru': "❌ Ошибка загрузки!",
                'en': "❌ Download error!"
            }
            
            await callback.answer(download_error_texts.get(language, download_error_texts['uz']))
        
        await callback.answer()
    
    # Qolgan handler'lar davomi...
    async def song_details_handler(self, callback: CallbackQuery):
        """
        Qo'shiq tafsilotlari
        """
        song_id = callback.data.split(':')[1]
        language = await self.get_user_language(callback.from_user.id)
        user = await self.get_or_create_user(callback.from_user)
        
        song = self.db.get_song(song_id)
        if not song:
            not_found_texts = {
                'uz': "❌ Qo'shiq topilmadi!",
                'ru': "❌ Песня не найдена!",
                'en': "❌ Song not found!"
            }
            await callback.answer(not_found_texts.get(language, not_found_texts['uz']))
            return
        
        # Sevimli ekanligini tekshirish
        favorites = self.db.get_favorites(user['id'])
        is_favorite = any(fav['shazam_id'] == song_id for fav in favorites)
        
        # Qo'shiq ma'lumotlari
        details_text = f"🎵 *{song['title']}*\n"
        details_text += f"👤 *{song['artist']}*\n"
        if song['album']:
            details_text += f"💿 {song['album']}\n"
        if song['duration']:
            duration_min = song['duration'] // 60
            duration_sec = song['duration'] % 60
            details_text += f"⏱ {duration_min}:{duration_sec:02d}\n"
        
        keyboard = InlineKeyboards.song_details(song_id, is_favorite, language)
        
        await callback.message.edit_text(details_text, reply_markup=keyboard, parse_mode='Markdown')
        await callback.answer()
    
    async def add_favorite_handler(self, callback: CallbackQuery):
        """
        Sevimlilar ro'yxatiga qo'shish
        """
        song_id = callback.data.split(':')[1]
        language = await self.get_user_language(callback.from_user.id)
        user = await self.get_or_create_user(callback.from_user)
        song = self.db.get_song(song_id)
        
        if song:
            self.db.add_favorite(user['id'], song['id'])
            
            success_texts = {
                'uz': "❤️ Sevimlilar ro'yxatiga qo'shildi!",
                'ru': "❤️ Добавлено в избранное!",
                'en': "❤️ Added to favorites!"
            }
            
            await callback.answer(success_texts.get(language, success_texts['uz']))
        else:
            error_texts = {
                'uz': "❌ Xatolik yuz berdi!",
                'ru': "❌ Произошла ошибка!",
                'en': "❌ An error occurred!"
            }
            
            await callback.answer(error_texts.get(language, error_texts['uz']))
    
    async def remove_favorite_handler(self, callback: CallbackQuery):
        """
        Sevimlilardan olib tashlash
        """
        song_id = callback.data.split(':')[1]
        language = await self.get_user_language(callback.from_user.id)
        user = await self.get_or_create_user(callback.from_user)
        song = self.db.get_song(song_id)
        
        if song:
            self.db.remove_favorite(user['id'], song['id'])
            
            success_texts = {
                'uz': "💔 Sevimlilardan olib tashlandi!",
                'ru': "💔 Удалено из избранного!",
                'en': "💔 Removed from favorites!"
            }
            
            await callback.answer(success_texts.get(language, success_texts['uz']))
        else:
            error_texts = {
                'uz': "❌ Xatolik yuz berdi!",
                'ru': "❌ Произошла ошибка!",
                'en': "❌ An error occurred!"
            }
            
            await callback.answer(error_texts.get(language, error_texts['uz']))
    
    async def favorites_handler(self, callback: CallbackQuery):
        """
        Sevimlilar ro'yxati
        """
        language = await self.get_user_language(callback.from_user.id)
        user = await self.get_or_create_user(callback.from_user)
        
        favorites = self.db.get_favorites(user['id'])
        
        if favorites:
            # Favorites formatini songs formatiga o'tkazish
            songs = []
            for fav in favorites:
                songs.append({
                    'id': fav['shazam_id'],
                    'title': fav['title'],
                    'artist': fav['artist'],
                    'album': fav['album'] or '',
                    'duration': fav['duration'] or 0,
                    'cover_url': fav['cover_url'] or '',
                    'preview_url': fav['preview_url'] or ''
                })
            
            favorites_texts = {
                'uz': f"❤️ Sevimlilar ({len(songs)} ta):",
                'ru': f"❤️ Избранное ({len(songs)} шт):",
                'en': f"❤️ Favorites ({len(songs)} pcs):"
            }
            
            text = favorites_texts.get(language, favorites_texts['uz'])
            keyboard = InlineKeyboards.songs_list(songs, 0, language)
            
            await callback.message.edit_text(text, reply_markup=keyboard)
        else:
            empty_texts = {
                'uz': "❤️ Sevimlilar ro'yxati bo'sh",
                'ru': "❤️ Список избранного пуст",
                'en': "❤️ Favorites list is empty"
            }
            
            text = empty_texts.get(language, empty_texts['uz'])
            keyboard = InlineKeyboards.main_menu(language)
            
            await callback.message.edit_text(text, reply_markup=keyboard)
        
        await callback.answer()
    
    async def history_handler(self, callback: CallbackQuery):
        """
        Qidiruv tarixi
        """
        language = await self.get_user_language(callback.from_user.id)
        user = await self.get_or_create_user(callback.from_user)
        
        history = self.db.get_search_history(user['id'], 10)
        
        if history:
            history_text = ""
            
            history_headers = {
                'uz': "📝 Qidiruv tarixi:\n\n",
                'ru': "📝 История поиска:\n\n",
                'en': "📝 Search history:\n\n"
            }
            
            history_text = history_headers.get(language, history_headers['uz'])
            
            for i, item in enumerate(history, 1):
                search_type = "🎵" if item['search_type'] == 'audio' else "📝"
                history_text += f"{i}. {search_type} {item['query']} ({item['results_count']} ta)\n"
            
            keyboard = InlineKeyboards.main_menu(language)
            await callback.message.edit_text(history_text, reply_markup=keyboard)
        else:
            empty_texts = {
                'uz': "📝 Qidiruv tarixi bo'sh",
                'ru': "📝 История поиска пуста",
                'en': "📝 Search history is empty"
            }
            
            text = empty_texts.get(language, empty_texts['uz'])
            keyboard = InlineKeyboards.main_menu(language)
            
            await callback.message.edit_text(text, reply_markup=keyboard)
        
        await callback.answer()