import os, json, hmac, hashlib, sqlite3, time
from contextlib import closing
from urllib.parse import parse_qsl
from flask import Flask, jsonify, request, send_from_directory

BASE_DIR = os.path.dirname(os.path.abspath(__file__))
BOT_DB = os.environ.get("BOT_DB_PATH", os.path.join(BASE_DIR, "bot.db"))
REFERRAL_DB = os.environ.get("REFERRAL_DB_PATH", os.path.join(BASE_DIR, "referral.db"))
BOT_TOKEN = os.environ.get("BOT_TOKEN", "")
BOT_USERNAME = os.environ.get("BOT_USERNAME", "V2ray170bot")
WEBAPP_MAX_AGE = int(os.environ.get("WEBAPP_MAX_AGE", "86400"))

app = Flask(__name__, static_folder="static")
app.config["MAX_CONTENT_LENGTH"] = 1024 * 1024

def db(path):
    # Read-only connection: the Mini App cannot alter bot balances or orders.
    uri = "file:" + os.path.abspath(path) + "?mode=ro"
    con = sqlite3.connect(uri, uri=True, timeout=8)
    con.row_factory = sqlite3.Row
    con.execute("PRAGMA query_only=ON")
    return con

def verify_init_data(raw):
    if not BOT_TOKEN or not raw:
        return None
    try:
        pairs = dict(parse_qsl(raw, keep_blank_values=True))
        received_hash = pairs.pop("hash", None)
        if not received_hash:
            return None
        auth_date = int(pairs.get("auth_date", "0"))
        if auth_date <= 0 or time.time() - auth_date > WEBAPP_MAX_AGE or auth_date > time.time() + 60:
            return None
        data_check = "\n".join(f"{k}={v}" for k, v in sorted(pairs.items()))
        secret = hmac.new(b"WebAppData", BOT_TOKEN.encode(), hashlib.sha256).digest()
        calculated = hmac.new(secret, data_check.encode(), hashlib.sha256).hexdigest()
        if not hmac.compare_digest(calculated, received_hash):
            return None
        user = json.loads(pairs.get("user", "{}"))
        tid = int(user.get("id", 0))
        return (tid, user) if tid else None
    except Exception:
        return None

def current_user():
    auth = verify_init_data(request.headers.get("X-Telegram-Init-Data", ""))
    if not auth:
        return None
    return auth

def api_error(message, status=400):
    return jsonify({"ok": False, "error": message}), status

@app.get("/")
def index():
    return send_from_directory("static", "index.html")

@app.get("/api/me")
def me():
    auth = current_user()
    if not auth: return api_error("اعتبارسنجی تلگرام ناموفق است؛ مینی‌اپ را از داخل ربات باز کنید.", 401)
    tid, tg = auth
    try:
        with closing(db(BOT_DB)) as con:
            u = con.execute("SELECT * FROM users WHERE telegram_id=?", (tid,)).fetchone()
            if not u: return api_error("حساب کاربری در دیتابیس ربات پیدا نشد.", 404)
            if u["is_banned"]: return api_error("حساب کاربری شما تعلیق شده است.", 403)
            purchases = con.execute("SELECT COUNT(*) n FROM purchases WHERE user_id=? AND status='completed'", (u["id"],)).fetchone()["n"]
            receipts = con.execute("SELECT id, amount, status, created_at FROM receipts WHERE user_id=? ORDER BY id DESC LIMIT 10", (u["id"],)).fetchall()
            settings = {r["key"]: r["value"] for r in con.execute("SELECT key,value FROM bot_settings WHERE key IN ('support_username','card_number','card_owner_name')")}
        with closing(db(BOT_DB)) as con:
            orders = con.execute("""SELECT id,tracking_code,service_name,duration_name,duration_days,price,status,config_name,config_link,created_at,expires_at
                                    FROM purchases WHERE user_id=? ORDER BY id DESC LIMIT 30""", (u["id"],)).fetchall()
        ref = {"count": 0, "commission": 0, "percent": 10}
        try:
            with closing(db(REFERRAL_DB)) as rc:
                ref["count"] = rc.execute("SELECT COUNT(*) n FROM referrals WHERE inviter_telegram_id=?", (tid,)).fetchone()["n"]
                row = rc.execute("SELECT COALESCE(SUM(commission_amount),0) total FROM referral_commissions c JOIN referrals r ON r.id=c.referral_id WHERE r.inviter_telegram_id=?", (tid,)).fetchone()
                ref["commission"] = row["total"]
                rate = rc.execute("SELECT percent FROM referral_commission_rates WHERE telegram_id=?", (tid,)).fetchone()
                if rate: ref["percent"] = rate["percent"]
                code = rc.execute("SELECT invite_code FROM referrers WHERE telegram_id=?", (tid,)).fetchone()
                ref["code"] = code["invite_code"] if code else None
        except (sqlite3.Error, OSError):
            pass
        code = ref.get("code")
        ref["link"] = f"https://t.me/{BOT_USERNAME}?start=ref_{code}" if code else f"https://t.me/{BOT_USERNAME}"
        return jsonify({
            "ok": True,
            "user": {"id": tid, "name": u["full_name"], "username": u["username"], "phone": u["phone"], "balance": u["balance"], "purchase_count": purchases},
            "purchases": [dict(x) for x in orders],
            "receipts": [dict(x) for x in receipts],
            "referral": ref,
            "support": (settings.get("support_username") or "SajjadAt7").lstrip("@"),
            "card": {"number": settings.get("card_number", ""), "owner": settings.get("card_owner_name", "")}
        })
    except sqlite3.Error:
        app.logger.exception("database read failed")
        return api_error("خطا در خواندن دیتابیس. مسیر دیتابیس را بررسی کنید.", 500)

@app.get("/api/catalog")
def catalog():
    auth = current_user()
    if not auth: return api_error("ابتدا مینی‌اپ را از داخل ربات باز کنید.", 401)
    try:
        with closing(db(BOT_DB)) as con:
            groups = con.execute("SELECT id,name FROM groups WHERE active=1 ORDER BY id").fetchall()
            result = []
            for g in groups:
                rows = con.execute("""SELECT s.id,s.name,s.volume_gb,s.volume_text,s.duration_text,s.duration_days,s.price,
                                      COALESCE(s.duration_text,d.name,'') duration_label
                                      FROM services s LEFT JOIN durations d ON d.id=s.duration_id
                                      WHERE s.active=1 AND s.group_id=? ORDER BY s.price,s.id""", (g["id"],)).fetchall()
                result.append({"id":g["id"],"name":g["name"],"services":[dict(r) for r in rows]})
        return jsonify({"ok":True,"groups":result})
    except sqlite3.Error:
        app.logger.exception("catalog read failed")
        return api_error("خطا در خواندن فهرست سرویس‌ها.", 500)

@app.get("/health")
def health():
    return jsonify({"ok": True})

if __name__ == "__main__":
    app.run(host="127.0.0.1", port=int(os.environ.get("PORT", "8000")), debug=False)
