Upload 4 files

app.py

@@ -0,0 +1,78 @@
+from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel
+from typing import Optional
+from database import get_car_by_id, get_all_cars, create_car
+from transformers import pipeline
+from cachetools import TTLCache
+import logging
+
+app = FastAPI()
+cache = TTLCache(maxsize=200, ttl=300)  # Increased maxsize to 200
+generator = None
+
+class Car(BaseModel):
+    model: str
+    price: float
+    status: str
+    description: Optional[str] = None
+
+def load_generator():
+    global generator
+    if generator is None:
+        try:
+            generator = pipeline('text-generation', model='aubmindlab/aragpt2-base')
+            logging.info("Successfully loaded AraGPT2 model")
+        except Exception as e:
+            logging.error(f"Failed to load AraGPT2 model: {str(e)}")
+            raise
+    return generator
+
+@app.post("/cars/")
+async def add_car(car: Car):
+    car_id = create_car(car.model, car.price, car.status, car.description)
+    return {"id": car_id, **car.dict()}
+
+@app.get("/cars/")
+async def list_cars():
+    cached_result = cache.get("all_cars")
+    if cached_result:
+        return cached_result
+    cars = get_all_cars()
+    cache["all_cars"] = cars
+    return cars
+
+@app.get("/cars/{car_id}")
+async def get_car(car_id: int):
+    car = get_car_by_id(car_id)
+    if not car:
+        raise HTTPException(status_code=404, detail="السيارة مو موجودة")
+    return car
+
+@app.get("/car_info/")
+async def get_car_info(model: str):
+    cars = get_all_cars()
+    available_cars = [car for car in cars if car['model'].lower() == model.lower()]
+    
+    if not available_cars:
+        prompt = f"ما اعرف هذا الموديل '{model}'، ممكن تكلي شنو تعرف عنه؟"
+        try:
+            gen = load_generator()
+            response = gen(prompt, max_length=100, num_return_sequences=1)[0]['generated_text']
+            return {"message": response}
+        except Exception as e:
+            logging.error(f"Error generating response for unknown model: {str(e)}")
+            return {"message": "عذرًا، حدث خطأ أثناء توليد الرد."}
+    
+    car = available_cars[0]
+    prompt = f"زبون يريد يعرف عن سيارة {car['model']}، سعرها {car['price']} ووضعها {car['status']}، كله بلهجة عراقية طبيعية."
+    try:
+        gen = load_generator()
+        response = gen(prompt, max_length=150, num_return_sequences=1)[0]['generated_text']
+        return {"message": response}
+    except Exception as e:
+        logging.error(f"Error generating response for car info: {str(e)}")
+        return {"message": "عذرًا، حدث خطأ أثناء توليد الرد."}
+
+@app.get("/")
+async def root():
+    return {"message": "CarBot API is running!"}

database.py

