Update app.py

app.py

@@ -1,154 +1,791 @@
 import os
 import uuid
 import json
+import asyncio
+import logging
+import time
+from datetime import datetime, timedelta
+from typing import Dict, List, Optional, Tuple, Any
+from dataclasses import dataclass
+from contextlib import asynccontextmanager
+
 import gradio as gr
 import requests
+import aiohttp
+import asyncpg
 from transformers import AutoTokenizer, AutoModelForCausalLM, pipeline
 from dotenv import load_dotenv
+from pydantic import BaseModel, ValidationError
+import jwt
+from functools import wraps
+import hashlib
+import secrets
 
-# ----------------- Configuração -----------------
+# ----------------- Configuration & Models -----------------
 load_dotenv()
 
-HF_TOKEN = os.environ.get("HF_TOKEN")  # Token Hugging Face para modelos gated
-MODEL_NAME = "google/gemma-3-270m-it"
-SUPABASE_URL = os.environ.get("SUPABASE_URL")
-SUPABASE_KEY = os.environ.get("SUPABASE_KEY")
-
-if not all([HF_TOKEN, SUPABASE_URL, SUPABASE_KEY]):
-    raise ValueError("Missing required environment variables.")
-
-HEADERS = {
-    "apikey": SUPABASE_KEY,
-    "Authorization": f"Bearer {SUPABASE_KEY}",
-    "Content-Type": "application/json"
-}
-
-# ----------------- Carregar Modelo -----------------
-try:
-    tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME, use_auth_token=HF_TOKEN)
-    model = AutoModelForCausalLM.from_pretrained(MODEL_NAME, use_auth_token=HF_TOKEN, device_map="auto")
-    gen_pipe = pipeline("text-generation", model=model, tokenizer=tokenizer)
-    print("✅ Model loaded successfully!")
-except Exception as e:
-    print(f"❌ Error loading model: {e}")
-    gen_pipe = None
+@dataclass
+class Config:
+    HF_TOKEN: str = os.getenv("HF_TOKEN", "")
+    MODEL_NAME: str = os.getenv("MODEL_NAME", "google/gemma-3-270m-it")
+    SUPABASE_URL: str = os.getenv("SUPABASE_URL", "")
+    SUPABASE_KEY: str = os.getenv("SUPABASE_KEY", "")
+    JWT_SECRET: str = os.getenv("JWT_SECRET", secrets.token_urlsafe(32))
+    RATE_LIMIT_PER_HOUR: int = int(os.getenv("RATE_LIMIT_PER_HOUR", "100"))
+    MAX_TOKENS: int = int(os.getenv("MAX_TOKENS", "500"))
+    LOG_LEVEL: str = os.getenv("LOG_LEVEL", "INFO")
 
-# ----------------- Funções Supabase -----------------
-def create_user(name: str, hf_user_id: str):
-    """Cria usuário no Supabase vinculado ao Hugging Face ID"""
-    if not name.strip():
-        return "⚠️ Name cannot be empty.", ""
-    api_key = str(uuid.uuid4())
-    data = {"name": name.strip(), "api_key": api_key, "hf_user_id": hf_user_id, "requests": 0}
-    try:
-        r = requests.post(f"{SUPABASE_URL}/rest/v1/users", headers=HEADERS, data=json.dumps(data))
-        r.raise_for_status()
-        return f"✅ API key created for {name}.", api_key
-    except Exception as e:
-        return f"❌ Error creating user: {e}", ""
+class GenerationRequest(BaseModel):
+    prompt: str
+    max_tokens: int = 200
+    temperature: float = 0.7
+    top_k: int = 50
+    top_p: float = 0.95
 
-def check_key(api_key: str) -> bool:
-    try:
-        r = requests.get(f"{SUPABASE_URL}/rest/v1/users?api_key=eq.{api_key.strip()}", headers=HEADERS)
-        r.raise_for_status()
-        return len(r.json()) > 0
-    except:
-        return False
+class UserCreate(BaseModel):
+    name: str
+    email: str
+    plan: str = "free"
 
