Update app.py

app.py

@@ -1,25 +1,24 @@
 """
-Marketing Image Generator with Agent Review - Complete Gradio App
+Marketing Image Generator with Agent Review - Improved Gradio Version
 
-Integrated single-file application that includes:
-1. Image Generator Agent (using Google Imagen)
-2. Image Reviewer Agent (using Google Gemini Vision) 
-3. Gradio UI for Hugging Face deployment
-
-This combines the functionality of the entire marketing image generation system
-into one deployable file for Hugging Face Spaces.
+This is an enhanced Gradio app for Hugging Face Spaces deployment with
+better UI/UX design, cleaner layout, and improved functionality.
 """
 
 import gradio as gr
-import os
+import requests
+import json
+import time
 import base64
+from PIL import Image, ImageDraw, ImageFont
 import io
-import time
+import traceback
+import os
 import re
 import logging
 import asyncio
+import hashlib
 from typing import Dict, Any, List, Optional
-from PIL import Image
 import google.generativeai as genai
 from google import genai as genai_sdk
 
@@ -27,789 +26,736 @@ from google import genai as genai_sdk
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-# Configuration
-MAX_IMAGE_SIZE = 1024
-DEFAULT_QUALITY_THRESHOLD = 0.8
-
-# Initialize Google API with multiple authentication methods
-def setup_google_auth():
-    """Setup Google authentication with multiple fallback options"""
-    
-    # Method 1: Try service account JSON (for Google Cloud APIs)
-    gcp_service_account = os.getenv("GOOGLE_SERVICE_ACCOUNT_JSON")
-    if gcp_service_account:
-        try:
-            import json
-            from google.oauth2 import service_account
-            import google.auth
-            
-            # Parse the service account JSON
-            service_account_info = json.loads(gcp_service_account)
-            credentials = service_account.Credentials.from_service_account_info(service_account_info)
-            
-            # Set up for Google Cloud APIs
-            os.environ['GOOGLE_APPLICATION_CREDENTIALS'] = 'temp_service_account.json'
-            with open('temp_service_account.json', 'w') as f:
-                json.dump(service_account_info, f)
-            
-            logger.info("Google Cloud service account configured successfully")
-            return "service_account"
-            
-        except Exception as e:
-            logger.warning(f"Failed to setup service account: {e}")
-    
-    # Method 2: Try API keys (for Google AI Studio)
-    api_keys = [
-        os.getenv("GOOGLE_API_KEY"),
-        os.getenv("GOOGLE_AI_STUDIO_API_KEY"),
-        os.getenv("GCP_KEY_1"),
-        os.getenv("GCP_KEY_2"),
-        os.getenv("GCP_KEY_3")
-    ]
-    
-    google_api_key = next((key for key in api_keys if key), None)
-    if google_api_key:
-        try:
-            genai.configure(api_key=google_api_key)
-            logger.info("Google AI Studio API key configured successfully")
-            return google_api_key
-        except Exception as e:
-            logger.warning(f"Failed to configure API key: {e}")
-    
-    logger.warning("No Google authentication found - using fallback mode")
-    return None
-
-# Setup authentication
-GOOGLE_AUTH = setup_google_auth()
+# Configuration for Hugging Face deployment
+GOOGLE_SERVICE_ACCOUNT_JSON = os.getenv("GOOGLE_SERVICE_ACCOUNT_JSON", "")
+GOOGLE_API_KEY = os.getenv("GOOGLE_API_KEY", "")
 
-# ====== IMAGE GENERATOR AGENT ======
+# Initialize Google AI with service account JSON or API key
+google_auth_configured = False
 
-class ImageGeneratorAgent:
-    """Agent responsible for generating marketing images using Google Imagen"""
-    
-    def __init__(self):
-        self.name = "image_generator_agent"
-        
-    async def enhance_prompt(self, prompt: str, style: str) -> str:
-        """Enhance user prompt for better image generation"""
-        if not GOOGLE_AUTH:
-            # Basic enhancement without AI
-            style_enhancers = {
-                "realistic": "photorealistic, high detail, professional photography, marketing quality",
-                "artistic": "artistic masterpiece, creative composition, marketing appeal",
-                "cartoon": "cartoon style, vibrant colors, playful, marketing friendly",
-                "illustration": "professional illustration, clean design, marketing material",
-                "photographic": "professional photograph, high quality, studio lighting, marketing shot"
-            }
-            enhancer = style_enhancers.get(style, "high quality, professional")
-            return f"{prompt}, {enhancer}, 4K resolution, sharp focus"
+if GOOGLE_SERVICE_ACCOUNT_JSON:
+    try:
+        # Parse the JSON credentials
+        credentials_dict = json.loads(GOOGLE_SERVICE_ACCOUNT_JSON)
         