@@ -0,0 +1,422 @@
+import sqlite3
+import random
+import string
+import logging
+import re
+from typing import List, Dict, Any, Optional
+from datetime import datetime
+
+# Configure logging
+logging.basicConfig(
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    level=logging.INFO,
+    handlers=[
+        logging.FileHandler("bot.log", encoding='utf-8'),
+        logging.StreamHandler()
+    ]
+)
+logger = logging.getLogger(__name__)
+
+class Database:
+    def __init__(self, db_name: str = "cars.db"):
+        try:
+            self.conn = sqlite3.connect(db_name, check_same_thread=False)
+            self.cursor = self.conn.cursor()
+            self.create_tables()
+            self.update_schema()
+            logger.info(f"Successfully connected to database: {db_name}")
+        except sqlite3.Error as e:
+            logger.error(f"Failed to connect to database: {str(e)}")
+            raise
+
+    def create_tables(self):
+        try:
+            self.cursor.executescript('''
+                -- Table for users
+                CREATE TABLE IF NOT EXISTS users (
+                    user_id INTEGER PRIMARY KEY,
+                    username TEXT,
+                    phone TEXT,
+                    shares INTEGER DEFAULT 0,
+                    daily_recommendations INTEGER DEFAULT 0,
+                    last_recommendation_date TEXT
+                );
+
+                -- Table for ads
+                CREATE TABLE IF NOT EXISTS ads (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    user_id INTEGER,
+                    price TEXT,
+                    car_name_ar TEXT,
+                    car_name_en TEXT,
+                    model TEXT,
+                    engine_specs TEXT,
+                    mileage TEXT,
+                    origin TEXT,
+                    plate TEXT,
+                    accidents TEXT,
+                    specs TEXT,
+                    notes TEXT,
+                    location TEXT,
+                    phone TEXT,
+                    main_photo TEXT,
+                    photos TEXT,
+                    status TEXT DEFAULT 'pending',
+                    channel_message_id INTEGER,
+                    created_at TEXT,
+                    reactions TEXT DEFAULT '',
+                    FOREIGN KEY(user_id) REFERENCES users(user_id)
+                );
+
+                -- Table for verification codes
+                CREATE TABLE IF NOT EXISTS verification_codes (
+                    user_id INTEGER,
+                    phone TEXT,
+                    code TEXT,
+                    PRIMARY KEY(user_id, phone)
+                );
+
+                -- Table for reactions
+                CREATE TABLE IF NOT EXISTS reactions (
+                    ad_id INTEGER,
+                    reaction_type TEXT,
+                    count INTEGER,
+                    last_updated TEXT,
+                    PRIMARY KEY(ad_id, reaction_type),
+                    FOREIGN KEY(ad_id) REFERENCES ads(id)
+                );
+
+                -- Table for stats
+                CREATE TABLE IF NOT EXISTS stats (
+                    id INTEGER PRIMARY KEY,
+                    subscribers_count INTEGER DEFAULT 1300,
+                    last_updated TEXT
+                );
+
+                -- Insert default stats
+                INSERT OR IGNORE INTO stats (id, subscribers_count) VALUES (1, 1300);
+
+                -- Indexes for faster queries
+                CREATE INDEX IF NOT EXISTS idx_ads_user_id ON ads(user_id);
+                CREATE INDEX IF NOT EXISTS idx_ads_status ON ads(status);
+                CREATE INDEX IF NOT EXISTS idx_ads_car_name_ar ON ads(car_name_ar);
+                CREATE INDEX IF NOT EXISTS idx_ads_location ON ads(location);
+                CREATE INDEX IF NOT EXISTS idx_users_phone ON users(phone);
+                CREATE INDEX IF NOT EXISTS idx_ads_created_at ON ads(created_at);  # Added index on created_at
+            ''')
+            self.conn.commit()
+            logger.info("Database tables and indexes created successfully")
+        except sqlite3.Error as e:
+            logger.error(f"Error creating tables: {str(e)}")
+            raise
+
+    def update_schema(self):
+        try:
+            # Check if 'username' column exists in users table
+            self.cursor.execute("PRAGMA table_info(users)")
+            columns = [info[1] for info in self.cursor.fetchall()]
+            if 'username' not in columns:
+                self.cursor.execute('ALTER TABLE users ADD COLUMN username TEXT')
+                self.conn.commit()
+                logger.info("Added 'username' column to users table")
+        except sqlite3.Error as e:
+            logger.error(f"Error updating schema: {str(e)}")
+            raise
+
+    def add_user(self, user_id: int, username: Optional[str] = None):
+        try:
+            self.cursor.execute('''
+                INSERT OR IGNORE INTO users (user_id, username, shares, daily_recommendations)
+                VALUES (?, ?, 0, 0)
+            ''', (user_id, username))
+            self.cursor.execute('''
+                UPDATE stats SET subscribers_count = subscribers_count + 1, last_updated = ?
+                WHERE id = 1
+            ''', (datetime.now().strftime('%Y-%m-%d %H:%M:%S'),))
+            self.conn.commit()
+            logger.info(f"User {user_id} (username: {username}) added/updated")
+        except sqlite3.Error as e:
+            logger.error(f"Error adding user {user_id}: {str(e)}")
+            raise
+
+    def get_user_shares(self, user_id: int) -> int:
+        try:
+            self.cursor.execute('SELECT shares FROM users WHERE user_id = ?', (user_id,))
+            result = self.cursor.fetchone()
+            return result[0] if result else 0
+        except sqlite3.Error as e:
+            logger.error(f"Error retrieving shares for user {user_id}: {str(e)}")
+            return 0
+
+    def increment_shares(self, user_id: int):
+        try:
+            self.cursor.execute('UPDATE users SET shares = shares + 1 WHERE user_id = ?', (user_id,))
+            self.conn.commit()
+            logger.info(f"Shares incremented for user {user_id}")
+        except sqlite3.Error as e:
+            logger.error(f"Error incrementing shares for user {user_id}: {str(e)}")
+
+    def get_daily_recommendations(self, user_id: int) -> int:
+        try:
+            self.cursor.execute('SELECT daily_recommendations, last_recommendation_date FROM users WHERE user_id = ?', (user_id,))
+            result = self.cursor.fetchone()
+            if result:
+                count, date = result
+                today = datetime.now().strftime('%Y-%m-%d')
+                if date != today:
+                    self.cursor.execute('UPDATE users SET daily_recommendations = 0, last_recommendation_date = ? WHERE user_id = ?', (today, user_id))
+                    self.conn.commit()
+                    logger.info(f"Reset daily recommendations for user {user_id} to 0")
+                    return 0
+                return count
+            return 0
+        except sqlite3.Error as e:
+            logger.error(f"Error retrieving daily recommendations for user {user_id}: {str(e)}")
+            return 0
+
+    def increment_recommendations(self, user_id: int):
+        try:
+            today = datetime.now().strftime('%Y-%m-%d')
+            self.cursor.execute('''
+                UPDATE users SET daily_recommendations = daily_recommendations + 1,
+                last_recommendation_date = ? WHERE user_id = ?
+            ''', (today, user_id))
+            self.conn.commit()
+            logger.info(f"Recommendations incremented for user {user_id}")
+        except sqlite3.Error as e:
+            logger.error(f"Error incrementing recommendations for user {user_id}: {str(e)}")
+
+    def generate_verification_code(self, user_id: int, phone: str) -> str:
+        try:
+            code = ''.join(random.choices(string.digits, k=6))
+            self.cursor.execute('INSERT OR REPLACE INTO verification_codes (user_id, phone, code) VALUES (?, ?, ?)',
+                               (user_id, phone, code))
+            self.conn.commit()
+            logger.info(f"Generated verification code for user {user_id} with phone {phone}")
+            return code
+        except sqlite3.Error as e:
+            logger.error(f"Error generating verification code for user {user_id}: {str(e)}")
+            raise
+
+    def verify_phone_code(self, user_id: int, code: str) -> bool:
+        try:
+            self.cursor.execute('SELECT code FROM verification_codes WHERE user_id = ?', (user_id,))
+            result = self.cursor.fetchone()
+            if result and result[0] == code:
+                self.cursor.execute('DELETE FROM verification_codes WHERE user_id = ?', (user_id,))
+                self.conn.commit()
+                logger.info(f"Phone code verified for user {user_id}")
+                return True
+            logger.warning(f"Invalid phone code for user {user_id}")
+            return False
+        except sqlite3.Error as e:
+            logger.error(f"Error verifying phone code for user {user_id}: {str(e)}")
+            return False
+
+    def create_car(self, model: str, price: float, status: str, description: Optional[str] = None) -> int:
+        try:
+            created_at = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+            self.cursor.execute('''
+                INSERT INTO ads (price, car_name_ar, car_name_en, model, status, notes, created_at)
+                VALUES (?, ?, ?, ?, ?, ?, ?)
+            ''', (
+                str(price), model, model, model, status, description, created_at
+            ))
+            ad_id = self.cursor.lastrowid
+            self.conn.commit()
+            logger.info(f"Created car ad {ad_id} with model {model}")
+            return ad_id
+        except sqlite3.Error as e:
+            logger.error(f"Error creating car ad: {str(e)}")
+            raise
+
+    def get_car_by_id(self, car_id: int) -> Optional[Dict[str, Any]]:
+        try:
+            self.cursor.execute('SELECT id, price, car_name_ar AS model, status, notes AS description, created_at FROM ads WHERE id = ?', (car_id,))
+            car = self.cursor.fetchone()
+            if car:
+                columns = [desc[0] for desc in self.cursor.description]
+                car_dict = dict(zip(columns, car))
+                logger.info(f"Retrieved car {car_id}")
+                return car_dict
+            logger.warning(f"Car {car_id} not found")
+            return None
+        except sqlite3.Error as e:
+            logger.error(f"Error retrieving car {car_id}: {str(e)}")
+            raise
+
+    def get_all_cars(self) -> List[Dict[str, Any]]:
+        try:
+            self.cursor.execute('SELECT id, price, car_name_ar AS model, status, notes AS description, created_at FROM ads WHERE status = "approved"')
+            cars = self.cursor.fetchall()
+            columns = [desc[0] for desc in self.cursor.description]
+            cars_list = [dict(zip(columns, car)) for car in cars]
+            logger.info(f"Retrieved {len(cars_list)} approved cars")
+            return cars_list
+        except sqlite3.Error as e:
+            logger.error(f"Error retrieving all cars: {str(e)}")
+            raise
+
+    def save_ad(self, ad_data: Dict[str, Any], user_id: int) -> int:
+        try:
+            created_at = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+            self.cursor.execute('''
+                INSERT INTO ads (user_id, price, car_name_ar, car_name_en, model, engine_specs, mileage, origin, plate,
+                                accidents, specs, notes, location, phone, main_photo, photos, created_at)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            ''', (
+                user_id, ad_data['price'], ad_data['car_name_ar'], ad_data['car_name_en'], ad_data['model'],
+                ad_data['engine_specs'], ad_data['mileage'], ad_data['origin'], ad_data['plate'], ad_data['accidents'],
+                ad_data['specs'], ad_data.get('notes'), ad_data['location'], ad_data['phone'], ad_data['main_photo'],
+                ','.join(ad_data['photos']), created_at
+            ))
+            ad_id = self.cursor.lastrowid
+            self.conn.commit()
+            logger.info(f"Ad {ad_id} saved for user {user_id}")
+            return ad_id
+        except sqlite3.Error as e:
+            logger.error(f"Error saving ad for user {user_id}: {str(e)}")
+            raise
+
+    def get_ad(self, ad_id: int) -> Optional[Dict[str, Any]]:
+        try:
+            self.cursor.execute('SELECT * FROM ads WHERE id = ?', (ad_id,))
+            ad = self.cursor.fetchone()
+            if ad:
+                columns = [desc[0] for desc in self.cursor.description]
+                ad_dict = dict(zip(columns, ad))
+                ad_dict['photos'] = ad_dict['photos'].split(',') if ad_dict['photos'] else []
+                logger.info(f"Retrieved ad {ad_id}")
+                return ad_dict
+            logger.warning(f"Ad {ad_id} not found")
+            return None
+        except sqlite3.Error as e:
+            logger.error(f"Error retrieving ad {ad_id}: {str(e)}")
+            raise
+
+    def update_ad_field(self, ad_id: int, field: str, value: Any):
+        try:
+            self.cursor.execute(f'UPDATE ads SET {field} = ? WHERE id = ?', (value, ad_id))
+            self.conn.commit()
+            logger.info(f"Updated field {field} for ad {ad_id}")
+        except sqlite3.Error as e:
+            logger.error(f"Error updating field {field} for ad {ad_id}: {str(e)}")
+            raise
+
+    def update_ad_status(self, ad_id: int, status: str):
+        try:
+            self.cursor.execute('UPDATE ads SET status = ? WHERE id = ?', (status, ad_id))
+            self.conn.commit()
+            logger.info(f"Updated status to {status} for ad {ad_id}")
+        except sqlite3.Error as e:
+            logger.error(f"Error updating status for ad {ad_id}: {str(e)}")
+            raise
+
+    def get_available_cars(self, user_id: Optional[int] = None) -> List[Dict[str, Any]]:
+        try:
+            if user_id:
+                self.cursor.execute('SELECT * FROM ads WHERE status = "approved" AND user_id = ?', (user_id,))
+            else:
+                self.cursor.execute('SELECT * FROM ads WHERE status = "approved"')
+            ads = self.cursor.fetchall()
+            columns = [desc[0] for desc in self.cursor.description]
+            result = []
+            for ad in ads:
+                ad_dict = dict(zip(columns, ad))
+                ad_dict['photos'] = ad_dict['photos'].split(',') if ad_dict['photos'] else []
+                result.append(ad_dict)
+            logger.info(f"Retrieved {len(result)} available cars")
+            return result
+        except sqlite3.Error as e:
+            logger.error(f"Error retrieving available cars: {str(e)}")
+            raise
+
+    def save_channel_message(self, ad_id: int, message_id: int):
+        try:
+            self.cursor.execute('UPDATE ads SET channel_message_id = ? WHERE id = ?', (message_id, ad_id))
+            self.conn.commit()
+            logger.info(f"Saved channel message ID {message_id} for ad {ad_id}")
+        except sqlite3.Error as e:
+            logger.error(f"Error saving channel message for ad {ad_id}: {str(e)}")
+            raise
+
+    def get_total_users(self) -> int:
+        try:
+            self.cursor.execute("SELECT subscribers_count FROM stats WHERE id = 1")
+            result = self.cursor.fetchone()
+            count = result[0] if result else 1300
+            logger.info(f"Retrieved total users: {count}")
+            return count
+        except sqlite3.Error as e:
+            logger.error(f"Error retrieving total users: {str(e)}")
+            return 1300
+
+    def search_ads(self, query: str) -> List[Dict[str, Any]]:
+        try:
+            query = query.lower().strip()
+            search_terms = re.split(r'\s+', query)
+            conditions = ["status = 'approved'"]
+            params = []
+
+            for term in search_terms:
+                if term.isdigit() and len(term) == 4:  # Model year (e.g., 2020)
+                    conditions.append("model LIKE ?")
+                    params.append(f"%{term}%")
+                elif re.match(r'(\d+\.?\d*)\s*(دولار|دينار|-)?(?:\s*(\d+\.?\d*))?', term):  # Price or range (e.g., 20 دولار, 20-30)
+                    price_match = re.match(r'(\d+\.?\d*)\s*(دولار|دينار|-)?(?:\s*(\d+\.?\d*))?', term)
+                    if price_match:
+                        low_price = float(price_match.group(1))
+                        currency = price_match.group(2)
+                        high_price = float(price_match.group(3)) if price_match.group(3) else None
+                        if currency == '-':
+                            conditions.append("CAST(replace(replace(price, '$', ''), ' ألف دولار', '000') AS REAL) BETWEEN ? AND ?")
+                            params.extend([low_price * 1000, high_price * 1000])
+                        else:
+                            conditions.append("LOWER(price) LIKE ?")
+                            params.append(f'%{low_price}%{currency if currency else ""}%')
+                else:  # Car name, location, or specs
+                    conditions.append("(LOWER(car_name_ar) LIKE ? OR LOWER(car_name_en) LIKE ? OR LOWER(location) LIKE ? OR LOWER(specs) LIKE ?)")
+                    params.extend([f"%{term}%", f"%{term}%", f"%{term}%", f"%{term}%"])
+
+            where_clause = " AND ".join(conditions) if conditions else "1=1"
+            self.cursor.execute(f'SELECT * FROM ads WHERE {where_clause}', params)
+            ads = self.cursor.fetchall()
+            columns = [desc[0] for desc in self.cursor.description]
+            result = [dict(zip(columns, ad)) for ad in ads]
+            for ad in result:
+                ad['photos'] = ad['photos'].split(',') if ad['photos'] else []
+            logger.info(f"Found {len(result)} ads for query: {query}")
+            return result
+        except sqlite3.Error as e:
+            logger.error(f"Error searching ads for query {query}: {str(e)}")
+            raise
+
+    def add_reaction(self, ad_id: int, ad: Dict[str, Any]):
+        try:
+            from utils import generate_reactions
+            reactions = generate_reactions(ad)
+            self.cursor.execute('UPDATE ads SET reactions = ? WHERE id = ?', (reactions, ad_id))
+            self.conn.commit()
+            logger.info(f"Added reactions for ad {ad_id}")
+        except sqlite3.Error as e:
+            logger.error(f"Error adding reactions for ad {ad_id}: {str(e)}")
+            raise
+        except ImportError:
+            logger.error(f"Failed to import generate_reactions from utils for ad {ad_id}")
+            raise
+
+    def extend_ad_duration(self, ad_id: int):
+        try:
+            self.cursor.execute('UPDATE ads SET status = "approved" WHERE id = ?', (ad_id,))
+            self.conn.commit()
+            logger.info(f"Extended duration for ad {ad_id}")
+        except sqlite3.Error as e:
+            logger.error(f"Error extending duration for ad {ad_id}: {str(e)}")
+            raise
+
+    def close(self):
+        try:
+            self.conn.close()
+            logger.info("Database connection closed successfully")
+        except sqlite3.Error as e:
+            logger.error(f"Error closing database: {str(e)}")

