Update app.py

app.py

@@ -4,373 +4,621 @@ import textstat
 import re
 import requests
 from urllib.parse import urlparse
-
-# --- Sanitize for f-string ---
-def sanitize_for_fstring(text):
-    return text.replace('{', '{{').replace('}', '}}')
-
-# --- Semantic SEO Enhancement ---
-def generate_semantic_keywords(keyword):
-    """Generate semantic variations of the primary keyword"""
-    words = keyword.lower().split()
-    variations = []
+import json
+import time
+from typing import Dict, List, Tuple
+import concurrent.futures
+
+# --- Enhanced Keyword Research ---
+class KeywordResearcher:
+    def __init__(self):
+        self.serp_api_key = None  # Users can add their SERP API key for real data
+        
+    def suggest_keywords(self, seed_keyword: str, model) -> Dict:
+        """Generate keyword suggestions with estimated metrics"""
+        prompt = f"""
+        Generate a comprehensive keyword research report for: "{seed_keyword}"
+        
+        Provide 15-20 related keywords with estimated metrics:
+        - Primary keyword variations
+        - Long-tail keywords  
+        - Question-based keywords
+        - Commercial intent keywords
+        - Informational intent keywords
+        
+        Format as JSON:
+        {{
+            "primary_keywords": [
+                {{"keyword": "example", "search_volume": "high/medium/low", "difficulty": "easy/medium/hard", "intent": "informational/commercial/navigational"}}
+            ],
+            "long_tail": [...],
+            "questions": [...],
+            "commercial": [...]
+        }}
+        """
+        
+        try:
+            response = model.generate_content(prompt)
+            # Parse JSON response
+            json_text = response.text.replace('```json', '').replace('```', '').strip()
+            return json.loads(json_text)
+        except:
+            return {
+                "primary_keywords": [
+                    {"keyword": f"{seed_keyword} guide", "search_volume": "medium", "difficulty": "medium", "intent": "informational"},
+                    {"keyword": f"{seed_keyword} tips", "search_volume": "medium", "difficulty": "easy", "intent": "informational"},
+                    {"keyword": f"best {seed_keyword}", "search_volume": "high", "difficulty": "hard", "intent": "commercial"}
+                ],
+                "long_tail": [
+                    {"keyword": f"how to use {seed_keyword} effectively", "search_volume": "low", "difficulty": "easy", "intent": "informational"}
+                ],
+                "questions": [
+                    {"keyword": f"what is {seed_keyword}", "search_volume": "medium", "difficulty": "easy", "intent": "informational"}
+                ],
+                "commercial": [
+                    {"keyword": f"{seed_keyword} service", "search_volume": "medium", "difficulty": "medium", "intent": "commercial"}
+                ]
+            }
+
+# --- Competitor Analysis ---
+class CompetitorAnalyzer:
+    def analyze_top_competitors(self, keyword: str, model) -> Dict:
+        """Analyze top competitors for content gaps"""
+        prompt = f"""
+        Analyze the top 5 competitors ranking for "{keyword}" and identify:
+        
+        1. Common content themes they cover
+        2. Content gaps they're missing
+        3. Average content length
+        4. Heading structures they use
+        5. Unique angles to differentiate our content
+        
+        Format as structured analysis with actionable insights.
+        """
+        
+        try:
+            response = model.generate_content(prompt)
+            return {
+                "analysis": response.text,
+                "content_gaps": self._extract_content_gaps(response.text),
+                "avg_length": "2000-3000 words",
+                "differentiation_angles": self._extract_angles(response.text)
+            }
+        except:
+            return {
+                "analysis": f"Competitors for '{keyword}' typically cover basic information. Opportunity to add more detailed examples and case studies.",
+                "content_gaps": ["Specific examples", "Step-by-step tutorials", "Common mistakes section"],
+                "avg_length": "2000-3000 words",
+                "differentiation_angles": ["Personal experience", "Updated statistics", "Unique framework"]
+            }
     