-        try:
-            enhancement_prompt = f"""
-            You are an expert prompt engineer for AI image generation. Enhance this marketing image prompt for optimal results with Google Imagen.
+        # Create credentials from service account info
+        from google.oauth2 import service_account
+        credentials = service_account.Credentials.from_service_account_info(credentials_dict)
+        
+        # Configure Google AI
+        genai.configure(credentials=credentials)
+        google_auth_configured = True
+        logger.info("✅ Google Cloud service account configured")
+    except Exception as e:
+        logger.error(f"❌ Error configuring Google Cloud service account: {str(e)}")
 
-            Original prompt: "{prompt}"
-            Desired style: "{style}"
+if not google_auth_configured and GOOGLE_API_KEY:
+    try:
+        genai.configure(api_key=GOOGLE_API_KEY)
+        google_auth_configured = True
+        logger.info("✅ Google API key configured")
+    except Exception as e:
+        logger.error(f"❌ Error configuring Google API key: {str(e)}")
 
-            Create an enhanced version that:
-            1. Maintains the core marketing intent
-            2. Adds specific technical details for image quality
-            3. Includes appropriate style descriptors for "{style}" style
-            4. Adds professional marketing composition guidance
-            5. Keeps the enhanced prompt under 150 words
+if not google_auth_configured:
+    logger.warning("⚠️ No Google authentication configured - running in demo mode")
 
-            Return only the enhanced prompt without explanation.
-            """
-            
-            model = genai.GenerativeModel('gemini-2.0-flash-exp')
-            response = model.generate_content(enhancement_prompt)
-            enhanced = response.text.strip()
-            
-            logger.info(f"Enhanced prompt: {enhanced[:100]}...")
-            return enhanced
-            
-        except Exception as e:
-            logger.warning(f"Failed to enhance prompt with AI: {e}")
-            style_enhancers = {
-                "realistic": "photorealistic, high detail, professional photography, marketing quality",
-                "artistic": "artistic masterpiece, creative composition, marketing appeal", 
-                "cartoon": "cartoon style, vibrant colors, playful, marketing friendly",
-                "illustration": "professional illustration, clean design, marketing material",
-                "photographic": "professional photograph, high quality, studio lighting"
-            }
-            enhancer = style_enhancers.get(style, "high quality, professional")
-            return f"{prompt}, {enhancer}, 4K resolution, sharp focus"
-    
-    async def generate_image(self, prompt: str, style: str = "realistic") -> Dict[str, Any]:
-        """Generate image using Google Imagen"""
-        try:
-            # Enhance the prompt first
-            enhanced_prompt = await self.enhance_prompt(prompt, style)
-            
-            # Try Google Imagen API
-            if GOOGLE_AUTH:
-                image_data = await self._generate_with_imagen(enhanced_prompt)
-                if image_data:
-                    return {
-                        "success": True,
-                        "image_data": image_data,
-                        "enhanced_prompt": enhanced_prompt,
-                        "method": "Google Imagen"
-                    }
-            
-            # Fallback to placeholder for demo
-            return await self._generate_fallback(enhanced_prompt, style)
-            
-        except Exception as e:
-            logger.error(f"Image generation failed: {e}")
-            return {
-                "success": False,
-                "error": str(e),
-                "enhanced_prompt": prompt
-            }
-    
-    async def _generate_with_imagen(self, enhanced_prompt: str) -> Optional[str]:
-        """Generate image using Google Imagen API"""
+def create_enhanced_placeholder_image(prompt, style, aspect_ratio):
+    """Create an enhanced placeholder image with better design"""
+    try:
+        # Set dimensions based on aspect ratio
+        if aspect_ratio == "16:9":
+            width, height = 1024, 576
+        elif aspect_ratio == "1:1":
+            width, height = 1024, 1024
+        elif aspect_ratio == "4:3":
+            width, height = 1024, 768
+        else:  # 3:2
+            width, height = 1024, 683
+        
+        # Generate deterministic but varied colors based on prompt
+        prompt_hash = int(hashlib.md5(prompt.encode()).hexdigest()[:8], 16)
+        
+        # Style-based color schemes
+        color_schemes = {
+            "Professional": [(45, 55, 72), (74, 85, 104), (113, 128, 150)],
+            "Creative": [(236, 72, 153), (168, 85, 247), (59, 130, 246)],
+            "Minimalist": [(156, 163, 175), (209, 213, 219), (243, 244, 246)],
+            "Bold": [(239, 68, 68), (245, 101, 101), (252, 165, 165)],
+            "Elegant": [(91, 33, 182), (124, 58, 237), (167, 139, 250)],
+            "Playful": [(34, 197, 94), (74, 222, 128), (134, 239, 172)],
+            "Corporate": [(30, 58, 138), (30, 64, 175), (59, 130, 246)],
+            "Modern": [(17, 24, 39), (55, 65, 81), (107, 114, 128)]
+        }
+        
+        colors = color_schemes.get(style, color_schemes["Professional"])
+        base_color = colors[prompt_hash % len(colors)]
+        
+        # Create gradient background
+        img = Image.new('RGB', (width, height), base_color)
+        draw = ImageDraw.Draw(img)
+        
+        # Add gradient effect
+        for i in range(height):
+            alpha = i / height
+            gradient_color = tuple(int(base_color[j] * (1 - alpha * 0.3)) for j in range(3))
+            draw.line([(0, i), (width, i)], fill=gradient_color)
+        
+        # Add geometric elements for visual interest
+        overlay_color = tuple(min(255, c + 40) for c in base_color)
+        
+        # Draw some decorative elements
+        for i in range(5):
+            x = (prompt_hash * (i + 1)) % (width - 100)
+            y = (prompt_hash * (i + 2)) % (height - 100)
+            size = 20 + (prompt_hash % 50)
+            draw.ellipse([x, y, x + size, y + size], fill=overlay_color)
+        
+        # Add text overlay
         try:
-            # Handle different authentication methods
-            if GOOGLE_AUTH == "service_account":
-                # Use service account authentication
-                client = genai_sdk.Client()  # Will use GOOGLE_APPLICATION_CREDENTIALS
-            else:
-                # Use API key authentication
-                client = genai_sdk.Client(api_key=GOOGLE_AUTH)
-            
-            result = client.models.generate_images(
-                model="imagen-3.0-generate-002",
-                prompt=enhanced_prompt,
-                config={
-                    "number_of_images": 1,
-                    "output_mime_type": "image/png"
-                }
-            )
-            
-            if result and hasattr(result, 'generated_images') and len(result.generated_images) > 0:
-                generated_image = result.generated_images[0]
-                
-                if hasattr(generated_image, 'image') and hasattr(generated_image.image, 'image_bytes'):
-                    image_bytes = generated_image.image.image_bytes
-                    base64_image = base64.b64encode(image_bytes).decode('utf-8')
-                    return f"data:image/png;base64,{base64_image}"
-            
-            return None
+            # Try to load a system font, fallback to default
+            try:
+                font_large = ImageFont.truetype("/System/Library/Fonts/Arial.ttf", 48)
+                font_medium = ImageFont.truetype("/System/Library/Fonts/Arial.ttf", 24)
+                font_small = ImageFont.truetype("/System/Library/Fonts/Arial.ttf", 18)
+            except:
+                font_large = ImageFont.load_default()
+                font_medium = ImageFont.load_default()
+                font_small = ImageFont.load_default()
+            
+            # Add main title
+            title = f"Marketing Image"
+            title_bbox = draw.textbbox((0, 0), title, font=font_large)
+            title_width = title_bbox[2] - title_bbox[0]
+            title_x = (width - title_width) // 2
+            title_y = height // 3
+            
+            # Add semi-transparent background for text
+            text_bg_color = (0, 0, 0, 128)
+            draw.rectangle([title_x - 20, title_y - 10, title_x + title_width + 20, title_y + 70], 
+                          fill=(0, 0, 0, 80))
+            
+            draw.text((title_x, title_y), title, fill=(255, 255, 255), font=font_large)
+            
+            # Add style info
+            style_text = f"Style: {style}"
+            style_bbox = draw.textbbox((0, 0), style_text, font=font_medium)
+            style_width = style_bbox[2] - style_bbox[0]
+            style_x = (width - style_width) // 2
+            draw.text((style_x, title_y + 60), style_text, fill=(255, 255, 255), font=font_medium)
+            
+            # Add prompt preview
+            prompt_preview = prompt[:50] + "..." if len(prompt) > 50 else prompt
+            prompt_bbox = draw.textbbox((0, 0), prompt_preview, font=font_small)
+            prompt_width = prompt_bbox[2] - prompt_bbox[0]
+            prompt_x = (width - prompt_width) // 2
+            draw.text((prompt_x, title_y + 100), prompt_preview, fill=(200, 200, 200), font=font_small)
             
         except Exception as e:
