Spaces:

alphabagibagi
/

iceboxai

Running

App Files Files Community

alphabagibagi commited on Jan 14

Commit

b56f837

verified ·

1 Parent(s): 8e7219c

Upload 5 files

Browse files

Files changed (5) hide show

Dockerfile +5 -1
admin.py +421 -0
bot.py +682 -682
requirements.txt +5 -4
start.sh +8 -0

Dockerfile CHANGED Viewed

@@ -8,4 +8,8 @@ RUN pip install --no-cache-dir -r requirements.txt
 COPY . .
-CMD ["python", "bot.py"]

 COPY . .
+# Make startup script executable
+RUN chmod +x start.sh
+# Run both bot and admin console
+CMD ["./start.sh"]

admin.py ADDED Viewed

	@@ -0,0 +1,421 @@

+import os
+import asyncio
+from flask import Flask, render_template_string, request, redirect, url_for, flash, session
+from functools import wraps
+from supabase import create_client, Client
+from dotenv import load_dotenv
+import requests
+# Load environment variables
+load_dotenv()
+# Configuration
+TELEGRAM_TOKEN = os.getenv("TELEGRAM_BOT_TOKEN")
+SUPABASE_URL = os.getenv("SUPABASE_URL")
+SUPABASE_KEY = os.getenv("SUPABASE_KEY")
+ADMIN_PASSWORD = os.getenv("ADMIN_PASSWORD", "admin123")  # Set this in your .env
+TELEGRAM_API_BASE = os.getenv("TELEGRAM_API_BASE_URL", "https://api.telegram.org")
+# Supabase Client
+supabase: Client = create_client(SUPABASE_URL, SUPABASE_KEY)
+app = Flask(__name__)
+app.secret_key = os.getenv("FLASK_SECRET_KEY", "your-secret-key-change-this")
+# HTML Templates
+LOGIN_TEMPLATE = """
+<!DOCTYPE html>
+<html>
+<head>
+    <title>Admin Login - Icebox AI</title>
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <style>
+        * { box-sizing: border-box; margin: 0; padding: 0; }
+        body {
+            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+            background: linear-gradient(135deg, #1a1a2e 0%, #16213e 100%);
+            min-height: 100vh;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            padding: 20px;
+        }
+        .login-box {
+            background: rgba(255,255,255,0.1);
+            backdrop-filter: blur(10px);
+            border-radius: 20px;
+            padding: 40px;
+            width: 100%;
+            max-width: 400px;
+            box-shadow: 0 8px 32px rgba(0,0,0,0.3);
+        }
+        h1 { color: #fff; text-align: center; margin-bottom: 30px; }
+        .form-group { margin-bottom: 20px; }
+        label { color: #aaa; display: block; margin-bottom: 8px; }
+        input[type="password"] {
+            width: 100%;
+            padding: 15px;
+            border: none;
+            border-radius: 10px;
+            background: rgba(255,255,255,0.1);
+            color: #fff;
+            font-size: 16px;
+        }
+        input[type="password"]:focus { outline: 2px solid #667eea; }
+        button {
+            width: 100%;
+            padding: 15px;
+            border: none;
+            border-radius: 10px;
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            color: #fff;
+            font-size: 16px;
+            font-weight: bold;
+            cursor: pointer;
+            transition: transform 0.2s;
+        }
+        button:hover { transform: scale(1.02); }
+        .error { color: #ff6b6b; text-align: center; margin-bottom: 20px; }
+    </style>
+</head>
+<body>
+    <div class="login-box">
+        <h1>🔐 Admin Login</h1>
+        {% if error %}<p class="error">{{ error }}</p>{% endif %}
+        <form method="POST">
+            <div class="form-group">
+                <label>Password</label>
+                <input type="password" name="password" required autofocus>
+            </div>
+            <button type="submit">Login</button>
+        </form>
+    </div>
+</body>
+</html>
+"""
+DASHBOARD_TEMPLATE = """
+<!DOCTYPE html>
+<html>
+<head>
+    <title>Admin Console - Icebox AI</title>
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <style>
+        * { box-sizing: border-box; margin: 0; padding: 0; }
+        body {
+            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+            background: linear-gradient(135deg, #1a1a2e 0%, #16213e 100%);
+            min-height: 100vh;
+            color: #fff;
+        }
+        .header {
+            background: rgba(255,255,255,0.1);
+            padding: 20px;
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+        }
+        .header h1 { font-size: 24px; }
+        .logout-btn {
+            background: rgba(255,255,255,0.2);
+            color: #fff;
+            border: none;
+            padding: 10px 20px;
+            border-radius: 8px;
+            cursor: pointer;
+            text-decoration: none;
+        }
+        .container { max-width: 1200px; margin: 0 auto; padding: 30px 20px; }
+        .stats-grid {
+            display: grid;
+            grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
+            gap: 20px;
+            margin-bottom: 30px;
+        }
+        .stat-card {
+            background: rgba(255,255,255,0.1);
+            backdrop-filter: blur(10px);
+            border-radius: 15px;
+            padding: 25px;
+            text-align: center;
+        }
+        .stat-card h3 { font-size: 36px; margin-bottom: 10px; }
+        .stat-card p { color: #aaa; }
+        .card {
+            background: rgba(255,255,255,0.1);
+            backdrop-filter: blur(10px);
+            border-radius: 15px;
+            padding: 25px;
+            margin-bottom: 20px;
+        }
+        .card h2 { margin-bottom: 20px; border-bottom: 1px solid rgba(255,255,255,0.2); padding-bottom: 15px; }
+        .form-group { margin-bottom: 20px; }
+        label { display: block; margin-bottom: 8px; color: #aaa; }
+        select, textarea, input[type="text"] {
+            width: 100%;
+            padding: 15px;
+            border: none;
+            border-radius: 10px;
+            background: rgba(255,255,255,0.1);
+            color: #fff;
+            font-size: 14px;
+            font-family: inherit;
+        }
+        textarea { min-height: 150px; resize: vertical; }
+        select option { background: #1a1a2e; }
+        .btn {
+            padding: 15px 30px;
+            border: none;
+            border-radius: 10px;
+            font-size: 16px;
+            font-weight: bold;
+            cursor: pointer;
+            transition: transform 0.2s;
+        }
+        .btn:hover { transform: scale(1.02); }
+        .btn-primary { background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); color: #fff; }
+        .btn-success { background: linear-gradient(135deg, #11998e 0%, #38ef7d 100%); color: #fff; }
+        .alert {
+            padding: 15px;
+            border-radius: 10px;
+            margin-bottom: 20px;
+        }
+        .alert-success { background: rgba(56, 239, 125, 0.2); color: #38ef7d; }
+        .alert-error { background: rgba(255, 107, 107, 0.2); color: #ff6b6b; }
+        .user-list {
+            max-height: 300px;
+            overflow-y: auto;
+            background: rgba(0,0,0,0.2);
+            border-radius: 10px;
+            padding: 15px;
+        }
+        .user-item {
+            display: flex;
+            justify-content: space-between;
+            padding: 10px;
+            border-bottom: 1px solid rgba(255,255,255,0.1);
+        }
+        .user-item:last-child { border-bottom: none; }
+        .checkbox-group { display: flex; flex-wrap: wrap; gap: 10px; }
+        .checkbox-item {
+            background: rgba(255,255,255,0.1);
+            padding: 10px 15px;
+            border-radius: 8px;
+            cursor: pointer;
+        }
+        .checkbox-item:hover { background: rgba(255,255,255,0.2); }
+        .checkbox-item input { margin-right: 8px; }
+    </style>
+</head>
+<body>
+    <div class="header">
+        <h1>🤖 Icebox AI Admin</h1>
+        <a href="/logout" class="logout-btn">Logout</a>
+    </div>
+    <div class="container">
+        {% with messages = get_flashed_messages(with_categories=true) %}
+            {% for category, message in messages %}
+                <div class="alert alert-{{ category }}">{{ message }}</div>
+            {% endfor %}
+        {% endwith %}
+        <div class="stats-grid">
+            <div class="stat-card">
+                <h3>{{ total_users }}</h3>
+                <p>Total Users</p>
+            </div>
+            <div class="stat-card">
+                <h3>{{ active_users }}</h3>
+                <p>Active Users</p>
+            </div>
+            <div class="stat-card">
+                <h3>{{ total_generations }}</h3>
+                <p>Total Generations</p>
+            </div>
+        </div>
+        <div class="card">
+            <h2>📢 Send Broadcast Message</h2>
+            <form method="POST" action="/broadcast">
+                <div class="form-group">
+                    <label>Target Audience</label>
+                    <select name="target">
+                        <option value="all">All Users</option>
+                        <option value="active">Active Users (last 7 days)</option>
+                        <option value="specific">Specific User (by Chat ID)</option>
+                    </select>
+                </div>
+                <div class="form-group" id="chatIdGroup" style="display:none;">
+                    <label>Chat ID (comma separated for multiple)</label>
+                    <input type="text" name="chat_ids" placeholder="123456789, 987654321">
+                </div>
+                <div class="form-group">
+                    <label>Message (supports Markdown)</label>
+                    <textarea name="message" placeholder="**New Update!** 🎉
+We've added exciting new features:
+• Image to Image generation
+• Multi-image support
+Try it now!"></textarea>
+                </div>
+                <button type="submit" class="btn btn-primary">Send Broadcast</button>
+            </form>
+        </div>
+        <div class="card">
+            <h2>👥 Recent Users</h2>
+            <div class="user-list">
+                {% for user in users %}
+                <div class="user-item">
+                    <span>
+                        <strong>{{ user.first_name or 'Unknown' }}</strong>
+                        {% if user.username %}(@{{ user.username }}){% endif %}
+                    </span>
+                    <span style="color: #aaa;">{{ user.chat_id }}</span>
+                </div>
+                {% endfor %}
+            </div>
+        </div>
+    </div>
+    <script>
+        document.querySelector('select[name="target"]').addEventListener('change', function() {
+            document.getElementById('chatIdGroup').style.display =
+                this.value === 'specific' ? 'block' : 'none';
+        });
+    </script>
+</body>
+</html>
+"""
+def login_required(f):
+    @wraps(f)
+    def decorated_function(*args, **kwargs):
+        if not session.get('logged_in'):
+            return redirect(url_for('login'))
+        return f(*args, **kwargs)
+    return decorated_function
+@app.route('/login', methods=['GET', 'POST'])
+def login():
+    error = None
+    if request.method == 'POST':
+        if request.form['password'] == ADMIN_PASSWORD:
+            session['logged_in'] = True
+            return redirect(url_for('dashboard'))
+        else:
+            error = 'Invalid password'
+    return render_template_string(LOGIN_TEMPLATE, error=error)
+@app.route('/logout')
+def logout():
+    session.pop('logged_in', None)
+    return redirect(url_for('login'))
+@app.route('/')
+@login_required
+def dashboard():
+    # Get stats
+    try:
+        total_users = supabase.table("telegram_users").select("id", count="exact").execute().count
+        active_users = supabase.table("telegram_users").select("id", count="exact").gte(
+            "last_active",
+            (datetime.now() - timedelta(days=7)).isoformat()
+        ).execute().count if total_users else 0
+        total_generations = supabase.table("image_generation_logs").select("id", count="exact").execute().count
+        # Get recent users
+        users = supabase.table("telegram_users").select("chat_id, username, first_name").order(
+            "last_active", desc=True
+        ).limit(20).execute().data
+    except Exception as e:
+        total_users = 0
+        active_users = 0
+        total_generations = 0
+        users = []
+        flash(f'Database error: {str(e)}', 'error')
+    return render_template_string(
+        DASHBOARD_TEMPLATE,
+        total_users=total_users or 0,
+        active_users=active_users or 0,
+        total_generations=total_generations or 0,
+        users=users or []
+    )
+def send_telegram_message(chat_id: int, message: str) -> bool:
+    """Send a message to a specific chat using Telegram API."""
+    try:
+        url = f"{TELEGRAM_API_BASE}/bot{TELEGRAM_TOKEN}/sendMessage"
+        data = {
+            "chat_id": chat_id,
+            "text": message,
+            "parse_mode": "Markdown"
+        }
+        response = requests.post(url, json=data, timeout=10)
+        return response.status_code == 200
+    except Exception as e:
+        print(f"Error sending to {chat_id}: {e}")
+        return False
+@app.route('/broadcast', methods=['POST'])
+@login_required
+def broadcast():
+    target = request.form.get('target', 'all')
+    message = request.form.get('message', '').strip()
+    chat_ids_input = request.form.get('chat_ids', '')
+    if not message:
+        flash('Message cannot be empty', 'error')
+        return redirect(url_for('dashboard'))
+    try:
+        if target == 'specific':
+            # Send to specific users
+            chat_ids = [int(cid.strip()) for cid in chat_ids_input.split(',') if cid.strip()]
+            if not chat_ids:
+                flash('Please provide at least one chat ID', 'error')
+                return redirect(url_for('dashboard'))
+        elif target == 'active':
+            # Get active users (last 7 days)
+            from datetime import datetime, timedelta
+            result = supabase.table("telegram_users").select("chat_id").gte(
+                "last_active",
+                (datetime.now() - timedelta(days=7)).isoformat()
+            ).execute()
+            chat_ids = [u['chat_id'] for u in result.data]
+        else:
+            # All users
+            result = supabase.table("telegram_users").select("chat_id").execute()
+            chat_ids = [u['chat_id'] for u in result.data]
+        # Send messages
+        success_count = 0
+        fail_count = 0
+        for chat_id in chat_ids:
+            if send_telegram_message(chat_id, message):
+                success_count += 1
+            else:
+                fail_count += 1
+        flash(f'Broadcast complete! Sent: {success_count}, Failed: {fail_count}', 'success')
+    except Exception as e:
+        flash(f'Error: {str(e)}', 'error')
+    return redirect(url_for('dashboard'))
+# Import for stats
+from datetime import datetime, timedelta
+if __name__ == "__main__":
+    app.run(host="0.0.0.0", port=7860, debug=False)