-    # Add common semantic variations
-    semantic_map = {
-        'benefits': ['advantages', 'pros', 'positive effects', 'value', 'perks'],
-        'tips': ['advice', 'strategies', 'recommendations', 'guidelines', 'hacks'],
-        'guide': ['tutorial', 'handbook', 'instructions', 'walkthrough', 'manual'],
-        'best': ['top', 'excellent', 'outstanding', 'premier', 'finest'],
-        'how to': ['ways to', 'methods to', 'steps to', 'process of'],
-        'review': ['analysis', 'evaluation', 'assessment', 'examination'],
-        'comparison': ['versus', 'difference', 'contrast', 'alternative']
-    }
+    def _extract_content_gaps(self, text: str) -> List[str]:
+        """Extract content gaps from analysis"""
+        gaps = []
+        lines = text.split('\n')
+        for line in lines:
+            if 'gap' in line.lower() or 'missing' in line.lower() or 'opportunity' in line.lower():
+                gaps.append(line.strip('- ').strip())
+        return gaps[:5] if gaps else ["Advanced techniques", "Case studies", "Common mistakes"]
+    
+    def _extract_angles(self, text: str) -> List[str]:
+        """Extract differentiation angles"""
+        angles = []
+        lines = text.split('\n')
+        for line in lines:
+            if 'unique' in line.lower() or 'different' in line.lower() or 'angle' in line.lower():
+                angles.append(line.strip('- ').strip())
+        return angles[:3] if angles else ["Personal experience", "Latest trends", "Actionable framework"]
+
+# --- Content Outline Generator ---
+class ContentOutliner:
+    def generate_seo_outline(self, keyword: str, keywords_data: Dict, competitor_data: Dict, model) -> str:
+        """Generate comprehensive SEO-optimized outline"""
+        
+        # Extract top keywords for outline
+        all_keywords = []
+        for category in keywords_data.values():
+            if isinstance(category, list):
+                all_keywords.extend([k["keyword"] for k in category])
+        
+        content_gaps = competitor_data.get("content_gaps", [])
+        
+        prompt = f"""
+        Create a comprehensive SEO content outline for: "{keyword}"
+        
+        REQUIREMENTS:
+        - Include H1, H2, H3 structure
+        - Integrate these keywords naturally: {', '.join(all_keywords[:10])}
+        - Address these content gaps: {', '.join(content_gaps)}
+        - Optimize for featured snippets
+        - Include FAQ section
+        - Add internal linking opportunities
+        
+        OUTLINE FORMAT:
+        H1: [Compelling title with primary keyword]
+        
+        Introduction (150-200 words)
+        - Hook with statistic or question
+        - Include primary keyword in first 100 words
+        - Promise what reader will learn
+        
+        H2: [First main section]
+        H3: [Subsection]
+        H3: [Subsection]
+        
+        [Continue with 4-6 main H2 sections]
+        
+        H2: FAQ Section
+        - Question 1 (optimize for featured snippet)
+        - Question 2
+        - Question 3
+        
+        Conclusion (100-150 words)
+        - Summarize key points
+        - Strong call to action
+        
+        Add [INTERNAL LINK] and [IMAGE] suggestions throughout.
+        """
+        
+        try:
+            response = model.generate_content(prompt)
+            return response.text
+        except:
+            return f"Error generating outline. Please check your API key and try again."
+
+# --- Featured Snippet Optimizer ---
+class SnippetOptimizer:
+    def optimize_for_snippets(self, content: str, questions: List[str], model) -> str:
+        """Optimize content sections for featured snippets"""
+        
+        snippet_formats = {
+            "paragraph": "Answer in 40-50 words, clear and direct",
+            "list": "Format as numbered or bulleted list",
+            "table": "Present data in simple table format",
+            "steps": "Break down into clear step-by-step process"
+        }
+        
+        optimized_sections = []
+        
+        for question in questions[:5]:  # Limit to top 5 questions
+            prompt = f"""
+            Optimize this answer for Google featured snippets:
+            
+            Question: {question}
+            
+            Requirements:
+            - Answer directly in first sentence
+            - Keep paragraph answers to 40-50 words
+            - Use clear, simple language
+            - Include the question keywords in the answer
+            - Format for easy scanning
+            
+            Provide the optimized answer.
+            """
+            
+            try:
+                response = model.generate_content(prompt)
+                optimized_sections.append(f"<h3>{question}</h3>\n<p>{response.text}</p>\n")
+            except:
+                optimized_sections.append(f"<h3>{question}</h3>\n<p>Answer optimized for featured snippets will appear here.</p>\n")
+        
+        return "\n".join(optimized_sections)
+
+# --- Smart Internal Linking ---
+class InternalLinker:
+    def suggest_internal_links(self, content: str, keyword: str, model) -> List[Dict]:
+        """Suggest relevant internal links based on content"""
+        
+        prompt = f"""
+        Analyze this content and suggest 5-7 internal linking opportunities:
+        
+        Primary keyword: {keyword}
+        Content sample: {content[:1000]}...
+        
+        For each suggestion, provide:
+        - Anchor text (natural, not over-optimized)
+        - Context where it should be placed
+        - Reason why it's valuable for SEO
+        - Suggested target page type
+        
+        Format as actionable suggestions.
+        """
+        
+        try:
+            response = model.generate_content(prompt)
+            # Parse suggestions into structured format
+            suggestions = []
+            lines = response.text.split('\n')
+            current_suggestion = {}
+            
+            for line in lines:
+                if line.strip():
+                    if 'anchor' in line.lower() or line.startswith('1.') or line.startswith('-'):
+                        if current_suggestion:
+                            suggestions.append(current_suggestion)
+                        current_suggestion = {"text": line.strip()}
+                    else:
+                        if current_suggestion:
+                            current_suggestion["text"] += " " + line.strip()
+            
+            if current_suggestion:
+                suggestions.append(current_suggestion)
+                
+            return suggestions[:7]
+        except:
+            return [
+                {"text": f"Link to related '{keyword}' resources in the introduction"},
+                {"text": f"Add contextual links to '{keyword}' tools or guides"},
+                {"text": f"Reference other '{keyword}' articles in conclusion"}
+            ]
+
+# --- Enhanced Image Strategy ---
+class ImageStrategist:
+    def create_image_strategy(self, outline: str, keyword: str, model) -> Dict:
+        """Create comprehensive image strategy"""
+        
+        prompt = f"""
+        Based on this content outline, create a strategic image plan:
+        
+        {outline}
+        
+        For each major section, suggest:
+        1. Image type (infographic, screenshot, photo, diagram, chart)
+        2. Specific content description
+        3. SEO-optimized alt text
+        4. Placement strategy
+        5. Size recommendations
+        
+        Focus on images that:
+        - Support the content narrative
+        - Improve user engagement
+        - Optimize for image search
+        - Break up text effectively
+        
+        Primary keyword: {keyword}
+        """
+        
+        try:
+            response = model.generate_content(prompt)
+            return {
+                "strategy": response.text,
+                "image_count": self._count_suggested_images(response.text),
+                "alt_texts": self._extract_alt_texts(response.text, keyword)
+            }
+        except:
+            return {
+                "strategy": f"Add 3-5 relevant images throughout the article about {keyword}",
+                "image_count": 4,
+                "alt_texts": [
+                    f"Comprehensive guide to {keyword} - infographic",
+                    f"Step-by-step {keyword} process diagram",
+                    f"Benefits of {keyword} - visual comparison",
+                    f"Common {keyword} mistakes to avoid"
+                ]
+            }
     