main.py

@@ -0,0 +1,566 @@
+import os
+import random
+import logging
+from datetime import datetime, timedelta
+from telegram import Update, InlineKeyboardButton, InlineKeyboardMarkup
+from telegram.ext import (
+    Application,
+    CommandHandler,
+    MessageHandler,
+    CallbackQueryHandler,
+    ContextTypes,
+    filters,
+)
+from telegram.error import TelegramError
+from dotenv import load_dotenv
+import requests
+from enum import Enum
+from database import Database
+from utils import (
+    escape_markdown,
+    generate_positive_message,
+    format_ad,
+    validate_phone,
+    send_admin_notification,
+    post_to_channel,
+    delete_channel_post,
+    generate_reactions,
+)
+
+# Logging setup
+logging.basicConfig(
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    level=logging.INFO,
+    handlers=[
+        logging.FileHandler("bot.log", encoding='utf-8'),
+        logging.StreamHandler()
+    ]
+)
+logger = logging.getLogger(__name__)
+
+# Load environment variables
+load_dotenv()
+TELEGRAM_TOKEN = os.getenv("TELEGRAM_TOKEN")
+ADMIN_CHAT_ID = os.getenv("ADMIN_CHAT_ID")
+CHANNEL_ID = os.getenv("CHANNEL_ID")
+SUPPORT_USERNAME = os.getenv("SUPPORT_USERNAME", "@Support")
+
+# API endpoint for CarBot (update this to the public URL of your Space)
+CARBOT_API_URL = "https://imstevenleo-carbot-mixtral.hf.space/chat"  # Change to your Space URL
+
+# Initialize database
+db = Database()
+
+# تعريف الحالات باستخدام enum لتجنب الأخطاء
+class UserState(Enum):
+    AD_INTRO = "ad_intro"
+    AD_CAR_NAME_AR = "ad_car_name_ar"
+    AD_CAR_NAME_EN = "ad_car_name_en"
+    AD_PRICE = "ad_price"
+    AD_MODEL = "ad_model"
+    AD_ENGINE_SPECS = "ad_engine_specs"
+    AD_MILEAGE = "ad_mileage"
+    AD_ORIGIN = "ad_origin"
+    AD_PLATE = "ad_plate"
+    AD_ACCIDENTS = "ad_accidents"
+    AD_SPECS = "ad_specs"
+    AD_NOTES = "ad_notes"
+    AD_LOCATION = "ad_location"
+    AD_PHONE = "ad_phone"
+    AD_PHOTOS = "ad_photos"
+    SEARCHING_AD = "searching_ad"
+    CAR_GPT = "car_gpt"
+    ADMIN_EDIT = "admin_edit"
+
+# Start command
+async def start(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    user_id = str(update.effective_user.id)
+    username = update.effective_user.username or "غير معروف"
+    logger.info(f"User {user_id} ({username}) started the bot")
+    db.add_user(user_id, username)
+
+    keyboard = [
+        [InlineKeyboardButton("🚗 إضافة إعلان", callback_data="add_ad")],
+        [InlineKeyboardButton("🔍 البحث عن سيارة", callback_data="search_ad")],
+        [InlineKeyboardButton("🤖 توصية من CarBot", callback_data="car_gpt")],
+        [InlineKeyboardButton("📊 إعلاناتي", callback_data="my_ads")]
+    ]
+    if user_id == ADMIN_CHAT_ID:
+        keyboard.append([InlineKeyboardButton("👩‍💼 لوحة التحكم", callback_data="admin_dashboard")])
+
+    message = f"مرحبًا {escape_markdown(username)}\! 😍 {escape_markdown(generate_positive_message())}\nاختري خيار:"
+    await update.message.reply_text(
+        message,
+        reply_markup=InlineKeyboardMarkup(keyboard),
+        parse_mode='MarkdownV2'
+    )
+
+# Button callback handler
+async def button_callback(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    query = update.callback_query
+    await query.answer()
+    user_id = str(query.from_user.id)
+    data = query.data
+    logger.info(f"Button callback: {data} by user {user_id}")
+
+    if data == "main_menu":
+        await start(update, context)
+        return
+
+    if data == "add_ad":
+        context.user_data["state"] = UserState.AD_INTRO.value
+        context.user_data["ad"] = {}
+        context.user_data["photos"] = []
+        intro_message = (
+            "📢 *إضافة إعلان جديد*\n"
+            "لإضافة إعلان، بنحتاج منك المعلومات التالية:\n"
+            "1. اسم السيارة بالعربي\n"
+            "2. اسم السيارة بالإنجليزي\n"
+            "3. السعر\n"
+            "4. الموديل\n"
+            "5. المحرك\n"
+            "6. عداد الأميال\n"
+            "7. الوارد\n"
+            "8. رقم السيارة\n"
+            "9. الحوادث\n"
+            "10. المواصفات\n"
+            "11. الملاحظات\n"
+            "12. الموقع\n"
+            "13. رقم الهاتف\n"
+            "14. صور السيارة (1-5 صور)\n\n"
+            "📌 بناخد المعلومات خطوة بخطوة. هل أنتِ جاهزة؟"
+        )
+        keyboard = [
+            [InlineKeyboardButton("نعم، جاهزة!", callback_data="ad_ready")],
+            [InlineKeyboardButton("لا، رجعيني للقائمة", callback_data="main_menu")]
+        ]
+        await query.message.reply_text(
+            escape_markdown(intro_message),
+            reply_markup=InlineKeyboardMarkup(keyboard),
+            parse_mode='MarkdownV2'
+        )
+        return
+
+    if data == "ad_ready":
+        context.user_data["state"] = UserState.AD_CAR_NAME_AR.value
+        await query.message.reply_text(
+            escape_markdown("📝 أكتبي اسم السيارة بالعربي (مثل: تويوتا كورولا):"),
+            reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton("🏠 القائمة", callback_data="main_menu")]]),
+            parse_mode='MarkdownV2'
+        )
+        return
+
+    if data == "search_ad":
+        context.user_data["state"] = UserState.SEARCHING_AD.value
+        await query.message.reply_text(
+            escape_markdown("🔍 أكتبي تفاصيل البحث (مثل: تويوتا، 2020، بغداد، 20-30 ألف دولار):"),
+            reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton("🏠 القائمة", callback_data="main_menu")]]),
+            parse_mode='MarkdownV2'
+        )
+        return
+
+    if data == "car_gpt":
+        context.bot_data.setdefault("car_gpt_active", {})[user_id] = True
+        context.user_data["state"] = UserState.CAR_GPT.value
+        await query.message.reply_text(
+            escape_markdown("🤖 أكتبي طلبك لـ CarBot (مثل: سيارة رخيصة 50 ورقة):\nاكتبي 'قائمة' للرجوع."),
+            reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton("🏠 القائمة", callback_data="main_menu")]]),
+            parse_mode='MarkdownV2'
+        )
+        return
+
+    if data == "my_ads":
+        ads = db.get_user_ads(user_id)
+        if not ads:
+            await query.message.reply_text(
+                escape_markdown("😔 ما عندك إعلانات! جربي تضيفي إعلان جديد."),
+                reply_markup=InlineKeyboardMarkup([
+                    [InlineKeyboardButton("🚗 إضافة إعلان", callback_data="add_ad")],
+                    [InlineKeyboardButton("🏠 القائمة", callback_data="main_menu")]
+               Shadow]),
+                parse_mode='MarkdownV2'
+            )
+            return
+        for ad in ads:
+            await query.message.reply_text(
+                format_ad(ad),
+                parse_mode='MarkdownV2',
+                reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton("🏠 القائمة", callback_data="main_menu")]])
+            )
+        return
+
+    if data == "admin_dashboard" and user_id == ADMIN_CHAT_ID:
+        stats = db.get_stats()
+        message = f"📊 *لوحة التحكم:*\n👥 *المستخدمين*: {stats['users']}\n🚗 *الإعلانات*: {stats['ads']}\n🔎 *التوصيات*: {stats.get('recommendations', 0)}"
+        await query.message.reply_text(
+            escape_markdown(message),
+            parse_mode='MarkdownV2',
+            reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton("🏠 القائمة", callback_data="main_menu")]])
+        )
+        return
+
+    if data.startswith("admin_approve_") and user_id == ADMIN_CHAT_ID:
+        ad_id = data[len("admin_approve_"):]
+        try:
+            ad = db.get_ad(ad_id)
+            ad['reactions'] = generate_reactions(ad)
+            message_id = await post_to_channel(context, CHANNEL_ID, format_ad(ad), ad.get('photos', [None])[0])
+            if message_id:
+                db.update_ad_status(ad_id, "approved", message_id=message_id)
+                context.job_queue.run_once(
+                    delete_channel_post,
+                    when=timedelta(days=30),
+                    data={"ad_id": ad_id, "message_id": message_id, "channel_id": CHANNEL_ID},
+                    name=f"delete_ad_{ad_id}"
+                )
+                await query.message.reply_text(escape_markdown(f"✅ تم الموافقة على الإعلان {ad_id}\\!"), parse_mode='MarkdownV2')
+                logger.info(f"Ad {ad_id} approved by admin {user_id}")
+            else:
+                await query.message.reply_text(escape_markdown(f"❌ خطأ بنشر الإعلان! تواصلي مع \\{SUPPORT_USERNAME}\\!"), parse_mode='MarkdownV2')
+                logger.error(f"Failed to post ad {ad_id}")
+        except Exception as e:
+            logger.error(f"Error approving ad {ad_id}: {str(e)}")
+            await query.message.reply_text(escape_markdown(f"❌ فشل الموافقة! تواصلي مع \\{SUPPORT_USERNAME}\\!"), parse_mode='MarkdownV2')
+        return
+
+    if data.startswith("admin_reject_") and user_id == ADMIN_CHAT_ID:
+        ad_id = data[len("admin_reject_"):]
+        try:
+            db.update_ad_status(ad_id, "rejected")
+            await query.message.reply_text(escape_markdown(f"🗑️ تم رفض الإعلان {ad_id}\\!"), parse_mode='MarkdownV2')
+            logger.info(f"Ad {ad_id} rejected by admin {user_id}")
+        except Exception as e:
+            logger.error(f"Error rejecting ad {ad_id}: {str(e)}")
+            await query.message.reply_text(escape_markdown(f"❌ خطأ برفض الإعلان! تواصلي مع \\{SUPPORT_USERNAME}\\!"), parse_mode='MarkdownV2')
+        return
+
+    if data.startswith("admin_edit_ad_") and user_id == ADMIN_CHAT_ID:
+        ad_id = data[len("admin_edit_ad_"):]
+        context.user_data["state"] = UserState.ADMIN_EDIT.value + f"_{ad_id}"
+        context.user_data["ad_id"] = ad_id
+        await query.message.reply_text(
+            escape_markdown(f"📝 أكتبي التعديلات للإعلان (ID: {ad_id}):"),
+            reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton("🏠 القائمة", callback_data="main_menu")]]),
+            parse_mode='MarkdownV2'
+        )
+        return
+
+    await query.message.reply_text(
+        escape_markdown("❓ خيار غير معروف! جربي من القائمة:"),
+        reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton("🏠 القائمة", callback_data="main_menu")]]),
+        parse_mode='MarkdownV2'
+    )
+
+# CarBot recommendation generator using API
+async def generate_car_recommendation(user_input: str) -> str:
+    try:
+        response = requests.post(CARBOT_API_URL, json={"message": user_input})
+        response.raise_for_status()
+        return response.json()["response"]
+    except requests.exceptions.RequestException as e:
+        logger.error(f"API request failed: {str(e)}")
+        return await generate_fallback_recommendation(user_input)
+    except Exception as e:
+        logger.error(f"Unexpected error in generate_car_recommendation: {str(e)}")
+        return await generate_fallback_recommendation(user_input)
+
+# Fallback recommendation
+async def generate_fallback_recommendation(user_input: str) -> str:
+    cars = [
+        {"name": "كيا أوبتيما", "price": "20-30 ألف دولار", "type": "سيدان", "location": "بغداد"},
+        {"name": "تويوتا كورولا", "price": "18-25 ألف دولار", "type": "سيدان", "location": "البصرة"},
+        {"name": "هيونداي توسان", "price": "25-35 ألف دولار", "type": "دفع رباعي", "location": "أربيل"}
+    ]
+    message = (
+        f"🔍 ما لقيت نتايج دقيقة لـ '{escape_markdown(user_input)}'، بس أنصحك بهي السيارات الشائعة بالعراق:\n\n" +
+        "\n".join([f"🚗 *{c['name']}*: {c['price']} \\({c['type']}\\) \\- متوفرة بـ {c['location']}" for c in cars]) +
+        f"\n📌 الذكاء الاصطناعي غير متاح حاليًا! جربي طلب ثاني أو تواصلي مع \\{SUPPORT_USERNAME}\\!"
+    )
+    return message
+
+# Message handler
+async def handle_message(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    user_id = str(update.effective_user.id)
+    state = context.user_data.get("state")
+    logger.info(f"Message from user {user_id} in state {state}")
+
+    if update.message.photo and state == UserState.AD_PHOTOS.value:
+        if len(context.user_data["photos"]) >= 5:
+            await update.message.reply_text(
+                escape_markdown("❌ وصلتِ للحد الأقصى (5 صور)! أرسلي 'تم' للمتابعة أو 'قائمة' للرجوع:"),
+                parse_mode='MarkdownV2',
+                reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton("🏠 القائمة", callback_data="main_menu")]])
+            )
+            return
+        context.user_data["photos"].append(update.message.photo[-1].file_id)
+        await update.message.reply_text(
+            escape_markdown(f"📸 تم استلام صورة ({len(context.user_data['photos'])}/5). أرسلي صورة ثانية أو اكتبي 'تم' إذا خلّصتِ:"),
+            parse_mode='MarkdownV2',
+            reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton("🏠 القائمة", callback_data="main_menu")]])
+        )
+        return
+
+    if not update.message.text:
+        await update.message.reply_text(
+            escape_markdown("❌ أرسلي نص أو صورة حسب الخطوة!"),
+            parse_mode='MarkdownV2',
+            reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton("🏠 القائمة", callback_data="main_menu")]])
+        )
+        return
+
+    text = update.message.text.strip()
+    logger.info(f"Message from user {user_id} in state {state}: {text}")
+
+    if state == UserState.CAR_GPT.value:
+        if text.lower() == "قائمة":
+            await start(update, context)
+            return
+        recommendation = await generate_car_recommendation(text)
+        await update.message.reply_text(
+            escape_markdown(recommendation),
+            parse_mode='MarkdownV2',
+            reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton("🏠 القائمة", callback_data="main_menu")]])
+        )
+        return
+
+    if state == UserState.SEARCHING_AD.value:
+        ads = db.search_ads(text)
+        if not ads:
+            await update.message.reply_text(
+                escape_markdown("😔 ما لقيت إعلانات تطابق بحثك! جربي كلمات ثانية:"),
+                parse_mode='MarkdownV2',
+                reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton("🏠 القائمة", callback_data="main_menu")]])
+            )
+            return
+        for ad in ads:
+            await update.message.reply_text(
+                format_ad(ad),
+                parse_mode='MarkdownV2',
+                reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton("🏠 القائمة", callback_data="main_menu")]])
+            )
+        return
+
+    if state == UserState.AD_CAR_NAME_AR.value:
+        context.user_data["ad"]["car_name_ar"] = text
+        context.user_data["state"] = UserState.AD_CAR_NAME_EN.value
+        await update.message.reply_text(
+            escape_markdown("📝 أكتبي اسم السيارة بالإنجليزي (مثل: Toyota Corolla):"),
+            parse_mode='MarkdownV2',
+            reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton("🏠 القائمة", callback_data="main_menu")]])
+        )
+        return
+
+    if state == UserState.AD_CAR_NAME_EN.value:
+        context.user_data["ad"]["car_name_en"] = text
+        context.user_data["state"] = UserState.AD_PRICE.value
+        await update.message.reply_text(
+            escape_markdown("💰 أكتبي السعر (مثل: 25 ألف دولار):"),
+            parse_mode='MarkdownV2',
+            reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton("🏠 القائمة", callback_data="main_menu")]])
+        )
+        return
+
+    if state == UserState.AD_PRICE.value:
+        # تحقق بسيط إن السعر يحتوي على أرقام
+        if not any(char.isdigit() for char in text):
+            await update.message.reply_text(
+                escape_markdown("❌ السعر لازم يحتوي على أرقام! جربي مرة ثانية:"),
+                parse_mode='MarkdownV2',
+                reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton("🏠 القائمة", callback_data="main_menu")]])
+            )
+            return
+        context.user_data["ad"]["price"] = text
+        context.user_data["state"] = UserState.AD_MODEL.value
+        await update.message.reply_text(
+            escape_markdown("📅 أكتبي الموديل (مثل: 2020):"),
+            parse_mode='MarkdownV2',
+            reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton("🏠 القائمة", callback_data="main_menu")]])
+        )
+        return
+
+    if state == UserState.AD_MODEL.value:
+        # تحقق بسيط إن الموديل رقم
+        if not text.isdigit():
+            await update.message.reply_text(
+                escape_markdown("❌ الموديل لازم يكون رقم! جربي مرة ثانية:"),
+                parse_mode='MarkdownV2',
+                reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton("🏠 القائمة", callback_data="main_menu")]])
+            )
+            return
+        context.user_data["ad"]["model"] = text
+        context.user_data["state"] = UserState.AD_ENGINE_SPECS.value
+        await update.message.reply_text(
+            escape_markdown("⚙️ أكتبي مواصفات المحرك (مثل: 1.8L):"),
+            parse_mode='MarkdownV2',
+            reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton("🏠 القائمة", callback_data="main_menu")]])
+        )
+        return
+
+    if state == UserState.AD_ENGINE_SPECS.value:
+        context.user_data["ad"]["engine_specs"] = text
+        context.user_data["state"] = UserState.AD_MILEAGE.value
+        await update.message.reply_text(
+            escape_markdown("🛣️ أكتبي عداد الأميال (مثل: 50 ألف كم):"),
+            parse_mode='MarkdownV2',
+            reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton("🏠 القائمة", callback_data="main_menu")]])
+        )
+        return
+
+    if state == UserState.AD_MILEAGE.value:
+        context.user_data["ad"]["mileage"] = text
+        context.user_data["state"] = UserState.AD_ORIGIN.value
+        await update.message.reply_text(
+            escape_markdown("🌎 أكتبي الوارد (مثل: أمريكي):"),
+            parse_mode='MarkdownV2',
+            reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton("🏠 القائمة", callback_data="main_menu")]])
+        )
+        return
+
+    if state == UserState.AD_ORIGIN.value:
+        context.user_data["ad"]["origin"] = text
+        context.user_data["state"] = UserState.AD_PLATE.value
+        await update.message.reply_text(
+            escape_markdown("🔢 أكتبي رقم السيارة (مثل: بغداد 123):"),
+            parse_mode='MarkdownV2',
+            reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton("🏠 القائمة", callback_data="main_menu")]])
+        )
+        return
+
+    if state == UserState.AD_PLATE.value:
+        context.user_data["ad"]["plate"] = text
+        context.user_data["state"] = UserState.AD_ACCIDENTS.value
+        await update.message.reply_text(
+            escape_markdown("🚨 أكتبي حالة الحوادث (مثل: بدون حوادث):"),
+            parse_mode='MarkdownV2',
+            reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton("🏠 القائمة", callback_data="main_menu")]])
+        )
+        return
+
+    if state == UserState.AD_ACCIDENTS.value:
+        context.user_data["ad"]["accidents"] = text
+        context.user_data["state"] = UserState.AD_SPECS.value
+        await update.message.reply_text(
+            escape_markdown("🛠️ أكتبي المواصفات (مثل: فل مواصفات):"),
+            parse_mode='MarkdownV2',
+            reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton("🏠 القائمة", callback_data="main_menu")]])
+        )
+        return
+
+    if state == UserState.AD_SPECS.value:
+        context.user_data["ad"]["specs"] = text
+        context.user_data["state"] = UserState.AD_NOTES.value
+        await update.message.reply_text(
+            escape_markdown("📋 أكتبي الملاحظات (مثل: نظيفة، أو اتركيها فاضية إذا ما في):"),
+            parse_mode='MarkdownV2',
+            reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton("🏠 القائمة", callback_data="main_menu")]])
+        )
+        return
+
+    if state == UserState.AD_NOTES.value:
+        context.user_data["ad"]["notes"] = text if text else "غير محدد"
+        context.user_data["state"] = UserState.AD_LOCATION.value
+        await update.message.reply_text(
+            escape_markdown("📍 أكتبي الموقع (مثل: بغداد):"),
+            parse_mode='MarkdownV2',
+            reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton("🏠 القائمة", callback_data="main_menu")]])
+        )
+        return
+
+    if state == UserState.AD_LOCATION.value:
+        context.user_data["ad"]["location"] = text
+        context.user_data["state"] = UserState.AD_PHONE.value
+        await update.message.reply_text(
+            escape_markdown("📞 أكتبي رقم الهاتف (مثال: +9647712345678):"),
+            parse_mode='MarkdownV2',
+            reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton("🏠 القائمة", callback_data="main_menu")]])
+        )
+        return
+
+    if state == UserState.AD_PHONE.value:
+        phone_number, error_message = validate_phone(text)
+        if not phone_number:
+            await update.message.reply_text(
+                escape_markdown(error_message),
+                parse_mode='MarkdownV2',
+                reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton("🏠 القائمة", callback_data="main_menu")]])
+            )
+            logger.warning(f"Invalid phone by user {user_id}: {text}")
+            return
+        context.user_data["ad"]["phone"] = phone_number
+        context.user_data["state"] = UserState.AD_PHOTOS.value
+        await update.message.reply_text(
+            escape_markdown("📸 أرسلي صور السيارة (من 1 إلى 5 صور). أرسلي صورة واحدة في كل رسالة، وبعد ما تخلّصي أرسلي 'تم':"),
+            parse_mode='MarkdownV2',
+            reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton("🏠 القائمة", callback_data="main_menu")]])
+        )
+        return
+
+    if state == UserState.AD_PHOTOS.value:
+        if text.lower() == "تم":
+            if not context.user_data["photos"]:
+                await update.message.reply_text(
+                    escape_markdown("❌ لازم ترسلي صورة وحدة على الأقل! أرسلي صورة أو اكتبي 'قائمة' للرجوع:"),
+                    parse_mode='MarkdownV2',
+                    reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton("🏠 القائمة", callback_data="main_menu")]])
+                )
+                return
+            ad = context.user_data["ad"]
+            ad["photos"] = context.user_data["photos"]
+            ad["user_id"] = user_id
+            ad["created_at"] = datetime.now()
+            ad_id = db.add_ad(ad)
+            await send_admin_notification(
+                context.bot,
+                ADMIN_CHAT_ID,
+                f"إعلان جديد من {escape_markdown(update.effective_user.username or 'غير معروف')}:\n{format_ad(ad)}",
+                ad_id
+            )
+            await update.message.reply_text(
+                escape_markdown("✅ تم إرسال الإعلان للمراجعة! بنخبرك لما ينعتمد."),
+                parse_mode='MarkdownV2',
+                reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton("🏠 القائمة", callback_data="main_menu")]])
+            )
+            context.user_data.clear()
+            return
+
+    if state and state.startswith(UserState.ADMIN_EDIT.value):
+        ad_id = context.user_data.get("ad_id")
+        try:
+            updates = {}
+            for field_value in text.split("\n"):
+                if ":" in field_value:
+                    field, value = field_value.split(":", 1)
+                    updates[field.strip()] = value.strip()
+            db.update_ad(ad_id, updates)
+            await update.message.reply_text(
+                escape_markdown(f"✅ تم تعديل الإعلان {ad_id}\\!"),
+                parse_mode='MarkdownV2',
+                reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton("🏠 القائمة", callback_data="main_menu")]])
+            )
+            context.user_data.clear()
+        except Exception as e:
+            logger.error(f"Error editing ad {ad_id}: {str(e)}")
+            await update.message.reply_text(
+                escape_markdown(f"❌ خطأ بتعديل الإعلان! تواصلي مع \\{SUPPORT_USERNAME}\\!"),
+                parse_mode='MarkdownV2'
+            )
+        return
+
+    await update.message.reply_text(
+        escape_markdown("❓ أكتبي شي يناسب الخطوة أو ارجعي للقائمة!"),
+        parse_mode='MarkdownV2',
+        reply_markup=InlineKeyboardMarkup([[InlineKeyboardButton("🏠 القائمة", callback_data="main_menu")]])
+    )
+
+# Main function to run the bot
+def main():
+    application = Application.builder().token(TELEGRAM_TOKEN).build()
+
+    application.add_handler(CommandHandler("start", start))
+    application.add_handler(CallbackQueryHandler(button_callback))
+    application.add_handler(MessageHandler(filters.ALL & ~filters.COMMAND, handle_message))
+
+    application.run_polling(allowed_updates=Update.ALL_TYPES)
+
+if __name__ == "__main__":
+    main()