bot.py CHANGED Viewed

@@ -1,682 +1,682 @@
-import os
-import logging
-import requests
-import asyncio
-from datetime import datetime, timezone, timedelta
-from dotenv import load_dotenv
-from telegram import Update, InlineKeyboardButton, InlineKeyboardMarkup
-from telegram.ext import Application, CommandHandler, CallbackQueryHandler, MessageHandler, filters, ContextTypes, ConversationHandler
-from supabase import create_client, Client
-# Load environment variables
-load_dotenv()
-# Configuration
-TELEGRAM_TOKEN = os.getenv("TELEGRAM_BOT_TOKEN")
-SUPABASE_URL = os.getenv("SUPABASE_URL")
-SUPABASE_KEY = os.getenv("SUPABASE_KEY")
-# Logging setup
-logging.basicConfig(
-    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s", level=logging.INFO
-)
-logger = logging.getLogger(__name__)
-# Supabase Client
-supabase: Client = create_client(SUPABASE_URL, SUPABASE_KEY)
-# States for ConversationHandler
-WAITING_FOR_GEN_TYPE = 1
-WAITING_FOR_PROMPT = 2
-WAITING_FOR_SIZE = 3
-WAITING_FOR_IMAGE = 4
-WAITING_FOR_IMAGE_ACTION = 5
-# Coin costs for each generation type
-COIN_COST_TEXT_TO_IMAGE = 1
-COIN_COST_IMAGE_TO_IMAGE = 3
-COIN_COST_MULTI_IMAGE = 5
-async def start(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    """Send a message when the command /start is issued."""
-    user = update.effective_user
-    chat_id = update.effective_chat.id
-    # Register/Update user in Supabase
-    try:
-        data = {
-            "p_chat_id": chat_id,
-            "p_username": user.username,
-            "p_first_name": user.first_name,
-            "p_last_name": user.last_name,
-            "p_language_code": user.language_code,
-            "p_is_bot": user.is_bot
-        }
-        supabase.rpc("upsert_telegram_user", data).execute()
-        logger.info(f"User {user.id} upserted to Supabase")
-    except Exception as e:
-        logger.error(f"Error upserting user: {e}")
-    await show_main_menu(update, context)
-import io
-from http.server import HTTPServer, BaseHTTPRequestHandler
-from threading import Thread
-# Dummy Server for Hugging Face Health Check (Port 7860)
-class HealthCheckHandler(BaseHTTPRequestHandler):
-    def do_GET(self):
-        self.send_response(200)
-        self.end_headers()
-        self.wfile.write(b"Bot is running")
-def run_health_server():
-    port = 7860
-    server = HTTPServer(("0.0.0.0", port), HealthCheckHandler)
-    print(f"Health check server running on port {port}")
-    server.serve_forever()
-def main():
-    """Start the bot."""
-    # Start health check server in background
-    Thread(target=run_health_server, daemon=True).start()
-    if not TELEGRAM_TOKEN:
-        print("Error: TELEGRAM_BOT_TOKEN not found.")
-        return
-    # Support for custom API URL (Proxy)
-    base_url = os.getenv("TELEGRAM_API_BASE_URL")
-    base_file_url = os.getenv("TELEGRAM_API_FILE_URL")
-    builder = Application.builder().token(TELEGRAM_TOKEN)
-    if base_url:
-        builder.base_url(base_url)
-        print(f"Using Custom API URL: {base_url}")
-    if base_file_url:
-        builder.base_file_url(base_file_url)
-    application = builder.build()
-    # Conversation handler for generating commands
-    conv_handler = ConversationHandler(
-        entry_points=[CallbackQueryHandler(enter_generate_mode, pattern="^generate_mode$")],
-        states={
-            WAITING_FOR_GEN_TYPE: [
-                CallbackQueryHandler(handle_gen_type_selection, pattern="^gen_type_"),
-            ],
-            WAITING_FOR_PROMPT: [
-                MessageHandler(filters.TEXT & ~filters.COMMAND, handle_prompt)
-            ],
-            WAITING_FOR_SIZE: [
-                CallbackQueryHandler(handle_size_selection)
-            ],
-            WAITING_FOR_IMAGE: [
-                MessageHandler(filters.PHOTO, handle_image_upload),
-                CallbackQueryHandler(cancel_generation, pattern="^cancel_gen$"),
-            ],
-            WAITING_FOR_IMAGE_ACTION: [
-                CallbackQueryHandler(handle_image_action, pattern="^img_action_"),
-                CallbackQueryHandler(cancel_generation, pattern="^cancel_gen$"),
-            ],
-        },
-        fallbacks=[
-            CommandHandler("start", start),
-            CallbackQueryHandler(show_main_menu, pattern="^main_menu$")
-        ]
-    )
-    application.add_handler(CommandHandler("start", start))
-    application.add_handler(conv_handler)
-    # Menu callbacks
-    application.add_handler(CallbackQueryHandler(show_main_menu, pattern="^main_menu$"))
-    application.add_handler(CallbackQueryHandler(show_profile, pattern="^profile$"))
-    application.add_handler(CallbackQueryHandler(show_help, pattern="^help$"))
-    # Run the bot
-    print("Bot is running...")
-    application.run_polling()
-async def show_main_menu(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    """Displays the main menu with inline buttons."""
-    user = update.effective_user
-    # Use @username if available, otherwise fallback to first_name
-    if user.username:
-        username = f"@{user.username}"
-    else:
-        username = user.first_name if user.first_name else "User"
-    # Clear any stored generation data
-    context.user_data.clear()
-    keyboard = [
-        [InlineKeyboardButton("Generate Image", callback_data="generate_mode")],
-        [InlineKeyboardButton("My Profile", callback_data="profile")],
-        [InlineKeyboardButton("Help & Support", callback_data="help")]
-    ]
-    reply_markup = InlineKeyboardMarkup(keyboard)
-    text = (
-        f"Hi {username}, welcome to the @iceboxai\\_bot.\n\n"
-        "✨ **What you can create:**\n"
-        "• Realistic photos\n"
-        "• Anime & illustration\n"
-        "• Cinematic portraits\n"
-        "• Fantasy & concept art\n"
-        "• Logos & product visuals\n\n"
-        "Choose an option below to get started 👇\n\n"
-    )
-    if update.callback_query:
-        await update.callback_query.answer()
-        try:
-            await update.callback_query.edit_message_text(text=text, reply_markup=reply_markup, parse_mode="Markdown")
-        except:
-             await update.callback_query.message.reply_text(text, reply_markup=reply_markup, parse_mode="Markdown")
-    else:
-        await update.message.reply_text(text, reply_markup=reply_markup, parse_mode="Markdown")
-    return ConversationHandler.END
-async def get_user_coins_info(chat_id: int):
-    """Get user coin balance and reset time."""
-    try:
-        user_response = supabase.table("telegram_users").select("id, tier, token_balance, daily_images_generated").eq("chat_id", chat_id).execute()
-        if not user_response.data:
-            return None, 0, None
-        user = user_response.data[0]
-        user_uuid = user['id']
-        # Get limits via RPC
-        check = supabase.rpc("can_generate_image", {"p_user_id": user_uuid}).execute()
-        status = check.data[0]
-        # Calculate coins remaining (for free tier, use daily_remaining)
-        if user['tier'] == 'free':
-            coins = status['daily_remaining']
-        else:
-            coins = user['token_balance']
-        # Calculate next reset time (00:00 UTC next day)
-        now_utc = datetime.now(timezone.utc)
-        today_reset = now_utc.replace(hour=0, minute=0, second=0, microsecond=0)
-        if now_utc >= today_reset:
-            next_reset = today_reset + timedelta(days=1)
-        else:
-            next_reset = today_reset
-        return user_uuid, coins, next_reset
-    except Exception as e:
-        logger.error(f"Error getting user coins: {e}")
-        return None, 0, None
-async def enter_generate_mode(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    """Show generation type selection with coin info."""
-    query = update.callback_query
-    await query.answer()
-    chat_id = update.effective_chat.id
-    user_uuid, coins, next_reset = await get_user_coins_info(chat_id)
-    if user_uuid is None:
-        keyboard = [[InlineKeyboardButton("Back to Home", callback_data="main_menu")]]
-        await query.edit_message_text(
-            text="Error: User record not found. Type /start to reset.",
-            reply_markup=InlineKeyboardMarkup(keyboard)
-        )
-        return ConversationHandler.END
-    # Store user_uuid for later use
-    context.user_data['user_uuid'] = user_uuid
-    context.user_data['coins'] = coins
-    reset_time_str = next_reset.strftime('%Y-%m-%d %H:%M') + " UTC" if next_reset else "N/A"
-    keyboard = [
-        [InlineKeyboardButton("Text to Image", callback_data="gen_type_text")],
-        [InlineKeyboardButton("Image to Image", callback_data="gen_type_image")],
-        [InlineKeyboardButton("Back to Menu", callback_data="main_menu")]
-    ]
-    reply_markup = InlineKeyboardMarkup(keyboard)
-    text = (
-        f"You have 🪙 **{coins} coins** remaining\n\n"
-        "**Choose what you want to generate:**\n\n"
-        "```\n"
-        f"Text to Image        : {COIN_COST_TEXT_TO_IMAGE} coin\n"
-        f"Image to Image       : {COIN_COST_IMAGE_TO_IMAGE} coins\n"
-        f"Multi Image to Image : {COIN_COST_MULTI_IMAGE} coins\n"
-        "```\n\n"
-        f"Your coins will be reset back to 30 at:\n"
-        f"`{reset_time_str}`"
-    )
-    await query.edit_message_text(
-        text=text,
-        reply_markup=reply_markup,
-        parse_mode="Markdown"
-    )
-    return WAITING_FOR_GEN_TYPE
-async def handle_gen_type_selection(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    """Handle generation type selection."""
-    query = update.callback_query
-    await query.answer()
-    gen_type = query.data.replace("gen_type_", "")
-    context.user_data['gen_type'] = gen_type
-    keyboard = [[InlineKeyboardButton("Back to Home", callback_data="main_menu")]]
-    reply_markup = InlineKeyboardMarkup(keyboard)
-    if gen_type == "text":
-        # Text to Image - go directly to prompt input
-        context.user_data['image_urls'] = []
-        await query.edit_message_text(
-            text="**Please Enter your prompt:**",
-            reply_markup=reply_markup,
-            parse_mode="Markdown"
-        )
-        return WAITING_FOR_PROMPT
-    elif gen_type == "image":
-        # Image to Image - ask for image upload
-        context.user_data['image_urls'] = []
-        keyboard = [[InlineKeyboardButton("Cancel", callback_data="cancel_gen")]]
-        reply_markup = InlineKeyboardMarkup(keyboard)
-        await query.edit_message_text(
-            text="**Please Upload your image:**",
-            reply_markup=reply_markup,
-            parse_mode="Markdown"
-        )
-        return WAITING_FOR_IMAGE
-    return ConversationHandler.END
-async def handle_image_upload(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    """Handle image upload from user."""
-    # Get the largest photo (best quality)
-    photo = update.message.photo[-1]
-    file_id = photo.file_id
-    try:
-        # Get file path from Telegram
-        file = await context.bot.get_file(file_id)
-        file_url = file.file_path
-        # Store the image URL
-        if 'image_urls' not in context.user_data:
-            context.user_data['image_urls'] = []
-        context.user_data['image_urls'].append(file_url)
-        image_count = len(context.user_data['image_urls'])
-        # Determine coin cost based on image count
-        if image_count == 1:
-            coin_cost = COIN_COST_IMAGE_TO_IMAGE
-            cost_text = f"({COIN_COST_IMAGE_TO_IMAGE} coins)"
-        else:
-            coin_cost = COIN_COST_MULTI_IMAGE
-            cost_text = f"({COIN_COST_MULTI_IMAGE} coins)"
-        # Show action options
-        keyboard = [
-            [InlineKeyboardButton(f"Enter Prompt", callback_data="img_action_prompt")],
-            [InlineKeyboardButton("Upload another Image", callback_data="img_action_upload")],
-            [InlineKeyboardButton("❌ Cancel", callback_data="cancel_gen")]
-        ]
-        reply_markup = InlineKeyboardMarkup(keyboard)
-        await update.message.reply_text(
-            text=f"✅ Image received! ({image_count} image{'s' if image_count > 1 else ''} uploaded)\n\n"
-                 f"Choose what to do next:",
-            reply_markup=reply_markup,
-            parse_mode="Markdown"
-        )
-        return WAITING_FOR_IMAGE_ACTION
-    except Exception as e:
-        logger.error(f"Error processing image: {e}")
-        keyboard = [[InlineKeyboardButton("Back to Home", callback_data="main_menu")]]
-        await update.message.reply_text(
-            text=f"Error processing image: {str(e)}",
-            reply_markup=InlineKeyboardMarkup(keyboard)
-        )
-        return ConversationHandler.END
-async def handle_image_action(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    """Handle image action selection (prompt or upload more)."""
-    query = update.callback_query
-    await query.answer()
-    action = query.data.replace("img_action_", "")
-    if action == "prompt":
-        # User wants to enter prompt
-        keyboard = [[InlineKeyboardButton("Back to Home", callback_data="main_menu")]]
-        reply_markup = InlineKeyboardMarkup(keyboard)
-        image_count = len(context.user_data.get('image_urls', []))
-        await query.edit_message_text(
-            text=f"**Please enter your prompt:**",
-            reply_markup=reply_markup,
-            parse_mode="Markdown"
-        )
-        return WAITING_FOR_PROMPT
-    elif action == "upload":
-        # User wants to upload another image
-        keyboard = [[InlineKeyboardButton("Cancel", callback_data="cancel_gen")]]
-        reply_markup = InlineKeyboardMarkup(keyboard)
-        image_count = len(context.user_data.get('image_urls', []))
-        await query.edit_message_text(
-            text=f"**Multi Image to Image** ({image_count} image{'s' if image_count > 1 else ''} uploaded)\n\n"
-                 f"Please upload another image:",
-            reply_markup=reply_markup,
-            parse_mode="Markdown"
-        )
-        return WAITING_FOR_IMAGE
-    return ConversationHandler.END
-async def cancel_generation(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    """Cancel generation and return to main menu."""
-    query = update.callback_query
-    await query.answer()
-    context.user_data.clear()
-    await show_main_menu(update, context)
-    return ConversationHandler.END
-async def handle_prompt(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    """Process the image prompt and ask for size."""
-    prompt = update.message.text
-    if prompt.lower() in ['/start', 'cancel']:
-        await start(update, context)
-        return ConversationHandler.END
-    # Save prompt to context
-    context.user_data['prompt'] = prompt
-    # Show Size Options
-    keyboard = [
-        [InlineKeyboardButton("Square (1:1)", callback_data="size_1024x1024"), InlineKeyboardButton("Portrait (3:4)", callback_data="size_1024x1280")],
-        [InlineKeyboardButton("Landscape (4:3)", callback_data="size_1280x1024"), InlineKeyboardButton("Wide (16:9)", callback_data="size_1280x720")],
-        [InlineKeyboardButton("Back to Home", callback_data="main_menu")]
-    ]
-    reply_markup = InlineKeyboardMarkup(keyboard)
-    await update.message.reply_text(
-        "**Select Aspect Ratio**\n\nChoose the size for your image:",
-        reply_markup=reply_markup,
-        parse_mode="Markdown"
-    )
-    return WAITING_FOR_SIZE
-async def handle_size_selection(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    """Execute generation with selected size."""
-    query = update.callback_query
-    await query.answer()
-    data = query.data
-    if data == "main_menu":
-        await show_main_menu(update, context)
-        return ConversationHandler.END
-    # Parse size "size_WxH"
-    try:
-        size_str = data.split("_")[1]
-        width, height = size_str.split("x")
-    except:
-        width, height = "1024", "1280"  # Fallback
-    prompt = context.user_data.get('prompt', '')
-    chat_id = update.effective_chat.id
-    gen_type = context.user_data.get('gen_type', 'text')
-    image_urls = context.user_data.get('image_urls', [])
-    # Determine model and coin cost based on generation type
-    if gen_type == 'text':
-        model = "zimage"
-        coin_cost = COIN_COST_TEXT_TO_IMAGE
-        image_param = ""
-    elif len(image_urls) == 1:
-        model = "gptimage"
-        coin_cost = COIN_COST_IMAGE_TO_IMAGE
-        image_param = f"&image={image_urls[0]}"
-    else:
-        model = "seedream"
-        coin_cost = COIN_COST_MULTI_IMAGE
-        image_param = f"&image={','.join(image_urls)}"
-    status_msg = await query.edit_message_text(f"Processing request for `{prompt}`...", parse_mode="Markdown")
-    try:
-        # Get user UUID
-        user_response = supabase.table("telegram_users").select("id").eq("chat_id", chat_id).execute()
-        if not user_response.data:
-            keyboard = [[InlineKeyboardButton("Back to Home", callback_data="main_menu")]]
-            await status_msg.edit_text(
-                "Error: User record not found. Type /start to reset.",
-                reply_markup=InlineKeyboardMarkup(keyboard)
-            )
-            return ConversationHandler.END
-        user_uuid = user_response.data[0]['id']
-        # Check limits with required coins
-        check = supabase.rpc("can_generate_image", {"p_user_id": user_uuid, "p_coins_required": coin_cost}).execute()
-        result = check.data[0]
-        if not result['can_generate']:
-            keyboard = [[InlineKeyboardButton("Back to Home", callback_data="main_menu")]]
-            await status_msg.edit_text(
-                f"Request Denied.\nReason: {result['reason']}",
-                reply_markup=InlineKeyboardMarkup(keyboard)
-            )
-            return ConversationHandler.END
-        # Generate
-        gen_type_display = "Text to Image" if gen_type == 'text' else f"Image to Image ({len(image_urls)} image{'s' if len(image_urls) > 1 else ''})"
-        await status_msg.edit_text(f"Generating image ({size_str})...\nType: {gen_type_display}\nPlease wait...", parse_mode="Markdown")
-        api_key = os.getenv("POLLINATIONS_KEY", "")
-        seed = int(datetime.now().timestamp() * 1000) % 100000
-        image_url = f"https://gen.pollinations.ai/image/{prompt}?model={model}&width={width}&height={height}&seed={seed}{image_param}"
-        if api_key:
-            image_url += f"&key={api_key}"
-        response = requests.get(image_url)
-        if response.status_code == 200:
-            # Process & Deduct
-            log_data = {
-                "p_user_id": user_uuid,
-                "p_chat_id": chat_id,
-                "p_prompt": prompt,
-                "p_model_used": model,
-                "p_image_size": size_str,
-                "p_seed": seed,
-                "p_generation_time_ms": int(response.elapsed.total_seconds() * 1000),
-                "p_coins_used": coin_cost
-            }
-            # RPC handles deduction and returns new stats
-            log_res = supabase.rpc("process_image_generation", log_data).execute()
-            log_info = log_res.data[0]
-            # Delete status message so clean chat
-            await status_msg.delete()
-            # 1. Send Image (Clean)
-            await context.bot.send_photo(
-                chat_id=chat_id,
-                photo=io.BytesIO(response.content)
-            )
-            # 2. Send Separate Info/Menu Message
-            if log_info['tier_used'] == 'free':
-                recheck = supabase.rpc("can_generate_image", {"p_user_id": user_uuid}).execute()
-                rem = recheck.data[0]
-                limit_status = f"`{rem['daily_remaining']}` coins remaining today"
-                # Calculate next reset time (00:00 UTC)
-                now_utc = datetime.now(timezone.utc)
-                today_reset = now_utc.replace(hour=0, minute=0, second=0, microsecond=0)
-                if now_utc >= today_reset:
-                    next_reset = today_reset + timedelta(days=1)
-                else:
-                    next_reset = today_reset
-                reset_time = f"{next_reset.strftime('%Y-%m-%d %H:%M')} UTC"
-            else:
-                limit_status = f"`{log_info['tokens_remaining']}` coins remaining"
-                reset_time = "Never (Paid)"
-            info_text = (
-                f"✅ **Generation Complete!**\n\n"
-                f"**Coins Used:** {coin_cost}\n"
-                f"**Balance:** {limit_status}\n\n"
-                f"**Coins will reset at:**\n"
-                f"`{reset_time}`"
-            )
-            keyboard = [
-                [InlineKeyboardButton("Generate Again", callback_data="generate_mode")],
-                [InlineKeyboardButton("Back to Home", callback_data="main_menu")]
-            ]
-            await context.bot.send_message(
-                chat_id=chat_id,
-                text=info_text,
-                reply_markup=InlineKeyboardMarkup(keyboard),
-                parse_mode="Markdown"
-            )
-        else:
-            keyboard = [[InlineKeyboardButton("Back to Home", callback_data="main_menu")]]
-            await status_msg.edit_text(
-                "Generation failed due to provider error.",
-                reply_markup=InlineKeyboardMarkup(keyboard)
-            )
-    except Exception as e:
-        logger.error(f"Error generation: {e}")
-        keyboard = [[InlineKeyboardButton("Back to Home", callback_data="main_menu")]]
-        await status_msg.edit_text(
-            f"System error: {str(e)}",
-            reply_markup=InlineKeyboardMarkup(keyboard)
-        )
-    return ConversationHandler.END
-async def show_profile(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    """Show detailed user profile."""
-    query = update.callback_query
-    await query.answer()
-    chat_id = update.effective_chat.id
-    try:
-        # Get basic user data
-        res = supabase.table("telegram_users").select("*").eq("chat_id", chat_id).execute()
-        if not res.data:
-            keyboard = [[InlineKeyboardButton("Back to Home", callback_data="main_menu")]]
-            await query.edit_message_text(
-                "Profile not found.",
-                reply_markup=InlineKeyboardMarkup(keyboard)
-            )
-            return
-        u = res.data[0]
-        user_uuid = u['id']
-        # Get detailed limits via RPC
-        check = supabase.rpc("can_generate_image", {"p_user_id": user_uuid}).execute()
-        status = check.data[0]
-        # Determine Status Text
-        tier_display = "Free" if u.get('tier') == 'free' else "Premium"
-        status_display = u.get('status', 'active').capitalize()
-        # Calculate limits
-        daily_used = u.get('daily_images_generated', 0)
-        daily_rem = status['daily_remaining']
-        daily_total = daily_used + daily_rem
-        # Calculate next reset time (00:00 UTC)
-        now_utc = datetime.now(timezone.utc)
-        today_reset = now_utc.replace(hour=0, minute=0, second=0, microsecond=0)
-        if now_utc >= today_reset:
-            next_reset = today_reset + timedelta(days=1)
-        else:
-            next_reset = today_reset
-        reset_display = next_reset.strftime('%Y-%m-%d %H:%M') + " UTC"
-        total_gen = u.get('total_images_generated', 0)
-        # Monospace format
-        text = (
-            f"```\n"
-            f"Name            : {u.get('first_name', 'User')}\n\n"
-            f"ID              : {chat_id}\n"
-            f"Region          : {u.get('language_code', 'en')}\n"
-            f"Tier            : {tier_display}\n"
-            f"Status          : {status_display}\n\n"
-            f"Activity\n"
-            f"Total Generated : {total_gen}\n\n"
-            f"Usage\n"
-        )
-        if u.get('tier') == 'paid':
-             text += f"Balance         : {u.get('token_balance', 0)} coins\n"
-        else:
-             text += f"Daily Coins     : {daily_used} / {daily_total}\n"
-             text += f"Reset Time      : {reset_display}\n"
-        text += "```"
-        keyboard = [[InlineKeyboardButton("🔙 Back to Menu", callback_data="main_menu")]]
-        await query.edit_message_text(text=text, reply_markup=InlineKeyboardMarkup(keyboard), parse_mode="Markdown")
-    except Exception as e:
-        logger.error(f"Profile error: {e}")
-        keyboard = [[InlineKeyboardButton("Back to Home", callback_data="main_menu")]]
-        await query.edit_message_text(
-            "Could not load profile.",
-            reply_markup=InlineKeyboardMarkup(keyboard)
-        )
-async def show_help(update: Update, context: ContextTypes.DEFAULT_TYPE):
-    """Show help and contact."""
-    query = update.callback_query
-    await query.answer()
-    text = (
-        "**Help & Support**\n\n"
-        "If you encounter any issues or have questions, please contact our admin:\n"
-        "📩 Contact: @pinturusak\n"
-    )
-    keyboard = [[InlineKeyboardButton("Back to Menu", callback_data="main_menu")]]
-    await query.edit_message_text(text=text, reply_markup=InlineKeyboardMarkup(keyboard), parse_mode="Markdown")
-if __name__ == "__main__":
-    main()

+import os
+import logging
+import requests
+import asyncio
+from datetime import datetime, timezone, timedelta
+from dotenv import load_dotenv
+from telegram import Update, InlineKeyboardButton, InlineKeyboardMarkup
+from telegram.ext import Application, CommandHandler, CallbackQueryHandler, MessageHandler, filters, ContextTypes, ConversationHandler
+from supabase import create_client, Client
+# Load environment variables
+load_dotenv()
+# Configuration
+TELEGRAM_TOKEN = os.getenv("TELEGRAM_BOT_TOKEN")
+SUPABASE_URL = os.getenv("SUPABASE_URL")
+SUPABASE_KEY = os.getenv("SUPABASE_KEY")
+# Logging setup
+logging.basicConfig(
+    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s", level=logging.INFO
+)
+logger = logging.getLogger(__name__)
+# Supabase Client
+supabase: Client = create_client(SUPABASE_URL, SUPABASE_KEY)
+# States for ConversationHandler
+WAITING_FOR_GEN_TYPE = 1
+WAITING_FOR_PROMPT = 2
+WAITING_FOR_SIZE = 3
+WAITING_FOR_IMAGE = 4
+WAITING_FOR_IMAGE_ACTION = 5
+# Coin costs for each generation type
+COIN_COST_TEXT_TO_IMAGE = 1
+COIN_COST_IMAGE_TO_IMAGE = 3
+COIN_COST_MULTI_IMAGE = 5
+async def start(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """Send a message when the command /start is issued."""
+    user = update.effective_user
+    chat_id = update.effective_chat.id
+    # Register/Update user in Supabase
+    try:
+        data = {
+            "p_chat_id": chat_id,
+            "p_username": user.username,
+            "p_first_name": user.first_name,
+            "p_last_name": user.last_name,
+            "p_language_code": user.language_code,
+            "p_is_bot": user.is_bot
+        }
+        supabase.rpc("upsert_telegram_user", data).execute()
+        logger.info(f"User {user.id} upserted to Supabase")
+    except Exception as e:
+        logger.error(f"Error upserting user: {e}")
+    await show_main_menu(update, context)
+import io
+from http.server import HTTPServer, BaseHTTPRequestHandler
+from threading import Thread
+# Dummy Server for Hugging Face Health Check (Port 7860)
+class HealthCheckHandler(BaseHTTPRequestHandler):
+    def do_GET(self):
+        self.send_response(200)
+        self.end_headers()
+        self.wfile.write(b"Bot is running")
+def run_health_server():
+    port = 7860
+    server = HTTPServer(("0.0.0.0", port), HealthCheckHandler)
+    print(f"Health check server running on port {port}")
+    server.serve_forever()
+def main():
+    """Start the bot."""
+    # Start health check server in background
+    Thread(target=run_health_server, daemon=True).start()
+    if not TELEGRAM_TOKEN:
+        print("Error: TELEGRAM_BOT_TOKEN not found.")
+        return
+    # Support for custom API URL (Proxy)
+    base_url = os.getenv("TELEGRAM_API_BASE_URL")
+    base_file_url = os.getenv("TELEGRAM_API_FILE_URL")
+    builder = Application.builder().token(TELEGRAM_TOKEN)
+    if base_url:
+        builder.base_url(base_url)
+        print(f"Using Custom API URL: {base_url}")
+    if base_file_url:
+        builder.base_file_url(base_file_url)
+    application = builder.build()
+    # Conversation handler for generating commands
+    conv_handler = ConversationHandler(
+        entry_points=[CallbackQueryHandler(enter_generate_mode, pattern="^generate_mode$")],
+        states={
+            WAITING_FOR_GEN_TYPE: [
+                CallbackQueryHandler(handle_gen_type_selection, pattern="^gen_type_"),
+            ],
+            WAITING_FOR_PROMPT: [
+                MessageHandler(filters.TEXT & ~filters.COMMAND, handle_prompt)
+            ],
+            WAITING_FOR_SIZE: [
+                CallbackQueryHandler(handle_size_selection)
+            ],
+            WAITING_FOR_IMAGE: [
+                MessageHandler(filters.PHOTO, handle_image_upload),
+                CallbackQueryHandler(cancel_generation, pattern="^cancel_gen$"),
+            ],
+            WAITING_FOR_IMAGE_ACTION: [
+                CallbackQueryHandler(handle_image_action, pattern="^img_action_"),
+                CallbackQueryHandler(cancel_generation, pattern="^cancel_gen$"),
+            ],
+        },
+        fallbacks=[
+            CommandHandler("start", start),
+            CallbackQueryHandler(show_main_menu, pattern="^main_menu$")
+        ]
+    )
+    application.add_handler(CommandHandler("start", start))
+    application.add_handler(conv_handler)
+    # Menu callbacks
+    application.add_handler(CallbackQueryHandler(show_main_menu, pattern="^main_menu$"))
+    application.add_handler(CallbackQueryHandler(show_profile, pattern="^profile$"))
+    application.add_handler(CallbackQueryHandler(show_help, pattern="^help$"))
+    # Run the bot
+    print("Bot is running...")
+    application.run_polling()
+async def show_main_menu(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """Displays the main menu with inline buttons."""
+    user = update.effective_user
+    # Use @username if available, otherwise fallback to first_name
+    if user.username:
+        username = f"@{user.username}"
+    else:
+        username = user.first_name if user.first_name else "User"
+    # Clear any stored generation data
+    context.user_data.clear()
+    keyboard = [
+        [InlineKeyboardButton("Generate Image", callback_data="generate_mode")],
+        [InlineKeyboardButton("My Profile", callback_data="profile")],
+        [InlineKeyboardButton("Help & Support", callback_data="help")]
+    ]
+    reply_markup = InlineKeyboardMarkup(keyboard)
+    text = (
+        f"Hi {username}, welcome to the @iceboxai\\_bot.\n\n"
+        "✨ **What you can create:**\n"
+        "• Realistic photos\n"
+        "• Anime & illustration\n"
+        "• Cinematic portraits\n"
+        "• Fantasy & concept art\n"
+        "• Logos & product visuals\n\n"
+        "Choose an option below to get started 👇\n\n"
+    )
+    if update.callback_query:
+        await update.callback_query.answer()
+        try:
+            await update.callback_query.edit_message_text(text=text, reply_markup=reply_markup, parse_mode="Markdown")
+        except:
+             await update.callback_query.message.reply_text(text, reply_markup=reply_markup, parse_mode="Markdown")
+    else:
+        await update.message.reply_text(text, reply_markup=reply_markup, parse_mode="Markdown")
+    return ConversationHandler.END
+async def get_user_coins_info(chat_id: int):
+    """Get user coin balance and reset time."""
+    try:
+        user_response = supabase.table("telegram_users").select("id, tier, token_balance, daily_images_generated").eq("chat_id", chat_id).execute()
+        if not user_response.data:
+            return None, 0, None
+        user = user_response.data[0]
+        user_uuid = user['id']
+        # Get limits via RPC
+        check = supabase.rpc("can_generate_image", {"p_user_id": user_uuid}).execute()
+        status = check.data[0]
+        # Calculate coins remaining (for free tier, use daily_remaining)
+        if user['tier'] == 'free':
+            coins = status['daily_remaining']
+        else:
+            coins = user['token_balance']
+        # Calculate next reset time (00:00 UTC next day)
+        now_utc = datetime.now(timezone.utc)
+        today_reset = now_utc.replace(hour=0, minute=0, second=0, microsecond=0)
+        if now_utc >= today_reset:
+            next_reset = today_reset + timedelta(days=1)
+        else:
+            next_reset = today_reset
+        return user_uuid, coins, next_reset
+    except Exception as e:
+        logger.error(f"Error getting user coins: {e}")
+        return None, 0, None
+async def enter_generate_mode(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """Show generation type selection with coin info."""
+    query = update.callback_query
+    await query.answer()
+    chat_id = update.effective_chat.id
+    user_uuid, coins, next_reset = await get_user_coins_info(chat_id)
+    if user_uuid is None:
+        keyboard = [[InlineKeyboardButton("Back to Home", callback_data="main_menu")]]
+        await query.edit_message_text(
+            text="Error: User record not found. Type /start to reset.",
+            reply_markup=InlineKeyboardMarkup(keyboard)
+        )
+        return ConversationHandler.END
+    # Store user_uuid for later use
+    context.user_data['user_uuid'] = user_uuid
+    context.user_data['coins'] = coins
+    reset_time_str = next_reset.strftime('%Y-%m-%d %H:%M') + " UTC" if next_reset else "N/A"
+    keyboard = [
+        [InlineKeyboardButton("Text to Image", callback_data="gen_type_text")],
+        [InlineKeyboardButton("Image to Image", callback_data="gen_type_image")],
+        [InlineKeyboardButton("Back to Menu", callback_data="main_menu")]
+    ]
+    reply_markup = InlineKeyboardMarkup(keyboard)
+    text = (
+        f"You have 🪙 **{coins} coins** remaining\n\n"
+        "**Choose what you want to generate:**\n\n"
+        "```\n"
+        f"Text to Image        : {COIN_COST_TEXT_TO_IMAGE} coin\n"
+        f"Image to Image       : {COIN_COST_IMAGE_TO_IMAGE} coins\n"
+        f"Multi Image to Image : {COIN_COST_MULTI_IMAGE} coins\n"
+        "```\n"
+        f"Your coins will be reset back to 30 at:\n"
+        f"`{reset_time_str}`"
+    )
+    await query.edit_message_text(
+        text=text,
+        reply_markup=reply_markup,
+        parse_mode="Markdown"
+    )
+    return WAITING_FOR_GEN_TYPE
+async def handle_gen_type_selection(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """Handle generation type selection."""
+    query = update.callback_query
+    await query.answer()
+    gen_type = query.data.replace("gen_type_", "")
+    context.user_data['gen_type'] = gen_type
+    keyboard = [[InlineKeyboardButton("Back to Home", callback_data="main_menu")]]
+    reply_markup = InlineKeyboardMarkup(keyboard)
+    if gen_type == "text":
+        # Text to Image - go directly to prompt input
+        context.user_data['image_urls'] = []
+        await query.edit_message_text(
+            text="**Please Enter your prompt:**",
+            reply_markup=reply_markup,
+            parse_mode="Markdown"
+        )
+        return WAITING_FOR_PROMPT
+    elif gen_type == "image":
+        # Image to Image - ask for image upload
+        context.user_data['image_urls'] = []
+        keyboard = [[InlineKeyboardButton("Cancel", callback_data="cancel_gen")]]
+        reply_markup = InlineKeyboardMarkup(keyboard)
+        await query.edit_message_text(
+            text="**Please Upload your image:**",
+            reply_markup=reply_markup,
+            parse_mode="Markdown"
+        )
+        return WAITING_FOR_IMAGE
+    return ConversationHandler.END
+async def handle_image_upload(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """Handle image upload from user."""
+    # Get the largest photo (best quality)
+    photo = update.message.photo[-1]
+    file_id = photo.file_id
+    try:
+        # Get file path from Telegram
+        file = await context.bot.get_file(file_id)
+        file_url = file.file_path
+        # Store the image URL
+        if 'image_urls' not in context.user_data:
+            context.user_data['image_urls'] = []
+        context.user_data['image_urls'].append(file_url)
+        image_count = len(context.user_data['image_urls'])
+        # Determine coin cost based on image count
+        if image_count == 1:
+            coin_cost = COIN_COST_IMAGE_TO_IMAGE
+            cost_text = f"({COIN_COST_IMAGE_TO_IMAGE} coins)"
+        else:
+            coin_cost = COIN_COST_MULTI_IMAGE
+            cost_text = f"({COIN_COST_MULTI_IMAGE} coins)"
+        # Show action options
+        keyboard = [
+            [InlineKeyboardButton(f"Enter Prompt", callback_data="img_action_prompt")],
+            [InlineKeyboardButton("Upload another Image", callback_data="img_action_upload")],
+            [InlineKeyboardButton("❌ Cancel", callback_data="cancel_gen")]
+        ]
+        reply_markup = InlineKeyboardMarkup(keyboard)
+        await update.message.reply_text(
+            text=f"✅ Image received! ({image_count} image{'s' if image_count > 1 else ''} uploaded)\n\n"
+                 f"Choose what to do next:",
+            reply_markup=reply_markup,
+            parse_mode="Markdown"
+        )
+        return WAITING_FOR_IMAGE_ACTION
+    except Exception as e:
+        logger.error(f"Error processing image: {e}")
+        keyboard = [[InlineKeyboardButton("Back to Home", callback_data="main_menu")]]
+        await update.message.reply_text(
+            text=f"Error processing image: {str(e)}",
+            reply_markup=InlineKeyboardMarkup(keyboard)
+        )
+        return ConversationHandler.END
+async def handle_image_action(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """Handle image action selection (prompt or upload more)."""
+    query = update.callback_query
+    await query.answer()
+    action = query.data.replace("img_action_", "")
+    if action == "prompt":
+        # User wants to enter prompt
+        keyboard = [[InlineKeyboardButton("Back to Home", callback_data="main_menu")]]
+        reply_markup = InlineKeyboardMarkup(keyboard)
+        image_count = len(context.user_data.get('image_urls', []))
+        await query.edit_message_text(
+            text=f"**Please enter your prompt:**",
+            reply_markup=reply_markup,
+            parse_mode="Markdown"
+        )
+        return WAITING_FOR_PROMPT
+    elif action == "upload":
+        # User wants to upload another image
+        keyboard = [[InlineKeyboardButton("Cancel", callback_data="cancel_gen")]]
+        reply_markup = InlineKeyboardMarkup(keyboard)
+        image_count = len(context.user_data.get('image_urls', []))
+        await query.edit_message_text(
+            text=f"**Multi Image to Image** ({image_count} image{'s' if image_count > 1 else ''} uploaded)\n\n"
+                 f"Please upload another image:",
+            reply_markup=reply_markup,
+            parse_mode="Markdown"
+        )
+        return WAITING_FOR_IMAGE
+    return ConversationHandler.END
+async def cancel_generation(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """Cancel generation and return to main menu."""
+    query = update.callback_query
+    await query.answer()
+    context.user_data.clear()
+    await show_main_menu(update, context)
+    return ConversationHandler.END
+async def handle_prompt(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """Process the image prompt and ask for size."""
+    prompt = update.message.text
+    if prompt.lower() in ['/start', 'cancel']:
+        await start(update, context)
+        return ConversationHandler.END
+    # Save prompt to context
+    context.user_data['prompt'] = prompt
+    # Show Size Options
+    keyboard = [
+        [InlineKeyboardButton("Square (1:1)", callback_data="size_1024x1024"), InlineKeyboardButton("Portrait (3:4)", callback_data="size_1024x1280")],
+        [InlineKeyboardButton("Landscape (4:3)", callback_data="size_1280x1024"), InlineKeyboardButton("Wide (16:9)", callback_data="size_1280x720")],
+        [InlineKeyboardButton("Back to Home", callback_data="main_menu")]
+    ]
+    reply_markup = InlineKeyboardMarkup(keyboard)
+    await update.message.reply_text(
+        "**Select Aspect Ratio**\n\nChoose the size for your image:",
+        reply_markup=reply_markup,
+        parse_mode="Markdown"
+    )
+    return WAITING_FOR_SIZE
+async def handle_size_selection(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """Execute generation with selected size."""
+    query = update.callback_query
+    await query.answer()
+    data = query.data
+    if data == "main_menu":
+        await show_main_menu(update, context)
+        return ConversationHandler.END
+    # Parse size "size_WxH"
+    try:
+        size_str = data.split("_")[1]
+        width, height = size_str.split("x")
+    except:
+        width, height = "1024", "1280"  # Fallback
+    prompt = context.user_data.get('prompt', '')
+    chat_id = update.effective_chat.id
+    gen_type = context.user_data.get('gen_type', 'text')
+    image_urls = context.user_data.get('image_urls', [])
+    # Determine model and coin cost based on generation type
+    if gen_type == 'text':
+        model = "zimage"
+        coin_cost = COIN_COST_TEXT_TO_IMAGE
+        image_param = ""
+    elif len(image_urls) == 1:
+        model = "gptimage"
+        coin_cost = COIN_COST_IMAGE_TO_IMAGE
+        image_param = f"&image={image_urls[0]}"
+    else:
+        model = "seedream"
+        coin_cost = COIN_COST_MULTI_IMAGE
+        image_param = f"&image={','.join(image_urls)}"
+    status_msg = await query.edit_message_text(f"Processing request for `{prompt}`...", parse_mode="Markdown")
+    try:
+        # Get user UUID
+        user_response = supabase.table("telegram_users").select("id").eq("chat_id", chat_id).execute()
+        if not user_response.data:
+            keyboard = [[InlineKeyboardButton("Back to Home", callback_data="main_menu")]]
+            await status_msg.edit_text(
+                "Error: User record not found. Type /start to reset.",
+                reply_markup=InlineKeyboardMarkup(keyboard)
+            )
+            return ConversationHandler.END
+        user_uuid = user_response.data[0]['id']
+        # Check limits with required coins
+        check = supabase.rpc("can_generate_image", {"p_user_id": user_uuid, "p_coins_required": coin_cost}).execute()
+        result = check.data[0]
+        if not result['can_generate']:
+            keyboard = [[InlineKeyboardButton("Back to Home", callback_data="main_menu")]]
+            await status_msg.edit_text(
+                f"Request Denied.\nReason: {result['reason']}",
+                reply_markup=InlineKeyboardMarkup(keyboard)
+            )
+            return ConversationHandler.END
+        # Generate
+        gen_type_display = "Text to Image" if gen_type == 'text' else f"Image to Image ({len(image_urls)} image{'s' if len(image_urls) > 1 else ''})"
+        await status_msg.edit_text(f"Generating image ({size_str})...\nType: {gen_type_display}\nPlease wait...", parse_mode="Markdown")
+        api_key = os.getenv("POLLINATIONS_KEY", "")
+        seed = int(datetime.now().timestamp() * 1000) % 100000
+        image_url = f"https://gen.pollinations.ai/image/{prompt}?model={model}&width={width}&height={height}&seed={seed}{image_param}"
+        if api_key:
+            image_url += f"&key={api_key}"
+        response = requests.get(image_url)
+        if response.status_code == 200:
+            # Process & Deduct
+            log_data = {
+                "p_user_id": user_uuid,
+                "p_chat_id": chat_id,
+                "p_prompt": prompt,
+                "p_model_used": model,
+                "p_image_size": size_str,
+                "p_seed": seed,
+                "p_generation_time_ms": int(response.elapsed.total_seconds() * 1000),
+                "p_coins_used": coin_cost
+            }
+            # RPC handles deduction and returns new stats
+            log_res = supabase.rpc("process_image_generation", log_data).execute()
+            log_info = log_res.data[0]
+            # Delete status message so clean chat
+            await status_msg.delete()
+            # 1. Send Image (Clean)
+            await context.bot.send_photo(
+                chat_id=chat_id,
+                photo=io.BytesIO(response.content)
+            )
+            # 2. Send Separate Info/Menu Message
+            if log_info['tier_used'] == 'free':
+                recheck = supabase.rpc("can_generate_image", {"p_user_id": user_uuid}).execute()
+                rem = recheck.data[0]
+                limit_status = f"`{rem['daily_remaining']}` coins remaining today"
+                # Calculate next reset time (00:00 UTC)
+                now_utc = datetime.now(timezone.utc)
+                today_reset = now_utc.replace(hour=0, minute=0, second=0, microsecond=0)
+                if now_utc >= today_reset:
+                    next_reset = today_reset + timedelta(days=1)
+                else:
+                    next_reset = today_reset
+                reset_time = f"{next_reset.strftime('%Y-%m-%d %H:%M')} UTC"
+            else:
+                limit_status = f"`{log_info['tokens_remaining']}` coins remaining"
+                reset_time = "Never (Paid)"
+            info_text = (
+                f"✅ **Generation Complete!**\n\n"
+                f"**Coins Used:** {coin_cost}\n"
+                f"**Balance:** {limit_status}\n\n"
+                f"**Coins will reset at:**\n"
+                f"`{reset_time}`"
+            )
+            keyboard = [
+                [InlineKeyboardButton("Generate Again", callback_data="generate_mode")],
+                [InlineKeyboardButton("Back to Home", callback_data="main_menu")]
+            ]
+            await context.bot.send_message(
+                chat_id=chat_id,
+                text=info_text,
+                reply_markup=InlineKeyboardMarkup(keyboard),
+                parse_mode="Markdown"
+            )
+        else:
+            keyboard = [[InlineKeyboardButton("Back to Home", callback_data="main_menu")]]
+            await status_msg.edit_text(
+                "Generation failed due to provider error.",
+                reply_markup=InlineKeyboardMarkup(keyboard)
+            )
+    except Exception as e:
+        logger.error(f"Error generation: {e}")
+        keyboard = [[InlineKeyboardButton("Back to Home", callback_data="main_menu")]]
+        await status_msg.edit_text(
+            f"System error: {str(e)}",
+            reply_markup=InlineKeyboardMarkup(keyboard)
+        )
+    return ConversationHandler.END
+async def show_profile(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """Show detailed user profile."""
+    query = update.callback_query
+    await query.answer()
+    chat_id = update.effective_chat.id
+    try:
+        # Get basic user data
+        res = supabase.table("telegram_users").select("*").eq("chat_id", chat_id).execute()
+        if not res.data:
+            keyboard = [[InlineKeyboardButton("Back to Home", callback_data="main_menu")]]
+            await query.edit_message_text(
+                "Profile not found.",
+                reply_markup=InlineKeyboardMarkup(keyboard)
+            )
+            return
+        u = res.data[0]
+        user_uuid = u['id']
+        # Get detailed limits via RPC
+        check = supabase.rpc("can_generate_image", {"p_user_id": user_uuid}).execute()
+        status = check.data[0]
+        # Determine Status Text
+        tier_display = "Free" if u.get('tier') == 'free' else "Premium"
+        status_display = u.get('status', 'active').capitalize()
+        # Calculate limits
+        daily_used = u.get('daily_images_generated', 0)
+        daily_rem = status['daily_remaining']
+        daily_total = daily_used + daily_rem
+        # Calculate next reset time (00:00 UTC)
+        now_utc = datetime.now(timezone.utc)
+        today_reset = now_utc.replace(hour=0, minute=0, second=0, microsecond=0)
+        if now_utc >= today_reset:
+            next_reset = today_reset + timedelta(days=1)
+        else:
+            next_reset = today_reset
+        reset_display = next_reset.strftime('%Y-%m-%d %H:%M') + " UTC"
+        total_gen = u.get('total_images_generated', 0)
+        # Monospace format
+        text = (
+            f"```\n"
+            f"Name            : {u.get('first_name', 'User')}\n\n"
+            f"ID              : {chat_id}\n"
+            f"Region          : {u.get('language_code', 'en')}\n"
+            f"Tier            : {tier_display}\n"
+            f"Status          : {status_display}\n\n"
+            f"Activity\n"
+            f"Total Generated : {total_gen}\n\n"
+            f"Usage\n"
+        )
+        if u.get('tier') == 'paid':
+             text += f"Balance         : {u.get('token_balance', 0)} coins\n"
+        else:
+             text += f"Daily Coins     : {daily_used} / {daily_total}\n"
+             text += f"Reset Time      : {reset_display}\n"
+        text += "```"
+        keyboard = [[InlineKeyboardButton("🔙 Back to Menu", callback_data="main_menu")]]
+        await query.edit_message_text(text=text, reply_markup=InlineKeyboardMarkup(keyboard), parse_mode="Markdown")
+    except Exception as e:
+        logger.error(f"Profile error: {e}")
+        keyboard = [[InlineKeyboardButton("Back to Home", callback_data="main_menu")]]
+        await query.edit_message_text(
+            "Could not load profile.",
+            reply_markup=InlineKeyboardMarkup(keyboard)
+        )
+async def show_help(update: Update, context: ContextTypes.DEFAULT_TYPE):
+    """Show help and contact."""
+    query = update.callback_query
+    await query.answer()
+    text = (
+        "**Help & Support**\n\n"
+        "If you encounter any issues or have questions, please contact our admin:\n"
+        "📩 Contact: @pinturusak\n"
+    )
+    keyboard = [[InlineKeyboardButton("Back to Menu", callback_data="main_menu")]]
+    await query.edit_message_text(text=text, reply_markup=InlineKeyboardMarkup(keyboard), parse_mode="Markdown")
+if __name__ == "__main__":
+    main()

requirements.txt CHANGED Viewed

@@ -1,4 +1,5 @@
-python-telegram-bot>=20.7
-supabase
-requests
-python-dotenv

+python-telegram-bot>=20.7
+supabase
+requests
+python-dotenv
+flask

start.sh ADDED Viewed

	@@ -0,0 +1,8 @@

+#!/bin/bash
+# Start both the Telegram bot and Admin console
+# Start the admin web console in background
+python admin.py &
+# Start the Telegram bot (main process)
+python bot.py