-def increment_requests(api_key: str):
-    """Incrementa contagem de requisições para API Key"""
-    try:
-        r = requests.get(f"{SUPABASE_URL}/rest/v1/users?api_key=eq.{api_key.strip()}", headers=HEADERS)
-        r.raise_for_status()
-        data = r.json()
-        if not data:
-            return
-        user_id = data[0]["id"]
-        requests_count = data[0].get("requests", 0) + 1
-        patch_data = {"requests": requests_count}
-        requests.patch(f"{SUPABASE_URL}/rest/v1/users?id=eq.{user_id}", headers=HEADERS, data=json.dumps(patch_data))
-    except:
-        pass
+class APIResponse(BaseModel):
+    success: bool
+    data: Any = None
+    error: str = None
+    timestamp: datetime = datetime.now()
 
-def get_user_info(api_key: str):
-    try:
-        r = requests.get(f"{SUPABASE_URL}/rest/v1/users?api_key=eq.{api_key.strip()}", headers=HEADERS)
-        r.raise_for_status()
-        data = r.json()
-        return data[0] if data else None
-    except:
-        return None
+# ----------------- Enhanced Logger -----------------
+def setup_logger():
+    logging.basicConfig(
+        level=getattr(logging, Config().LOG_LEVEL),
+        format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+        handlers=[
+            logging.FileHandler('gemma_saas.log'),
+            logging.StreamHandler()
+        ]
+    )
+    return logging.getLogger(__name__)
 
-# ----------------- Função de Geração -----------------
-def generate_text(prompt: str, api_key: str):
-    if gen_pipe is None:
-        return "❌ Model not loaded."
-    if not api_key.strip() or not check_key(api_key):
-        return "⚠️ Invalid API key!"
-    if not prompt.strip():
-        return "⚠️ Prompt cannot be empty."
-    try:
-        result = gen_pipe(prompt.strip(), max_new_tokens=200, do_sample=True, temperature=0.7, top_k=50, top_p=0.95)
-        increment_requests(api_key)
-        return result[0]["generated_text"]
-    except Exception as e:
-        print(f"❌ Error: {e}")
-        return "❌ Something went wrong."
+logger = setup_logger()
 