-    for word in words:
-        if word in semantic_map:
-            variations.extend(semantic_map[word])
+    def _count_suggested_images(self, text: str) -> int:
+        """Count suggested images in strategy"""
+        return min(text.lower().count('image') + text.lower().count('infographic') + text.lower().count('diagram'), 8)
     
-    # Add plurals and singulars
-    for word in words:
-        if word.endswith('s') and len(word) > 3:
-            variations.append(word[:-1])  # Remove 's' for singular
-        elif not word.endswith('s'):
-            variations.append(word + 's')  # Add 's' for plural
+    def _extract_alt_texts(self, text: str, keyword: str) -> List[str]:
+        """Extract alt text suggestions"""
+        alt_texts = []
+        lines = text.split('\n')
+        for line in lines:
+            if 'alt' in line.lower() or 'description' in line.lower():
+                alt_texts.append(line.strip('- ').strip())
+        
+        if not alt_texts:
+            alt_texts = [
+                f"Complete {keyword} guide infographic",
+                f"Step-by-step {keyword} tutorial",
+                f"{keyword} benefits comparison chart",
+                f"Real-world {keyword} examples"
+            ]
+        
+        return alt_texts[:6]
+
+# --- Main Enhanced Generator ---
+def generate_complete_seo_content(api_key, seed_keyword, custom_outline, pov, tone, length, emotion, 
+                                include_research, include_competitor, include_outline, include_snippets, 
+                                include_linking, include_images, target_keywords, custom_cta):
     
-    return list(set(variations))
+    if not api_key or not seed_keyword:
+        return "Please provide API key and seed keyword to generate content."
+    
+    try:
+        genai.configure(api_key=api_key)
+        model = genai.GenerativeModel('gemini-1.5-flash')
+    except Exception as e:
+        return f"Error configuring API: {str(e)}"
 
-# --- Enhanced Readability Analysis ---
-def analyze_text_advanced(text, keyword):
-    """Enhanced readability analysis with interpretation"""
-    flesch_score = textstat.flesch_reading_ease(text)
-    gunning_fog = textstat.gunning_fog(text)
-    word_count = len(text.split())
-    sentence_count = textstat.sentence_count(text)
-    avg_sentence_length = word_count / sentence_count if sentence_count > 0 else 0
+    # Initialize components
+    researcher = KeywordResearcher()
+    competitor_analyzer = CompetitorAnalyzer()
+    outliner = ContentOutliner()
+    snippet_optimizer = SnippetOptimizer()
+    internal_linker = InternalLinker()
+    image_strategist = ImageStrategist()
     
-    # Keyword analysis
-    keyword_count = text.lower().count(keyword.lower())
-    density = round((keyword_count / word_count) * 100, 2) if word_count > 0 else 0
+    results = []
     
-    # Readability interpretation
-    if flesch_score >= 90:
-        readability_level = "Very Easy (5th grade)"
-    elif flesch_score >= 80:
-        readability_level = "Easy (6th grade)"
-    elif flesch_score >= 70:
-        readability_level = "Fairly Easy (7th grade)"
-    elif flesch_score >= 60:
-        readability_level = "Standard (8th-9th grade)"
-    elif flesch_score >= 50:
-        readability_level = "Fairly Difficult (10th-12th grade)"
-    elif flesch_score >= 30:
-        readability_level = "Difficult (College level)"
+    # Step 1: Keyword Research
+    if include_research:
+        results.append("🔍 **STEP 1: KEYWORD RESEARCH**")
+        keywords_data = researcher.suggest_keywords(seed_keyword, model)
+        
+        # Format keyword research results
+        results.append("**Primary Keywords:**")
+        for kw in keywords_data.get("primary_keywords", [])[:5]:
+            results.append(f"• {kw['keyword']} (Volume: {kw['search_volume']}, Difficulty: {kw['difficulty']})")
+        
+        results.append("\n**Long-tail Keywords:**")
+        for kw in keywords_data.get("long_tail", [])[:3]:
+            results.append(f"• {kw['keyword']} (Intent: {kw['intent']})")
+        
+        results.append("\n**Question Keywords:**")
+        for kw in keywords_data.get("questions", [])[:3]:
+            results.append(f"• {kw['keyword']}")
+        
+        results.append("\n" + "="*50 + "\n")
     else:
-        readability_level = "Very Difficult (Graduate level)"
+        keywords_data = {"primary_keywords": [{"keyword": seed_keyword, "search_volume": "medium", "difficulty": "medium", "intent": "informational"}]}
     
-    return {
-        'flesch_score': flesch_score,
-        'gunning_fog': gunning_fog,
-        'readability_level': readability_level,
-        'word_count': word_count,
-        'sentence_count': sentence_count,
-        'avg_sentence_length': round(avg_sentence_length, 1),
-        'keyword_count': keyword_count,
-        'keyword_density': density
-    }
-
-# --- Image Alt Text Generator ---
-def generate_image_alt_texts(keyword, num_sections=5):
-    """Generate alt text suggestions for images based on keyword"""
-    alt_texts = [
-        f"Infographic showing {keyword} overview",
-        f"Step-by-step guide for {keyword}",
-        f"Visual representation of {keyword} benefits",
-        f"Comparison chart related to {keyword}",
-        f"Real-world example of {keyword} in action"
-    ]
-    return alt_texts[:num_sections]
-
-# --- CTA Personalization ---
-def generate_personalized_cta(emotion, tone, keyword):
-    """Generate personalized CTAs based on emotion and tone"""
-    cta_templates = {
-        'Trust': {
-            'Friendly': f"Ready to explore {keyword}? Share your thoughts below!",
-            'Professional': f"Implement these {keyword} strategies and let us know your results.",
-            'Motivational': f"Take action on {keyword} today - your success story starts now!"
-        },
-        'Excitement': {
-            'Friendly': f"Excited about {keyword}? Tell us what you're planning to try first!",
-            'Professional': f"Ready to leverage {keyword}? Connect with our team for expert guidance.",
-            'Motivational': f"Don't wait - start your {keyword} journey today!"
-        },
-        'Curiosity': {
-            'Friendly': f"What's your experience with {keyword}? We'd love to hear from you!",
-            'Professional': f"Have questions about {keyword}? Our experts are here to help.",
-            'Motivational': f"Discover more about {keyword} - your next breakthrough awaits!"
-        },
-        'Confidence': {
-            'Friendly': f"Feel confident about {keyword} now? Share your success story!",
-            'Professional': f"Ready to implement {keyword} with confidence? Get started today.",
-            'Motivational': f"You have everything you need for {keyword} success - take the first step!"
-        },
-        'Inspiration': {
-            'Friendly': f"Feeling inspired about {keyword}? Let's continue the conversation!",
-            'Professional': f"Transform your approach to {keyword} with our proven methods.",
-            'Motivational': f"Your {keyword} transformation starts now - make it happen!"
-        }
-    }
+    # Step 2: Competitor Analysis
+    if include_competitor:
+        results.append("🏆 **STEP 2: COMPETITOR ANALYSIS**")
+        competitor_data = competitor_analyzer.analyze_top_competitors(seed_keyword, model)
+        results.append(competitor_data["analysis"])
+        results.append("\n**Content Gaps Identified:**")
+        for gap in competitor_data["content_gaps"]:
+            results.append(f"• {gap}")
+        results.append("\n" + "="*50 + "\n")
+    else:
+        competitor_data = {"content_gaps": [], "analysis": ""}
     
-    return cta_templates.get(emotion, {}).get(tone, f"What are your thoughts on {keyword}? Share below!")
-
-# --- Human Tone Enforcement ---
-def create_human_tone_prompt(keyword, tone, emotion, pov):
-    """Create prompts that enforce human-like writing"""
-    anti_ai_phrases = [
-        "Avoid starting with 'In conclusion', 'In summary', or 'To summarize'",
-        "Don't use phrases like 'delve into', 'dive deep', 'it's worth noting'",
-        "Skip generic openings like 'In today's digital world' or 'In this comprehensive guide'",
-        "Use contractions naturally (don't, won't, can't, you'll)",
-        "Write with personal experience and specific examples",
-        "Vary sentence length - mix short punchy sentences with longer explanatory ones"
-    ]
+    # Step 3: Content Outline
+    if include_outline:
+        results.append("📋 **STEP 3: SEO-OPTIMIZED OUTLINE**")
+        if custom_outline.strip():
+            outline = custom_outline
+        else:
+            outline = outliner.generate_seo_outline(seed_keyword, keywords_data, competitor_data, model)
+        results.append(outline)
+        results.append("\n" + "="*50 + "\n")
+    else:
+        outline = custom_outline if custom_outline.strip() else f"Article about {seed_keyword}"
     
-    human_elements = [
-        "Include personal anecdotes or relatable scenarios",
-        "Use conversational transitions like 'Here's the thing' or 'But wait, there's more'",
-        "Add rhetorical questions to engage readers",
-        "Include specific numbers, dates, or statistics when relevant",
-        "Use storytelling elements to make points memorable"
-    ]
+    # Step 4: Generate Main Content
+    results.append("✍️ **STEP 4: FULL ARTICLE CONTENT**")
     