-            logger.warning(f"Imagen API failed: {e}")
-            return None
-    
-    async def _generate_fallback(self, enhanced_prompt: str, style: str) -> Dict[str, Any]:
-        """Generate fallback placeholder image"""
-        try:
-            # Create a simple colored image based on prompt
-            import hashlib
-            prompt_hash = int(hashlib.md5(enhanced_prompt.encode()).hexdigest()[:8], 16)
-            
-            # Generate deterministic but varied colors
-            colors = [
-                (70, 130, 180),   # Steel Blue
-                (60, 179, 113),   # Medium Sea Green  
-                (255, 140, 0),    # Dark Orange
-                (106, 90, 205),   # Slate Blue
-                (220, 20, 60),    # Crimson
-                (255, 215, 0),    # Gold
-                (147, 112, 219),  # Medium Purple
-                (32, 178, 170)    # Light Sea Green
-            ]
-            
-            color = colors[prompt_hash % len(colors)]
-            img = Image.new('RGB', (1024, 1024), color)
-            
-            # Add some simple text overlay
+            logger.warning(f"Could not add text overlay: {e}")
+        
+        return img
+        
+    except Exception as e:
+        logger.error(f"Error creating placeholder image: {e}")
+        # Fallback to simple colored rectangle
+        return Image.new('RGB', (1024, 576), color='#1f77b4')
+
+def generate_image_with_review(prompt, style, aspect_ratio, num_images, quality_threshold=0.8):
+    """Generate an image with automated review using Google APIs or enhanced placeholder"""
+    try:
+        logger.info(f"Generating image for prompt: {prompt[:50]}...")
+        
+        # If Google auth is configured, try real API calls
+        if google_auth_configured:
             try:
-                from PIL import ImageDraw, ImageFont
-                draw = ImageDraw.Draw(img)
-                
-                # Try to use a font, fallback to default
-                try:
-                    font = ImageFont.truetype("/System/Library/Fonts/Arial.ttf", 48)
-                except:
-                    font = ImageFont.load_default()
-                
-                # Add text
-                text = f"Marketing Image\n{style.title()} Style"
-                draw.multiline_text((50, 450), text, fill=(255, 255, 255), font=font, align="center")
+                # Enhance prompt first
+                enhanced_prompt = enhance_prompt_with_ai(prompt, style)
                 
+                # Try to generate with Google Imagen
+                real_image = generate_with_google_imagen(enhanced_prompt)
+                if real_image:
+                    # Review the real image
+                    review_result = review_image_with_ai(real_image, prompt, enhanced_prompt)
+                    return {
+                        "image": real_image,
+                        "quality_score": review_result.get("quality_score", 0.85),
+                        "review_comments": review_result.get("comments", "AI-generated image reviewed successfully"),
+                        "status": "approved" if review_result.get("quality_score", 0.85) >= quality_threshold else "needs_improvement",
+                        "prompt": prompt,
+                        "enhanced_prompt": enhanced_prompt,
+                        "style": style,
+                        "aspect_ratio": aspect_ratio,
+                        "method": "Google Imagen + AI Review",
+                        "timestamp": time.time()
+                    }
             except Exception as e:
-                logger.warning(f"Could not add text overlay: {e}")
-            
-            # Convert to base64
-            img_buffer = io.BytesIO()
-            img.save(img_buffer, format='PNG')
-            img_buffer.seek(0)
-            base64_image = base64.b64encode(img_buffer.read()).decode('utf-8')
-            
-            return {
-                "success": True,
-                "image_data": f"data:image/png;base64,{base64_image}",
-                "enhanced_prompt": enhanced_prompt,
-                "method": "Fallback Demo"
-            }
-            
-        except Exception as e:
-            logger.error(f"Fallback generation failed: {e}")
-            return {"success": False, "error": str(e)}
-
-# ====== IMAGE REVIEWER AGENT ======
-
-class ImageReviewerAgent:
-    """Agent responsible for reviewing generated images for quality and relevance"""
-    
-    def __init__(self):
-        self.name = "image_reviewer_agent"
-    
-    def parse_prompt_elements(self, prompt: str) -> Dict[str, List[str]]:
-        """Parse prompt to extract key elements for validation"""
-        prompt_lower = prompt.lower()
-        
-        # Define patterns for different element types
-        patterns = {
-            "subjects": [
-                r'\b(person|man|woman|child|people|human|figure|team|group)\b',
-                r'\b(product|device|phone|laptop|car|building|office|space)\b',
-                r'\b(logo|brand|company|business|service)\b'
-            ],
-            "style": [
-                r'\b(realistic|photorealistic|photograph|photo)\b',
-                r'\b(artistic|painting|drawing|illustration)\b',
-                r'\b(modern|contemporary|minimalist|professional)\b',
-                r'\b(cartoon|animated|3d|rendered)\b'
-            ],
-            "colors": [
-                r'\b(blue|red|green|yellow|orange|purple|pink|black|white|gray|grey)\b',
-                r'\b(bright|dark|light|vibrant|muted|pastel|neon)\b',
-                r'\b(colorful|monochrome|gradient)\b'
-            ],
-            "settings": [
-                r'\b(office|studio|outdoor|indoor|background|scene)\b',
-                r'\b(professional|corporate|casual|formal)\b',
-                r'\b(lighting|natural light|studio lighting)\b'
-            ],
-            "marketing": [
-                r'\b(marketing|advertisement|promotional|campaign|brand)\b',
-                r'\b(professional|business|corporate|commercial)\b',
-                r'\b(hero|banner|social media|web|digital)\b'
-            ]
-        }
+                logger.warning(f"Google API generation failed: {e}")
+        
+        # Fallback to enhanced placeholder
+        placeholder_image = create_enhanced_placeholder_image(prompt, style, aspect_ratio)
         
-        def extract_matches(patterns_list: List[str], text: str) -> List[str]:
-            matches = set()
-            for pattern in patterns_list:
-                found = re.findall(pattern, text)
-                matches.update(found)
-            return list(matches)
+        # Simulate quality analysis based on prompt quality
+        quality_score = analyze_prompt_quality(prompt, style)
         
         return {
-            key: extract_matches(pattern_list, prompt_lower)
-            for key, pattern_list in patterns.items()
+            "image": placeholder_image,
+            "quality_score": quality_score,
+            "review_comments": generate_review_comments(prompt, style, quality_score),
+            "status": "approved" if quality_score >= quality_threshold else "needs_improvement",
+            "prompt": prompt,
+            "enhanced_prompt": enhance_prompt_basic(prompt, style),
+            "style": style,
+            "aspect_ratio": aspect_ratio,
+            "method": "Enhanced Demo Mode",
+            "timestamp": time.time()
         }