-# ----------------- CSS para Sidebar e Cards -----------------
-custom_css = """
-body {background: linear-gradient(135deg,#f0f4f8 0%,#d9e2ec 100%); font-family:'Inter', sans-serif;}
-.gradio-container {max-width: 1200px !important; margin:auto !important; padding-top:2rem;}
-.sidebar {background:#1e293b; color:white; padding:1rem; border-radius:10px;}
-.sidebar label {color:#cbd5e1; font-weight:600;}
-.gr-button {border-radius:12px !important; background:linear-gradient(90deg,#4f46e5,#3b82f6) !important; color:white !important; font-weight:600;}
-.gr-button:hover {transform: translateY(-2px); box-shadow:0 6px 12px rgba(0,0,0,0.15);}
-"""
+# ----------------- Database Manager -----------------
+class DatabaseManager:
+    def __init__(self, config: Config):
+        self.config = config
+        self.headers = {
+            "apikey": config.SUPABASE_KEY,
+            "Authorization": f"Bearer {config.SUPABASE_KEY}",
+            "Content-Type": "application/json"
+        }
+    
+    async def create_user(self, user_data: UserCreate, hf_user_id: str = None) -> Tuple[bool, str, str]:
+        """Create user with enhanced validation and security"""
+        try:
+            # Generate secure API key
+            api_key = self._generate_api_key()
+            api_key_hash = hashlib.sha256(api_key.encode()).hexdigest()
+            
+            data = {
+                "name": user_data.name.strip(),
+                "email": user_data.email.strip(),
+                "api_key_hash": api_key_hash,
+                "hf_user_id": hf_user_id,
+                "requests": 0,
+                "plan": user_data.plan,
+                "created_at": datetime.now().isoformat(),
+                "last_request": None,
+                "rate_limit_reset": (datetime.now() + timedelta(hours=1)).isoformat()
+            }
+            
+            async with aiohttp.ClientSession() as session:
+                async with session.post(
+                    f"{self.config.SUPABASE_URL}/rest/v1/users",
+                    headers=self.headers,
+                    data=json.dumps(data)
+                ) as response:
+                    if response.status == 201:
+                        logger.info(f"User created successfully: {user_data.email}")
+                        return True, f"✅ User created successfully for {user_data.name}", api_key
+                    else:
+                        error_text = await response.text()
+                        logger.error(f"Error creating user: {error_text}")
+                        return False, f"❌ Error creating user: {error_text}", ""
+                        
+        except Exception as e:
+            logger.error(f"Database error creating user: {e}")
+            return False, f"❌ Database error: {str(e)}", ""
+    
+    def _generate_api_key(self) -> str:
+        """Generate secure API key with prefix"""
+        return f"gsa_{secrets.token_urlsafe(32)}"
+    
+    async def validate_api_key(self, api_key: str) -> Optional[Dict]:
+        """Validate API key and return user data"""
+        try:
+            api_key_hash = hashlib.sha256(api_key.encode()).hexdigest()
+            
+            async with aiohttp.ClientSession() as session:
+                async with session.get(
+                    f"{self.config.SUPABASE_URL}/rest/v1/users?api_key_hash=eq.{api_key_hash}",
+                    headers=self.headers
+                ) as response:
+                    if response.status == 200:
+                        data = await response.json()
+                        return data[0] if data else None
+                    return None
+        except Exception as e:
+            logger.error(f"Error validating API key: {e}")
+            return None
+    
+    async def check_rate_limit(self, user_id: int) -> bool:
+        """Check if user has exceeded rate limit"""
+        try:
+            async with aiohttp.ClientSession() as session:
+                async with session.get(
+                    f"{self.config.SUPABASE_URL}/rest/v1/users?id=eq.{user_id}",
+                    headers=self.headers
+                ) as response:
+                    if response.status == 200:
+                        data = await response.json()
+                        if data:
+                            user = data[0]
+                            reset_time = datetime.fromisoformat(user.get('rate_limit_reset', ''))
+                            
+                            if datetime.now() > reset_time:
+                                # Reset rate limit
+                                await self._reset_rate_limit(user_id)
+                                return True
+                            
+                            return user.get('requests_this_hour', 0) < Config().RATE_LIMIT_PER_HOUR
+                    return False
+        except Exception as e:
+            logger.error(f"Error checking rate limit: {e}")
+            return False
+    
+    async def _reset_rate_limit(self, user_id: int):
+        """Reset hourly rate limit"""
+        try:
+            data = {
+                "requests_this_hour": 0,
+                "rate_limit_reset": (datetime.now() + timedelta(hours=1)).isoformat()
+            }
+            
+            async with aiohttp.ClientSession() as session:
+                async with session.patch(
+                    f"{self.config.SUPABASE_URL}/rest/v1/users?id=eq.{user_id}",
+                    headers=self.headers,
+                    data=json.dumps(data)
+                ) as response:
+                    if response.status != 200:
+                        logger.error(f"Failed to reset rate limit for user {user_id}")
+        except Exception as e:
+            logger.error(f"Error resetting rate limit: {e}")
+    
+    async def increment_usage(self, user_id: int, tokens_used: int):
+        """Increment user usage statistics"""
+        try:
+            # Get current stats
+            async with aiohttp.ClientSession() as session:
+                async with session.get(
+                    f"{self.config.SUPABASE_URL}/rest/v1/users?id=eq.{user_id}",
+                    headers=self.headers
+                ) as response:
+                    if response.status == 200:
+                        data = await response.json()
+                        if data:
+                            user = data[0]
+                            new_data = {
+                                "requests": user.get('requests', 0) + 1,
+                                "requests_this_hour": user.get('requests_this_hour', 0) + 1,
+                                "tokens_used": user.get('tokens_used', 0) + tokens_used,
+                                "last_request": datetime.now().isoformat()
+                            }
+                            
+                            await session.patch(
+                                f"{self.config.SUPABASE_URL}/rest/v1/users?id=eq.{user_id}",
+                                headers=self.headers,
+                                data=json.dumps(new_data)
+                            )
+        except Exception as e:
+            logger.error(f"Error incrementing usage: {e}")
 
