import time
import requests
import sqlite3
import logging
from telegram import Update, InlineKeyboardButton, InlineKeyboardMarkup
from telegram.ext import (
    ApplicationBuilder, CommandHandler, CallbackQueryHandler, 
    ContextTypes, MessageHandler, filters
)

logging.basicConfig(
    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s", 
    level=logging.INFO
)

# ==========================================
# ⚙️ CONFIGURATION SETTINGS (EDIT THESE)
# ==========================================
BOT_TOKEN = "YOUR_TELEGRAM_BOT_TOKEN_FROM_BOTFATHER"
API_KEY = "YOUR_VansOTP_API_KEY"
BASE_URL = "https://vansotp.com/api/v1"
ADMIN_TELEGRAM_ID = 123456789  # Replace with your numeric Telegram User ID (from @userinfobot)

# Retail Prices in NGN (You set these retail prices - keep 100% markup profit!)
RETAIL_PRICES = {
    "whatsapp_us": 1200.0,
    "whatsapp_uk": 1400.0,
    "telegram_us": 1000.0,
    "google_us": 800.0,
    "tiktok_views_1k": 500.0,
    "ig_followers_1k": 1800.0
}

# Your Bank Account for Manual Customer Transfers
BANK_NAME = "Opay / Moniepoint / Palmpay"
ACCOUNT_NUMBER = "1234567890"
ACCOUNT_NAME = "VansOTP Reseller Store"

# ==========================================
# 🗄️ SQLITE DATABASE INITIALIZATION
# ==========================================
def init_db():
    conn = sqlite3.connect("bot_store.db")
    cursor = conn.cursor()
    # Users table
    cursor.execute("""
        CREATE TABLE IF NOT EXISTS users (
            telegram_id INTEGER PRIMARY KEY,
            username TEXT,
            full_name TEXT,
            balance REAL DEFAULT 0.0,
            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
        )
    """)
    # Deposit requests table
    cursor.execute("""
        CREATE TABLE IF NOT EXISTS deposit_requests (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            telegram_id INTEGER,
            username TEXT,
            amount REAL,
            status TEXT DEFAULT 'pending',
            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
        )
    """)
    # Transactions log (purchases & deposits)
    cursor.execute("""
        CREATE TABLE IF NOT EXISTS transactions (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            telegram_id INTEGER,
            type TEXT,
            amount REAL,
            description TEXT,
            status TEXT,
            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
        )
    """)
    conn.commit()
    conn.close()

init_db()

def get_or_create_user(user):
    conn = sqlite3.connect("bot_store.db")
    cursor = conn.cursor()
    cursor.execute("SELECT balance FROM users WHERE telegram_id = ?", (user.id,))
    row = cursor.fetchone()
    if not row:
        cursor.execute(
            "INSERT INTO users (telegram_id, username, full_name, balance) VALUES (?, ?, ?, ?)",
            (user.id, user.username or "", user.full_name or "", 0.0)
        )
        conn.commit()
        balance = 0.0
    else:
        balance = row[0]
        cursor.execute(
            "UPDATE users SET username = ?, full_name = ? WHERE telegram_id = ?",
            (user.username or "", user.full_name or "", user.id)
        )
        conn.commit()
    conn.close()
    return balance

def update_user_balance(telegram_id, delta, tx_type="admin", description=""):
    conn = sqlite3.connect("bot_store.db")
    cursor = conn.cursor()
    cursor.execute("UPDATE users SET balance = balance + ? WHERE telegram_id = ?", (delta, telegram_id))
    cursor.execute(
        "INSERT INTO transactions (telegram_id, type, amount, description, status) VALUES (?, ?, ?, ?, ?)",
        (telegram_id, tx_type, delta, description, "completed")
    )
    conn.commit()
    cursor.execute("SELECT balance FROM users WHERE telegram_id = ?", (telegram_id,))
    new_bal = cursor.fetchone()[0]
    conn.close()
    return new_bal