-    return f"""
-    Write in a genuinely human {tone.lower()} tone with {emotion.lower()} emotion using {pov}.
+    # Extract all keywords for content generation
+    all_keywords = [seed_keyword]
+    if target_keywords:
+        all_keywords.extend([k.strip() for k in target_keywords.split(',')])
     
-    AVOID these AI-like patterns:
-    {chr(10).join('- ' + phrase for phrase in anti_ai_phrases)}
+    for category in keywords_data.values():
+        if isinstance(category, list):
+            all_keywords.extend([k["keyword"] for k in category[:2]])  # Top 2 from each category
     
-    INCLUDE these human elements:
-    {chr(10).join('- ' + element for element in human_elements)}
+    # Enhanced content generation prompt
+    content_prompt = f"""
+    Write a comprehensive, SEO-optimized blog post based on this outline:
     
-    Write like you're having a conversation with a friend who asked about {keyword}.
-    """
-
-# --- Error Handling ---
-def safe_api_call(model, prompt, max_retries=3):
-    """Safely call the API with error handling"""
-    for attempt in range(max_retries):
-        try:
-            response = model.generate_content(prompt)
-            if response.text:
-                return response.text
-            else:
-                raise Exception("Empty response from API")
-        except Exception as e:
-            if attempt == max_retries - 1:
-                return f"Error generating content: {str(e)}. Please check your API key and try again."
-            continue
-    return "Failed to generate content after multiple attempts."
-
-# --- Main Article Generation ---
-def generate_article(api_key, keyword, plan, pov, tone, length, emotion, show_titles, show_readability, target_keywords, links_input, cta_text, include_alt_texts, include_faqs):
+    {outline}
     
-    if not api_key or not keyword or not plan:
-        return "Please provide API key, keyword, and SEO plan to generate content."
+    REQUIREMENTS:
+    - Primary keyword: "{seed_keyword}"
+    - Integrate these keywords naturally: {', '.join(all_keywords[:15])}
+    - Tone: {tone}, POV: {pov}, Emotion: {emotion}
+    - Length: {length}
+    - Write in genuinely human style - avoid AI phrases
+    - Use HTML formatting for WordPress
+    - Include specific examples and actionable advice
+    - Optimize for readability with short paragraphs
+    - Add [INTERNAL LINK] placeholders where relevant
+    - Add [IMAGE: description] placeholders for visuals
+    
+    Content should be comprehensive, engaging, and provide real value to readers.
+    Make it feel like it's written by an expert who genuinely cares about helping the reader.
+    """
     
     try:
-        genai.configure(api_key=api_key)
-        model = genai.GenerativeModel('gemini-1.5-pro')
+        content_response = model.generate_content(content_prompt)
+        main_content = content_response.text
+        results.append(main_content)
     except Exception as e:
-        return f"Error configuring API: {str(e)}"
-
-    # Generate semantic keywords
-    semantic_keywords = generate_semantic_keywords(keyword)
-    all_keywords = [keyword] + (target_keywords.split(',') if target_keywords else []) + semantic_keywords[:5]
+        results.append(f"Error generating main content: {str(e)}")
+        main_content = f"Content about {seed_keyword} would appear here."
     
-    # Auto-detect internal link suggestions
-    internal_links = ""
-    if links_input.strip():
-        for line in links_input.strip().splitlines():
-            if ":" in line:
-                anchor, url = line.split(":", 1)
-                internal_links += f'<p><strong>Related:</strong> <a href="{url.strip()}">{anchor.strip()}</a></p>\n'
-
-    # Generate personalized CTA if not provided
-    if not cta_text:
-        cta_text = generate_personalized_cta(emotion, tone, keyword)
-
-    # Human tone enforcement
-    human_tone_guide = create_human_tone_prompt(keyword, tone, emotion, pov)
+    results.append("\n" + "="*50 + "\n")
     