-# ----------------- Interface Gradio -----------------
-with gr.Blocks(css=custom_css) as app:
-    # Header
-    gr.Markdown("<h1 style='text-align:center; font-size:3rem; background: linear-gradient(90deg,#4f46e5,#3b82f6); -webkit-background-clip:text; -webkit-text-fill-color:transparent;'>✨ Gemma SaaS Platform</h1>")
-    gr.Markdown("<p style='text-align:center; font-size:1.2rem; color:#334155;'>Playground + Profile with Hugging Face login & API keys</p>")
+# ----------------- Model Manager -----------------
+class ModelManager:
+    def __init__(self, config: Config):
+        self.config = config
+        self.tokenizer = None
+        self.model = None
+        self.pipeline = None
+        self.model_loaded = False
+    
+    async def initialize(self):
+        """Initialize model asynchronously"""
+        try:
+            logger.info("Loading model...")
+            loop = asyncio.get_event_loop()
+            
+            # Load tokenizer
+            self.tokenizer = await loop.run_in_executor(
+                None, 
+                lambda: AutoTokenizer.from_pretrained(
+                    self.config.MODEL_NAME, 
+                    use_auth_token=self.config.HF_TOKEN
+                )
+            )
+            
+            # Load model
+            self.model = await loop.run_in_executor(
+                None,
+                lambda: AutoModelForCausalLM.from_pretrained(
+                    self.config.MODEL_NAME,
+                    use_auth_token=self.config.HF_TOKEN,
+                    device_map="auto",
+                    torch_dtype="auto"
+                )
+            )
+            
+            # Create pipeline
+            self.pipeline = await loop.run_in_executor(
+                None,
+                lambda: pipeline(
+                    "text-generation",
+                    model=self.model,
+                    tokenizer=self.tokenizer,
+                    pad_token_id=self.tokenizer.eos_token_id
+                )
+            )
+            
+            self.model_loaded = True
+            logger.info("✅ Model loaded successfully!")
+            
+        except Exception as e:
+            logger.error(f"❌ Error loading model: {e}")
+            self.model_loaded = False
+    
+    async def generate(self, request: GenerationRequest) -> Tuple[bool, str, int]:
+        """Generate text with the model"""
+        if not self.model_loaded:
+            return False, "❌ Model not loaded", 0
+        
+        try:
+            # Input validation
+            if len(request.prompt.strip()) == 0:
+                return False, "⚠️ Prompt cannot be empty", 0
+            
+            if len(request.prompt) > 2000:
+                return False, "⚠️ Prompt too long (max 2000 characters)", 0
+            
+            # Generate text
+            loop = asyncio.get_event_loop()
+            result = await loop.run_in_executor(
+                None,
+                lambda: self.pipeline(
+                    request.prompt.strip(),
+                    max_new_tokens=min(request.max_tokens, self.config.MAX_TOKENS),
+                    do_sample=True,
+                    temperature=request.temperature,
+                    top_k=request.top_k,
+                    top_p=request.top_p,
+                    pad_token_id=self.tokenizer.eos_token_id,
+                    return_full_text=False
+                )
+            )
+            
+            generated_text = result[0]["generated_text"]
+            tokens_used = len(self.tokenizer.encode(generated_text))
+            
+            return True, generated_text, tokens_used
+            
+        except Exception as e:
+            logger.error(f"Generation error: {e}")
+            return False, f"❌ Generation failed: {str(e)}", 0
 