# ==========================================
# 🚀 USER COMMANDS & HANDLERS
# ==========================================
async def start(update: Update, context: ContextTypes.DEFAULT_TYPE):
    user = update.effective_user
    bal = get_or_create_user(user)
    keyboard = [
        [InlineKeyboardButton("📱 Buy WhatsApp USA (₦1,200)", callback_data="buy:whatsapp:US:1200")],
        [InlineKeyboardButton("✈️ Buy Telegram USA (₦1,000)", callback_data="buy:telegram:US:1000")],
        [InlineKeyboardButton("🔍 Buy Google/Gmail USA (₦800)", callback_data="buy:google:US:800")],
        [InlineKeyboardButton("💳 Fund Wallet", callback_data="menu_deposit"), InlineKeyboardButton("💰 My Balance", callback_data="check_bal")],
        [InlineKeyboardButton("📜 My Transactions", callback_data="my_tx"), InlineKeyboardButton("📞 Support", url="https://t.me/YourSupportUsername")]
    ]
    await update.message.reply_text(
        f"👋 Welcome {user.first_name} to **VansOTP Automated Store**!\n\n"
        f"💰 Your Balance: **₦{bal:,.2f}**\n\n"
        f"Select a service below for instant delivery:",
        reply_markup=InlineKeyboardMarkup(keyboard),
        parse_mode="Markdown"
    )