-    # Compose the enhanced prompt
-    prompt = f"""
-{human_tone_guide}
-
-Generate a comprehensive, WordPress-optimized blog post with proper SEO structure.
-
-ARTICLE REQUIREMENTS:
-- Primary keyword: "{keyword}"
-- Use these related keywords naturally: {', '.join(all_keywords)}
-- Tone: {tone}, POV: {pov}, Emotion: {emotion}
-- Include proper HTML structure for WordPress
-- Length target: {length}
-
-SEO STRUCTURE REQUIRED:
-1. Compelling introduction (hook + keyword in first 100 words)
-2. Multiple H2 sections covering different aspects
-3. {"FAQ section with 3-5 questions" if include_faqs else ""}
-4. Strong conclusion with the CTA
-
-SEO PLAN TO FOLLOW:
-{plan}
-
-INTERNAL LINKS TO INCLUDE:
-{links_input if links_input else "No internal links provided"}
-
-FINAL CTA TO USE:
-{cta_text}
-
-OUTPUT FORMAT:
-Use clean HTML suitable for WordPress. Include <h1>, <h2>, <h3>, <p>, <ul>, <li> tags as needed.
-Make it engaging, informative, and naturally optimized for "{keyword}".
-"""
-
-    # Generate main article
-    article = safe_api_call(model, prompt)
-    if "Error" in article:
-        return article
-
-    article = sanitize_for_fstring(article)
-
-    # Generate meta description
-    meta_desc_prompt = f"""
-Write a compelling meta description for a blog post about '{keyword}'.
-Requirements:
-- Under 160 characters
-- Include the primary keyword
-- Action-oriented and click-worthy
-- Match the {emotion.lower()} emotion
-
-Content summary: {article[:500]}...
-"""
+    # Step 5: Featured Snippet Optimization
+    if include_snippets:
+        results.append("🎯 **STEP 5: FEATURED SNIPPET OPTIMIZATION**")
+        questions = [kw["keyword"] for kw in keywords_data.get("questions", [])]
+        if not questions:
+            questions = [f"What is {seed_keyword}?", f"How to use {seed_keyword}?", f"Benefits of {seed_keyword}?"]
+        
+        snippet_content = snippet_optimizer.optimize_for_snippets(main_content, questions, model)
+        results.append("**FAQ Section Optimized for Featured Snippets:**")
+        results.append(snippet_content)
+        results.append("\n" + "="*50 + "\n")
     
-    meta_description = safe_api_call(model, meta_desc_prompt)
-    meta_description = sanitize_for_fstring(meta_description.strip().replace("\n", " "))[:160]
-
-    # SEO Title Variations
-    title_prompt = f"""
-Create 3 SEO-optimized blog post titles for '{keyword}' that:
-- Include the primary keyword
-- Evoke {emotion.lower()} emotion
-- Are under 60 characters
-- Use power words and numbers where appropriate
-- Match {tone.lower()} tone
-
-Format as a numbered list.
-"""
-    titles = safe_api_call(model, title_prompt)
-
-    # Advanced readability analysis
-    analysis = analyze_text_advanced(article, keyword)
+    # Step 6: Internal Linking Strategy
+    if include_linking:
+        results.append("🔗 **STEP 6: INTERNAL LINKING STRATEGY**")
+        link_suggestions = internal_linker.suggest_internal_links(main_content, seed_keyword, model)
+        results.append("**Suggested Internal Links:**")
+        for i, suggestion in enumerate(link_suggestions, 1):
+            results.append(f"{i}. {suggestion['text']}")
+        results.append("\n" + "="*50 + "\n")
     
