import asyncio
import aiohttp
import json
import os
from config import (
    BASE_API_URL, AUTO_UPDATE_INTERVAL, CONFIG_FILE
)
from bot_handlers import (
    get_updates, handle_start, handle_callback_query,
    user_states, user_sessions, send_message
)
from lms_extractor import login, process_range, auto_update_questions
from search_utils import advanced_search
from view_utils import view_questions_in_range


# متغیر گلوبال برای کنترل آپدیت خودکار
auto_update_active = False
auto_update_chat_id = None


def get_last_known_id() -> int:
    """خوندن last_known_id از فایل تنظیمات"""
    if os.path.exists(CONFIG_FILE):
        try:
            with open(CONFIG_FILE, "r", encoding="utf-8") as f:
                config_data = json.load(f)
            return config_data.get("last_known_id", 0)
        except:
            pass
    return 0


def save_last_known_id(last_id: int):
    """ذخیره last_known_id توی فایل تنظیمات"""
    config_data = {}
    if os.path.exists(CONFIG_FILE):
        try:
            with open(CONFIG_FILE, "r", encoding="utf-8") as f:
                config_data = json.load(f)
        except:
            pass
    
    config_data["last_known_id"] = last_id
    config_data["updated_at"] = str(asyncio.get_event_loop().time())
    
    with open(CONFIG_FILE, "w", encoding="utf-8") as f:
        json.dump(config_data, f, ensure_ascii=False, indent=2)


async def auto_update_task():
    """تسک آپدیت خودکار - هیچوقت قطع نمیشه"""
    global auto_update_active, auto_update_chat_id
    
    await asyncio.sleep(5)
    
    while True:  # حلقه بی‌نهایت
        try:
            if auto_update_active and auto_update_chat_id:
                last_id = get_last_known_id()
                
                if last_id > 0:
                    print(f"🔄 شروع آپدیت خودکار از ID {last_id}...")
                    
                    try:
                        lms_session = await login()
                        
                        if lms_session:
                            # فقط بار اول پیام بده
                            new_count, reached_end, new_id = await auto_update_questions(
                                lms_session, 
                                auto_update_chat_id, 
                                last_id
                            )
                            
                            await lms_session.close()
                            
                            # آپدیت last_known_id
                            if new_id > last_id:
                                save_last_known_id(new_id)
                                print(f"💾 last_known_id آپدیت شد: {new_id}")
                            
                            # اگه به انتها رسید - ولی قطع نشه!
                            if reached_end and new_count == 0:
                                await send_message(
                                    auto_update_chat_id,
                                    f"🛑 **به انتهای دیتابیس رسیدیم** (ID: {new_id})\n"
                                    f"⏰ آپدیت بعدی: {AUTO_UPDATE_INTERVAL // 60} دقیقه دیگر\n"
                                    f"🔄 آپدیت خودکار همچنان فعال است..."
                                )
                                # ⚠️ قطع نمیشه - به چک کردن ادامه میده
                            elif new_count > 0:
                                await send_message(
                                    auto_update_chat_id,
                                    f"✅ **{new_count} سوال جدید اضافه شد!**\n"
                                    f"📝 آخرین ID: {new_id}"
                                )
                        else:
                            await send_message(auto_update_chat_id, "❌ ورود به سایت ناموفق - تلاش مجدد در آپدیت بعدی")
                            
                    except Exception as e:
                        print(f"⚠️ خطا در آپدیت خودکار: {e}")
                        # خطا رو به کاربر نگو - فقط توی لاگ ثبت کن
                
            # صبر کن به اندازه INTERVAL (حتی اگه ارور بخوره)
            await asyncio.sleep(AUTO_UPDATE_INTERVAL)
            
        except Exception as e:
            print(f"💥 خطای بحرانی در تسک آپدیت: {e}")
            await asyncio.sleep(60)  # ۱ دقیقه صبر کن بعد دوباره تلاش کن