async def handle_callback(update: Update, context: ContextTypes.DEFAULT_TYPE):
    query = update.callback_query
    await query.answer()
    user = query.from_user
    data = query.data

    # Check Balance
    if data == "check_bal":
        bal = get_or_create_user(user)
        await query.message.reply_text(f"💳 Your Wallet Balance is: **₦{bal:,.2f}**", parse_mode="Markdown")

    # View User Transactions
    elif data == "my_tx":
        conn = sqlite3.connect("bot_store.db")
        c = conn.cursor()
        c.execute("SELECT type, amount, description, created_at FROM transactions WHERE telegram_id = ? ORDER BY id DESC LIMIT 5", (user.id,))
        rows = c.fetchall()
        conn.close()
        if not rows:
            await query.message.reply_text("ℹ️ You have no transaction history yet.")
            return
        tx_text = "📜 **Your Recent Transactions:**\n\n"
        for r in rows:
            sign = "+" if r[1] > 0 else ""
            tx_text += f"• `{r[3][:16]}` | {r[0].upper()} | **{sign}₦{r[1]:,.2f}**\n  _{r[2]}_\n\n"
        await query.message.reply_text(tx_text, parse_mode="Markdown")

    # Deposit Menu
    elif data == "menu_deposit":
        keyboard = [
            [InlineKeyboardButton("₦1,000", callback_data="req_dep:1000"), InlineKeyboardButton("₦2,000", callback_data="req_dep:2000")],
            [InlineKeyboardButton("₦5,000", callback_data="req_dep:5000"), InlineKeyboardButton("₦10,000", callback_data="req_dep:10000")]
        ]
        await query.message.reply_text(
            f"🏦 **BANK TRANSFER DEPOSIT INSTRUCTIONS**\n\n"
            f"• Bank: **{BANK_NAME}**\n"
            f"• Account Number: `{ACCOUNT_NUMBER}`\n"
            f"• Account Name: **{ACCOUNT_NAME}**\n\n"
            f"Select the amount you want to transfer below:",
            reply_markup=InlineKeyboardMarkup(keyboard),
            parse_mode="Markdown"
        )

    # Customer Logs Deposit Request
    elif data.startswith("req_dep:"):
        amount = float(data.split(":")[1])
        conn = sqlite3.connect("bot_store.db")
        cursor = conn.cursor()
        cursor.execute(
            "INSERT INTO deposit_requests (telegram_id, username, amount) VALUES (?, ?, ?)",
            (user.id, user.username or user.first_name, amount)
        )
        req_id = cursor.lastrowid
        conn.commit()
        conn.close()

        await query.message.reply_text(
            f"✅ **Deposit Request #{req_id} Submitted!**\n\n"
            f"Please transfer **₦{amount:,.2f}** to `{ACCOUNT_NUMBER}` ({BANK_NAME}).\n"
            f"Our admin is verifying your transfer and will approve your balance shortly!",
            parse_mode="Markdown"
        )

        # Send 1-Tap Approval + Rejection to Admin
        admin_markup = InlineKeyboardMarkup([
            [InlineKeyboardButton(f"✅ Approve ₦{amount:,.0f}", callback_data=f"adm_app:{req_id}:{user.id}:{amount}")],
            [InlineKeyboardButton("❌ Reject", callback_data=f"adm_rej:{req_id}:{user.id}:{amount}")]
        ])
        await context.bot.send_message(
            chat_id=ADMIN_TELEGRAM_ID,
            text=f"🔔 **NEW DEPOSIT ALERT!**\n\n"
                 f"👤 User: {user.full_name} (@{user.username})\n"
                 f"🆔 Telegram ID: `{user.id}`\n"
                 f"💰 Amount: **₦{amount:,.2f}**\n"
                 f"📋 Request ID: `#{req_id}`\n\n"
                 f"Tap below to approve or reject:",
            reply_markup=admin_markup,
            parse_mode="Markdown"
        )

    # Admin 1-Tap APPROVE Handler
    elif data.startswith("adm_app:"):
        if user.id != ADMIN_TELEGRAM_ID:
            await query.answer("❌ Unauthorized!", show_alert=True)
            return
        _, req_id, cust_id, amt = data.split(":")
        cust_id, amt, req_id = int(cust_id), float(amt), int(req_id)
        
        conn = sqlite3.connect("bot_store.db")
        c = conn.cursor()
        c.execute("UPDATE deposit_requests SET status = 'approved' WHERE id = ?", (req_id,))
        conn.commit()
        conn.close()

        new_bal = update_user_balance(cust_id, amt, tx_type="deposit", description=f"Deposit Request #{req_id}")
        await query.edit_message_text(f"✅ Approved Request #{req_id}. User `{cust_id}` credited ₦{amt:,.2f}. New balance: ₦{new_bal:,.2f}")
        
        try:
            await context.bot.send_message(
                chat_id=cust_id,
                text=f"🎉 **PAYMENT CONFIRMED & CREDITED!**\n\n"
                     f"₦{amt:,.2f} has been added to your wallet!\n"
                     f"💰 New Balance: **₦{new_bal:,.2f}**\n\n"
                     f"You can now order OTP numbers using /start.",
                parse_mode="Markdown"
            )
        except Exception as e:
            logging.error(f"Failed to notify user {cust_id}: {e}")

    # Admin 1-Tap REJECT Handler
    elif data.startswith("adm_rej:"):
        if user.id != ADMIN_TELEGRAM_ID:
            await query.answer("❌ Unauthorized!", show_alert=True)
            return
        _, req_id, cust_id, amt = data.split(":")
        cust_id, amt, req_id = int(cust_id), float(amt), int(req_id)
        
        conn = sqlite3.connect("bot_store.db")
        c = conn.cursor()
        c.execute("UPDATE deposit_requests SET status = 'rejected' WHERE id = ?", (req_id,))
        conn.commit()
        conn.close()

        await query.edit_message_text(f"❌ Rejected Deposit Request #{req_id} (₦{amt:,.2f}) for user `{cust_id}`.")
        try:
            await context.bot.send_message(
                chat_id=cust_id,
                text=f"❌ **Deposit Request #{req_id} Rejected**\n\n"
                     f"We could not verify your transfer of ₦{amt:,.2f}.\n"
                     f"If you made this payment, please contact support.",
                parse_mode="Markdown"
            )
        except Exception as e:
            pass

    # Order Virtual Number Handler
    elif data.startswith("buy:"):
        _, service_slug, country_iso, price = data.split(":")
        price = float(price)
        bal = get_or_create_user(user)

        if bal < price:
            await query.message.reply_text(
                f"❌ Insufficient balance (₦{bal:,.2f}). This number costs ₦{price:,.2f}.\n"
                f"Please click 'Fund Wallet' to top up.",
                parse_mode="Markdown"
            )
            return

        # Deduct wallet & call VansOTP Wholesale API
        update_user_balance(user.id, -price, tx_type="purchase", description=f"{service_slug.upper()} ({country_iso}) Number")
        msg = await query.message.reply_text("🔄 Ordering virtual number from wholesale pool...")

        headers = {"X-API-KEY": API_KEY, "Accept": "application/json"}
        resp = requests.post(f"{BASE_URL}/numbers/order", json={"service_slug": service_slug, "country_iso": country_iso}, headers=headers)
        
        if resp.status_code != 200 or not resp.json().get("success"):
            update_user_balance(user.id, price, tx_type="refund", description=f"Refund: {service_slug} unavailable")
            await msg.edit_text("❌ Carrier pool busy or no numbers available. Wallet refunded 100%.")
            return

        order_data = resp.json()["data"]["order"]
        order_id = order_data["order_id"]
        phone_num = order_data["phone_number"]

        await msg.edit_text(
            f"🎉 **NUMBER READY!**\n\n"
            f"📞 Number: `{phone_num}`\n"
            f"📱 Service: **{service_slug.upper()} ({country_iso})**\n\n"
            f"⏳ Waiting for incoming SMS code (will auto-poll for 15 minutes)...",
            parse_mode="Markdown"
        )

        # Auto-poll for SMS OTP code (up to 5 minutes / 60 iterations of 5s)
        for _ in range(60):
            time.sleep(5)
            chk = requests.get(f"{BASE_URL}/numbers/{order_id}/sms", headers=headers)
            if chk.status_code == 200:
                sms_res = chk.json()["data"]
                if sms_res.get("sms_received"):
                    code = sms_res.get("latest_code")
                    full_text = sms_res.get("latest_message")
                    await query.message.reply_text(
                        f"📬 **YOUR VERIFICATION CODE HAS ARRIVED!**\n\n"
                        f"🔑 Code: `{code}`\n\n"
                        f"Full Message:\n_{full_text}_",
                        parse_mode="Markdown"
                    )
                    return

        # Timeout: Auto-cancel and auto-refund
        requests.post(f"{BASE_URL}/numbers/{order_id}/cancel", headers=headers)
        update_user_balance(user.id, price, tx_type="refund", description=f"Refund: OTP Timeout on {phone_num}")
        await query.message.reply_text("⚠️ No SMS received within timeout. Your wallet has been 100% refunded.")