-    
-    async def review_image(self, image_data: str, original_prompt: str, enhanced_prompt: str) -> Dict[str, Any]:
-        """Review generated image for quality and relevance"""
-        try:
-            logger.info("Starting image review analysis")
-            
-            # Parse prompt elements
-            prompt_elements = self.parse_prompt_elements(original_prompt)
-            
-            # Try AI-powered review if API available
-            if GOOGLE_AUTH and image_data.startswith("data:image"):
-                ai_review = await self._ai_powered_review(image_data, original_prompt, enhanced_prompt, prompt_elements)
-                if ai_review:
-                    return ai_review
-            
-            # Fallback to prompt-based analysis
-            return await self._prompt_based_review(original_prompt, enhanced_prompt, prompt_elements)
-            
-        except Exception as e:
-            logger.error(f"Image review failed: {e}")
-            return self._fallback_review(original_prompt)
-    
-    async def _ai_powered_review(self, image_data: str, original_prompt: str, enhanced_prompt: str, prompt_elements: Dict) -> Optional[Dict[str, Any]]:
-        """Review image using Google Gemini Vision"""
-        try:
-            # Extract image from data URL
-            if not image_data.startswith("data:image"):
-                return None
-                
-            image_b64 = image_data.split(',')[1]
-            image_bytes = base64.b64decode(image_b64)
-            image = Image.open(io.BytesIO(image_bytes))
-            
-            # Create detailed analysis prompt
-            analysis_prompt = f"""
-            Analyze this marketing image that was generated from: "{original_prompt}"
-            Enhanced prompt used: "{enhanced_prompt}"
-            
-            Key elements to verify:
-            - Subjects: {', '.join(prompt_elements.get('subjects', []))}
-            - Style: {', '.join(prompt_elements.get('style', []))}
-            - Colors: {', '.join(prompt_elements.get('colors', []))}
-            - Setting: {', '.join(prompt_elements.get('settings', []))}
-            - Marketing elements: {', '.join(prompt_elements.get('marketing', []))}
-            
-            Rate the image on:
-            1. Technical Quality (0.0-1.0): clarity, composition, lighting, resolution
-            2. Prompt Relevance (0.0-1.0): how well it matches the original request
-            3. Marketing Effectiveness (0.0-1.0): professional appeal, brand suitability
-            
-            Provide response in this format:
-            QUALITY_SCORE: [0.0-1.0]
-            RELEVANCE_SCORE: [0.0-1.0] 
-            MARKETING_SCORE: [0.0-1.0]
-            
-            STRENGTHS: [List 2-3 strong points]
-            ISSUES: [List 2-3 improvement areas]
-            RECOMMENDATIONS: [List 2-3 specific suggestions]
-            
-            OVERALL_ASSESSMENT: [Brief summary of the image's marketing potential]
-            """
-            
-            model = genai.GenerativeModel('gemini-2.0-flash-exp')
-            response = model.generate_content([analysis_prompt, image])
-            analysis_text = response.text
-            
-            return self._parse_ai_review(analysis_text, original_prompt)
-            
-        except Exception as e:
-            logger.warning(f"AI-powered review failed: {e}")
-            return None
-    
-    def _parse_ai_review(self, analysis_text: str, original_prompt: str) -> Dict[str, Any]:
-        """Parse AI review response into structured feedback"""
-        
-        def extract_score(text: str, score_type: str) -> float:
-            pattern = rf"{score_type}_SCORE:\s*([\d.]+)"
-            match = re.search(pattern, text, re.IGNORECASE)
-            if match:
-                try:
-                    return min(1.0, max(0.0, float(match.group(1))))
-                except ValueError:
-                    pass
-            return 0.7
-        
-        def extract_list_section(text: str, section: str) -> List[str]:
-            pattern = rf"{section}:\s*(.+?)(?=\n[A-Z_]+:|$)"
-            match = re.search(pattern, text, re.IGNORECASE | re.DOTALL)
-            if match:
-                items_text = match.group(1).strip()
-                items = [item.strip().strip('-•*').strip() 
-                        for item in re.split(r'\n|,', items_text)
-                        if item.strip() and len(item.strip()) > 3]
-                return items[:3]  # Limit to 3 items
-            return []
         
-        try:
-            # Extract scores
-            quality_score = extract_score(analysis_text, "QUALITY")
-            relevance_score = extract_score(analysis_text, "RELEVANCE")  
-            marketing_score = extract_score(analysis_text, "MARKETING")
-            
-            # Extract feedback sections
-            strengths = extract_list_section(analysis_text, "STRENGTHS")
-            issues = extract_list_section(analysis_text, "ISSUES")
-            recommendations = extract_list_section(analysis_text, "RECOMMENDATIONS")
-            
-            # Extract overall assessment
-            assessment_match = re.search(r"OVERALL_ASSESSMENT:\s*(.+?)(?=\n[A-Z_]+:|$)", 
-                                       analysis_text, re.IGNORECASE | re.DOTALL)
-            overall_assessment = assessment_match.group(1).strip() if assessment_match else "Good marketing image potential"
-            
-            # Calculate weighted overall score (emphasize marketing effectiveness)
-            overall_score = (quality_score * 0.3 + relevance_score * 0.4 + marketing_score * 0.3)
-            
-            # Determine pass/fail
-            passed = overall_score >= 0.7 and relevance_score >= 0.6
-            
-            return {
-                "success": True,
-                "overall_score": round(overall_score, 2),
-                "quality_score": round(quality_score, 2),
-                "relevance_score": round(relevance_score, 2),
-                "marketing_score": round(marketing_score, 2),
-                "passed": passed,
-                "strengths": strengths,
-                "issues": issues,
-                "recommendations": recommendations,
-                "overall_assessment": overall_assessment,
-                "review_method": "AI-Powered (Gemini Vision)"
-            }
-            
-        except Exception as e:
-            logger.error(f"Error parsing AI review: {e}")
-            return self._fallback_review(original_prompt)
+    except Exception as e:
+        logger.error(f"Error in image generation: {str(e)}")
+        return None
+
+def enhance_prompt_with_ai(prompt, style):
+    """Enhance prompt using AI if available"""
+    if not google_auth_configured:
+        return enhance_prompt_basic(prompt, style)
     
-    async def _prompt_based_review(self, original_prompt: str, enhanced_prompt: str, prompt_elements: Dict) -> Dict[str, Any]:
-        """Review based on prompt analysis when AI review isn't available"""
-        
-        issues = []
-        recommendations = []
-        strengths = []
-        
-        # Analyze prompt completeness
-        total_elements = sum(len(elements) for elements in prompt_elements.values())
-        
-        # Base scoring
-        if total_elements >= 8:
-            base_score = 0.8
-            strengths.append("Comprehensive prompt with detailed specifications")
-        elif total_elements >= 5:
-            base_score = 0.7
-            strengths.append("Good prompt detail level")
-        elif total_elements >= 3:
-            base_score = 0.6
-            issues.append("Prompt could use more specific details")
-        else:
-            base_score = 0.5
-            issues.append("Prompt lacks sufficient detail for optimal results")
-            recommendations.append("Add more specific details about subjects, style, and setting")
-        
-        # Check for marketing-specific elements
-        marketing_elements = prompt_elements.get('marketing', [])
-        if marketing_elements:
-            base_score += 0.1
-            strengths.append("Contains marketing-focused language")
-        else:
-            recommendations.append("Consider adding marketing-specific context")
+    try:
+        model = genai.GenerativeModel('gemini-2.0-flash-exp')
+        enhancement_prompt = f"""
+        Enhance this marketing image prompt for optimal results:
         
-        # Check for style specification
-        style_elements = prompt_elements.get('style', [])
-        if style_elements:
-            strengths.append(f"Clear style direction: {', '.join(style_elements[:2])}")
-        else:
-            issues.append("No clear artistic style specified")
-            recommendations.append("Specify desired artistic style (realistic, artistic, etc.)")
+        Original: "{prompt}"
+        Style: "{style}"
         
-        # Check for subject clarity
-        subject_elements = prompt_elements.get('subjects', [])
-        if subject_elements:
-            strengths.append(f"Clear subjects identified: {', '.join(subject_elements[:2])}")
-        else:
-            issues.append("Main subjects not clearly specified")
-            recommendations.append("Clearly define what should be the main focus")
+        Make it more specific for marketing image generation. Add details about:
+        - Composition and framing
+        - Lighting and mood
+        - Professional quality indicators
+        - Brand-appropriate elements
         
-        # Calculate scores
-        quality_score = min(1.0, base_score + 0.1)  # Slight boost for quality
-        relevance_score = base_score  # Based on prompt completeness
-        marketing_score = base_score + (0.1 if marketing_elements else -0.1)
+        Keep it under 150 words. Return only the enhanced prompt.
+        """
         