-    with gr.Row():
-        # Sidebar
-        with gr.Column(scale=1, min_width=250):
-            gr.Markdown("### Menu")
-            menu_radio = gr.Radio(choices=["Playground", "Profile"], value="Playground", label="", elem_classes=["sidebar"])
+# ----------------- Service Layer -----------------
+class GemmaSaaSService:
+    def __init__(self):
+        self.config = Config()
+        self.db = DatabaseManager(self.config)
+        self.model_manager = ModelManager(self.config)
+        self._validate_config()
+    
+    def _validate_config(self):
+        """Validate required configuration"""
+        required_fields = ['HF_TOKEN', 'SUPABASE_URL', 'SUPABASE_KEY']
+        missing_fields = [field for field in required_fields if not getattr(self.config, field)]
+        
+        if missing_fields:
+            raise ValueError(f"Missing required environment variables: {', '.join(missing_fields)}")
+    
+    async def initialize(self):
+        """Initialize all services"""
+        await self.model_manager.initialize()
+    
+    async def create_user(self, name: str, email: str, plan: str = "free") -> APIResponse:
+        """Create new user with API key"""
+        try:
+            user_data = UserCreate(name=name, email=email, plan=plan)
+            success, message, api_key = await self.db.create_user(user_data)
+            
+            return APIResponse(
+                success=success,
+                data={"api_key": api_key} if success else None,
+                error=message if not success else None
+            )
+        except ValidationError as e:
+            return APIResponse(success=False, error=f"Validation error: {e}")
+        except Exception as e:
+            logger.error(f"Service error creating user: {e}")
+            return APIResponse(success=False, error="Internal service error")
+    
+    async def generate_text(self, prompt: str, api_key: str, **kwargs) -> APIResponse:
+        """Generate text with authentication and rate limiting"""
+        try:
+            # Validate API key
+            user = await self.db.validate_api_key(api_key)
+            if not user:
+                return APIResponse(success=False, error="⚠️ Invalid API key")
+            
+            # Check rate limit
+            if not await self.db.check_rate_limit(user['id']):
+                return APIResponse(success=False, error="⚠️ Rate limit exceeded. Try again later.")
+            
+            # Generate text
+            request = GenerationRequest(prompt=prompt, **kwargs)
+            success, text, tokens_used = await self.model_manager.generate(request)
+            
+            if success:
+                # Update usage statistics
+                await self.db.increment_usage(user['id'], tokens_used)
+                
+                return APIResponse(
+                    success=True,
+                    data={
+                        "generated_text": text,
+                        "tokens_used": tokens_used,
+                        "user_plan": user.get('plan', 'free')
+                    }
+                )
+            else:
+                return APIResponse(success=False, error=text)
+                
+        except Exception as e:
+            logger.error(f"Service error generating text: {e}")
+            return APIResponse(success=False, error="Internal service error")
+    
+    async def get_user_stats(self, api_key: str) -> APIResponse:
+        """Get user statistics"""
+        try:
+            user = await self.db.validate_api_key(api_key)
+            if not user:
+                return APIResponse(success=False, error="Invalid API key")
+            
+            stats = {
+                "name": user.get('name'),
+                "email": user.get('email'),
+                "plan": user.get('plan', 'free'),
+                "total_requests": user.get('requests', 0),
+                "tokens_used": user.get('tokens_used', 0),
+                "requests_this_hour": user.get('requests_this_hour', 0),
+                "rate_limit": self.config.RATE_LIMIT_PER_HOUR,
+                "created_at": user.get('created_at'),
+                "last_request": user.get('last_request')
+            }
+            
+            return APIResponse(success=True, data=stats)
+            
+        except Exception as e:
+            logger.error(f"Error getting user stats: {e}")
+            return APIResponse(success=False, error="Error retrieving stats")
 
