import logging
from telegram import Update, ReplyKeyboardMarkup, KeyboardButton, InlineKeyboardButton, InlineKeyboardMarkup
from telegram.ext import Application, CommandHandler, MessageHandler, CallbackQueryHandler, filters, ContextTypes
import json
import random
from datetime import datetime



token = "8178678800:AAHG1QEKqXYQgtg5g2hq484aWsAqSykI-ww" # PUT Your Token Here
# Configure logging
logging.basicConfig(format='%(asctime)s - %(name)s - %(levelname)s - %(message)s', level=logging.INFO)
logger = logging.getLogger(__name__)

# Data storage
users_data = {}
user_id_map = {}  # Map user_id to short codes
settings = {"bot_active": True, "attack_enabled": True}  # Bot settings
messages = {  # Default messages
    "buy_country_success": "✅ کشور {country_name} با موفقیت خریداری شد!\n\n🏠 خانه‌های پایه: {base_houses}\n💰 موجودی باقی‌مانده: {stars} ستاره\n\nاکنون می‌توانید مهمات، سیستم‌های دفاعی یا معادن خریداری کنید.",
    "buy_country_failure": "❌ موجودی کافی نیست!\n\n💰 موجودی شما: {stars} ستاره\n💳 قیمت {country_name}: {price} ستاره",
    "buy_weapon_success": "✅ خرید موفق!\n\n🛡️ {weapon_name}: {quantity} عدد\n💪 افزایش قدرت: +{power_increase}\n💰 هزینه: {total_price} ستاره\n💳 موجودی باقی‌مانده: {stars} ستاره",
    "buy_weapon_failure": "❌ موجودی کافی نیست!\n💰 موجودی: {stars}\n💳 نیاز: {total_price}",
    "buy_mine_success": "✅ خرید موفق!\n\n⛏️ {mine_name}: {quantity} عدد\n📊 تولید روزانه: {daily_stars} ستاره\n💰 هزینه: {total_price} ستاره\n💳 موجودی باقی‌مانده: {stars} ستاره",
    "buy_mine_failure": "❌ موجودی کافی نیست!\n💰 موجودی شما: {stars}\n💳 قیمت {mine_name}: {price} ستاره",
    "attack_success": "⚔️ گزارش حمله:\n\n🏴 مهاجم: {attacker_country}\n🎯 هدف: {target_country}\n🛡️ سلاح: {weapon_name} ({quantity} عدد)\n💥 قدرت حمله: {attack_power}\n🏠 خسارت به زیرساخت: {damage}\n💰 ستاره‌های کسب شده: {stars_won}\n💳 موجودی شما: {stars}",
    "attack_failure": "⚔️ حمله ناموفق! تعداد کافی از این سلاح ندارید!",
    "under_attack": "⚠️ کشور {target_country} شما توسط {attacker_country} مورد حمله قرار گرفت! خسارت: {damage}",
    "channel_attack_notification": "⚔️ {user_name} ({attacker_country}) به {target_country} حمله کرد! خسارت: {damage}",
    "channel_country_destroyed": "🏆 کشور {target_country} توسط {attacker_country} از {target_user_name} فتح شد!",
    "collect_stars_success": "⛏️ ستاره‌های روزانه از معادن جمع‌آوری شد!\n\n💰 مبلغ: {total_stars} ستاره\n💳 موجودی جدید: {stars}",
    "collect_stars_none": "شما هیچ معدنی ندارید! ابتدا از مدیریت معادن، معدن خریداری کنید."
}
ADMIN_ID = 7211175805 # Replace with your Telegram user ID
CHANNEL_ID = "@shalshq"

# Country codes for shorter callback_data
COUNTRY_CODES = {
    "ایران": "IR",
    "آمریکا": "US",
    "چین": "CN",
    "آلمان": "DE",
    "پرتغال": "PT",
    "اسرائیل": "IL",
    "روسیه": "RU",
    "فرانسه": "FR",
    "انگلیس": "UK",
    "کانادا": "CA",
    "ژاپن": "JP",
    "کره جنوبی": "KR",
    "هند": "IN",
    "برزیل": "BR",
    "استرالیا": "AU",
    "ترکیه": "TR",
    "اوکراین": "UA",
    "عربستان": "SA",
    "مصر": "EG",
    "پاکستان": "PK"
}

# Weapon codes for shorter callback_data
WEAPON_CODES = {
    "موشک_بالستیک": "MB",
    "بمب_اتم": "NA",
    "تانک_آبرامز": "TA",
    "جنگنده_اف35": "F35",
    "هلیکوپتر_آپاچی": "HA",
    "موشک_کروز": "CR",
    "موشک_اسکاد": "SC",
    "جنگنده_سوخو": "SU",
    "پهپاد_ریپر": "RP",
    "موشک_توماهاوک": "TH",
    "ناوشکن": "DS",
    "زیردریایی": "SB",
    "بمب_افکن_b52": "B52",
    "توپ_هویتزر": "HW",
    "موشک_پاتریوت": "PT",
    "تانک_t90": "T90",
    "موشک_اسکندر": "IS",
    "جنگنده_رافائل": "RF",
    "هلیکوپتر_کبرا": "HC",
    "موشک_جاولین": "JV",
    "پهپاد_بیرقدار": "BY",
    "موشک_فجر": "FJ",
    "تانک_چالنجر": "CH",
    "جنگنده_یوروفایتر": "EF",
    "موشک_حیدر": "HD",
    "بمب_هیدروژنی": "HN",
    "ناوهواپیمابر": "CV",
    "موشک_متئور": "MT",
    "خمپاره_انداز": "MR",
    "راکت_انداز": "RL",
    "رادار_هشدار": "WR",
    "پدافند_موشکی": "MD",
    "گنبد_آهنین": "ID",
    "دفاع_هوایی_s400": "S400",
    "تالوس_آمریکا": "TL",
    "دفاع_تور": "TR",
    "رادار_فازی": "PR",
    "دفاع_پانتسیر": "PN",
    "خوشه_15": "C15",
    "آرو_3": "AR3",
    "دفاع_اسپادا": "SP",
    "رادار_گرین_پاین": "GP",
    "دفاع_ناسامز": "NS",
    "پدافند_باراک": "BR",
    "سپر_موشکی": "MS",
    "دفاع_سام_17": "S17",
    "رادار_آنتی_استلث": "AS",
    "دفاع_لیزری": "LD",
    "جنگ_الکترونیک": "EW",
    "دفاع_کیوپولا": "CP"
}

# Quantity codes for shorter callback_data
QUANTITY_CODES = {
    1: "A",
    3: "B",
    5: "C",
    10: "D"
}
REVERSE_QUANTITY_CODES = {v: k for k, v in QUANTITY_CODES.items()}

# Available countries with base houses
AVAILABLE_COUNTRIES = {
     "ایران": 100,
    "آمریکا": 120,
    "چین": 110,
    "آلمان": 90,
    "پرتغال": 80,
    "اسرائیل": 70,
    "روسیه": 130,
    "فرانسه": 95,
    "انگلیس": 150,
    "کانادا": 85,
    "ژاپن": 95,
    "کره جنوبی": 80,
    "هند": 110,
    "برزیل": 90,
    "استرالیا": 70,
    "ترکیه": 85,
    "اوکراین": 70,
    "عربستان": 90,
    "مصر": 80,
    "پاکستان": 70
}

# Available mines with daily star production
AVAILABLE_MINES = {
    "معدن_طلا": {"daily_stars": 1000, "price": 5000, "name": "معدن طلا"},
    "معدن_نقره": {"daily_stars": 500, "price": 2500, "name": "معدن نقره"},
    "معدن_برنز": {"daily_stars": 200, "price": 1000, "name": "معدن برنز"}
}