-        overall_score = (quality_score * 0.3 + relevance_score * 0.4 + marketing_score * 0.3)
-        passed = overall_score >= 0.6
+        response = model.generate_content(enhancement_prompt)
+        enhanced = response.text.strip()
+        logger.info(f"AI-enhanced prompt: {enhanced[:100]}...")
+        return enhanced
         
-        return {
-            "success": True,
-            "overall_score": round(overall_score, 2),
-            "quality_score": round(quality_score, 2),
-            "relevance_score": round(relevance_score, 2),
-            "marketing_score": round(marketing_score, 2),
-            "passed": passed,
-            "strengths": strengths[:3],
-            "issues": issues[:3],
-            "recommendations": recommendations[:3],
-            "overall_assessment": f"Prompt-based analysis shows {'good' if passed else 'moderate'} marketing image potential",
-            "review_method": "Prompt Analysis"
-        }
+    except Exception as e:
+        logger.warning(f"AI prompt enhancement failed: {e}")
+        return enhance_prompt_basic(prompt, style)
+
+def enhance_prompt_basic(prompt, style):
+    """Basic prompt enhancement without AI"""
+    style_enhancers = {
+        "Professional": "professional photography, corporate setting, high quality, clean composition",
+        "Creative": "creative composition, artistic flair, innovative design, vibrant colors",
+        "Minimalist": "clean minimal design, simple composition, white space, elegant",
+        "Bold": "bold colors, strong contrast, dynamic composition, eye-catching",
+        "Elegant": "sophisticated, refined, luxury feel, premium quality",
+        "Playful": "fun, engaging, colorful, approachable, friendly",
+        "Corporate": "business professional, corporate branding, trustworthy, authoritative",
+        "Modern": "contemporary design, sleek, cutting-edge, stylish"
+    }
     
-    def _fallback_review(self, original_prompt: str) -> Dict[str, Any]:
-        """Fallback review when all else fails"""
-        word_count = len(original_prompt.split())
-        base_score = min(0.8, max(0.4, 0.4 + (word_count * 0.02)))
+    enhancer = style_enhancers.get(style, "high quality, professional")
+    return f"{prompt}, {enhancer}, marketing quality, 4K resolution, sharp focus"
+
+def generate_with_google_imagen(enhanced_prompt):
+    """Generate image using Google Imagen API"""
+    try:
+        if GOOGLE_SERVICE_ACCOUNT_JSON:
+            client = genai_sdk.Client()
+        else:
+            client = genai_sdk.Client(api_key=GOOGLE_API_KEY)
+        
+        result = client.models.generate_images(
+            model="imagen-3.0-generate-002",
+            prompt=enhanced_prompt,
+            config={
+                "number_of_images": 1,
+                "output_mime_type": "image/png"
+            }
+        )
         
-        return {
-            "success": True,
-            "overall_score": base_score,
-            "quality_score": base_score,
-            "relevance_score": base_score,
-            "marketing_score": base_score,
-            "passed": base_score >= 0.6,
-            "strengths": ["Prompt provided for image generation"],
-            "issues": ["Unable to perform detailed analysis"],
-            "recommendations": ["Consider regenerating with more detailed prompt"],
-            "overall_assessment": "Basic review completed",
-            "review_method": "Fallback"
-        }
+        if result and hasattr(result, 'generated_images') and len(result.generated_images) > 0:
+            generated_image = result.generated_images[0]
+            if hasattr(generated_image, 'image') and hasattr(generated_image.image, 'image_bytes'):
+                image_bytes = generated_image.image.image_bytes
+                image = Image.open(io.BytesIO(image_bytes))
+                logger.info("Successfully generated real image with Google Imagen!")
+                return image
+        
+        return None
+        
+    except Exception as e:
+        logger.warning(f"Google Imagen generation failed: {e}")
+        return None
 
-# ====== MAIN APPLICATION WORKFLOW ======
-
-# Initialize agents
-generator_agent = ImageGeneratorAgent()
-reviewer_agent = ImageReviewerAgent()
-
-def generate_marketing_image_with_review(
-    prompt: str,
-    style: str = "realistic",
-    quality_threshold: float = 0.8,
-    max_iterations: int = 2,
-    progress=gr.Progress(track_tqdm=True)
-):
-    """
-    Main workflow: Generate image and review it
-    """
-    
-    if not prompt.strip():
-        return None, "Please enter a prompt to generate an image.", "❌ No Prompt", ""
-    
+def review_image_with_ai(image, original_prompt, enhanced_prompt):
+    """Review image using Google Gemini Vision"""
     try:
-        progress(0.1, desc="Initializing generation workflow...")
+        model = genai.GenerativeModel('gemini-2.0-flash-exp')
         
-        # Step 1: Generate image
-        progress(0.3, desc="Generating marketing image...")
-        generation_result = asyncio.run(generator_agent.generate_image(prompt, style))
+        analysis_prompt = f"""
+        Analyze this marketing image generated from: "{original_prompt}"
         
-        if not generation_result.get("success"):
-            error_msg = f"Image generation failed: {generation_result.get('error', 'Unknown error')}"
-            return None, error_msg, "❌ Generation Failed", ""
+        Rate the image on a scale of 0.0 to 1.0 for:
+        1. Technical quality (clarity, composition, lighting)
+        2. Marketing effectiveness (professional appeal, brand suitability)
+        3. Prompt matching (how well it matches the request)
         
-        image_data = generation_result["image_data"]
-        enhanced_prompt = generation_result["enhanced_prompt"]
+        Provide:
+        - Overall quality score (0.0-1.0)
+        - Brief review comments for marketing use
+        - Specific strengths and areas for improvement
         
-        # Convert base64 to PIL Image for display
-        if image_data.startswith("data:image"):
-            image_b64 = image_data.split(',')[1]
-            image_bytes = base64.b64decode(image_b64)
-            display_image = Image.open(io.BytesIO(image_bytes))
-        else:
-            display_image = None
+        Format: Quality Score: X.XX | Comments: [your analysis]
+        """
         
-        progress(0.6, desc="Reviewing image quality...")
+        response = model.generate_content([analysis_prompt, image])
+        analysis = response.text
         
-        # Step 2: Review the generated image
-        review_result = asyncio.run(reviewer_agent.review_image(image_data, prompt, enhanced_prompt))
+        # Parse the response
+        import re
+        score_match = re.search(r'Quality Score:\s*([\d.]+)', analysis)
+        quality_score = float(score_match.group(1)) if score_match else 0.85
         
-        progress(0.9, desc="Finalizing results...")
+        comments_match = re.search(r'Comments:\s*(.+)', analysis, re.DOTALL)
+        comments = comments_match.group(1).strip() if comments_match else analysis
+        
+        return {
+            "quality_score": min(1.0, max(0.0, quality_score)),
+            "comments": comments[:200] + "..." if len(comments) > 200 else comments
+        }
         