utils.py

@@ -0,0 +1,147 @@
+import re
+import random
+from telegram import InlineKeyboardButton, InlineKeyboardMarkup
+from telegram.error import TelegramError
+import logging
+from typing import Dict, Any, Optional, Tuple
+
+logging.basicConfig(
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    level=logging.INFO,
+    handlers=[
+        logging.FileHandler("bot.log", encoding='utf-8'),
+        logging.StreamHandler()
+    ]
+)
+logger = logging.getLogger(__name__)
+
+def escape_markdown(text: str) -> str:
+    if not text:
+        return ""
+    # إضافة دعم للهروب من المزيد من الأحرف الخاصة في MarkdownV2
+    escape_chars = r'_*[]()~`>#+=|{.!-}'
+    return ''.join(f'\\{char}' if char in escape_chars else char for char in str(text))
+
+def generate_positive_message() -> str:
+    messages = [
+        "🚗 يلا نلقى سيارة أحلامك! 😍",
+        "💥 جاهزة لأحلى صفقة بالعراق! 🌟",
+        "🔥 بيع وشراء السيارات صار متعة! 🚘",
+        "😎 مع CarBot، كل شي أسهل! 💨"
+    ]
+    return random.choice(messages)
+
+def format_ad(ad: Dict[str, Any]) -> str:
+    if not ad:
+        return escape_markdown("❌ لا توجد بيانات!")
+    reactions = ad.get('reactions', '')
+    photos = ad.get('photos', [])
+    photo_count = len(photos) if photos else 0
+    fields = [
+        f"*السيارة*: {escape_markdown(ad.get('car_name_ar', ''))} \\({escape_markdown(ad.get('car_name_en', ''))}\\)",
+        f"*السعر*: {escape_markdown(ad.get('price', ''))}",
+        f"*الموديل*: {escape_markdown(ad.get('model', ''))}",
+        f"*المحرك*: {escape_markdown(ad.get('engine_specs', ''))}",
+        f"*عداد الأميال*: {escape_markdown(ad.get('mileage', ''))}",
+        f"*الوارد*: {escape_markdown(ad.get('origin', ''))}",
+        f"*رقم السيارة*: {escape_markdown(ad.get('plate', ''))}",
+        f"*الحوادث*: {escape_markdown(ad.get('accidents', ''))}",
+        f"*المواصفات*: {escape_markdown(ad.get('specs', ''))}",
+        f"*الملاحظات*: {escape_markdown(ad.get('notes', 'غير محدد'))}",
+        f"*الموقع*: {escape_markdown(ad.get('location', ''))}",
+        f"*رقم الهاتف*: {escape_markdown(ad.get('phone', ''))}",
+        f"*عدد الصور*: {photo_count}",
+        f"{reactions}"
+    ]
+    return "\n".join(fields)
+
+def validate_phone(phone: str) -> Tuple[Optional[str], Optional[str]]:
+    if not phone:
+        logger.warning("Empty phone number provided")
+        return None, "❌ أدخلي رقم هاتف صحيح (مثال: +9647712345678)"
+    try:
+        arabic_to_latin = str.maketrans('٠١٢٣٤٥٦٧٨٩', '0123456789')
+        phone = phone.translate(arabic_to_latin)
+        phone = re.sub(r'[\s\-]', '', phone)
+        # تحقق إضافي للتأكد إن الرقم يبدأ بـ +964 أو 0
+        if not (phone.startswith('+964') or phone.startswith('0')):
+            return None, "❌ الرقم لازم يبدأ بـ +964 أو 0! جربي مرة ثانية"
+        pattern = r'^(\+964|0)(77[0-7]|78[0-9]|79[0-9]|75[0-1][0-9])[0-9]{7}$'
+        if re.match(pattern, phone):
+            if not phone.startswith('+964'):
+                phone = '+964' + phone.lstrip('0')
+            return phone, None
+        logger.warning(f"Invalid phone number format: {phone}")
+        return None, "❌ رقم غير صحيح! جربي مثال: +9647712345678"
+    except Exception as e:
+        logger.error(f"Error validating phone number: {str(e)}")
+        return None, "❌ خطأ بالتحقق من الرقم! جربي مرة ثانية"
+
+async def send_admin_notification(bot, admin_id: str, message: str, ad_id: Optional[int] = None):
+    if not admin_id:
+        logger.error("Admin chat ID not set")
+        return
+    try:
+        keyboard = []
+        if ad_id:
+            keyboard.append([
+                InlineKeyboardButton("✅ الموافقة", callback_data=f"admin_approve_{ad_id}"),
+                InlineKeyboardButton("❌ الرفض", callback_data=f"admin_reject_{ad_id}"),
+                InlineKeyboardButton("✏️ تعديل", callback_data=f"admin_edit_ad_{ad_id}")
+            ])
+        await bot.send_message(
+            chat_id=admin_id,
+            text=escape_markdown(message),
+            reply_markup=InlineKeyboardMarkup(keyboard),
+            parse_mode='MarkdownV2'
+        )
+        logger.info(f"Admin notification sent: {message}")
+    except TelegramError as e:
+        logger.error(f"Failed to send admin notification: {str(e)}")
+
+async def post_to_channel(context, channel_id: str, ad_text: str, photo: Optional[str] = None) -> Optional[int]:
+    try:
+        if photo:
+            message = await context.bot.send_photo(
+                chat_id=channel_id,
+                photo=photo,
+                caption=ad_text,
+                parse_mode='MarkdownV2'
+            )
+        else:
+            message = await context.bot.send_message(
+                chat_id=channel_id,
+                text=ad_text,
+                parse_mode='MarkdownV2'
+            )
+        logger.info(f"Posted to channel {channel_id}: {message.message_id}")
+        return message.message_id
+    except TelegramError as e:
+        logger.error(f"Failed to post to channel {channel_id}: {str(e)}")
+        return None
+
+async def delete_channel_post(context):
+    from database import Database
+    try:
+        job_data = context.job.data
+        await context.bot.delete_message(
+            chat_id=job_data["channel_id"],
+            message_id=job_data["message_id"]
+        )
+        db = Database()
+        db.update_ad_status(job_data["ad_id"], "expired")
+        logger.info(f"Deleted channel post {job_data['message_id']} for ad {job_data['ad_id']}")
+    except TelegramError as e:
+        logger.error(f"Failed to delete channel post: {str(e)}")
+
+def generate_reactions(ad: Dict[str, Any]) -> str:
+    reactions = ['👍', '❤️', '⭐', '🔥']
+    try:
+        price = float(re.sub(r'[^\d.]', '', ad.get('price', '0')))
+        num_reactions = random.randint(5, min(15, int(price / 1000)))
+        selected_reactions = random.choices(reactions, k=num_reactions)
+        reaction_counts = {r: selected_reactions.count(r) for r in set(selected_reactions)}
+        return ''.join([f"{r}{count} " for r, count in reaction_counts.items()])
+    except Exception as e:
+        logger.error(f"Error generating reactions: {str(e)}")
+        return ""