-        # Main Content
-        with gr.Column(scale=4):
-            with gr.Group():
-                # Playground
-                with gr.Tab("Playground"):
+# ----------------- Enhanced UI -----------------
+class GradioInterface:
+    def __init__(self, service: GemmaSaaSService):
+        self.service = service
+        
+    def create_advanced_css(self):
+        return """
+        @import url('https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700&display=swap');
+        
+        :root {
+            --primary-gradient: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            --secondary-gradient: linear-gradient(135deg, #f093fb 0%, #f5576c 100%);
+            --success-gradient: linear-gradient(135deg, #4facfe 0%, #00f2fe 100%);
+            --card-shadow: 0 10px 30px rgba(0,0,0,0.1);
+            --hover-shadow: 0 15px 40px rgba(0,0,0,0.15);
+        }
+        
+        body {
+            background: linear-gradient(135deg, #f5f7fa 0%, #c3cfe2 100%);
+            font-family: 'Inter', sans-serif;
+            margin: 0;
+            padding: 0;
+        }
+        
+        .gradio-container {
+            max-width: 1400px !important;
+            margin: 0 auto !important;
+            padding: 2rem !important;
+        }
+        
+        .main-header {
+            text-align: center;
+            margin-bottom: 3rem;
+            padding: 2rem;
+            background: white;
+            border-radius: 20px;
+            box-shadow: var(--card-shadow);
+        }
+        
+        .main-title {
+            font-size: 3.5rem;
+            font-weight: 700;
+            background: var(--primary-gradient);
+            -webkit-background-clip: text;
+            -webkit-text-fill-color: transparent;
+            margin-bottom: 1rem;
+        }
+        
+        .main-subtitle {
+            font-size: 1.3rem;
+            color: #64748b;
+            font-weight: 400;
+        }
+        
+        .feature-card {
+            background: white;
+            border-radius: 15px;
+            padding: 2rem;
+            box-shadow: var(--card-shadow);
+            transition: all 0.3s ease;
+            border: 1px solid rgba(255,255,255,0.2);
+        }
+        
+        .feature-card:hover {
+            transform: translateY(-5px);
+            box-shadow: var(--hover-shadow);
+        }
+        
+        .gr-button {
+            border-radius: 12px !important;
+            font-weight: 600 !important;
+            padding: 0.8rem 2rem !important;
+            transition: all 0.3s ease !important;
+            border: none !important;
+        }
+        
+        .gr-button-primary {
+            background: var(--primary-gradient) !important;
+            color: white !important;
+        }
+        
+        .gr-button-secondary {
+            background: var(--secondary-gradient) !important;
+            color: white !important;
+        }
+        
+        .gr-button:hover {
+            transform: translateY(-2px) !important;
+            box-shadow: 0 8px 25px rgba(0,0,0,0.2) !important;
+        }
+        
+        .stats-card {
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            color: white;
+            border-radius: 15px;
+            padding: 2rem;
+            margin: 1rem 0;
+        }
+        
+        .metric {
+            text-align: center;
+            padding: 1rem;
+        }
+        
+        .metric-value {
+            font-size: 2.5rem;
+            font-weight: 700;
+        }
+        
+        .metric-label {
+            font-size: 0.9rem;
+            opacity: 0.8;
+            text-transform: uppercase;
+            letter-spacing: 1px;
+        }
+        
+        .alert-success {
+            background: linear-gradient(135deg, #4facfe 0%, #00f2fe 100%);
+            color: white;
+            padding: 1rem;
+            border-radius: 10px;
+            margin: 1rem 0;
+        }
+        
+        .alert-error {
+            background: linear-gradient(135deg, #ff6b6b 0%, #ee5a52 100%);
+            color: white;
+            padding: 1rem;
+            border-radius: 10px;
+            margin: 1rem 0;
+        }
+        """
+    
+    async def create_interface(self):
+        """Create the enhanced Gradio interface"""
+        with gr.Blocks(css=self.create_advanced_css(), title="Gemma SaaS Platform") as app:
+            
+            # Header
+            with gr.Row():
+                gr.HTML("""
+                <div class="main-header">
+                    <h1 class="main-title">���� Gemma SaaS Platform</h1>
+                    <p class="main-subtitle">Professional AI Text Generation with Advanced Analytics</p>
+                </div>
+                """)
+            
+            # Main Content
+            with gr.Tabs():
+                
+                # Playground Tab
+                with gr.Tab("🎮 Playground", elem_classes=["feature-card"]):
                     with gr.Row():
+                        with gr.Column(scale=1):
+                            gr.Markdown("### 📋 Generation Parameters")
+                            api_key_playground = gr.Textbox(
+                                label="🔑 API Key",
+                                type="password",
+                                placeholder="Enter your API key..."
+                            )
+                            
+                            with gr.Accordion("⚙️ Advanced Settings", open=False):
+                                max_tokens_input = gr.Slider(
+                                    minimum=50, maximum=500, value=200,
+                                    label="Max Tokens"
+                                )
+                                temperature_input = gr.Slider(
+                                    minimum=0.1, maximum=2.0, value=0.7,
+                                    label="Temperature"
+                                )
+                                top_k_input = gr.Slider(
+                                    minimum=1, maximum=100, value=50,
+                                    label="Top K"
+                                )
+                                top_p_input = gr.Slider(
+                                    minimum=0.1, maximum=1.0, value=0.95,
+                                    label="Top P"
+                                )
+                        
                         with gr.Column(scale=2):