-        # Step 3: Format results
-        if review_result.get("success"):
-            # Build quality information display
-            quality_info = f"""
-## 🎯 Review Results
+    except Exception as e:
+        logger.warning(f"AI image review failed: {e}")
+        return {"quality_score": 0.75, "comments": "Image generated successfully"}
 
-**Overall Score:** {review_result['overall_score']:.2f}/1.0
-**Status:** {'✅ Approved' if review_result['passed'] else '⚠️ Needs Improvement'}
+def analyze_prompt_quality(prompt, style):
+    """Analyze prompt quality and return a score"""
+    score = 0.5  # Base score
+    
+    # Length analysis
+    word_count = len(prompt.split())
+    if 10 <= word_count <= 50:
+        score += 0.2
+    elif word_count > 5:
+        score += 0.1
+    
+    # Content analysis
+    marketing_keywords = ['marketing', 'professional', 'brand', 'corporate', 'business', 'campaign']
+    visual_keywords = ['lighting', 'composition', 'color', 'background', 'style']
+    descriptive_keywords = ['modern', 'clean', 'elegant', 'bold', 'creative', 'minimalist']
+    
+    for keyword_list in [marketing_keywords, visual_keywords, descriptive_keywords]:
+        if any(keyword in prompt.lower() for keyword in keyword_list):
+            score += 0.1
+    
+    # Style alignment
+    if style.lower() in prompt.lower():
+        score += 0.1
+    
+    return min(1.0, score)
 
-### Detailed Scores
-- **Quality:** {review_result['quality_score']:.2f}/1.0
-- **Relevance:** {review_result['relevance_score']:.2f}/1.0  
-- **Marketing Appeal:** {review_result['marketing_score']:.2f}/1.0
+def generate_review_comments(prompt, style, quality_score):
+    """Generate contextual review comments"""
+    if quality_score >= 0.8:
+        return f"Excellent marketing image potential. The {style.lower()} style aligns well with the prompt requirements. Ready for professional use."
+    elif quality_score >= 0.6:
+        return f"Good marketing image with {style.lower()} styling. Consider adding more specific details for enhanced results."
+    else:
+        return f"Basic image generated. For better marketing results, try adding more descriptive details and specific {style.lower()} elements."
 
-### 💪 Strengths
-{chr(10).join(f"• {strength}" for strength in review_result.get('strengths', []))}
+def process_generation(prompt, style, aspect_ratio, num_images, quality_threshold):
+    """Process image generation and return results for Gradio"""
+    if not prompt.strip():
+        return None, "❌ Please enter a prompt", "Error", "Error", "Please provide a description for your marketing image."
+    
+    try:
+        result = generate_image_with_review(prompt, style, aspect_ratio, num_images, quality_threshold)
+        
+        if result:
+            status_emoji = "✅" if result["status"] == "approved" else "⚠️"
+            return (
+                result["image"],
+                f"🎯 {result['quality_score']:.2f}/1.0",
+                f"{status_emoji} {result['status'].replace('_', ' ').title()}",
+                f"🎨 {result['style']} | 📐 {result['aspect_ratio']} | ⚡ {result['method']}",
+                f"💬 {result['review_comments']}"
+            )
+        else:
+            return None, "❌ Generation failed", "Error", "Error", "An error occurred during image generation. Please try again."
+            
+    except Exception as e:
+        logger.error(f"Process generation error: {str(e)}")
+        return None, "❌ System error", "Error", "Error", f"System error: {str(e)}"
 
-### ⚠️ Areas for Improvement
-{chr(10).join(f"• {issue}" for issue in review_result.get('issues', []))}
+# Custom CSS for enhanced styling
+custom_css = """
+.gradio-container {
+    font-family: 'Inter', -apple-system, BlinkMacSystemFont, sans-serif;
+    max-width: 1400px !important;
+    margin: 0 auto !important;
+}
 
-### 💡 Recommendations
-{chr(10).join(f"• {rec}" for rec in review_result.get('recommendations', []))}
+.main-header {
+    text-align: center;
+    padding: 2rem 1rem;
+    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+    color: white;
+    border-radius: 16px;
+    margin-bottom: 2rem;
+    box-shadow: 0 10px 25px rgba(102, 126, 234, 0.2);
+}
 
-### 📝 Assessment
-{review_result.get('overall_assessment', 'Review completed')}
+.main-header h1 {
+    font-size: 2.5rem;
+    font-weight: 700;
+    margin: 0 0 0.5rem 0;
+    text-shadow: 0 2px 4px rgba(0,0,0,0.1);
+}
 
----
-*Review Method: {review_result.get('review_method', 'Standard')}*
-*Enhanced Prompt: {enhanced_prompt[:100]}...*
-            """
-            
-            review_status = "✅ Approved" if review_result['passed'] else "⚠️ Needs Review"
-            
-            # Add generation method info
-            debug_info = f"""
-**Generation Details:**
-- Method: {generation_result.get('method', 'Unknown')}
-- Original Prompt: {prompt}
-- Enhanced Prompt: {enhanced_prompt}
-- Style: {style}
-- API Status: {'✅ Connected' if GOOGLE_AUTH else '⚠️ Demo Mode'}
-            """
-            
-        else:
-            quality_info = f"Review failed: {review_result.get('error', 'Unknown error')}"
-            review_status = "❌ Review Failed" 
-            debug_info = f"Generation Method: {generation_result.get('method', 'Unknown')}"
-        
-        progress(1.0, desc="Complete!")
-        
-        return display_image, quality_info, review_status, debug_info
-        
-    except Exception as e:
-        logger.error(f"Workflow error: {str(e)}")
-        error_msg = f"Workflow failed: {str(e)}"
-        return None, error_msg, "❌ Error", f"Error details: {str(e)}"
+.main-header p {
+    font-size: 1.2rem;
+    opacity: 0.95;
+    margin: 0;
+    font-weight: 300;
+}
+
+.status-indicator {
+    padding: 1rem;
+    border-radius: 12px;
+    margin-bottom: 1.5rem;
+    display: flex;
+    align-items: center;
+    gap: 0.75rem;
+    font-weight: 600;
+}
+
+.status-success {
+    background: linear-gradient(135deg, #d1fae5 0%, #a7f3d0 100%);
+    border: 2px solid #10b981;
+    color: #065f46;
+}
+
+.status-warning {
+    background: linear-gradient(135deg, #fef3c7 0%, #fde68a 100%);
+    border: 2px solid #f59e0b;
+    color: #92400e;
+}
+
+.input-section {
+    background: linear-gradient(135deg, #f8fafc 0%, #f1f5f9 100%);
+    border: 2px solid #e2e8f0;
+    border-radius: 16px;
+    padding: 2rem;
+    margin-bottom: 2rem;
+    box-shadow: 0 4px 6px rgba(0, 0, 0, 0.05);
+}
+
+.output-section {
+    background: white;
+    border: 2px solid #e2e8f0;
+    border-radius: 16px;
+    padding: 2rem;
+    box-shadow: 0 4px 6px rgba(0, 0, 0, 0.05);
+}
+
+.generate-btn {
+    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%) !important;
+    border: none !important;
+    color: white !important;
+    font-weight: 600 !important;
+    padding: 1rem 2rem !important;
+    border-radius: 12px !important;
+    font-size: 1.1rem !important;
+    transition: all 0.3s ease !important;
+    box-shadow: 0 4px 15px rgba(102, 126, 234, 0.3) !important;
+}
+
+.generate-btn:hover {
+    transform: translateY(-2px) !important;
+    box-shadow: 0 8px 25px rgba(102, 126, 234, 0.4) !important;
+}
+
+.metric-display {
+    background: #f8fafc;
+    border: 1px solid #e2e8f0;
+    border-radius: 12px;
+    padding: 1rem;
+    text-align: center;
+    font-weight: 600;
+}
+
+.info-section {
+    background: linear-gradient(135deg, #fafafa 0%, #f4f4f5 100%);
+    padding: 1.5rem;
+    border-radius: 12px;
+    border: 1px solid #e4e4e7;
+}
 
-# ====== GRADIO INTERFACE ======
+.info-section h3 {
+    color: #374151;
+    font-size: 1.1rem;
+    margin-bottom: 1rem;
+    font-weight: 600;
+}
 
-def create_gradio_interface():
-    """Create the complete Gradio interface"""
+.info-section ul {
+    margin: 0;
+    padding-left: 1.2rem;
+}
+
+.info-section li {
+    margin-bottom: 0.5rem;
+    color: #6b7280;
+    line-height: 1.5;
+}
+
+.footer-info {
+    text-align: center;
+    color: #6b7280;
+    font-size: 0.9rem;
+    margin-top: 2rem;
+    padding: 1rem;
+    background: #f9fafb;
+    border-radius: 8px;
+}
+"""
+
+# Create the enhanced Gradio interface
+with gr.Blocks(
+    title="Marketing Image Generator with AI Review",
+    theme=gr.themes.Soft(
+        primary_hue="blue",
+        secondary_hue="purple",
+        neutral_hue="slate"
+    ),
+    css=custom_css
+) as demo:
     