# Weapons and defense systems
WEAPONS_AND_DEFENSE = {
    "موشک_بالستیک": {"power": 100, "type": "weapon", "name": "موشک بالستیک", "description": "موشک متوسط برد +100 قدرت", "price": 50},
    "بمب_اتم": {"power": 1000, "type": "weapon", "name": "بمب اتم", "description": "قدرتمندترین سلاح هسته‌ای +1000 قدرت", "price": 500},
    "تانک_آبرامز": {"power": 150, "type": "weapon", "name": "تانک M1 آبرامز", "description": "تانک جنگی سنگین +150 قدرت", "price": 75},
    "جنگنده_اف35": {"power": 200, "type": "weapon", "name": "جنگنده اف-35", "description": "جنگنده نسل پنجم +200 قدرت", "price": 100},
    "هلیکوپتر_آپاچی": {"power": 120, "type": "weapon", "name": "هلیکوپتر آپاچی", "description": "هلیکوپتر تهاجمی +120 قدرت", "price": 60},
    "موشک_کروز": {"power": 130, "type": "weapon", "name": "موشک کروز", "description": "موشک هدایت شونده +130 قدرت", "price": 65},
    "موشک_اسکاد": {"power": 180, "type": "weapon", "name": "موشک اسکاد", "description": "موشک بالستیک کوتاه برد +180 قدرت", "price": 90},
    "جنگنده_سوخو": {"power": 190, "type": "weapon", "name": "جنگنده سوخو-57", "description": "جنگنده روسی پیشرفته +190 قدرت", "price": 95},
    "پهپاد_ریپر": {"power": 80, "type": "weapon", "name": "پهپاد MQ-9 ریپر", "description": "پهپاد نظامی +80 قدرت", "price": 40},
    "موشک_توماهاوک": {"power": 160, "type": "weapon", "name": "موشک توماهاوک", "description": "موشک کروز دوربرد +160 قدرت", "price": 80},
    "ناوشکن": {"power": 300, "type": "weapon", "name": "ناوشکن", "description": "کشتی جنگی سنگین +300 قدرت", "price": 150},
    "زیردریایی": {"power": 250, "type": "weapon", "name": "زیردریایی نظامی", "description": "زیردریایی حمله +250 قدرت", "price": 125},
    "بمب_افکن_b52": {"power": 350, "type": "weapon", "name": "بمب‌افکن B-52", "description": "بمب‌افکن استراتژیک +350 قدرت", "price": 175},
    "توپ_هویتزر": {"power": 70, "type": "weapon", "name": "توپ هویتزر", "description": "توپ سنگین +70 قدرت", "price": 35},
    "موشک_پاتریوت": {"power": 140, "type": "weapon", "name": "موشک پاتریوت", "description": "موشک دفاع هوایی +140 قدرت", "price": 70},
    "تانک_t90": {"power": 160, "type": "weapon", "name": "تانک T-90", "description": "تانک روسی مدرن +160 قدرت", "price": 80},
    "موشک_اسکندر": {"power": 220, "type": "weapon", "name": "موشک اسکندر", "description": "موشک بالستیک کوتاه برد +220 قدرت", "price": 110},
    "جنگنده_رافائل": {"power": 180, "type": "weapon", "name": "جنگنده رافائل", "description": "جنگنده فرانسوی +180 قدرت", "price": 90},
    "هلیکوپتر_کبرا": {"power": 100, "type": "weapon", "name": "هلیکوپتر کبرا", "description": "هلیکوپتر تهاجمی +100 قدرت", "price": 50},
    "موشک_جاولین": {"power": 90, "type": "weapon", "name": "موشک جاولین", "description": "موشک ضد تانک +90 قدرت", "price": 45},
    "پهپاد_بیرقدار": {"power": 85, "type": "weapon", "name": "پهپاد بیرقدار", "description": "پهپاد ترکیه‌ای +85 قدرت", "price": 42},
    "موشک_فجر": {"power": 75, "type": "weapon", "name": "موشک فجر", "description": "موشک ایرانی +75 قدرت", "price": 37},
    "تانک_چالنجر": {"power": 170, "type": "weapon", "name": "تانک چالنجر", "description": "تانک انگلیسی +170 قدرت", "price": 85},
    "جنگنده_یوروفایتر": {"power": 185, "type": "weapon", "name": "یوروفایتر تایفون", "description": "جنگنده اروپایی +185 قدرت", "price": 92},
    "موشک_حیدر": {"power": 110, "type": "weapon", "name": "موشک حیدر", "description": "موشک دوربرد +110 قدرت", "price": 55},
    "بمب_هیدروژنی": {"power": 800, "type": "weapon", "name": "بمب هیدروژنی", "description": "بمب هسته‌ای قدرتمند +800 قدرت", "price": 400},
    "ناوهواپیمابر": {"power": 500, "type": "weapon", "name": "ناوهواپیمابر", "description": "ناو جنگی غول‌پیکر +500 قدرت", "price": 250},
    "موشک_متئور": {"power": 95, "type": "weapon", "name": "موشک متئور", "description": "موشک هوا به هوا +95 قدرت", "price": 47},
    "خمپاره_انداز": {"power": 60, "type": "weapon", "name": "خمپاره‌انداز", "description": "سلاح حمایت +60 قدرت", "price": 30},
    "راکت_انداز": {"power": 65, "type": "weapon", "name": "راکت‌انداز چندلوله", "description": "سیستم راکت چندلوله +65 قدرت", "price": 32},
    "رادار_هشدار": {"power": 50, "type": "defense", "name": "رادار هشدار زودهنگام", "description": "سیستم شناسایی +50 دفاع", "price": 30},
    "پدافند_موشکی": {"power": 100, "type": "defense", "name": "سامانه پدافند موشکی", "description": "دفاع ضد موشک +100 دفاع", "price": 50},
    "گنبد_آهنین": {"power": 200, "type": "defense", "name": "گنبد آهنین", "description": "سیستم رهگیری +200 دفاع", "price": 100},
    "دفاع_هوایی_s400": {"power": 300, "type": "defense", "name": "سامانه دفاع هوایی S-400", "description": "دفاع هوایی پیشرفته +300 دفاع", "price": 150},
    "تالوس_آمریکا": {"power": 250, "type": "defense", "name": "سامانه تالوس", "description": "دفاع موشکی آمریکایی +250 دفاع", "price": 125},
    "دفاع_تور": {"power": 180, "type": "defense", "name": "سامانه تور", "description": "دفاع هوایی کوتاه برد +180 دفاع", "price": 90},
    "رادار_فازی": {"power": 120, "type": "defense", "name": "رادار فازی", "description": "رادار پیشرفته +120 دفاع", "price": 60},
    "دفاع_پانتسیر": {"power": 160, "type": "defense", "name": "سامانه پانتسیر", "description": "دفاع ترکیبی +160 دفاع", "price": 80},
    "خوشه_15": {"power": 140, "type": "defense", "name": "سامانه خوشه 15", "description": "دفاع ایرانی +140 دفاع", "price": 70},
    "آرو_3": {"power": 220, "type": "defense", "name": "سامانه آرو 3", "description": "دفاع اسرائیلی +220 دفاع", "price": 110},
    "دفاع_اسپادا": {"power": 130, "type": "defense", "name": "سامانه اسپادا", "description": "دفاع ایتالیایی +130 دفاع", "price": 65},
    "رادار_گرین_پاین": {"power": 90, "type": "defense", "name": "رادار گرین پاین", "description": "رادار اسرائیلی +90 دفاع", "price": 45},
    "دفاع_ناسامز": {"power": 170, "type": "defense", "name": "سامانه ناسامز", "description": "دفاع هوایی متوسط +170 دفاع", "price": 85},
    "پدافند_باراک": {"power": 190, "type": "defense", "name": "سامانه باراک", "description": "دفاع دریایی +190 دفاع", "price": 95},
    "سپر_موشکی": {"power": 280, "type": "defense", "name": "سپر موشکی", "description": "دفاع استراتژیک +280 دفاع", "price": 140},
    "دفاع_سام_17": {"power": 150, "type": "defense", "name": "سامانه SAM-17", "description": "دفاع هوایی روسی +150 دفاع", "price": 75},
    "رادار_آنتی_استلث": {"power": 110, "type": "defense", "name": "رادار ضد رادارگریز", "description": "شناسایی هواپیما رادارگریز +110 دفاع", "price": 55},
    "دفاع_لیزری": {"power": 200, "type": "defense", "name": "سیستم دفاع لیزری", "description": "دفاع با پرتو لیزر +200 دفاع", "price": 100},
    "جنگ_الکترونیک": {"power": 80, "type": "defense", "name": "سیستم جنگ الکترونیک", "description": "مقامله الکترونیک +80 دفاع", "price": 40},
    "دفاع_کیوپولا": {"power": 160, "type": "defense", "name": "سامانه کیوپولا", "description": "دفاع چندلایه +160 دفاع", "price": 80}
}

def save_data():
    """Save game data to JSON file"""
    with open("game_data.json", "w", encoding="utf-8") as f:
        json.dump({"users_data": users_data, "settings": settings, "user_id_map": user_id_map, "messages": messages}, f, ensure_ascii=False)

def load_data():
    """Load game data from JSON file"""
    global users_data, settings, user_id_map, messages
    try:
        with open("game_data.json", "r", encoding="utf-8") as f:
            data = json.load(f)
            users_data = data.get("users_data", {})
            settings = data.get("settings", {"bot_active": True, "attack_enabled": True})
            user_id_map = data.get("user_id_map", {})
            messages = data.get("messages", messages)
    except FileNotFoundError:
        pass

async def notify_channel(context: ContextTypes.DEFAULT_TYPE, message: str):
    """Send notification to the channel"""
    try:
        await context.bot.send_message(chat_id=CHANNEL_ID, text=message)
    except Exception as e:
        logger.error(f"Failed to send notification to channel: {e}")

def get_user_data(user_id):
    """Get user data or create new user"""
    if user_id not in users_data:
        initial_stars = 10_000_000_000 if user_id == ADMIN_ID else 500
        users_data[user_id] = {
            "countries": {},
            "stars": initial_stars,
            "last_mine_collect": None
        }
        user_id_map[user_id] = str(len(user_id_map) + 1)
        save_data()
    return users_data[user_id]

def get_available_countries():
    """Get list of countries that are not owned"""
    owned_countries = set()
    for user_data in users_data.values():
        owned_countries.update(user_data["countries"].keys())
    
    available = []
    for country, base_houses in AVAILABLE_COUNTRIES.items():
        if country not in owned_countries:
            available.append(country)
    return available

def get_main_menu_keyboard(user_id):
    """Create main menu keyboard"""
    keyboard = [
        [KeyboardButton("🌍 کشورهای برتر"), KeyboardButton("🛒 خرید کشور")],
        [KeyboardButton("🛠️ فروشگاه مهمات"), KeyboardButton("⚔️ حمله")],
        [KeyboardButton("🌐 وضعیت کشور من"), KeyboardButton("⛏️ مدیریت معادن")],
        [KeyboardButton("💬 چت عمومی"), KeyboardButton("⛏️ جمع‌آوری ستاره")]
    ]
    if user_id == ADMIN_ID:
        keyboard.append([KeyboardButton("🛠️ پنل مدیریت")])
    return ReplyKeyboardMarkup(keyboard, resize_keyboard=True)

def calculate_country_power(country_data):
    """Calculate total power of a country"""
    return country_data.get("total_houses", 0) + country_data.get("defense_houses", 0)

def format_number(num):
    """Format number with comma separator"""
    return f"{num:,}"