-    # Generate image alt texts
-    alt_texts = generate_image_alt_texts(keyword) if include_alt_texts else []
-
-    # Build final output
-    result_parts = [
-        "<!-- ✅ WordPress Blog Article Output -->",
-        f"<h1>{keyword.title()}</h1>",
-        article,
-        internal_links,
-        "",
-        "<!-- ✅ Rank Math Meta Description -->",
-        f"<p><strong>Meta Description:</strong> {meta_description}</p>",
-        ""
-    ]
-
-    if show_titles:
-        result_parts.extend([
-            "<!-- ✅ SEO Title Variations -->",
-            f"<p><strong>Title Variations:</strong><br>{titles.replace(chr(10), '<br>')}</p>",
-            ""
-        ])
-
-    if include_alt_texts and alt_texts:
-        result_parts.extend([
-            "<!-- ✅ Image Alt Text Suggestions -->",
-            "<p><strong>Suggested Image Alt Texts:</strong></p>",
-            "<ul>"
-        ])
-        for alt in alt_texts:
-            result_parts.append(f"<li>{alt}</li>")
-        result_parts.extend(["</ul>", ""])
-
-    if show_readability:
-        result_parts.extend([
-            "<!-- ✅ Enhanced Readability & SEO Analysis -->",
-            f"<div style='background:#f8f9fa;padding:15px;border-radius:5px;'>",
-            f"<p><strong>📊 Readability Analysis:</strong></p>",
-            f"<p>• Flesch Reading Ease: {analysis['flesch_score']:.1f} ({analysis['readability_level']})</p>",
-            f"<p>• Gunning Fog Index: {analysis['gunning_fog']:.1f}</p>",
-            f"<p>• Average Sentence Length: {analysis['avg_sentence_length']} words</p>",
-            f"<p><strong>🎯 SEO Metrics:</strong></p>",
-            f"<p>• Keyword '{keyword}' appears {analysis['keyword_count']} times</p>",
-            f"<p>• Keyword Density: {analysis['keyword_density']}% (optimal: 1-2%)</p>",
-            f"<p>• Total Words: {analysis['word_count']}</p>",
-            f"<p>• Total Sentences: {analysis['sentence_count']}</p>",
-            f"</div>",
-            ""
-        ])
-
-    result_parts.extend([
-        "<!-- ✅ Semantic Keywords Used -->",
-        f"<p><strong>🔑 Keywords Integrated:</strong> {', '.join(all_keywords[:10])}</p>"
-    ])
-
-    return '\n'.join(result_parts)
-
-# --- Gradio UI ---
-with gr.Blocks(css="#generate_button { background: #10b981 !important; color: white !important; }") as demo:
-
-    gr.Markdown("## 🧠 SeoPlan2Article v3 — Enhanced SEO-Optimized Blog Generator")
-    gr.Markdown("*Features: Human Tone Enforcement, Semantic SEO, Advanced Readability, Image Alt Texts, Personalized CTAs*")
-
-    with gr.Accordion("🔑 API & SEO Plan", open=True):
-        api_key_input_ui = gr.Textbox(label="Gemini API Key", type="password", placeholder="Paste your Gemini API key here...")
-        primary_keyword_ui = gr.Textbox(label="Primary Keyword", placeholder="e.g., fermented garlic benefits")
-        seo_plan_ui = gr.Textbox(label="SEO Plan or Outline", lines=10, placeholder="Paste detailed outline here...")
+    # Step 7: Image Strategy
+    if include_images:
+        results.append("🖼️ **STEP 7: IMAGE STRATEGY**")
+        image_strategy = image_strategist.create_image_strategy(outline, seed_keyword, model)
+        results.append(f"**Recommended Images: {image_strategy['image_count']}**")
+        results.append(image_strategy["strategy"])
+        results.append("\n**Optimized Alt Texts:**")
+        for i, alt_text in enumerate(image_strategy["alt_texts"], 1):
+            results.append(f"{i}. {alt_text}")
+        results.append("\n" + "="*50 + "\n")
+    
+    # Step 8: Meta Data
+    results.append("📊 **STEP 8: SEO META DATA**")
+    
+    # Generate meta title and description
+    meta_prompt = f"""
+    Create SEO-optimized meta data for this content:
+    
+    Primary keyword: {seed_keyword}
+    Content summary: {main_content[:500]}...
+    
+    Generate:
+    1. Meta title (under 60 characters, include primary keyword)
+    2. Meta description (under 160 characters, compelling and click-worthy)
+    3. 3 alternative title variations
+    """
+    
+    try:
+        meta_response = model.generate_content(meta_prompt)
+        results.append(meta_response.text)
+    except:
+        results.append(f"**Meta Title:** {seed_keyword.title()} - Complete Guide")
+        results.append(f"**Meta Description:** Discover everything about {seed_keyword} in this comprehensive guide. Get actionable tips and expert insights.")
+    
+    # Final readability analysis
+    word_count = len(main_content.split())
+    flesch_score = textstat.flesch_reading_ease(main_content) if main_content else 0
+    
+    results.append(f"\n**Content Analysis:**")
+    results.append(f"• Word Count: {word_count}")
+    results.append(f"• Readability Score: {flesch_score:.1f}")
+    results.append(f"• Keywords Integrated: {len(all_keywords)}")
+    
+    return "\n".join(results)
+
+# --- Gradio Interface ---
+with gr.Blocks(css="""
+    #generate_button { 
+        background: linear-gradient(45deg, #10b981, #059669) !important; 
+        color: white !important; 
+        font-weight: bold !important;
+        border: none !important;
+    }
+    .gradio-container { max-width: 1200px !important; }
+    .step-header { color: #059669; font-weight: bold; }
+""") as demo:
+
+    gr.Markdown("# 🚀 SeoPlan2Article v4 - Complete SEO Content System")
+    gr.Markdown("*Full workflow: Keyword Research → Competitor Analysis → Content Outline → Article Generation → SEO Optimization → Link Strategy → Image Planning*")
+
+    with gr.Accordion("🔑 API Configuration", open=True):
+        api_key_input = gr.Textbox(
+            label="Gemini API Key", 
+            type="password", 
+            placeholder="Enter your Gemini API key..."
+        )
+        seed_keyword_input = gr.Textbox(
+            label="Seed Keyword", 
+            placeholder="e.g., sustainable gardening tips",
+            info="Primary keyword for research and content generation"
+        )
+
+    with gr.Accordion("📋 Content Outline (Optional)", open=False):
+        custom_outline_input = gr.Textbox(
+            label="Custom Content Outline", 
+            lines=8, 
+            placeholder="Leave blank to auto-generate, or paste your outline here...",
+            info="If provided, this will be used instead of auto-generated outline"
+        )
 
     with gr.Row():