-                            gr.Markdown("### Instructions / Example JSON")
-                            gr.Markdown("```json\n{\n  \"prompt\": \"Write a short story about a robot\",\n  \"api_key\": \"YOUR_API_KEY\"\n}```")
-                        with gr.Column(scale=3):
-                            prompt_input = gr.Textbox(label="💬 Prompt", lines=5)
-                            api_key_input = gr.Textbox(label="🔑 API Key", type="password")
-                            output_text = gr.Textbox(label="💡 Result", interactive=False, lines=8)
+                            gr.Markdown("### 💭 Text Generation")
+                            prompt_input = gr.Textbox(
+                                label="✍️ Prompt",
+                                lines=8,
+                                placeholder="Enter your prompt here... (e.g., 'Write a short story about a robot discovering emotions')"
+                            )
+                            
                             with gr.Row():
-                                clear_btn = gr.ClearButton(value="Clear", components=[prompt_input, output_text])
-                                generate_btn = gr.Button("Generate")
-                            generate_btn.click(fn=generate_text, inputs=[prompt_input, api_key_input], outputs=output_text)
-
-                # Profile
-                with gr.Tab("Profile"):
-                    gr.Markdown("### Manage your API Key (Login required)")
-                    name_input = gr.Textbox(label="👤 Your Name")
-                    status_output = gr.Textbox(label="Status", interactive=False)
-                    key_output = gr.Textbox(label="✅ API Key", interactive=False)
-                    request_count_output = gr.Textbox(label="Requests Made", interactive=False)
-
-                    def create_key_profile(name):
-                        # Aqui você pode vincular hf_user_id se usar OAuth
-                        msg, key = create_user(name, hf_user_id="demo")  # demo placeholder
-                        return msg, key, 0
+                                generate_btn = gr.Button(
+                                    "🚀 Generate",
+                                    elem_classes=["gr-button-primary"],
+                                    variant="primary"
+                                )
+                                clear_btn = gr.ClearButton(
+                                    components=[prompt_input],
+                                    value="🗑️ Clear",
+                                    elem_classes=["gr-button-secondary"]
+                                )
+                            
+                            output_text = gr.Textbox(
+                                label="📝 Generated Text",
+                                lines=12,
+                                interactive=False
+                            )
+                            
+                            # Stats display
+                            generation_stats = gr.JSON(
+                                label="📊 Generation Statistics",
+                                visible=False
+                            )
+                
+                # Profile Tab
+                with gr.Tab("👤 Profile", elem_classes=["feature-card"]):
+                    with gr.Row():
+                        with gr.Column():
+                            gr.Markdown("### 🆕 Create Account")
+                            name_input = gr.Textbox(label="👤 Full Name")
+                            email_input = gr.Textbox(label="📧 Email Address")
+                            plan_input = gr.Dropdown(
+                                choices=["free", "pro", "enterprise"],
+                                value="free",
+                                label="📋 Plan"
+                            )
+                            
+                            create_btn = gr.Button(
+                                "✨ Create API Key",
+                                elem_classes=["gr-button-primary"],
+                                variant="primary"
+                            )
+                            
+                            creation_status = gr.HTML()
+                            api_key_display = gr.Textbox(
+                                label="🔑 Your API Key",
+                                interactive=False,
+                                visible=False
+                            )
+                        
+                        with gr.Column():
+                            gr.Markdown("### 📊 Account Statistics")
+                            stats_api_key = gr.Textbox(
+                                label="🔑 API Key",
+                                type="password",
+                                placeholder="Enter API key to view stats"
+                            )
+                            
+                            refresh_stats_btn = gr.Button(
+                                "🔄 Refresh Stats",
+                                elem_classes=["gr-button-secondary"]
+                            )
+                            
+                            user_stats_display = gr.HTML()
+                
+                # Analytics Tab
+                with gr.Tab("📈 Analytics", elem_classes=["feature-card"]):
+                    gr.Markdown("### 📊 Platform Analytics")
+                    
+                    # Placeholder for future analytics
+                    gr.HTML("""
+                    <div style="text-align: center; padding: 3rem;">
+                        <h3>📈 Advanced Analytics Coming Soon</h3>
+                        <p>Real-time usage metrics, performance insights, and detailed reporting.</p>
+                    </div>
+                    """)
+            
+            # Event Handlers
+            async def handle_generation(prompt, api_key, max_tokens, temperature, top_k, top_p):
+                if not api_key.strip():
+                    return "⚠️ Please enter your API key", {}, False
+                
+                response = await self.service.generate_text(
+                    prompt=prompt,
+                    api_key=api_key,
+                    max_tokens=max_tokens,
+                    temperature=temperature,
+                    top_k=top_k,
+                    top_p=top_p
+                )
+                
+                if response.success:
+                    return (
+                        response.data["generated_text"],
+                        response.data,
+                        True
+                    )
+                else:
+                    return response.error, {}, False
+            
+            async def handle_user_creation(name, email, plan):
+                response = await self.service.create_user(name, email, plan)
+                
+                if response.success:
+                    return (
+                        f'<div class="alert-success">✅ Account created successfully!</div>',
+                        response.data["api_key"],
+                        True
+                    )
+                else:
+                    return (
+                        f'<div class="alert-error">❌ {response.error}</div>',
+                        "",
+                        False
+                    )
+            
+            async def handle_stats_refresh(api_key):
+                response = await self.service.get_user_stats(api_key)
+                
+                if response.success:
+                    stats = response.data
+                    return f"""
+                    <div class="stats-card">
+                        <div style="display: grid; grid-template-columns: repeat(auto-fit, minmax(200px, 1fr)); gap: 1rem;">
+                            <div class="metric">
+                                <div class="metric-value">{stats['total_requests']}</div>
+                                <div class="metric-label">Total Requests</div>
+                            </div>
+                            <div class="metric">
+                                <div class="metric-value">{stats['tokens_used']:,}</div>
+                                <div class="metric-label">Tokens Used</div>
+                            </div>
+                            <div class="metric">
+                                <div class="metric-value">{stats['requests_this_hour']}/{stats['rate_limit']}</div>
+                                <div class="metric-label">Hourly Usage</div>
+                            </div>
+                            <div class="metric">
+                                <div class="metric-value">{stats['plan'].title()}</div>
+                                <div class="metric-label">Current Plan</div>
+                            </div>
+                        </div>
+                        <hr style="margin: 2rem 0; opacity: 0.3;">
+                        <p><strong>Account:</strong> {stats['name']} ({stats['email']})</p>
+                        <p><strong>Member since:</strong> {stats['created_at'][:10] if stats['created_at'] else 'N/A'}</p>
+                    </div>
+                    """
+                else:
+                    return f'<div class="alert-error">❌ {response.error}</div>'
+            
+            # Wire up events
+            generate_btn.click(
+                fn=handle_generation,
+                inputs=[
+                    prompt_input, api_key_playground, max_tokens_input,
+                    temperature_input, top_k_input, top_p_input
+                ],
+                outputs=[output_text, generation_stats, generation_stats]
+            )
+            
+            create_btn.click(
+                fn=handle_user_creation,
+                inputs=[name_input, email_input, plan_input],
+                outputs=[creation_status, api_key_display, api_key_display]
+            )
+            
+            refresh_stats_btn.click(
+                fn=handle_stats_refresh,
+                inputs=[stats_api_key],
+                outputs=[user_stats_display]
+            )
+        
+        return app
 
-                    create_btn = gr.Button("Create API Key")
-                    create_btn.click(fn=create_key_profile, inputs=name_input, outputs=[status_output, key_output, request_count_output])
+# ----------------- Main Application -----------------
+async def main():
+    """Main application entry point"""
+    try:
+        # Initialize service
+        service = GemmaSaaSService()
+        await service.initialize()
+        
+        # Create interface
+        interface = GradioInterface(service)
+        app = await interface.create_interface()
+        
+        # Launch with enhanced configuration
+        app.launch(
+            server_name="0.0.0.0",
+            server_port=7860,
+            share=False,
+            debug=False,
+            show_error=True,
+            quiet=False,
+            favicon_path=None,
+            ssl_keyfile=None,
+            ssl_certfile=None,
+            auth=None,  # Add your auth function here if needed
+            max_threads=10
+        )
+        
+    except Exception as e:
+        logger.error(f"Failed to start application: {e}")
+        raise
 
-app.launch(server_name="0.0.0.0", server_port=786)
+if __name__ == "__main__":
+    # Run the application
+    asyncio.run(main())