-    custom_css = """
-    .gradio-container {
-        max-width: 1400px !important;
-        margin: auto !important;
-    }
-    .header-text {
-        text-align: center;
-        color: #1f77b4;
-        margin-bottom: 2rem;
-    }
-    .quality-info {
-        background-color: #f8f9fa;
-        padding: 1rem;
-        border-radius: 0.5rem;
-        border-left: 4px solid #1f77b4;
-        font-family: monospace;
-    }
-    .status-approved { color: #28a745; font-weight: bold; }
-    .status-warning { color: #ffc107; font-weight: bold; }
-    .status-error { color: #dc3545; font-weight: bold; }
-    """
+    # Main header
+    gr.HTML("""
+    <div class="main-header">
+        <h1>🎨 Marketing Image Generator with AI Review</h1>
+        <p>Create professional marketing images with automated quality assurance</p>
+    </div>
+    """)
     
-    with gr.Blocks(css=custom_css, title="Marketing Image Generator with AI Review") as interface:
-        
-        # Header
-        gr.Markdown("""
-        # 🎨 Marketing Image Generator with AI Review
-        ### Professional marketing images with automated quality assurance
-        
-        This system combines **Google Imagen** for image generation with **Google Gemini Vision** for intelligent quality review.
-        Perfect for creating professional marketing materials with AI-powered feedback.
-        """, elem_classes=["header-text"])
-        
-        # API Status indicator
-        api_status = "🟢 Google AI Connected" if GOOGLE_AUTH else "🟡 Demo Mode (No API Key)"
-        gr.Markdown(f"**Status:** {api_status}")
-        
-        with gr.Row():
-            with gr.Column(scale=2):
-                # Input Section
+    # Status indicator
+    if google_auth_configured:
+        gr.HTML("""
+        <div class="status-indicator status-success">
+            <span style="font-size: 1.2rem;">✅</span>
+            <div>
+                <strong>Ready for Production</strong><br>
+                <small>Google Cloud AI services are configured and active</small>
+            </div>
+        </div>
+        """)
+    else:
+        gr.HTML("""
+        <div class="status-indicator status-warning">
+            <span style="font-size: 1.2rem;">⚠️</span>
+            <div>
+                <strong>Demo Mode Active</strong><br>
+                <small>Enhanced placeholders will be generated. Configure Google Cloud for full AI capabilities.</small>
+            </div>
+        </div>
+        """)
+    
+    with gr.Row():
+        with gr.Column(scale=3):
+            # Input section
+            with gr.Group():
+                gr.HTML('<div class="input-section">')
+                
                 gr.Markdown("## 📝 Describe Your Marketing Image")
                 