async def process_message(chat_id: int, text: str):
    """پردازش پیام کاربر"""
    global auto_update_active, auto_update_chat_id
    
    if text in ["/start", "/menu"]:
        await handle_start(chat_id)
        return
    elif text == "/search":
        user_states[chat_id] = "waiting_advanced_search"
        await send_message(chat_id, "🔍 کلمه مورد نظر را وارد کنید:")
        return
    elif text == "/view":
        user_states[chat_id] = "waiting_view_start"
        await send_message(chat_id, "🔢 شماره شروع بازه را وارد کنید:")
        return
    elif text == "/auto":
        last_id = get_last_known_id()
        if last_id > 0:
            auto_update_active = True
            auto_update_chat_id = chat_id
            await send_message(chat_id, 
                f"✅ **آپدیت خودکار فعال شد!**\n"
                f"🔢 شروع از ID: {last_id}\n"
                f"⏰ هر {AUTO_UPDATE_INTERVAL // 60} دقیقه\n"
                f"🛑 با /stop متوقف کنید"
            )
        else:
            await send_message(chat_id, "❌ ابتدا از منو گزینه آپدیت خودکار رو بزن و ID رو وارد کن!")
        return
    elif text == "/stop":
        auto_update_active = False
        await send_message(chat_id, "⏹️ آپدیت خودکار متوقف شد")
        return
    elif text == "/status":
        status = "✅ فعال" if auto_update_active else "❌ غیرفعال"
        last_id = get_last_known_id()
        await send_message(chat_id, 
            f"📊 **وضعیت آپدیت خودکار:**\n"
            f"• وضعیت: {status}\n"
            f"• آخرین ID: {last_id}\n"
            f"• فاصله: {AUTO_UPDATE_INTERVAL // 60} دقیقه"
        )
        return
    
    state = user_states.get(chat_id)
    
    if state == "waiting_range_start":
        try:
            start = int(text)
            user_sessions[chat_id] = {"start": start}
            user_states[chat_id] = "waiting_range_end"
            await send_message(chat_id, f"✅ شروع: {start}\n🔢 پایان بازه را وارد کنید:")
        except ValueError:
            await send_message(chat_id, "❌ عدد وارد کنید!")
    
    elif state == "waiting_range_end":
        try:
            end = int(text)
            start = user_sessions.get(chat_id, {}).get("start", 0)
            if start > end:
                start, end = end, start
            
            user_states[chat_id] = None
            await send_message(chat_id, "⏳ در حال ورود به سایت...")
            
            lms_session = await login()
            if not lms_session:
                await send_message(chat_id, "❌ ورود ناموفق!")
                return
            
            await process_range(lms_session, chat_id, start, end)
            await lms_session.close()
            await handle_start(chat_id)
            
        except ValueError:
            await send_message(chat_id, "❌ عدد وارد کنید!")
    
    elif state == "waiting_view_start":
        try:
            start = int(text)
            user_sessions[chat_id] = {"view_start": start}
            user_states[chat_id] = "waiting_view_end"
            await send_message(chat_id, f"✅ شروع: {start}\n🔢 پایان بازه:")
        except ValueError:
            await send_message(chat_id, "❌ عدد وارد کنید!")
    
    elif state == "waiting_view_end":
        try:
            end = int(text)
            start = user_sessions.get(chat_id, {}).get("view_start", 0)
            if start > end:
                start, end = end, start
            
            user_states[chat_id] = None
            await view_questions_in_range(chat_id, start, end)
            
        except ValueError:
            await send_message(chat_id, "❌ عدد وارد کنید!")
    
    elif state == "waiting_advanced_search":
        user_states[chat_id] = None
        await advanced_search(chat_id, text)
    
    elif state == "waiting_auto_update_id":
        try:
            last_id = int(text)
            user_states[chat_id] = None
            
            # ذخیره توی فایل
            save_last_known_id(last_id)
            
            # فعال کردن آپدیت خودکار
            auto_update_active = True
            auto_update_chat_id = chat_id
            
            await send_message(chat_id, 
                f"✅ **آپدیت خودکار فعال شد!**\n\n"
                f"🔢 شروع از ID: {last_id}\n"
                f"⏰ هر {AUTO_UPDATE_INTERVAL // 60} دقیقه چک می‌شود\n"
                f"🛑 با /stop متوقف کنید\n"
                f"📊 با /status وضعیت رو ببینید\n\n"
                f"💾 آخرین ID در فایل ذخیره شد."
            )
        except ValueError:
            await send_message(chat_id, "❌ لطفاً یک عدد معتبر وارد کنید!")


async def main():
    """تابع اصلی"""
    print("🤖 ربات استخراج سوالات - با آپدیت خودکار")
    
    async with aiohttp.ClientSession() as session:
        async with session.get(f"{BASE_API_URL}/getMe") as resp:
            data = await resp.json()
            if data.get("ok"):
                print(f"✅ @{data['result'].get('username', 'Unknown')}")
            else:
                print("❌ توکن نامعتبر!")
                return
    
    # استارت تسک آپدیت خودکار
    asyncio.create_task(auto_update_task())
    print(f"🔄 تسک آپدیت خودکار آماده (هر {AUTO_UPDATE_INTERVAL // 60} دقیقه)")
    
    last_update_id = 0
    print("🔍 در حال دریافت آپدیت...")
    
    while True:
        try:
            updates = await get_updates(offset=last_update_id + 1 if last_update_id else None)
            
            for update in updates:
                last_update_id = max(last_update_id, update.get("update_id", 0))
                
                message = update.get("message")
                if message:
                    chat_id = message.get("chat", {}).get("id")
                    text = message.get("text", "")
                    if chat_id and text:
                        await process_message(chat_id, text)
                        continue
                
                callback_query = update.get("callback_query")
                if callback_query:
                    chat_id = callback_query.get("from", {}).get("id")
                    data = callback_query.get("data", "")
                    callback_id = callback_query.get("id", "")
                    if chat_id and data:
                        await handle_callback_query(chat_id, data, callback_id)
            
            await asyncio.sleep(2)
            
        except KeyboardInterrupt:
            print("\n⏹️ خداحافظ!")
            break
        except Exception as e:
            print(f"⚠️ خطا: {e}")
            await asyncio.sleep(5)


if __name__ == "__main__":
    asyncio.run(main())