# ==========================================
# 👑 ADMIN COMMANDS (Full Control Panel)
# ==========================================
async def admin_fund(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Credit a user's wallet: /fund  """
    if update.effective_user.id != ADMIN_TELEGRAM_ID: return
    try:
        target_id, amount = int(context.args[0]), float(context.args[1])
        new_bal = update_user_balance(target_id, amount, tx_type="admin_credit", description="Manual Admin Credit")
        await update.message.reply_text(f"✅ Credited `{target_id}` with ₦{amount:,.2f}. New Balance: ₦{new_bal:,.2f}")
        await context.bot.send_message(chat_id=target_id, text=f"🎉 Admin credited your wallet with ₦{amount:,.2f}!\n💰 Balance: ₦{new_bal:,.2f}")
    except Exception as e:
        await update.message.reply_text("Usage: `/fund  `\nExample: `/fund 123456789 5000`", parse_mode="Markdown")

async def admin_deduct(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Deduct from a user's wallet: /deduct  """
    if update.effective_user.id != ADMIN_TELEGRAM_ID: return
    try:
        target_id, amount = int(context.args[0]), float(context.args[1])
        new_bal = update_user_balance(target_id, -amount, tx_type="admin_debit", description="Manual Admin Debit")
        await update.message.reply_text(f"✅ Deducted ₦{amount:,.2f} from `{target_id}`. New Balance: ₦{new_bal:,.2f}")
        await context.bot.send_message(chat_id=target_id, text=f"⚠️ Admin deducted ₦{amount:,.2f} from your wallet.\n💰 Balance: ₦{new_bal:,.2f}")
    except Exception as e:
        await update.message.reply_text("Usage: `/deduct  `\nExample: `/deduct 123456789 1000`", parse_mode="Markdown")

async def admin_transactions(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """View recent transactions: /transactions"""
    if update.effective_user.id != ADMIN_TELEGRAM_ID: return
    conn = sqlite3.connect("bot_store.db")
    c = conn.cursor()
    c.execute("SELECT id, telegram_id, type, amount, description, created_at FROM transactions ORDER BY id DESC LIMIT 10")
    rows = c.fetchall()
    conn.close()
    if not rows:
        await update.message.reply_text("No transactions found.")
        return
    text = "📊 **Recent 10 Transactions:**\n\n"
    for r in rows:
        sign = "+" if r[3] > 0 else ""
        text += f"• `#{r[0]}` | User: `{r[1]}` | {r[2].upper()}\n  Amount: **{sign}₦{r[3]:,.2f}** | _{r[4]}_\n  Date: `{r[5][:16]}`\n\n"
    await update.message.reply_text(text, parse_mode="Markdown")

async def admin_users(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """View registered users: /users"""
    if update.effective_user.id != ADMIN_TELEGRAM_ID: return
    conn = sqlite3.connect("bot_store.db")
    c = conn.cursor()
    c.execute("SELECT telegram_id, username, full_name, balance FROM users ORDER BY balance DESC LIMIT 15")
    rows = c.fetchall()
    c.execute("SELECT COUNT(*), SUM(balance) FROM users")
    total_users, total_bal = c.fetchone()
    conn.close()
    
    text = f"👥 **Bot User Directory:**\nTotal Users: **{total_users}** | Total User Balances: **₦{(total_bal or 0):,.2f}**\n\n"
    for r in rows:
        text += f"• `{r[0]}` | @{r[1] or 'NoUser'} ({r[2]})\n  💰 Balance: **₦{r[3]:,.2f}**\n\n"
    await update.message.reply_text(text, parse_mode="Markdown")

async def admin_broadcast(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Broadcast announcement to all users: /broadcast """
    if update.effective_user.id != ADMIN_TELEGRAM_ID: return
    msg = " ".join(context.args)
    if not msg:
        await update.message.reply_text("Usage: `/broadcast `", parse_mode="Markdown")
        return
    conn = sqlite3.connect("bot_store.db")
    c = conn.cursor()
    c.execute("SELECT telegram_id FROM users")
    users = c.fetchall()
    conn.close()
    
    sent = 0
    for (u_id,) in users:
        try:
            await context.bot.send_message(chat_id=u_id, text=f"📢 **ANNOUNCEMENT:**\n\n{msg}", parse_mode="Markdown")
            sent += 1
        except Exception:
            pass
    await update.message.reply_text(f"✅ Broadcast sent to **{sent}/{len(users)}** users!")

# ==========================================
# 🏁 MAIN ENTRY POINT
# ==========================================
if __name__ == "__main__":
    print("🤖 VansOTP Reseller Telegram Bot Engine is running...")
    app = ApplicationBuilder().token(BOT_TOKEN).build()
    
    # User Handlers
    app.add_handler(CommandHandler("start", start))
    app.add_handler(CallbackQueryHandler(handle_callback))
    
    # Admin Handlers
    app.add_handler(CommandHandler("fund", admin_fund))
    app.add_handler(CommandHandler("deduct", admin_deduct))
    app.add_handler(CommandHandler("transactions", admin_transactions))
    app.add_handler(CommandHandler("users", admin_users))
    app.add_handler(CommandHandler("broadcast", admin_broadcast))
    
    app.run_polling()