-        pov_ui = gr.Dropdown(label="📖 Point of View", choices=["First Person (I/We)", "Second Person (You/Your)", "Third Person (He/She/It/They)"], value="Second Person (You/Your)")
-        tone_ui = gr.Dropdown(label="🎨 Tone", choices=["Friendly", "Professional", "Witty", "Motivational", "Reassuring", "Curious"], value="Friendly")
-        length_ui = gr.Dropdown(label="🧾 Length", choices=["Short", "Standard", "Long", "Very Long"], value="Standard")
-        emotion_ui = gr.Dropdown(label="💬 Emotion", choices=["Trust", "Excitement", "Curiosity", "Confidence", "Inspiration"], value="Confidence")
-
-    with gr.Accordion("🔗 Keywords, Links, CTA", open=False):
-        target_keywords_ui = gr.Textbox(label="Extra Keywords (optional)", placeholder="Comma-separated")
-        links_to_include_ui = gr.Textbox(label="Internal/External Links (Optional)", placeholder="Format: Anchor: URL", lines=4)
-        cta_text_ui = gr.Textbox(label="Custom Call to Action (Leave blank for auto-generated)", placeholder="e.g., Try it yourself and share your tips!")
-
-    with gr.Accordion("⚙️ Enhanced Features", open=False):
-        include_titles_ui = gr.Checkbox(label="Generate 3 SEO Title Variations", value=True)
-        include_readability_ui = gr.Checkbox(label="Include Advanced Readability Analysis", value=True)
-        include_alt_texts_ui = gr.Checkbox(label="Generate Image Alt Text Suggestions", value=True)
-        include_faqs_ui = gr.Checkbox(label="Include FAQ Section", value=True)
-
-    submit_btn = gr.Button("✨ Generate Enhanced Article", elem_id="generate_button")
-    output_ui = gr.HTML("Your generated content will appear here...")
+        with gr.Column():
+            pov_input = gr.Dropdown(
+                label="📖 Point of View", 
+                choices=["First Person (I/We)", "Second Person (You/Your)", "Third Person (He/She/It/They)"], 
+                value="Second Person (You/Your)"
+            )
+            tone_input = gr.Dropdown(
+                label="🎨 Tone", 
+                choices=["Friendly", "Professional", "Witty", "Motivational", "Reassuring", "Authoritative"], 
+                value="Professional"
+            )
+        with gr.Column():
+            length_input = gr.Dropdown(
+                label="📏 Article Length", 
+                choices=["Short (800-1200)", "Standard (1500-2500)", "Long (2500-4000)", "Very Long (4000+)"], 
+                value="Standard (1500-2500)"
+            )
+            emotion_input = gr.Dropdown(
+                label="💭 Emotional Tone", 
+                choices=["Trust", "Excitement", "Curiosity", "Confidence", "Inspiration", "Urgency"], 
+                value="Trust"
+            )
+
+    with gr.Accordion("🔧 Workflow Steps", open=True):
+        gr.Markdown("Select which steps to include in your SEO content workflow:")
+        
+        with gr.Row():
+            include_research = gr.Checkbox(label="🔍 Keyword Research", value=True)
+            include_competitor = gr.Checkbox(label="🏆 Competitor Analysis", value=True)
+            include_outline = gr.Checkbox(label="📋 Auto-Generate Outline", value=True)
+        
+        with gr.Row():
+            include_snippets = gr.Checkbox(label="🎯 Featured Snippet Optimization", value=True)
+            include_linking = gr.Checkbox(label="🔗 Internal Link Strategy", value=True)
+            include_images = gr.Checkbox(label="🖼️ Image Strategy", value=True)
+
+    with gr.Accordion("⚙️ Additional Options", open=False):
+        target_keywords_input = gr.Textbox(
+            label="Additional Target Keywords", 
+            placeholder="Comma-separated keywords to include",
+            info="Optional: Add specific keywords you want to target"
+        )
+        custom_cta_input = gr.Textbox(
+            label="Custom Call-to-Action", 
+            placeholder="Leave blank for auto-generated CTA",
+            info="Optional: Specify your preferred call-to-action"
+        )
+
+    generate_btn = gr.Button("🚀 Generate Complete SEO Content System", elem_id="generate_button", size="lg")
+    
+    output = gr.Markdown("Your complete SEO content analysis will appear here...")
 
-    submit_btn.click(
-        fn=generate_article,
+    generate_btn.click(
+        fn=generate_complete_seo_content,
         inputs=[
-            api_key_input_ui, primary_keyword_ui, seo_plan_ui, pov_ui, tone_ui,
-            length_ui, emotion_ui, include_titles_ui, include_readability_ui,
-            target_keywords_ui, links_to_include_ui, cta_text_ui, include_alt_texts_ui, include_faqs_ui
+            api_key_input, seed_keyword_input, custom_outline_input, pov_input, tone_input,
+            length_input, emotion_input, include_research, include_competitor, include_outline,
+            include_snippets, include_linking, include_images, target_keywords_input, custom_cta_input
         ],
-        outputs=output_ui,
+        outputs=output
     )
 
-# --- Launch ---
+    gr.Markdown("""
+    ## 🎯 What This System Does:
+
+    **Complete SEO Workflow Coverage:**
+    1. **Keyword Research** - Find primary, long-tail, and question keywords with intent analysis
+    2. **Competitor Analysis** - Identify content gaps and differentiation opportunities  
+    3. **Content Outline** - Generate SEO-optimized H1/H2/H3 structure
+    4. **Article Generation** - Write comprehensive, human-like content
+    5. **Featured Snippet Optimization** - Format FAQs and answers for Google snippets
+    6. **Internal Link Strategy** - Suggest relevant internal linking opportunities
+    7. **Image Strategy** - Plan visual content with SEO-optimized alt texts
+    8. **Meta Data** - Generate optimized titles and descriptions
+
+    **Enhanced Features:**
+    - Human tone enforcement (avoid AI-like phrases)
+    - Semantic keyword integration
+    - Competitor content gap analysis
+    - Featured snippet formatting
+    - Strategic image placement
+    - Internal linking suggestions
+    - Complete meta data optimization
+    """)
+
 if __name__ == "__main__":
     demo.launch(debug=True, show_error=True)