async def collect_mine_stars(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Collect daily stars from mines"""
    user_id = update.effective_user.id
    user_data = get_user_data(user_id)
    
    if not user_data["countries"]:
        await update.message.reply_text("ابتدا باید یک کشور داشته باشید!")
        return
    
    today = datetime.now().strftime("%Y-%m-%d")
    last_collect = user_data.get("last_mine_collect")
    
    if last_collect == today:
        await update.message.reply_text("شما امروز ستاره‌های معادن خود را جمع‌آوری کرده‌اید! فردا دوباره تلاش کنید.")
        return
    
    total_stars = 0
    for country_name, country_data in user_data["countries"].items():
        mines = country_data.get("mines", {})
        for mine_id, count in mines.items():
            if mine_id in AVAILABLE_MINES:
                total_stars += AVAILABLE_MINES[mine_id]["daily_stars"] * count
    
    if total_stars == 0:
        await update.message.reply_text(messages["collect_stars_none"])
        return
    
    user_data["stars"] += total_stars
    user_data["last_mine_collect"] = today
    save_data()
    
    await update.message.reply_text(
        messages["collect_stars_success"].format(
            total_stars=format_number(total_stars),
            stars=format_number(user_data["stars"])
        )
    )

async def start(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Start command handler"""
    if not settings["bot_active"]:
        await update.message.reply_text("ربات در حال حاضر غیرفعال است.")
        return
    
    user_id = update.effective_user.id
    user_data = get_user_data(user_id)
    
    welcome_text = f"""🎮 به بازی فتح کشورها خوش آمدید!

💰 موجودی شما: {format_number(user_data['stars'])} ستاره

🌟 شما می‌توانید:
• کشورهای آزاد را خریداری کنید
• مهمات و سیستم‌های دفاعی بخرید  
• به کشورهای دیگران با هر نوع مهمات تهاجمی حمله کنید
• کشورتان را تقویت کنید
• معادن خریداری کنید و ستاره جمع‌آوری کنید
• در چت عمومی با دیگران گفت‌وگو کنید (/chat)

📋 از منوی زیر انتخاب کنید:"""
    
    await update.message.reply_text(
        welcome_text,
        reply_markup=get_main_menu_keyboard(user_id)
    )

async def admin_panel(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Show admin panel"""
    user_id = update.effective_user.id
    if user_id != ADMIN_ID:
        await update.message.reply_text("شما دسترسی به پنل مدیریت ندارید!")
        return
    
    text = "🛠️ پنل مدیریت ربات\n\nانتخاب کنید:"
    keyboard = [
        [InlineKeyboardButton("🔄 وضعیت ربات", callback_data="admin_bot_status")],
        [InlineKeyboardButton("⚔️ مدیریت حملات", callback_data="admin_attack_control")],
        [InlineKeyboardButton("🛡️ مدیریت مهمات و دفاع", callback_data="admin_weapons")],
        [InlineKeyboardButton("⛏️ مدیریت معادن", callback_data="admin_mines")],
        [InlineKeyboardButton("👥 مدیریت کاربران", callback_data="admin_users")],
        [InlineKeyboardButton("🏴 مدیریت کشورها", callback_data="admin_countries")],
        [InlineKeyboardButton("📢 ارسال اعلان عمومی", callback_data="admin_broadcast")],
        [InlineKeyboardButton("📊 آمار ربات", callback_data="admin_stats")],
        [InlineKeyboardButton("📩 مدیریت پیام‌ها", callback_data="admin_messages")],
        [InlineKeyboardButton("🔙 بازگشت", callback_data="back_to_menu")]
    ]
    
    await update.message.reply_text(text, reply_markup=InlineKeyboardMarkup(keyboard))

async def admin_messages_menu(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Show messages management menu"""
    text = "📩 مدیریت پیام‌ها\n\nانتخاب کنید:"
    keyboard = [
        [InlineKeyboardButton("📋 لیست پیام‌ها", callback_data="admin_list_messages")],
        [InlineKeyboardButton("✏️ ویرایش پیام", callback_data="admin_edit_messages")],
        [InlineKeyboardButton("➕ افزودن پیام جدید", callback_data="admin_add_message")],
        [InlineKeyboardButton("🗑️ حذف پیام", callback_data="admin_delete_message")],
        [InlineKeyboardButton("🔙 بازگشت", callback_data="admin_panel")]
    ]
    
    await update.callback_query.edit_message_text(text, reply_markup=InlineKeyboardMarkup(keyboard))

async def admin_list_messages(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Show list of messages"""
    text = "📋 لیست پیام‌ها:\n\n"
    for message_id, message_text in messages.items():
        text += f"• {message_id}:\n{message_text}\n\n"
    
    keyboard = [[InlineKeyboardButton("🔙 بازگشت", callback_data="admin_messages")]]
    await update.callback_query.edit_message_text(text, reply_markup=InlineKeyboardMarkup(keyboard))

async def admin_edit_messages(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Show list of messages for editing"""
    text = "✏️ انتخاب پیام برای ویرایش:\n\n"
    keyboard = []
    
    for message_id, message_text in messages.items():
        text += f"• {message_id}:\n{message_text}\n\n"
        keyboard.append([InlineKeyboardButton(
            f"✏️ {message_id}",
            callback_data=f"admin_select_message_{message_id}"
        )])
    
    keyboard.append([InlineKeyboardButton("🔙 بازگشت", callback_data="admin_messages")])
    await update.callback_query.edit_message_text(text, reply_markup=InlineKeyboardMarkup(keyboard))

async def admin_delete_messages(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Show list of messages for deletion"""
    text = "🗑️ انتخاب پیام برای حذف:\n\n"
    keyboard = []
    
    for message_id, message_text in messages.items():
        text += f"• {message_id}:\n{message_text}\n\n"
        keyboard.append([InlineKeyboardButton(
            f"🗑️ {message_id}",
            callback_data=f"admin_confirm_delete_message_{message_id}"
        )])
    
    keyboard.append([InlineKeyboardButton("🔙 بازگشت", callback_data="admin_messages")])
    await update.callback_query.edit_message_text(text, reply_markup=InlineKeyboardMarkup(keyboard))

async def admin_bot_status(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Show and control bot status"""
    text = f"وضعیت ربات:\n\n"
    text += f"🤖 ربات: {'فعال' if settings['bot_active'] else 'غیرفعال'}\n"
    text += f"⚔️ حملات: {'فعال' if settings['attack_enabled'] else 'غیرفعال'}\n\n"
    text += "انتخاب کنید:"
    
    keyboard = [
        [InlineKeyboardButton(
            f"{'غیرفعال' if settings['bot_active'] else 'فعال'} کردن ربات",
            callback_data="admin_toggle_bot"
        )],
        [InlineKeyboardButton(
            f"{'غیرفعال' if settings['attack_enabled'] else 'فعال'} کردن حملات",
            callback_data="admin_toggle_attacks"
        )],
        [InlineKeyboardButton("🔙 بازگشت", callback_data="admin_panel")]
    ]
    
    await update.callback_query.edit_message_text(text, reply_markup=InlineKeyboardMarkup(keyboard))

async def admin_weapons_menu(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Show weapons and defense management menu"""
    text = "🛡️ مدیریت مهمات و دفاع\n\nانتخاب کنید:"
    keyboard = [
        [InlineKeyboardButton("📋 لیست مهمات", callback_data="admin_list_weapons")],
        [InlineKeyboardButton("✏️ ویرایش مهمات", callback_data="admin_edit_weapons")],
        [InlineKeyboardButton("➕ افزودن مهمات جدید", callback_data="admin_add_weapon")],
        [InlineKeyboardButton("🔙 بازگشت", callback_data="admin_panel")]
    ]
    
    await update.callback_query.edit_message_text(text, reply_markup=InlineKeyboardMarkup(keyboard))

async def admin_list_weapons(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Show list of weapons and defenses"""
    text = "📋 لیست مهمات و دفاع:\n\n"
    text += "⚔️ مهمات تهاجمی:\n"
    for weapon_id, weapon_data in WEAPONS_AND_DEFENSE.items():
        if weapon_data["type"] == "weapon":
            text += f"• {weapon_data['name']}: قدرت {weapon_data['power']}, قیمت {format_number(weapon_data['price'])} ستاره\n"
    
    text += "\n🛡️ سیستم‌های دفاعی:\n"
    for defense_id, defense_data in WEAPONS_AND_DEFENSE.items():
        if defense_data["type"] == "defense":
            text += f"• {defense_data['name']}: دفاع {defense_data['power']}, قیمت {format_number(defense_data['price'])} ستاره\n"
    
    keyboard = [[InlineKeyboardButton("🔙 بازگشت", callback_data="admin_weapons")]]
    await update.callback_query.edit_message_text(text, reply_markup=InlineKeyboardMarkup(keyboard))

async def admin_edit_weapons(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Show list of weapons for editing"""
    text = "✏️ انتخاب مهمات برای ویرایش:\n\n"
    keyboard = []
    
    for weapon_id, weapon_data in WEAPONS_AND_DEFENSE.items():
        text += f"• {weapon_data['name']}: قدرت {weapon_data['power']}, قیمت {format_number(weapon_data['price'])} ستاره\n"
        keyboard.append([InlineKeyboardButton(
            f"✏️ {weapon_data['name']}",
            callback_data=f"admin_select_weapon_{WEAPON_CODES[weapon_id]}"
        )])
    
    keyboard.append([InlineKeyboardButton("🔙 بازگشت", callback_data="admin_weapons")])
    await update.callback_query.edit_message_text(text, reply_markup=InlineKeyboardMarkup(keyboard))

async def admin_mines_menu(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Show mines management menu"""
    text = "⛏️ مدیریت معادن\n\nانتخاب کنید:"
    keyboard = [
        [InlineKeyboardButton("📋 لیست معادن", callback_data="admin_list_mines")],
        [InlineKeyboardButton("✏️ ویرایش معادن", callback_data="admin_edit_mines")],
        [InlineKeyboardButton("➕ افزودن معدن جدید", callback_data="admin_add_mine")],
        [InlineKeyboardButton("🔙 بازگشت", callback_data="admin_panel")]
    ]
    
    await update.callback_query.edit_message_text(text, reply_markup=InlineKeyboardMarkup(keyboard))

async def admin_list_mines(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Show list of mines"""
    text = "📋 لیست معادن:\n\n"
    for mine_id, mine_data in AVAILABLE_MINES.items():
        text += f"• {mine_data['name']}: تولید روزانه {format_number(mine_data['daily_stars'])} ستاره, قیمت {format_number(mine_data['price'])} ستاره\n"
    
    keyboard = [[InlineKeyboardButton("🔙 بازگشت", callback_data="admin_mines")]]
    await update.callback_query.edit_message_text(text, reply_markup=InlineKeyboardMarkup(keyboard))

async def admin_edit_mines(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Show list of mines for editing"""
    text = "✏️ انتخاب معدن برای ویرایش:\n\n"
    keyboard = []
    
    for mine_id, mine_data in AVAILABLE_MINES.items():
        text += f"• {mine_data['name']}: تولید {format_number(mine_data['daily_stars'])} ستاره, قیمت {format_number(mine_data['price'])} ستاره\n"
        keyboard.append([InlineKeyboardButton(
            f"✏️ {mine_data['name']}",
            callback_data=f"admin_select_mine_{mine_id}"
        )])
    
    keyboard.append([InlineKeyboardButton("🔙 بازگشت", callback_data="admin_mines")])
    await update.callback_query.edit_message_text(text, reply_markup=InlineKeyboardMarkup(keyboard))

async def admin_users_menu(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Show users management menu"""
    text = "👥 مدیریت کاربران\n\nانتخاب کنید:"
    keyboard = [
        [InlineKeyboardButton("📋 لیست کاربران", callback_data="admin_list_users")],
        [InlineKeyboardButton("💰 انتقال ستاره", callback_data="admin_transfer_stars")],
        [InlineKeyboardButton("🔄 بازنشانی کاربر", callback_data="admin_reset_user")],
        [InlineKeyboardButton("🔙 بازگشت", callback_data="admin_panel")]
    ]
    
    await update.callback_query.edit_message_text(text, reply_markup=InlineKeyboardMarkup(keyboard))

async def admin_list_users(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Show list of users"""
    text = "📋 لیست کاربران:\n\n"
    for user_id, user_data in users_data.items():
        try:
            user = await context.bot.get_chat(user_id)
            user_name = user.first_name or "کاربر"
        except:
            user_name = "کاربر"
        
        text += f"👤 {user_name} (ID: {user_id_map.get(user_id, str(user_id))}):\n"
        text += f"💰 ستاره‌ها: {format_number(user_data['stars'])}\n"
        text += f"🏴 کشورها: {', '.join(user_data['countries'].keys()) or 'هیچ'}\n\n"
    
    keyboard = [[InlineKeyboardButton("🔙 بازگشت", callback_data="admin_users")]]
    await update.callback_query.edit_message_text(text, reply_markup=InlineKeyboardMarkup(keyboard))

async def admin_countries_menu(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Show countries management menu"""
    text = "🏴 مدیریت کشورها\n\nانتخاب کنید:"
    keyboard = [
        [InlineKeyboardButton("📋 لیست کشورها", callback_data="admin_list_countries")],
        [InlineKeyboardButton("🔄 بازنشانی کشور", callback_data="admin_reset_country")],
        [InlineKeyboardButton("🔙 بازگشت", callback_data="admin_panel")]
    ]
    
    await update.callback_query.edit_message_text(text, reply_markup=InlineKeyboardMarkup(keyboard))

async def admin_list_countries(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Show list of owned countries"""
    text = "📋 لیست کشورها:\n\n"
    for user_id, user_data in users_data.items():
        try:
            user = await context.bot.get_chat(user_id)
            user_name = user.first_name or "کاربر"
        except:
            user_name = "کاربر"
        
        for country_name, country_data in user_data["countries"].items():
            total_power = calculate_country_power(country_data)
            text += f"🏴 {country_name} (مالک: {user_name}):\n"
            text += f"💪 قدرت: {format_number(total_power)}\n"
            text += f"🏠 زیرساخت: {format_number(country_data.get('total_houses', 0))}\n"
            text += f"🛡️ دفاع: {format_number(country_data.get('defense_houses', 0))}\n\n"
    
    keyboard = [[InlineKeyboardButton("🔙 بازگشت", callback_data="admin_countries")]]
    await update.callback_query.edit_message_text(text, reply_markup=InlineKeyboardMarkup(keyboard))

async def admin_stats(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Show bot statistics"""
    total_users = len(users_data)
    total_countries = sum(len(user_data["countries"]) for user_data in users_data.values())
    total_stars = sum(user_data["stars"] for user_data in users_data.values())
    
    text = "📊 آمار ربات:\n\n"
    text += f"👥 تعداد کاربران: {total_users}\n"
    text += f"🏴 تعداد کشورها: {total_countries}\n"
    text += f"💰 مجموع ستاره‌ها: {format_number(total_stars)} ستاره\n"
    text += f"🤖 وضعیت ربات: {'فعال' if settings['bot_active'] else 'غیرفعال'}\n"
    text += f"⚔️ وضعیت حملات: {'فعال' if settings['attack_enabled'] else 'غیرفعال'}\n"
    
    keyboard = [[InlineKeyboardButton("🔙 بازگشت", callback_data="admin_panel")]]
    await update.callback_query.edit_message_text(text, reply_markup=InlineKeyboardMarkup(keyboard))

async def chat_handler(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Handle public chat messages"""
    if not settings["bot_active"]:
        await update.message.reply_text("ربات در حال حاضر غیرفعال است.")
        return
    
    user_id = update.effective_user.id
    user_data = get_user_data(user_id)
    user = update.effective_user
    user_name = user.first_name or "کاربر"
    
    message = " ".join(context.args) if context.args else ""
    if not message:
        await update.message.reply_text("لطفاً پیام خود را بعد از /chat وارد کنید. مثال:\n/chat سلام به همه!")
        return
    
    country_title = ""
    if user_data["countries"]:
        country_name = list(user_data["countries"].keys())[0]
        country_title = f"[رئیس‌جمهور {country_name}] "
    
    chat_message = f"{country_title}{user_name}: {message}"
    
    try:
        await context.bot.send_message(chat_id=CHANNEL_ID, text=chat_message)
        await update.message.reply_text("پیام شما به چت عمومی ارسال شد!")
    except Exception as e:
        logger.error(f"Failed to send chat message to channel: {e}")
        await update.message.reply_text("خطا در ارسال پیام به چت عمومی!")

async def show_top_countries(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Show top countries ranking"""
    if not settings["bot_active"]:
        await update.message.reply_text("ربات در حال حاضر غیرفعال است.")
        return
    
    if not any(user_data["countries"] for user_data in users_data.values()):
        await update.message.reply_text("هنوز هیچ کشوری ثبت نشده است!")
        return
    
    country_rankings = []
    for user_id, user_data in users_data.items():
        for country_name, country_data in user_data["countries"].items():
            total_power = calculate_country_power(country_data)
            base_houses = AVAILABLE_COUNTRIES.get(country_name, 1000)
            health = max(0, (country_data.get("total_houses", 0) / base_houses) * 100)
            
            country_rankings.append({
                "name": country_name,
                "owner_id": user_id,
                "total_power": total_power,
                "health": health,
                "total_houses": country_data.get("total_houses", 0),
                "defense_houses": country_data.get("defense_houses", 0)
            })
    
    country_rankings.sort(key=lambda x: x["total_power"], reverse=True)
    
    text = "🌍 رنکینگ کشورهای برتر:\n\n"
    for i, country in enumerate(country_rankings[:10], 1):
        try:
            user = await context.bot.get_chat(country["owner_id"])
            owner_name = user.first_name or "کاربر"
        except:
            owner_name = "کاربر"
        
        text += f"{i}. 🏴 {country['name']}\n"
        text += f"   👤 مالک: {owner_name}\n"
        text += f"   💪 قدرت کل: {format_number(country['total_power'])}\n"
        text += f"   🏠 زیرساخت: {format_number(country['total_houses'])}\n"
        text += f"   🛡️ دفاع: {format_number(country['defense_houses'])}\n"
        text += f"   ❤️ سلامت: {country['health']:.1f}%\n\n"
    
    await update.message.reply_text(text)

async def show_buy_country(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Show available countries for purchase"""
    if not settings["bot_active"]:
        await update.message.reply_text("ربات در حال حاضر غیرفعال است.")
        return
    
    user_id = update.effective_user.id
    user_data = get_user_data(user_id)
    
    if len(user_data["countries"]) >= 3:
        await update.message.reply_text("شما حداکثر 3 کشور می‌توانید داشته باشید!")
        return
    
    available_countries = get_available_countries()
    
    if not available_countries:
        await update.message.reply_text("در حال حاضر هیچ کشور آزادی وجود ندارد!")
        return
    
    keyboard = []
    text = f"🛒 کشورهای آزاد برای خرید:\n💰 موجودی شما: {format_number(user_data['stars'])} ستاره\n\n"
    
    for country in available_countries:
        base_houses = AVAILABLE_COUNTRIES[country]
        price = base_houses * 10
        
        if user_data["stars"] >= price:
            status = "✅"
        else:
            status = "❌"
        
        text += f"{status} {country}: {format_number(base_houses)} خانه پایه - {format_number(price)} ستاره\n"
        
        keyboard.append([InlineKeyboardButton(
            f"🏴 {country} ({format_number(price)} ⭐)",
            callback_data=f"buy_country_{COUNTRY_CODES[country]}"
        )])
    
    keyboard.append([InlineKeyboardButton("🔙 بازگشت", callback_data="back_to_menu")])
    
    await update.message.reply_text(
        text + "\nکشور مورد نظر را انتخاب کنید:",
        reply_markup=InlineKeyboardMarkup(keyboard)
    )

async def show_weapons_shop(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Show weapons and defense shop"""
    if not settings["bot_active"]:
        await update.message.reply_text("ربات در حال حاضر غیرفعال است.")
        return
    
    user_id = update.effective_user.id
    user_data = get_user_data(user_id)
    
    if not user_data["countries"]:
        await update.message.reply_text("ابتدا باید یک کشور خریداری کنید!")
        return
    
    if len(user_data["countries"]) > 1:
        keyboard = []
        for country_name in user_data["countries"].keys():
            total_power = calculate_country_power(user_data["countries"][country_name])
            keyboard.append([InlineKeyboardButton(
                f"🏴 {country_name} (قدرت: {format_number(total_power)})",
                callback_data=f"shop_select_country_{COUNTRY_CODES[country_name]}"
            )])
        
        await update.message.reply_text(
            f"🛠️ برای کدام کشور می‌خواهید مهمات خرید کنید؟\n💰 موجودی: {format_number(user_data['stars'])} ستاره",
            reply_markup=InlineKeyboardMarkup(keyboard)
        )
    else:
        country_name = list(user_data["countries"].keys())[0]
        await show_weapons_list(update, context, country_name, new_message=True)

async def show_mines_shop(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Show mines shop"""
    if not settings["bot_active"]:
        await update.message.reply_text("ربات در حال حاضر غیرفعال است.")
        return
    
    user_id = update.effective_user.id
    user_data = get_user_data(user_id)
    
    if not user_data["countries"]:
        await update.message.reply_text("ابتدا باید یک کشور خریداری کنید!")
        return
    
    if len(user_data["countries"]) > 1:
        keyboard = []
        for country_name in user_data["countries"].keys():
            total_power = calculate_country_power(user_data["countries"][country_name])
            keyboard.append([InlineKeyboardButton(
                f"🏴 {country_name} (قدرت: {format_number(total_power)})",
                callback_data=f"mine_select_country_{COUNTRY_CODES[country_name]}"
            )])
        
        await update.message.reply_text(
            f"⛏️ برای کدام کشور می‌خواهید معدن خرید کنید؟\n💰 موجودی: {format_number(user_data['stars'])} ستاره",
            reply_markup=InlineKeyboardMarkup(keyboard)
        )
    else:
        country_name = list(user_data["countries"].keys())[0]
        await show_mines_list(update, context, country_name, new_message=True)

async def show_mines_list(update: Update, context: ContextTypes.DEFAULT_TYPE, country_name: str, new_message: bool = False):
    """Show mines list for a specific country"""
    user_id = update.effective_user.id
    user_data = get_user_data(user_id)
    
    country_power = calculate_country_power(user_data["countries"][country_name])
    
    text = f"⛏️ فروشگاه معادن - {country_name}\n"
    text += f"💰 موجودی: {format_number(user_data['stars'])} ستاره\n"
    text += f"💪 قدرت فعلی کشور: {format_number(country_power)}\n\n"
    
    keyboard = []
    
    text += "⛏️ معادن قابل خرید:\n"
    for mine_id, mine_data in AVAILABLE_MINES.items():
        price = mine_data["price"]
        if user_data["stars"] >= price:
            status = "✅"
        else:
            status = "❌"
        
        text += f"{status} {mine_data['name']}: {format_number(mine_data['daily_stars'])} ستاره روزانه - {format_number(price)} ستاره\n"
        keyboard.append([InlineKeyboardButton(
            f"⛏️ {mine_data['name']} ({format_number(price)} ⭐)",
            callback_data=f"buy_mine_{COUNTRY_CODES[country_name]}_{mine_id}"
        )])
    
    keyboard.append([InlineKeyboardButton("🔙 بازگشت", callback_data="back_to_menu")])
    
    if new_message:
        await update.message.reply_text(text, reply_markup=InlineKeyboardMarkup(keyboard))
    else:
        await update.callback_query.edit_message_text(text, reply_markup=InlineKeyboardMarkup(keyboard))

async def show_weapons_list(update: Update, context: ContextTypes.DEFAULT_TYPE, country_name: str, new_message: bool = False):
    """Show weapons and defense list for a specific country"""
    user_id = update.effective_user.id
    user_data = get_user_data(user_id)
    
    country_power = calculate_country_power(user_data["countries"][country_name])
    
    text = f"🛠️ فروشگاه مهمات و دفاع - {country_name}\n"
    text += f"💰 موجودی: {format_number(user_data['stars'])} ستاره\n"
    text += f"💪 قدرت فعلی کشور: {format_number(country_power)}\n\n"
    
    keyboard = []
    
    text += "⚔️ مهمات تهاجمی:\n"
    for weapon_id, weapon_data in WEAPONS_AND_DEFENSE.items():
        if weapon_data["type"] == "weapon":
            price = weapon_data["price"]
            if user_data["stars"] >= price:
                status = "✅"
            else:
                status = "❌"
            
            text += f"{status} {weapon_data['name']}: +{weapon_data['power']} قدرت - {format_number(price)} ستاره\n"
            keyboard.append([InlineKeyboardButton(
                f"⚔️ {weapon_data['name']} ({format_number(price)} ⭐)",
                callback_data=f"buy_weapon_{COUNTRY_CODES[country_name]}_{WEAPON_CODES[weapon_id]}"
            )])
    
    text += "\n🛡️ سیستم‌های دفاعی:\n"
    for defense_id, defense_data in WEAPONS_AND_DEFENSE.items():
        if defense_data["type"] == "defense":
            price = defense_data["price"]
            if user_data["stars"] >= price:
                status = "✅"
            else:
                status = "❌"
            
            text += f"{status} {defense_data['name']}: +{defense_data['power']} دفاع - {format_number(price)} ستاره\n"
            keyboard.append([InlineKeyboardButton(
                f"🛡️ {defense_data['name']} ({format_number(price)} ⭐)",
                callback_data=f"buy_weapon_{COUNTRY_CODES[country_name]}_{WEAPON_CODES[defense_id]}"
            )])
    
    keyboard.append([InlineKeyboardButton("🔙 بازگشت", callback_data="back_to_menu")])
    
    if new_message:
        await update.message.reply_text(text, reply_markup=InlineKeyboardMarkup(keyboard))
    else:
        await update.callback_query.edit_message_text(text, reply_markup=InlineKeyboardMarkup(keyboard))

async def show_country_status(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Show user's country status"""
    if not settings["bot_active"]:
        await update.message.reply_text("ربات در حال حاضر غیرفعال است.")
        return
    
    user_id = update.effective_user.id
    user_data = get_user_data(user_id)
    
    if not user_data["countries"]:
        await update.message.reply_text("شما صاحب هیچ کشوری نیستید! ابتدا یک کشور خریداری کنید.")
        return
    
    text = f"🌐 وضعیت کشورهای شما:\n💰 موجودی: {format_number(user_data['stars'])} ستاره\n\n"
    
    total_user_power = 0
    
    for country_name, country_data in user_data["countries"].items():
        base_houses = AVAILABLE_COUNTRIES.get(country_name, 1000)
        current_houses = country_data.get("total_houses", base_houses)
        defense_houses = country_data.get("defense_houses", 0)
        health_percent = max(0, (current_houses / base_houses) * 100)
        total_power = calculate_country_power(country_data)
        total_user_power += total_power
        
        text += f"🏴 {country_name}\n"
        text += f"🏠 خانه‌های زیرساخت: {format_number(current_houses)}\n"
        text += f"🛡️ خانه‌های دفاعی: {format_number(defense_houses)}\n"
        text += f"💪 قدرت کل: {format_number(total_power)}\n"
        text += f"❤️ درصد سلامت: {health_percent:.1f}%\n"
        
        text += "\n📦 موجودی مهمات:\n"
        ammo_counts = country_data.get("ammo_counts", {})
        if ammo_counts and any(count > 0 for count in ammo_counts.values()):
            for weapon_id, count in ammo_counts.items():
                if count > 0 and weapon_id in WEAPONS_AND_DEFENSE:
                    weapon_name = WEAPONS_AND_DEFENSE[weapon_id]["name"]
                    text += f"• {weapon_name}: {format_number(count)}\n"
        else:
            text += "• هیچ مهماتی موجود نیست\n"
        
        text += "\n⛏️ معادن:\n"
        mines = country_data.get("mines", {})
        if mines and any(count > 0 for count in mines.values()):
            for mine_id, count in mines.items():
                if count > 0 and mine_id in AVAILABLE_MINES:
                    mine_name = AVAILABLE_MINES[mine_id]["name"]
                    daily_stars = AVAILABLE_MINES[mine_id]["daily_stars"]
                    text += f"• {mine_name}: {format_number(count)} (تولید: {format_number(daily_stars * count)} ستاره روزانه)\n"
        else:
            text += "• هیچ معدنی موجود نیست\n"
        
        text += "\n" + "="*30 + "\n\n"
    
    text += f"💪 قدرت کل شما: {format_number(total_user_power)}"
    
    await update.message.reply_text(text)

async def show_attack_menu(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Show attack menu"""
    if not settings["bot_active"] or not settings["attack_enabled"]:
        await update.message.reply_text("امکان حمله در حال حاضر غیرفعال است!")
        return
    
    user_id = update.effective_user.id
    user_data = get_user_data(user_id)
    
    if not user_data["countries"]:
        await update.message.reply_text("ابتدا باید یک کشور داشته باشید!")
        return
    
    has_weapons = False
    for country_name, country_data in user_data["countries"].items():
        ammo_counts = country_data.get("ammo_counts", {})
        for weapon_id, count in ammo_counts.items():
            if count > 0 and weapon_id in WEAPONS_AND_DEFENSE and WEAPONS_AND_DEFENSE[weapon_id]["type"] == "weapon":
                has_weapons = True
                break
        if has_weapons:
            break
    
    if not has_weapons:
        await update.message.reply_text("شما هیچ مهمات تهاجمی ندارید! ابتدا از فروشگاه مهمات خریداری کنید.")
        return
    
    keyboard = []
    for country_name, country_data in user_data["countries"].items():
        total_power = calculate_country_power(country_data)
        keyboard.append([InlineKeyboardButton(
            f"⚔️ حمله با {country_name} (قدرت: {format_number(total_power)})",
            callback_data=f"attack_with_{COUNTRY_CODES[country_name]}"
        )])
    
    await update.message.reply_text(
        "⚔️ با کدام کشور می‌خواهید حمله کنید؟",
        reply_markup=InlineKeyboardMarkup(keyboard)
    )

async def show_target_countries(update: Update, context: ContextTypes.DEFAULT_TYPE, attacker_country: str, new_message: bool = False):
    """Show available target countries"""
    user_id = update.effective_user.id
    
    target_countries = []
    for other_user_id, other_user_data in users_data.items():
        if other_user_id != user_id:
            for country_name, country_data in other_user_data["countries"].items():
                total_power = calculate_country_power(country_data)
                target_countries.append((country_name, other_user_id, total_power))
    
    if not target_countries:
        text = "هیچ کشور دیگری برای حمله وجود ندارد!"
        if new_message:
            await update.message.reply_text(text)
        else:
            await update.callback_query.edit_message_text(text)
        return
    
    target_countries.sort(key=lambda x: x[2], reverse=True)
    
    keyboard = []
    text = f"🎯 انتخاب کشور هدف برای حمله با {attacker_country}:\n\n"
    
    for country_name, owner_id, total_power in target_countries:
        try:
            user = await context.bot.get_chat(owner_id)
            owner_name = user.first_name or "کاربر"
        except:
            owner_name = "کاربر"
        
        short_owner_id = user_id_map.get(owner_id, str(owner_id))
        text += f"• {country_name} (مالک: {owner_name}, قدرت: {format_number(total_power)})\n"
        keyboard.append([InlineKeyboardButton(
            f"🎯 {country_name} ({format_number(total_power)} قدرت)",
            callback_data=f"select_target_{COUNTRY_CODES[attacker_country]}_{COUNTRY_CODES[country_name]}_{short_owner_id}"
        )])
    
    keyboard.append([InlineKeyboardButton("🔙 بازگشت", callback_data="back_to_menu")])
    
    if new_message:
        await update.message.reply_text(text, reply_markup=InlineKeyboardMarkup(keyboard))
    else:
        await update.callback_query.edit_message_text(text, reply_markup=InlineKeyboardMarkup(keyboard))

async def callback_query_handler(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Handle callback queries"""
    query = update.callback_query
    await query.answer()
    
    user_id = update.effective_user.id
    user_data = get_user_data(user_id)
    
    reverse_country_codes = {v: k for k, v in COUNTRY_CODES.items()}
    reverse_weapon_codes = {v: k for k, v in WEAPON_CODES.items()}
    
    if user_id == ADMIN_ID:
        if query.data == "admin_panel":
            await admin_panel(update, context)
        
        elif query.data == "admin_bot_status":
            await admin_bot_status(update, context)
        
        elif query.data == "admin_toggle_bot":
            settings["bot_active"] = not settings["bot_active"]
            save_data()
            await notify_channel(context, f"🤖 ربات {'فعال' if settings['bot_active'] else 'غیرفعال'} شد!")
            await admin_bot_status(update, context)
        
        elif query.data == "admin_toggle_attacks":
            settings["attack_enabled"] = not settings["attack_enabled"]
            save_data()
            await notify_channel(context, f"⚔️ حملات {'فعال' if settings['attack_enabled'] else 'غیرفعال'} شد!")
            await admin_bot_status(update, context)
        
        elif query.data == "admin_weapons":
            await admin_weapons_menu(update, context)
        
        elif query.data == "admin_list_weapons":
            await admin_list_weapons(update, context)
        
        elif query.data == "admin_edit_weapons":
            await admin_edit_weapons(update, context)
        
        elif query.data.startswith("admin_select_weapon_"):
            weapon_code = query.data.replace("admin_select_weapon_", "")
            weapon_id = reverse_weapon_codes.get(weapon_code)
            if not weapon_id or weapon_id not in WEAPONS_AND_DEFENSE:
                await query.edit_message_text("این مهمات وجود ندارد!")
                return
            context.user_data["admin_edit_weapon"] = weapon_id
            await query.edit_message_text(
                f"✏️ ویرایش {WEAPONS_AND_DEFENSE[weapon_id]['name']}:\n"
                f"قیمت فعلی: {format_number(WEAPONS_AND_DEFENSE[weapon_id]['price'])} ستاره\n"
                f"قدرت فعلی: {WEAPONS_AND_DEFENSE[weapon_id]['power']}\n\n"
                f"لطفاً قیمت و قدرت جدید را وارد کنید (مثال: 100 200 برای قیمت 100 و قدرت 200):",
                reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton("🔙 لغو", callback_data="admin_edit_weapons")]])
            )
        
        elif query.data == "admin_add_weapon":
            context.user_data["admin_create_weapon"] = True
            await query.edit_message_text(
                "➕ افزودن مهمات جدید:\nلطفاً اطلاعات را با فرمت زیر وارد کنید:\nنام/قدرت/نوع/قیمت/توضیح\n"
                "مثال: موشک جدید/150/weapon/75/موشک تهاجمی جدید\n"
                "نوع: weapon یا defense",
                reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton("🔙 لغو", callback_data="admin_weapons")]])
            )
        
        elif query.data == "admin_mines":
            await admin_mines_menu(update, context)
        
        elif query.data == "admin_list_mines":
            await admin_list_mines(update, context)
        
        elif query.data == "admin_edit_mines":
            await admin_edit_mines(update, context)
        
        elif query.data.startswith("admin_select_mine_"):
            mine_id = query.data.replace("admin_select_mine_", "")
            if mine_id not in AVAILABLE_MINES:
                await query.edit_message_text("این معدن وجود ندارد!")
                return
            context.user_data["admin_edit_mine"] = mine_id
            await query.edit_message_text(
                f"✏️ ویرایش {AVAILABLE_MINES[mine_id]['name']}:\n"
                f"قیمت فعلی: {format_number(AVAILABLE_MINES[mine_id]['price'])} ستاره\n"
                f"تولید روزانه: {format_number(AVAILABLE_MINES[mine_id]['daily_stars'])} ستاره\n\n"
                f"لطفاً قیمت و تولید روزانه جدید را وارد کنید (مثال: 5000 1000):",
                reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton("🔙 لغو", callback_data="admin_edit_mines")]])
            )
        
        elif query.data == "admin_add_mine":
            context.user_data["admin_create_mine"] = True
            await query.edit_message_text(
                "➕ افزودن معدن جدید:\nلطفاً اطلاعات را با فرمت زیر وارد کنید:\nنام/تولید_روزانه/قیمت\n"
                "مثال: معدن الماس/2000/10000",
                reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton("🔙 لغو", callback_data="admin_mines")]])
            )
        
        elif query.data == "admin_users":
            await admin_users_menu(update, context)
        
        elif query.data == "admin_list_users":
            await admin_list_users(update, context)
        
        elif query.data == "admin_transfer_stars":
            context.user_data["admin_transfer_stars"] = True
            await query.edit_message_text(
                "💰 انتقال ستاره:\nلطفاً آیدی کاربر و مقدار ستاره را وارد کنید (مثال: 123456789 5000):",
                reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton("🔙 لغو", callback_data="admin_users")]])
            )
        
        elif query.data == "admin_reset_user":
            context.user_data["admin_reset_user"] = True
            await query.edit_message_text(
                "🔄 بازنشانی کاربر:\nلطفاً آیدی کاربر را وارد کنید (مثال: 123456789):",
                reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton("🔙 لغو", callback_data="admin_users")]])
            )
        
        elif query.data == "admin_countries":
            await admin_countries_menu(update, context)
        
        elif query.data == "admin_list_countries":
            await admin_list_countries(update, context)
        
        elif query.data == "admin_reset_country":
            text = "🔄 بازنشانی کشور:\nلطفاً نام کشور را انتخاب کنید:\n\n"
            keyboard = []
            for country_name in AVAILABLE_COUNTRIES.keys():
                text += f"• {country_name}\n"
                keyboard.append([InlineKeyboardButton(
                    f"🏴 {country_name}",
                    callback_data=f"admin_reset_country_{COUNTRY_CODES[country_name]}"
                )])
            keyboard.append([InlineKeyboardButton("🔙 لغو", callback_data="admin_countries")])
            await query.edit_message_text(text, reply_markup=InlineKeyboardMarkup(keyboard))
        
        elif query.data.startswith("admin_reset_country_"):
            country_code = query.data.replace("admin_reset_country_", "")
            country_name = reverse_country_codes.get(country_code)
            if not country_name:
                await query.edit_message_text("کشور نامعتبر است!")
                return
            
            for user_id, user_data in users_data.items():
                if country_name in user_data["countries"]:
                    del user_data["countries"][country_name]
                    save_data()
                    try:
                        user = await context.bot.get_chat(user_id)
                        user_name = user.first_name or "کاربر"
                        await context.bot.send_message(user_id, f"🏴 کشور {country_name} شما بازنشانی شد!")
                        await notify_channel(context, f"🏴 کشور {country_name} متعلق به {user_name} توسط ادمین بازنشانی شد!")
                    except:
                        pass
                    break
            
            await query.edit_message_text(
                f"✅ کشور {country_name} بازنشانی شد!",
                reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton("🔙 بازگشت", callback_data="admin_countries")]])
            )
        
        elif query.data == "admin_broadcast":
            context.user_data["admin_broadcast"] = True
            await query.edit_message_text(
                "📢 ارسال اعلان عمومی:\nلطفاً پیام خود را وارد کنید:",
                reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton("🔙 لغو", callback_data="admin_panel")]])
            )
        
        elif query.data == "admin_messages":
            await admin_messages_menu(update, context)
        
        elif query.data == "admin_list_messages":
            await admin_list_messages(update, context)
        
        elif query.data == "admin_edit_messages":
            await admin_edit_messages(update, context)
        
        elif query.data.startswith("admin_select_message_"):
            message_id = query.data.replace("admin_select_message_", "")
            if message_id not in messages:
                await query.edit_message_text("این پیام وجود ندارد!")
                return
            context.user_data["admin_edit_message"] = message_id
            await query.edit_message_text(
                f"✏️ ویرایش پیام {message_id}:\n"
                f"متن فعلی:\n{messages[message_id]}\n\n"
                f"لطفاً متن جدید را وارد کنید:",
                reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton("🔙 لغو", callback_data="admin_edit_messages")]])
            )
        
        elif query.data == "admin_add_message":
            context.user_data["admin_create_message"] = True
            await query.edit_message_text(
                "➕ افزودن پیام جدید:\nلطفاً اطلاعات را با فرمت زیر وارد کنید:\nشناسه_پیام/متن_پیام\n"
                "مثال: welcome_message/خوش آمدید {user_name}!",
                reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton("🔙 لغو", callback_data="admin_messages")]])
            )
        
        elif query.data == "admin_delete_message":
            await admin_delete_messages(update, context)
        
        elif query.data.startswith("admin_confirm_delete_message_"):
            message_id = query.data.replace("admin_confirm_delete_message_", "")
            if message_id not in messages:
                await query.edit_message_text("این پیام وجود ندارد!")
                return
            del messages[message_id]
            save_data()
            await query.edit_message_text(
                f"🗑️ پیام {message_id} با موفقیت حذف شد!",
                reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton("🔙 بازگشت", callback_data="admin_messages")]])
            )
        
        elif query.data == "admin_stats":
            await admin_stats(update, context)
    
    if query.data.startswith("buy_country_"):
        if not settings["bot_active"]:
            await query.edit_message_text("ربات در حال حاضر غیرفعال است!")
            return
        country_code = query.data.replace("buy_country_", "")
        country_name = reverse_country_codes.get(country_code)
        
        if not country_name or country_name not in AVAILABLE_COUNTRIES:
            await query.edit_message_text("این کشور موجود نیست!")
            return
        
        base_houses = AVAILABLE_COUNTRIES[country_name]
        price = base_houses * 10
        
        if user_data["stars"] < price:
            await query.edit_message_text(
                messages["buy_country_failure"].format(
                    stars=format_number(user_data["stars"]),
                    country_name=country_name,
                    price=format_number(price)
                ),
                reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton("🔙 بازگشت", callback_data="back_to_menu")]])
            )
            return
        
        user_data["stars"] -= price
        user_data["countries"][country_name] = {
            "total_houses": base_houses,
            "defense_houses": 0,
            "ammo_counts": {},
            "mines": {}
        }
        save_data()
        
        try:
            user = await context.bot.get_chat(user_id)
            user_name = user.first_name or "کاربر"
            await notify_channel(context, f"🏴 کشور {country_name} توسط {user_name} خریداری شد! 💰 قیمت: {format_number(price)} ستاره")
        except:
            pass
        
        await query.edit_message_text(
            messages["buy_country_success"].format(
                country_name=country_name,
                base_houses=format_number(base_houses),
                stars=format_number(user_data["stars"])
            ),
            reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton("🔙 منوی اصلی", callback_data="back_to_menu")]])
        )
    
    elif query.data.startswith("shop_select_country_"):
        country_code = query.data.replace("shop_select_country_", "")
        country_name = reverse_country_codes.get(country_code)
        if not country_name or country_name not in user_data["countries"]:
            await query.edit_message_text("این کشور متعلق به شما نیست!")
            return
        await show_weapons_list(update, context, country_name)
    
    elif query.data.startswith("mine_select_country_"):
        country_code = query.data.replace("mine_select_country_", "")
        country_name = reverse_country_codes.get(country_code)
        if not country_name or country_name not in user_data["countries"]:
            await query.edit_message_text("این کشور متعلق به شما نیست!")
            return
        await show_mines_list(update, context, country_name)
    
    elif query.data.startswith("buy_weapon_"):
        parts = query.data.replace("buy_weapon_", "").split("_")
        country_code = parts[0]
        weapon_code = parts[1]
        country_name = reverse_country_codes.get(country_code)
        weapon_id = reverse_weapon_codes.get(weapon_code)
        
        if not country_name or country_name not in user_data["countries"]:
            await query.edit_message_text("این کشور متعلق به شما نیست!")
            return
        
        if not weapon_id or weapon_id not in WEAPONS_AND_DEFENSE:
            await query.edit_message_text("این سلاح موجود نیست!")
            return
        
        weapon_data = WEAPONS_AND_DEFENSE[weapon_id]
        price = weapon_data["price"]
        
        keyboard = []
        max_affordable = min(100, user_data["stars"] // price) if price > 0 else 100
        
        if max_affordable == 0:
            await query.edit_message_text(
                messages["buy_weapon_failure"].format(
                    stars=format_number(user_data["stars"]),
                    total_price=format_number(price)
                ),
                reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton("🔙 بازگشت", callback_data=f"shop_select_country_{COUNTRY_CODES[country_name]}")]])
            )
            return
        
        for qty in [1, 5, 10, 25, 50]:
            if qty <= max_affordable:
                total_price = qty * price
                keyboard.append([InlineKeyboardButton(
                    f"{qty} عدد ({format_number(total_price)} ⭐)",
                    callback_data=f"confirm_buy_weapon_{COUNTRY_CODES[country_name]}_{WEAPON_CODES[weapon_id]}_{qty}"
                )])
        
        text = f"🛒 خرید {weapon_data['name']} برای {country_name}\n\n"
        text += f"📊 قدرت: +{weapon_data['power']}\n"
        text += f"💰 قیمت واحد: {format_number(price)} ستاره\n"
        text += f"📝 {weapon_data['description']}\n"
        text += f"💳 موجودی شما: {format_number(user_data['stars'])} ستاره\n\n"
        text += "لطفاً تعداد مورد نظر را انتخاب کنید:"
        
        keyboard.append([InlineKeyboardButton("🔙 بازگشت", callback_data=f"shop_select_country_{COUNTRY_CODES[country_name]}")])
        
        await query.edit_message_text(
            text,
            reply_markup=InlineKeyboardMarkup(keyboard)
        )
    
    elif query.data.startswith("confirm_buy_weapon_"):
        parts = query.data.replace("confirm_buy_weapon_", "").split("_")
        country_code = parts[0]
        weapon_code = parts[1]
        quantity = int(parts[2])
        
        country_name = reverse_country_codes.get(country_code)
        weapon_id = reverse_weapon_codes.get(weapon_code)
        
        if not country_name or country_name not in user_data["countries"]:
            await query.edit_message_text("این کشور متعلق به شما نیست!")
            return
        
        if not weapon_id or weapon_id not in WEAPONS_AND_DEFENSE:
            await query.edit_message_text("این سلاح موجود نیست!")
            return
        
        weapon_data = WEAPONS_AND_DEFENSE[weapon_id]
        total_price = weapon_data["price"] * quantity
        
        if user_data["stars"] < total_price:
            await query.edit_message_text(
                messages["buy_weapon_failure"].format(
                    stars=format_number(user_data["stars"]),
                    total_price=format_number(total_price)
                ),
                reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton("🔙 بازگشت", callback_data=f"shop_select_country_{COUNTRY_CODES[country_name]}")]])
            )
            return
        
        user_data["stars"] -= total_price
        country_data = user_data["countries"][country_name]
        country_data["ammo_counts"] = country_data.get("ammo_counts", {})
        
        power_increase = weapon_data["power"] * quantity
        if weapon_data["type"] == "weapon":
            country_data["ammo_counts"][weapon_id] = country_data["ammo_counts"].get(weapon_id, 0) + quantity
        else:  # defense
            country_data["defense_houses"] = country_data.get("defense_houses", 0) + power_increase
        
        save_data()
        
        try:
            user = await context.bot.get_chat(user_id)
            user_name = user.first_name or "کاربر"
            await notify_channel(context, f"🛒 {user_name} {quantity} عدد {weapon_data['name']} برای {country_name} خرید! 💰 هزینه: {format_number(total_price)} ستاره")
        except:
            pass
        
        await query.edit_message_text(
            messages["buy_weapon_success"].format(
                weapon_name=weapon_data["name"],
                quantity=quantity,
                power_increase=format_number(power_increase),
                total_price=format_number(total_price),
                stars=format_number(user_data["stars"])
            ),
            reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton("🔙 منوی اصلی", callback_data="back_to_menu")]])
        )
    
    elif query.data.startswith("buy_mine_"):
        parts = query.data.replace("buy_mine_", "").split("_")
        country_code = parts[0]
        mine_id = parts[1]
        
        country_name = reverse_country_codes.get(country_code)
        
        if not country_name or country_name not in user_data["countries"]:
            await query.edit_message_text("این کشور متعلق به شما نیست!")
            return
        
        if mine_id not in AVAILABLE_MINES:
            await query.edit_message_text("این معدن وجود ندارد!")
            return
        
        mine_data = AVAILABLE_MINES[mine_id]
        price = mine_data["price"]
        
        keyboard = []
        max_affordable = min(100, user_data["stars"] // price) if price > 0 else 100
        
        if max_affordable == 0:
            await query.edit_message_text(
                messages["buy_mine_failure"].format(
                    stars=format_number(user_data["stars"]),
                    mine_name=mine_data["name"],
                    price=format_number(price)
                ),
                reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton("🔙 بازگشت", callback_data=f"mine_select_country_{COUNTRY_CODES[country_name]}")]])
            )
            return
        
        for qty in [1, 5, 10, 25, 50]:
            if qty <= max_affordable:
                total_price = qty * price
                keyboard.append([InlineKeyboardButton(
                    f"{qty} عدد ({format_number(total_price)} ⭐)",
                    callback_data=f"confirm_buy_mine_{COUNTRY_CODES[country_name]}_{mine_id}_{qty}"
                )])
        
        text = f"⛏️ خرید {mine_data['name']} برای {country_name}\n\n"
        text += f"📊 تولید روزانه: {format_number(mine_data['daily_stars'])} ستاره\n"
        text += f"💰 قیمت واحد: {format_number(price)} ستاره\n"
        text += f"💳 موجودی شما: {format_number(user_data['stars'])} ستاره\n\n"
        text += "لطفاً تعداد مورد نظر را انتخاب کنید:"
        
        keyboard.append([InlineKeyboardButton("🔙 بازگشت", callback_data=f"mine_select_country_{COUNTRY_CODES[country_name]}")])
        
        await query.edit_message_text(
            text,
            reply_markup=InlineKeyboardMarkup(keyboard)
        )
    
    elif query.data.startswith("confirm_buy_mine_"):
        parts = query.data.replace("confirm_buy_mine_", "").split("_")
        country_code = parts[0]
        mine_id = parts[1]
        quantity = int(parts[2])
        
        country_name = reverse_country_codes.get(country_code)
        
        if not country_name or country_name not in user_data["countries"]:
            await query.edit_message_text("این کشور متعلق به شما نیست!")
            return
        
        if mine_id not in AVAILABLE_MINES:
            await query.edit_message_text("این معدن وجود ندارد!")
            return
        
        mine_data = AVAILABLE_MINES[mine_id]
        total_price = mine_data["price"] * quantity
        
        if user_data["stars"] < total_price:
            await query.edit_message_text(
                messages["buy_mine_failure"].format(
                    stars=format_number(user_data["stars"]),
                    mine_name=mine_data["name"],
                    price=format_number(total_price)
                ),
                reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton("🔙 بازگشت", callback_data=f"mine_select_country_{COUNTRY_CODES[country_name]}")]])
            )
            return
        
        user_data["stars"] -= total_price
        country_data = user_data["countries"][country_name]
        country_data["mines"] = country_data.get("mines", {})
        country_data["mines"][mine_id] = country_data["mines"].get(mine_id, 0) + quantity
        save_data()
        
        try:
            user = await context.bot.get_chat(user_id)
            user_name = user.first_name or "کاربر"
            await notify_channel(context, f"⛏️ {user_name} {quantity} عدد {mine_data['name']} برای {country_name} خرید! 💰 هزینه: {format_number(total_price)} ستاره")
        except:
            pass
        
        await query.edit_message_text(
            messages["buy_mine_success"].format(
                mine_name=mine_data["name"],
                quantity=quantity,
                daily_stars=format_number(mine_data["daily_stars"] * quantity),
                total_price=format_number(total_price),
                stars=format_number(user_data["stars"])
            ),
            reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton("🔙 منوی اصلی", callback_data="back_to_menu")]])
        )
    
    elif query.data.startswith("attack_with_"):
        country_code = query.data.replace("attack_with_", "")
        country_name = reverse_country_codes.get(country_code)
        
        if not country_name or country_name not in user_data["countries"]:
            await query.edit_message_text("این کشور متعلق به شما نیست!")
            return
        
        await show_target_countries(update, context, country_name)
    
    elif query.data.startswith("select_target_"):
        parts = query.data.replace("select_target_", "").split("_")
        attacker_code = parts[0]
        target_code = parts[1]
        target_owner_id = parts[2]
        
        attacker_country = reverse_country_codes.get(attacker_code)
        target_country = reverse_country_codes.get(target_code)
        
        if not attacker_country or attacker_country not in user_data["countries"]:
            await query.edit_message_text("کشور مهاجم متعلق به شما نیست!")
            return
        
        target_user_id = None
        for uid, data in user_id_map.items():
            if data == target_owner_id:
                target_user_id = int(uid)
                break
        
        if not target_user_id or target_user_id not in users_data or target_country not in users_data[target_user_id]["countries"]:
            await query.edit_message_text("کشور هدف معتبر نیست!")
            return
        
        country_data = user_data["countries"][attacker_country]
        ammo_counts = country_data.get("ammo_counts", {})
        
        keyboard = []
        for weapon_id, count in ammo_counts.items():
            if count > 0 and weapon_id in WEAPONS_AND_DEFENSE and WEAPONS_AND_DEFENSE[weapon_id]["type"] == "weapon":
                weapon_name = WEAPONS_AND_DEFENSE[weapon_id]["name"]
                keyboard.append([InlineKeyboardButton(
                    f"⚔️ {weapon_name} ({count} عدد)",
                    callback_data=f"select_weapon_{COUNTRY_CODES[attacker_country]}_{COUNTRY_CODES[target_country]}_{target_owner_id}_{WEAPON_CODES[weapon_id]}"
                )])
        
        if not keyboard:
            await query.edit_message_text(
                messages["attack_failure"],
                reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton("🔙 بازگشت", callback_data=f"attack_with_{COUNTRY_CODES[attacker_country]}")]])
            )
            return
        
        keyboard.append([InlineKeyboardButton("🔙 بازگشت", callback_data=f"attack_with_{COUNTRY_CODES[attacker_country]}")])
        
        await query.edit_message_text(
            f"⚔️ انتخاب سلاح برای حمله به {target_country}:",
            reply_markup=InlineKeyboardMarkup(keyboard)
        )
    
    elif query.data.startswith("select_weapon_"):
        parts = query.data.replace("select_weapon_", "").split("_")
        attacker_code = parts[0]
        target_code = parts[1]
        target_owner_id = parts[2]
        weapon_code = parts[3]
        
        attacker_country = reverse_country_codes.get(attacker_code)
        target_country = reverse_country_codes.get(target_code)
        weapon_id = reverse_weapon_codes.get(weapon_code)
        
        if not attacker_country or attacker_country not in user_data["countries"]:
            await query.edit_message_text("کشور مهاجم متعلق به شما نیست!")
            return
        
        target_user_id = None
        for uid, data in user_id_map.items():
            if data == target_owner_id:
                target_user_id = int(uid)
                break
        
        if not target_user_id or target_user_id not in users_data or target_country not in users_data[target_user_id]["countries"]:
            await query.edit_message_text("کشور هدف معتبر نیست!")
            return
        
        if not weapon_id or weapon_id not in WEAPONS_AND_DEFENSE or WEAPONS_AND_DEFENSE[weapon_id]["type"] != "weapon":
            await query.edit_message_text("سلاح انتخاب‌شده معتبر نیست!")
            return
        
        weapon_data = WEAPONS_AND_DEFENSE[weapon_id]
        country_data = user_data["countries"][attacker_country]
        available_count = country_data["ammo_counts"].get(weapon_id, 0)
        
        if available_count == 0:
            await query.edit_message_text(
                messages["attack_failure"],
                reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton("🔙 بازگشت", callback_data=f"select_target_{COUNTRY_CODES[attacker_country]}_{COUNTRY_CODES[target_country]}_{target_owner_id}")]])
            )
            return
        
        keyboard = []
        for qty in sorted(QUANTITY_CODES.keys()):
            if qty <= available_count:
                keyboard.append([InlineKeyboardButton(
                    f"{qty} عدد",
                    callback_data=f"confirm_attack_{COUNTRY_CODES[attacker_country]}_{COUNTRY_CODES[target_country]}_{target_owner_id}_{WEAPON_CODES[weapon_id]}_{QUANTITY_CODES[qty]}"
                )])
        
        keyboard.append([InlineKeyboardButton("🔙 بازگشت", callback_data=f"select_target_{COUNTRY_CODES[attacker_country]}_{COUNTRY_CODES[target_country]}_{target_owner_id}")])
        
        await query.edit_message_text(
            f"⚔️ تعداد {weapon_data['name']} برای حمله به {target_country}:\n"
            f"موجودی: {available_count} عدد\n\n"
            f"لطفاً تعداد مورد نظر را انتخاب کنید:",
            reply_markup=InlineKeyboardMarkup(keyboard)
        )
    
    elif query.data.startswith("confirm_attack_"):
        parts = query.data.replace("confirm_attack_", "").split("_")
        attacker_code = parts[0]
        target_code = parts[1]
        target_owner_id = parts[2]
        weapon_code = parts[3]
        quantity_code = parts[4]
        
        attacker_country = reverse_country_codes.get(attacker_code)
        target_country = reverse_country_codes.get(target_code)
        weapon_id = reverse_weapon_codes.get(weapon_code)
        quantity = REVERSE_QUANTITY_CODES.get(quantity_code)
        
        if not attacker_country or attacker_country not in user_data["countries"]:
            await query.edit_message_text("کشور مهاجم متعلق به شما نیست!")
            return
        
        target_user_id = None
        for uid, data in user_id_map.items():
            if data == target_owner_id:
                target_user_id = int(uid)
                break
        
        if not target_user_id or target_user_id not in users_data or target_country not in users_data[target_user_id]["countries"]:
            await query.edit_message_text("کشور هدف معتبر نیست!")
            return
        
        if not weapon_id or weapon_id not in WEAPONS_AND_DEFENSE or WEAPONS_AND_DEFENSE[weapon_id]["type"] != "weapon":
            await query.edit_message_text("سلاح انتخاب‌شده معتبر نیست!")
            return
        
        if not quantity:
            await query.edit_message_text("تعداد نامعتبر است!")
            return
        
        country_data = user_data["countries"][attacker_country]
        available_count = country_data["ammo_counts"].get(weapon_id, 0)
        
        if available_count < quantity:
            await query.edit_message_text(
                messages["attack_failure"],
                reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton("🔙 بازگشت", callback_data=f"select_target_{COUNTRY_CODES[attacker_country]}_{COUNTRY_CODES[target_country]}_{target_owner_id}")]])
            )
            return
        
        weapon_data = WEAPONS_AND_DEFENSE[weapon_id]
        attack_power = weapon_data["power"] * quantity
        target_data = users_data[target_user_id]["countries"][target_country]
        base_houses = AVAILABLE_COUNTRIES.get(target_country, 1000)
        
        damage = int(attack_power * random.uniform(0.5, 1.0))
        damage = min(damage, target_data.get("total_houses", base_houses))
        
        stars_won = int(damage * random.uniform(5, 10))
        user_data["stars"] += stars_won
        users_data[target_user_id]["stars"] -= min(stars_won, users_data[target_user_id]["stars"])
        
        target_data["total_houses"] = max(0, target_data.get("total_houses", base_houses) - damage)
        country_data["ammo_counts"][weapon_id] -= quantity
        if country_data["ammo_counts"][weapon_id] == 0:
            del country_data["ammo_counts"][weapon_id]
        
        save_data()
        
        try:
            attacker_user = await context.bot.get_chat(user_id)
            attacker_name = attacker_user.first_name or "کاربر"
            target_user = await context.bot.get_chat(target_user_id)
            target_user_name = target_user.first_name or "کاربر"
            
            await context.bot.send_message(
                target_user_id,
                messages["under_attack"].format(
                    target_country=target_country,
                    attacker_country=attacker_country,
                    damage=format_number(damage)
                )
            )
            
            await notify_channel(context, messages["channel_attack_notification"].format(
                user_name=attacker_name,
                attacker_country=attacker_country,
                target_country=target_country,
                damage=format_number(damage)
            ))
            
            if target_data["total_houses"] <= 0:
                del users_data[target_user_id]["countries"][target_country]
                user_data["countries"][target_country] = {
                    "total_houses": base_houses,
                    "defense_houses": 0,
                    "ammo_counts": {},
                    "mines": {}
                }
                save_data()
                
                await context.bot.send_message(
                    target_user_id,
                    f"🏴 کشور {target_country} شما فتح شد!"
                )
                
                await notify_channel(context, messages["channel_country_destroyed"].format(
                    target_country=target_country,
                    attacker_country=attacker_country,
                    target_user_name=target_user_name
                ))
        
        except:
            pass
        
        await query.edit_message_text(
            messages["attack_success"].format(
                attacker_country=attacker_country,
                target_country=target_country,
                weapon_name=weapon_data["name"],
                quantity=quantity,
                attack_power=format_number(attack_power),
                damage=format_number(damage),
                stars_won=format_number(stars_won),
                stars=format_number(user_data["stars"])
            ),
            reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton("🔙 منوی اصلی", callback_data="back_to_menu")]])
        )
    
    elif query.data == "back_to_menu":
        await query.message.delete()
        await start(update, context)