-                prompt = gr.Textbox(
+                prompt_input = gr.Textbox(
                     label="Marketing Image Description",
-                    placeholder="e.g., A professional team of diverse colleagues collaborating in a modern office space with natural lighting, for a corporate website hero image",
+                    placeholder="A professional team of diverse colleagues collaborating around a modern conference table in a bright office space, clean corporate design, high-quality lighting, suitable for website hero section...",
                     lines=4,
-                    info="Be specific about subjects, setting, style, and intended marketing use"
+                    info="💡 Be specific about subjects, setting, mood, and intended marketing use for best results."
                 )
                 
                 with gr.Row():
-                    style = gr.Dropdown(
-                        choices=["realistic", "artistic", "cartoon", "illustration", "photographic"],
-                        value="realistic",
-                        label="Art Style",
-                        info="Choose the visual style that fits your brand"
-                    )
+                    with gr.Column():
+                        style_dropdown = gr.Dropdown(
+                            choices=["Professional", "Creative", "Minimalist", "Bold", "Elegant", "Playful", "Corporate", "Modern"],
+                            value="Professional",
+                            label="🎨 Visual Style",
+                            info="Choose the style that matches your brand identity"
+                        )
                     
-                    quality_threshold = gr.Slider(
-                        minimum=0.0,
-                        maximum=1.0,
-                        value=0.7,
-                        step=0.1,
-                        label="Quality Threshold",
-                        info="Minimum score for approval (0.0 = lenient, 1.0 = strict)"
-                    )
+                    with gr.Column():
+                        aspect_ratio = gr.Dropdown(
+                            choices=["16:9", "1:1", "4:3", "3:2"],
+                            value="16:9",
+                            label="📐 Aspect Ratio",
+                            info="Select dimensions for your use case"
+                        )
                 
-                with gr.Accordion("🔧 Advanced Options", open=False):
-                    max_iterations = gr.Slider(
-                        minimum=1,
-                        maximum=3,
-                        value=2,
-                        step=1,
-                        label="Max Review Iterations",
-                        info="Maximum attempts to improve the image"
-                    )
+                with gr.Row():
+                    with gr.Column():
+                        num_images = gr.Slider(
+                            minimum=1,
+                            maximum=1,  # Simplified for demo
+                            value=1,
+                            step=1,
+                            label="🖼️ Images to Generate",
+                            info="Number of variations"
+                        )
+                    
+                    with gr.Column():
+                        quality_slider = gr.Slider(
+                            minimum=0.5,
+                            maximum=1.0,
+                            value=0.8,
+                            step=0.05,
+                            label="🎯 Quality Threshold",
+                            info="Minimum quality score for approval"
+                        )
                 
                 generate_btn = gr.Button(
-                    "🚀 Generate & Review Marketing Image",
+                    "🚀 Generate Marketing Image",
                     variant="primary",
+                    elem_classes="generate-btn",
                     size="lg"
                 )
-            
-            with gr.Column(scale=3):
-                # Output Section
-                gr.Markdown("## 🖼️ Generated Image & Analysis")
                 
-                with gr.Row():
-                    with gr.Column(scale=2):
-                        generated_image = gr.Image(
-                            label="Your Marketing Image",
-                            type="pil",
-                            interactive=False,
-                            height=400
-                        )
-                    
-                    with gr.Column(scale=1):
-                        review_status = gr.Textbox(
-                            label="Review Status",
-                            value="⏳ Ready to Generate",
-                            interactive=False,
-                            max_lines=1
-                        )
+                gr.HTML('</div>')
+        
+        with gr.Column(scale=1):
+            # Info panel
+            gr.HTML("""
+            <div class="info-section">
+                <h3>🔍 How It Works</h3>
+                <ul>
+                    <li><strong>Describe:</strong> Detail your vision with specific marketing context</li>
+                    <li><strong>Style:</strong> Choose from professional design styles</li>
+                    <li><strong>Generate:</strong> AI creates optimized marketing images</li>
+                    <li><strong>Review:</strong> Automated quality analysis and feedback</li>
+                    <li><strong>Use:</strong> Download high-quality results</li>
+                </ul>
                 
-                quality_info = gr.Markdown(
-                    label="AI Quality Analysis",
-                    value="*Generate an image to see detailed AI quality analysis and recommendations*",
-                    elem_classes=["quality-info"]
-                )
-        
-        # Debug/Technical Info (Collapsible)
-        with gr.Accordion("🔧 Technical Details", open=False):
-            debug_info = gr.Markdown(
-                value="*Technical information will appear here after generation*"
+                <h3>💡 Tips for Best Results</h3>
+                <ul>
+                    <li>Include target audience and use case</li>
+                    <li>Specify colors, mood, and setting</li>
+                    <li>Mention brand elements or style preferences</li>
+                    <li>Be specific about composition and framing</li>
+                </ul>
+            </div>
+            """)
+    
+    # Output section
+    gr.HTML('<div class="output-section">')
+    
+    gr.Markdown("## 🖼️ Generated Marketing Image & Analysis")
+    
+    with gr.Row():
+        with gr.Column(scale=2):
+            image_output = gr.Image(
+                label="Generated Marketing Image",
+                height=400,
+                show_label=True,
+                show_download_button=True
             )
         
-        # Examples Section
-        gr.Markdown("## 💡 Example Marketing Prompts")
-        
-        examples = gr.Examples(
-            examples=[
-                ["A diverse team of professionals collaborating around a modern conference table in a bright office space, corporate website hero image", "realistic"],
-                ["A sleek product showcase featuring a smartphone on a clean white background with dramatic lighting, for e-commerce", "photographic"],
-                ["A friendly customer service representative wearing a headset, smiling while helping clients in a contemporary office", "realistic"],
-                ["A minimalist workspace setup with laptop, coffee, and plants, perfect for productivity app marketing", "artistic"],
-                ["An abstract representation of data flow and connectivity, modern tech company branding", "illustration"],
-                ["A celebration scene with confetti and happy people, perfect for achievement or success marketing", "realistic"]
+        with gr.Column(scale=1):
+            gr.Markdown("### 📊 Quality Metrics")
+            
+            quality_output = gr.Textbox(
+                label="Quality Score",
+                interactive=False,
+                elem_classes="metric-display"
+            )
+            
+            status_output = gr.Textbox(
+                label="Review Status",
+                interactive=False,
+                elem_classes="metric-display"
+            )
+            
+            style_output = gr.Textbox(
+                label="Generation Details",
+                interactive=False,
+                elem_classes="metric-display"
+            )
+    
+    review_output = gr.Textbox(
+        label="📋 AI Quality Review & Recommendations",
+        lines=3,
+        interactive=False,
+        info="Detailed feedback and suggestions from our AI review system"
+    )
+    
+    gr.HTML('</div>')
+    
+    # Examples section
+    gr.Markdown("## 💡 Example Prompts")
+    
+    examples = gr.Examples(
+        examples=[
+            [
+                "A diverse team of professionals collaborating around a modern conference table in a bright, contemporary office space with large windows and natural lighting, suitable for corporate website hero section",
+                "Professional",
+                "16:9",
+                1,
+                0.8
             ],
-            inputs=[prompt, style],
-            label="Click any example to try it out!"
-        )
-        
-        # Connect the workflow
-        generate_btn.click(
-            fn=generate_marketing_image_with_review,
-            inputs=[prompt, style, quality_threshold, max_iterations],
-            outputs=[generated_image, quality_info, review_status, debug_info],
-            show_progress=True
-        )
-        
-        # Footer
-        gr.Markdown("""
-        ---
-        <div style='text-align: center; color: #666; font-size: 0.9rem;'>
-            <p>🎨 <strong>Marketing Image Generator with AI Review</strong></p>
-            <p>Powered by Google Imagen & Gemini Vision | Built for Professional Marketing Teams</p>
-            <p><em>Generate → Review → Perfect: Your AI-powered creative workflow</em></p>
-        </div>
-        """)
+            [
+                "A sleek product showcase featuring a smartphone floating above a clean white surface with dramatic studio lighting and subtle reflections, perfect for e-commerce marketing",
+                "Minimalist",
+                "1:1",
+                1,
+                0.8
+            ],
+            [
+                "A friendly customer service representative wearing a headset, smiling warmly while helping clients in a modern call center environment with soft lighting",
+                "Corporate",
+                "4:3",
+                1,
+                0.8
+            ],
+            [
+                "An inspiring workspace setup with a laptop, coffee cup, and plants on a wooden desk, warm natural lighting streaming through a window, perfect for productivity app marketing",
+                "Modern",
+                "16:9",
+                1,
+                0.8
+            ]
+        ],
+        inputs=[prompt_input, style_dropdown, aspect_ratio, num_images, quality_slider],
+        label="Click any example to try it out!"
+    )
     
-    return interface
-
-# ====== APPLICATION ENTRY POINT ======
-
-# Create the interface
-demo = create_gradio_interface()
+    # Footer
+    gr.HTML("""
+    <div class="footer-info">
+        <strong>Marketing Image Generator with AI Review</strong><br>
+        Powered by Google Imagen3 & Gemini Vision | Built for Professional Marketing Teams<br>
+        <em>Transform your marketing vision into professional-quality images with AI-powered review</em>
+    </div>
+    """)
+    
+    # Connect the generation function
+    generate_btn.click(
+        fn=process_generation,
+        inputs=[prompt_input, style_dropdown, aspect_ratio, num_images, quality_slider],
+        outputs=[image_output, quality_output, status_output, style_output, review_output],
+        show_progress=True
+    )
 
+# Launch configuration
 if __name__ == "__main__":
-    logger.info("Starting Marketing Image Generator with AI Review")
     demo.launch(
         server_name="0.0.0.0",
         server_port=7860,
-        share=False,
         show_error=True,
-    )
+        share=False
+    )