async def message_handler(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Handle incoming messages"""
    user_id = update.effective_user.id
    text = update.message.text
    
    if user_id == ADMIN_ID:
        if "admin_edit_weapon" in context.user_data:
            try:
                price, power = map(int, text.split())
                weapon_id = context.user_data["admin_edit_weapon"]
                WEAPONS_AND_DEFENSE[weapon_id]["price"] = price
                WEAPONS_AND_DEFENSE[weapon_id]["power"] = power
                save_data()
                await update.message.reply_text(
                    f"✅ {WEAPONS_AND_DEFENSE[weapon_id]['name']} به‌روزرسانی شد!\n"
                    f"قیمت جدید: {format_number(price)} ستاره\n"
                    f"قدرت جدید: {power}",
                    reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton("🔙 بازگشت", callback_data="admin_edit_weapons")]])
                )
                del context.user_data["admin_edit_weapon"]
            except:
                await update.message.reply_text("فرمت اشتباه! لطفاً قیمت و قدرت را به صورت عدد وارد کنید (مثال: 100 200)")
        
        elif "admin_create_weapon" in context.user_data:
            try:
                name, power, type_, price, description = text.split("/", 4)
                power = int(power)
                price = int(price)
                weapon_id = name.replace(" ", "_").lower()
                WEAPONS_AND_DEFENSE[weapon_id] = {
                    "name": name,
                    "power": power,
                    "type": type_.strip(),
                    "price": price,
                    "description": description.strip()
                }
                WEAPON_CODES[weapon_id] = weapon_id[:2].upper() + str(len(WEAPON_CODES) + 1)
                save_data()
                await update.message.reply_text(
                    f"✅ مهمات جدید اضافه شد!\n"
                    f"نام: {name}\n"
                    f"قدرت: {power}\n"
                    f"نوع: {type_}\n"
                    f"قیمت: {format_number(price)} ستاره\n"
                    f"توضیح: {description}",
                    reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton("🔙 بازگشت", callback_data="admin_weapons")]])
                )
                del context.user_data["admin_create_weapon"]
            except:
                await update.message.reply_text("فرمت اشتباه! لطفاً اطلاعات را به درستی وارد کنید (مثال: موشک جدید/150/weapon/75/موشک تهاجمی جدید)")
        
        elif "admin_edit_mine" in context.user_data:
            try:
                price, daily_stars = map(int, text.split())
                mine_id = context.user_data["admin_edit_mine"]
                AVAILABLE_MINES[mine_id]["price"] = price
                AVAILABLE_MINES[mine_id]["daily_stars"] = daily_stars
                save_data()
                await update.message.reply_text(
                    f"✅ {AVAILABLE_MINES[mine_id]['name']} به‌روزرسانی شد!\n"
                    f"قیمت جدید: {format_number(price)} ستاره\n"
                    f"تولید روزانه: {format_number(daily_stars)} ستاره",
                    reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton("🔙 بازگشت", callback_data="admin_edit_mines")]])
                )
                del context.user_data["admin_edit_mine"]
            except:
                await update.message.reply_text("فرمت اشتباه! لطفاً قیمت و تولید روزانه را به صورت عدد وارد کنید (مثال: 5000 1000)")
        
        elif "admin_create_mine" in context.user_data:
            try:
                name, daily_stars, price = text.split("/")
                daily_stars = int(daily_stars)
                price = int(price)
                mine_id = name.replace(" ", "_").lower()
                AVAILABLE_MINES[mine_id] = {
                    "name": name,
                    "daily_stars": daily_stars,
                    "price": price
                }
                save_data()
                await update.message.reply_text(
                    f"✅ معدن جدید اضافه شد!\n"
                    f"نام: {name}\n"
                    f"تولید روزانه: {format_number(daily_stars)} ستاره\n"
                    f"قیمت: {format_number(price)} ستاره",
                    reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton("🔙 بازگشت", callback_data="admin_mines")]])
                )
                del context.user_data["admin_create_mine"]
            except:
                await update.message.reply_text("فرمت اشتباه! لطفاً اطلاعات را به درستی وارد کنید (مثال: معدن الماس/2000/10000)")
        
        elif "admin_transfer_stars" in context.user_data:
            try:
                target_user_id, stars = map(int, text.split())
                if target_user_id not in users_data:
                    await update.message.reply_text("کاربر مورد نظر یافت نشد!")
                    return
                users_data[target_user_id]["stars"] += stars
                save_data()
                try:
                    target_user = await context.bot.get_chat(target_user_id)
                    target_user_name = target_user.first_name or "کاربر"
                    await context.bot.send_message(target_user_id, f"💰 شما {format_number(stars)} ستاره از ادمین دریافت کردید!")
                    await notify_channel(context, f"💰 {target_user_name} {format_number(stars)} ستاره از ادمین دریافت کرد!")
                except:
                    pass
                await update.message.reply_text(
                    f"✅ {format_number(stars)} ستاره به کاربر {target_user_id} منتقل شد!",
                    reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton("🔙 بازگشت", callback_data="admin_users")]])
                )
                del context.user_data["admin_transfer_stars"]
            except:
                await update.message.reply_text("فرمت اشتباه! لطفاً آیدی کاربر و مقدار ستاره را وارد کنید (مثال: 123456789 5000)")
        
        elif "admin_reset_user" in context.user_data:
            try:
                target_user_id = int(text)
                if target_user_id not in users_data:
                    await update.message.reply_text("کاربر مورد نظر یافت نشد!")
                    return
                users_data[target_user_id] = {
                    "countries": {},
                    "stars": 500,
                    "last_mine_collect": None
                }
                save_data()
                try:
                    target_user = await context.bot.get_chat(target_user_id)
                    target_user_name = target_user.first_name or "کاربر"
                    await context.bot.send_message(target_user_id, "🔄 حساب شما توسط ادمین بازنشانی شد!")
                    await notify_channel(context, f"🔄 حساب {target_user_name} توسط ادمین بازنشانی شد!")
                except:
                    pass
                await update.message.reply_text(
                    f"✅ حساب کاربر {target_user_id} بازنشانی شد!",
                    reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton("🔙 بازگشت", callback_data="admin_users")]])
                )
                del context.user_data["admin_reset_user"]
            except:
                await update.message.reply_text("فرمت اشتباه! لطفاً آیدی کاربر را به صورت عدد وارد کنید (مثال: 123456789)")
        
        elif "admin_broadcast" in context.user_data:
            for uid in users_data.keys():
                try:
                    await context.bot.send_message(uid, f"📢 اعلان عمومی:\n{text}")
                except:
                    pass
            await notify_channel(context, f"📢 اعلان عمومی:\n{text}")
            await update.message.reply_text(
                "✅ اعلان عمومی ارسال شد!",
                reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton("🔙 بازگشت", callback_data="admin_panel")]])
            )
            del context.user_data["admin_broadcast"]
        
        elif "admin_edit_message" in context.user_data:
            message_id = context.user_data["admin_edit_message"]
            if message_id not in messages:
                await update.message.reply_text("این پیام وجود ندارد!")
                return
            messages[message_id] = text
            save_data()
            await update.message.reply_text(
                f"✅ پیام {message_id} به‌روزرسانی شد:\n{text}",
                reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton("🔙 بازگشت", callback_data="admin_edit_messages")]])
            )
            del context.user_data["admin_edit_message"]
        
        elif "admin_create_message" in context.user_data:
            try:
                message_id, message_text = text.split("/", 1)
                message_id = message_id.strip()
                if message_id in messages:
                    await update.message.reply_text("این شناسه پیام قبلاً وجود دارد!")
                    return
                messages[message_id] = message_text.strip()
                save_data()
                await update.message.reply_text(
                    f"✅ پیام جدید اضافه شد!\nشناسه: {message_id}\nمتن: {message_text}",
                    reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton("🔙 بازگشت", callback_data="admin_messages")]])
                )
                del context.user_data["admin_create_message"]
            except:
                await update.message.reply_text("فرمت اشتباه! لطفاً اطلاعات را به درستی وارد کنید (مثال: welcome_message/خوش آمدید {user_name}!)")
        
        else:
            if text == "🛠️ پنل مدیریت":
                await admin_panel(update, context)
            elif text == "🌍 کشورهای برتر":
                await show_top_countries(update, context)
            elif text == "🛒 خرید کشور":
                await show_buy_country(update, context)
            elif text == "🛠️ فروشگاه مهمات":
                await show_weapons_shop(update, context)
            elif text == "⚔️ حمله":
                await show_attack_menu(update, context)
            elif text == "🌐 وضعیت کشور من":
                await show_country_status(update, context)
            elif text == "⛏️ مدیریت معادن":
                await show_mines_shop(update, context)
            elif text == "⛏️ جمع‌آوری ستاره":
                await collect_mine_stars(update, context)
            elif text == "💬 چت عمومی":
                await update.message.reply_text("لطفاً پیام خود را با دستور /chat ارسال کنید. مثال:\n/chat سلام به همه!")
    
    else:
        if text == "🌍 کشورهای برتر":
            await show_top_countries(update, context)
        elif text == "🛒 خرید کشور":
            await show_buy_country(update, context)
        elif text == "🛠️ فروشگاه مهمات":
            await show_weapons_shop(update, context)
        elif text == "⚔️ حمله":
            await show_attack_menu(update, context)
        elif text == "🌐 وضعیت کشور من":
            await show_country_status(update, context)
        elif text == "⛏️ مدیریت معادن":
            await show_mines_shop(update, context)
        elif text == "⛏️ جمع‌آوری ستاره":
            await collect_mine_stars(update, context)
        elif text == "💬 چت عمومی":
            await update.message.reply_text("لطفاً پیام خود را با دستور /chat ارسال کنید. مثال:\n/chat سلام به همه!")

def main():
    """Start the bot"""
    load_data()
    
    application = Application.builder().token(token).build()
    
    application.add_handler(CommandHandler("start", start))
    application.add_handler(CommandHandler("chat", chat_handler))
    application.add_handler(CallbackQueryHandler(callback_query_handler))
    application.add_handler(MessageHandler(filters.TEXT & ~filters.COMMAND, message_handler))
    
    application.run_polling()

if __name__ == "__main__":
    main()