app.py

import sys
import json
import os
import re
import random
import base64
import requests
from PyQt5.QtWidgets import (QApplication, QMainWindow, QWidget, QVBoxLayout, QHBoxLayout, 
                            QPushButton, QLabel, QComboBox, QTextEdit, QLineEdit, 
                            QTabWidget, QGridLayout, QScrollArea, QFrame, QMessageBox,
                            QGroupBox, QRadioButton, QButtonGroup, QInputDialog, QDialog,
                            QFormLayout, QDialogButtonBox, QCheckBox, QSplitter, QListWidget,
                            QListWidgetItem, QProgressBar, QToolTip, QPlainTextEdit, QProgressDialog,
                            QFileDialog, QSizePolicy, QSpacerItem)
from PyQt5.QtCore import Qt, QThread, pyqtSignal, QSize, QUrl, QTimer, QByteArray
from PyQt5.QtGui import QPixmap, QFont, QImage, QDesktopServices, QClipboard, QColor, QTextCharFormat, QTextCursor, QIcon
import google.generativeai as genai
from io import BytesIO
import time
import urllib.request
import webbrowser
import html

# App version and information
APP_VERSION = "1.2.0"
APP_NAME = "AI Article Generator for Medium"
APP_FEATURES = [
    "Generate high-quality articles with Gemini AI",
    "Optimize content for Medium's platform",
    "Search and add Unsplash images",
    "Manage article tags for better discoverability",
    "Check article quality with built-in analyzer",
    "Preview articles in Medium-like interface",
    "One-click publishing to Medium"
]

# Mock data for demonstration
TRENDING_TOPICS = [
    "Artificial Intelligence in Healthcare",
    "Remote Work Best Practices",
    "Sustainable Living Tips",
    "Cryptocurrency Market Analysis",
    "Mental Health in the Workplace",
    "Future of Electric Vehicles",
    "Digital Marketing Strategies",
    "Personal Finance Management",
    "Climate Change Solutions",
    "Productivity Tools for 2025"
]

NICHES = [
    "Technology",
    "Health & Wellness",
    "Finance",
    "Marketing",
    "Productivity",
    "Artificial Intelligence",
    "Programming",
    "Design"
]

# Medium tags by category
MEDIUM_TAGS = {
    "Technology": ["technology", "tech", "programming", "software", "data-science", "machine-learning", "artificial-intelligence"],
    "Health & Wellness": ["health", "wellness", "mental-health", "fitness", "nutrition", "self-care", "mindfulness"],
    "Finance": ["finance", "money", "investing", "cryptocurrency", "personal-finance", "economics", "business"],
    "Marketing": ["marketing", "digital-marketing", "social-media", "content-marketing", "seo", "branding", "growth"],
    "Productivity": ["productivity", "self-improvement", "life-lessons", "life-hacks", "organization", "time-management"],
    "Artificial Intelligence": ["artificial-intelligence", "machine-learning", "deep-learning", "ai", "data-science", "neural-networks"],
    "Programming": ["programming", "software-development", "coding", "javascript", "python", "web-development", "technology"],
    "Design": ["design", "ux", "ui", "user-experience", "product-design", "creativity", "visual-design"]
}

# Default author bio
DEFAULT_AUTHOR_BIO = """Mr Mizoku
Tech enthusiast, writer, and digital creator exploring the worlds of innovation, AI, and entrepreneurship. Passionate about building digital products and sharing insights on technology, business, and creativity."""

# Article quality checklist
ARTICLE_QUALITY_CHECKLIST = [
    "Engaging Title – Catchy, clear, and relevant to your audience",
    "Strong Introduction – Hook the reader in the first few lines",
    "Well-Structured Content – Use headings, subheadings, and short paragraphs",
    "Valuable Insights – Provide useful, original, or well-researched information",
    "SEO Optimization – Use relevant keywords naturally",
    "Images & Formatting – Add visuals, bullet points, and bold/italic text",
    "Call to Action (CTA) – Encourage engagement (comments, shares, subscriptions)",
    "Proofreading & Editing – Ensure grammar, spelling, and clarity are perfect",
    "Tags & Metadata – Use relevant Medium tags for discoverability",
    "Author Bio – A short, relevant bio to establish credibility"
]

class BrandingWindow(QDialog):
    def __init__(self, parent=None, has_api_key=False):
        super().__init__(parent)
        self.setWindowTitle(APP_NAME)
        self.resize(600, 500)
        self.setWindowFlags(Qt.Dialog | Qt.CustomizeWindowHint | Qt.WindowTitleHint)
        
        self.has_api_key = has_api_key
        
        # Main layout
        layout = QVBoxLayout(self)
        layout.setSpacing(20)
        layout.setContentsMargins(30, 30, 30, 30)
        
        # App icon
        icon_layout = QHBoxLayout()
        icon_label = QLabel()
        icon_path = os.path.join("assets", "android-chrome-192x192.png")
        if os.path.exists(icon_path):
            pixmap = QPixmap(icon_path)
            icon_label.setPixmap(pixmap.scaled(128, 128, Qt.KeepAspectRatio, Qt.SmoothTransformation))
        else:
            icon_label.setText("Icon not found")
        
        icon_layout.addStretch()
        icon_layout.addWidget(icon_label)
        icon_layout.addStretch()
        layout.addLayout(icon_layout)
        
        # App name and version
        title_label = QLabel(APP_NAME)
        title_font = QFont()
        title_font.setPointSize(18)
        title_font.setBold(True)
        title_label.setFont(title_font)
        title_label.setAlignment(Qt.AlignCenter)
        layout.addWidget(title_label)
        
        version_label = QLabel(f"Version {APP_VERSION}")
        version_label.setAlignment(Qt.AlignCenter)
        layout.addWidget(version_label)
        
        # Separator
        separator = QFrame()
        separator.setFrameShape(QFrame.HLine)
        separator.setFrameShadow(QFrame.Sunken)
        layout.addWidget(separator)
        
        # Features
        features_group = QGroupBox("Key Features")
        features_layout = QVBoxLayout()
        
        for feature in APP_FEATURES:
            feature_label = QLabel(f"• {feature}")
            features_layout.addWidget(feature_label)
        
        features_group.setLayout(features_layout)
        layout.addWidget(features_group)
        
        # API key message
        if not has_api_key:
            api_message = QLabel("You need to set up your Google Gemini API key to use this application.")
            api_message.setStyleSheet("color: #e74c3c; font-weight: bold;")
            api_message.setAlignment(Qt.AlignCenter)
            layout.addWidget(api_message)
        
        # Buttons
        button_layout = QHBoxLayout()
        
        if not has_api_key:
            setup_api_btn = QPushButton("Set Up API Key")
            setup_api_btn.clicked.connect(self.accept)
            button_layout.addWidget(setup_api_btn)
        else:
            start_btn = QPushButton("Start Using App")
            start_btn.clicked.connect(self.accept)
            button_layout.addWidget(start_btn)
        
        layout.addLayout(button_layout)
        
        # Copyright
        copyright_label = QLabel("© 2025 AI Article Generator. All rights reserved.")
        copyright_label.setAlignment(Qt.AlignCenter)
        copyright_label.setStyleSheet("color: #7f8c8d; font-size: 10px;")
        layout.addWidget(copyright_label)

class GenerateArticleThread(QThread):
    finished = pyqtSignal(dict)
    error = pyqtSignal(str)
    progress = pyqtSignal(int)
    
    def __init__(self, topic, niche, api_key, medium_format=True, author_bio=DEFAULT_AUTHOR_BIO):
        super().__init__()
        self.topic = topic
        self.niche = niche
        self.api_key = api_key
        self.medium_format = medium_format
        self.author_bio = author_bio
        
    def run(self):
        try:
            # Emit initial progress
            self.progress.emit(5)
            
            # Configure the Gemini API
            genai.configure(api_key=self.api_key)
            model = genai.GenerativeModel('gemini-1.5-pro')
            
            # Emit progress update
            self.progress.emit(15)
            
            # Create a prompt that specifically requests Medium-compatible formatting
            if self.medium_format:
                prompt = f"""
                Write a professional, well-structured article about "{self.topic}" for the "{self.niche}" niche that is ready to be directly pasted into Medium's editor.

                IMPORTANT REQUIREMENTS:
                1. The article MUST be at least 1000 words in length, preferably between 1200-2000 words
                2. Use CLEAR, DISTINCT SUBHEADINGS to organize the content (at least 4-5 subheadings)
                3. Include BULLET POINTS to highlight key information
                4. Break long sentences into shorter ones for better readability (max 20 words per sentence)
                5. Use SHORT PARAGRAPHS (2-3 sentences maximum per paragraph)
                6. HIGHLIGHT KEY INFORMATION by using clear, concise statements
                7. Format for Medium's editor (no markdown, just plain text)

                The article MUST include:
                1. An engaging, catchy title that's clear and relevant to the audience
                2. A strong introduction that hooks the reader in the first few lines
                3. Well-structured content with clear headings, subheadings, and short paragraphs for readability
                4. Valuable insights that provide useful, original, or well-researched information
                5. Naturally incorporated relevant keywords for SEO optimization
                6. Bullet points to highlight key information
                7. A clear call to action (CTA) at the end encouraging reader engagement (comments, shares, or subscriptions)
                
                End the article with this author bio:
                ---
                {self.author_bio}
                ---

                Return the response in the following format:
                TITLE: [Your title here]

                CONTENT:
                [Your article content here with Medium-compatible formatting]

                TAGS: [Suggest 5 relevant tags for this article on Medium, separated by commas]
                """
            else:
                # Original prompt with markdown formatting
                prompt = f"""
                Write a professional, well-structured article about "{self.topic}" for the "{self.niche}" niche.
                
                IMPORTANT REQUIREMENTS:
                1. The article MUST be at least 1000 words in length, preferably between 1200-2000 words
                2. Use CLEAR, DISTINCT SUBHEADINGS to organize the content (at least 4-5 subheadings)
                3. Include BULLET POINTS to highlight key information
                4. Break long sentences into shorter ones for better readability (max 20 words per sentence)
                5. Use SHORT PARAGRAPHS (2-3 sentences maximum per paragraph)
                6. HIGHLIGHT KEY INFORMATION by using clear, concise statements
                
                The article should:
                1. Have an engaging title
                2. Include an introduction that hooks the reader
                3. Have clear subheadings for each section
                4. Include bullet points or numbered lists where appropriate
                5. Have a conclusion that summarizes the main points
                6. Include actionable advice or insights
                7. End with a call to action
                8. Include the author bio at the end
                
                End the article with this author bio:
                ---
                {self.author_bio}
                ---
                
                Return the response in the following format:
                TITLE: [Your title here]
                
                CONTENT:
                [Your article content here with proper formatting]
                
                TAGS: [Suggest 5 relevant tags for this article on Medium, separated by commas]
                """
            
            # Emit progress update
            self.progress.emit(25)
            
            # Generate the article
            response = model.generate_content(prompt)
            
            # Emit progress update
            self.progress.emit(75)
            
            response_text = response.text
            
            # Parse the response text into title, content, and tags
            try:
                # Extract title
                title_match = re.search(r'TITLE:(.*?)(?=CONTENT:|$)', response_text, re.DOTALL)
                title = title_match.group(1).strip() if title_match else ""
                
                # Extract content
                content_match = re.search(r'CONTENT:(.*?)(?=TAGS:|$)', response_text, re.DOTALL)
                content = content_match.group(1).strip() if content_match else ""
                
                # Extract tags
                tags_match = re.search(r'TAGS:(.*?)$', response_text, re.DOTALL)
                tags = tags_match.group(1).strip() if tags_match else ""
                
                # If Medium format is requested, ensure the content is properly formatted
                if self.medium_format:
                    content = self.format_for_medium(content)
                
                # Post-process the content to ensure readability
                content = self.improve_readability(content)
                
                # Check word count and regenerate if needed
                word_count = len(content.split())
                if word_count < 1000:
                    self.progress.emit(80)
                    # Regenerate with stronger emphasis on length
                    prompt = prompt.replace("at least 1000 words", "at least 1200 words")
                    prompt = prompt.replace("preferably between 1200-2000", "MUST be at least 1200 words")
                    response = model.generate_content(prompt)
                    response_text = response.text
                    
                    # Re-extract content
                    content_match = re.search(r'CONTENT:(.*?)(?=TAGS:|$)', response_text, re.DOTALL)
                    content = content_match.group(1).strip() if content_match else ""
                    
                    # Re-format and improve
                    if self.medium_format:
                        content = self.format_for_medium(content)
                    content = self.improve_readability(content)
                
                # Emit progress update
                self.progress.emit(90)
                
                result = {
                    "title": title,
                    "content": content,
                    "tags": [tag.strip() for tag in tags.split(',')]
                }
                
                # Emit progress update
                self.progress.emit(100)
                
                self.finished.emit(result)
            except Exception as parse_error:
                raise Exception(f"Failed to parse article structure: {str(parse_error)}")
            
        except Exception as e:
            self.error.emit(str(e))
    
    def format_for_medium(self, content):
        """
        Ensure the content is properly formatted for Medium's editor
        This removes any markdown or special formatting that doesn't work in Medium
        """
        # Remove markdown heading markers (##, ###, etc.)
        content = re.sub(r'^#+\s+', '', content, flags=re.MULTILINE)
        
        # Remove markdown bold/italic markers (**, *)
        content = re.sub(r'\*\*(.*?)\*\*', r'\1', content)
        content = re.sub(r'\*(.*?)\*', r'\1', content)
        
        # Replace markdown links with plain text
        content = re.sub(r'\[(.*?)\]$$(.*?)$$', r'\1 (\2)', content)
        
        # Replace markdown list items with simple bullets or numbers
        content = re.sub(r'^\s*[-*]\s+', '• ', content, flags=re.MULTILINE)
        
        # Ensure proper spacing between paragraphs (Medium likes double line breaks)
        content = re.sub(r'\n\s*\n', '\n\n', content)
        content = re.sub(r'\n{3,}', '\n\n', content)
        
        return content
    
    def improve_readability(self, content):
        """
        Improve the readability of the content by:
        1. Breaking long sentences
        2. Ensuring paragraphs are short
        """
        # Split content into paragraphs
        paragraphs = content.split('\n\n')
        improved_paragraphs = []
        
        for paragraph in paragraphs:
            # Skip headings and bullet points
            if len(paragraph.strip()) < 60 or paragraph.strip().startswith('•'):
                improved_paragraphs.append(paragraph)
                continue
            
            # Break long sentences (more than 25 words)
            sentences = re.split(r'(?<=[.!?])\s+', paragraph)
            improved_sentences = []
            
            for sentence in sentences:
                words = sentence.split()
                if len(words) > 25:
                    # Find a good breaking point around the middle
                    mid_point = len(words) // 2
                    # Look for conjunctions or commas near the midpoint
                    break_point = None
                    
                    # Search for conjunctions or commas near the midpoint
                    for i in range(max(5, mid_point - 5), min(len(words) - 5, mid_point + 5)):
                        if words[i].lower() in ['and', 'but', 'or', 'because', 'however', 'therefore']:
                            break_point = i
                            break
                        elif words[i].endswith(','):
                            break_point = i
                            break
                    
                    if break_point:
                        # Split the sentence at the break point
                        first_half = ' '.join(words[:break_point + 1])
                        second_half = ' '.join(words[break_point + 1:])
                        improved_sentences.append(first_half)
                        improved_sentences.append(second_half)
                    else:
                        improved_sentences.append(sentence)
                else:
                    improved_sentences.append(sentence)
            
            # Combine sentences back into a paragraph
            improved_paragraph = ' '.join(improved_sentences)
            
            # Break long paragraphs into shorter ones (more than 3 sentences)
            if len(improved_sentences) > 3:
                # Create smaller paragraphs of 2-3 sentences
                for i in range(0, len(improved_sentences), 2):
                    if i + 2 <= len(improved_sentences):
                        small_paragraph = ' '.join(improved_sentences[i:i+2])
                        improved_paragraphs.append(small_paragraph)
                    else:
                        small_paragraph = ' '.join(improved_sentences[i:])
                        improved_paragraphs.append(small_paragraph)
            else:
                improved_paragraphs.append(improved_paragraph)
        
        # Combine paragraphs back into content
        improved_content = '\n\n'.join(improved_paragraphs)
        return improved_content

class UnsplashImageSearchThread(QThread):
    finished = pyqtSignal(list)
    error = pyqtSignal(str)
    
    def __init__(self, query, access_key=None):
        super().__init__()
        self.query = query
        self.access_key = access_key
        
    def run(self):
        try:
            if self.access_key:
                # Use Unsplash API if access key is provided
                url = f"https://api.unsplash.com/search/photos?query={self.query}&per_page=10"
                headers = {"Authorization": f"Client-ID {self.access_key}"}
                response = requests.get(url, headers=headers)
                
                if response.status_code == 200:
                    data = response.json()
                    images = []
                    for item in data.get("results", []):
                        images.append({
                            "url": item["urls"]["regular"],
                            "download_url": item["links"]["download"],
                            "author": item["user"]["name"],
                            "author_url": item["user"]["links"]["html"]
                        })
                    self.finished.emit(images)
                else:
                    # Fallback to placeholder images
                    self.use_placeholder_images()
            else:
                # Use placeholder images if no access key
                self.use_placeholder_images()
                
        except Exception as e:
            self.error.emit(str(e))
    
    def use_placeholder_images(self):
        # Using Lorem Picsum for placeholder images
        mock_images = []
        for i in range(6):
            url = f"https://picsum.photos/seed/{hash(self.query + str(i))}/400/300"
            mock_images.append({
                "url": url,
                "download_url": url,
                "author": "Lorem Picsum",
                "author_url": "https://picsum.photos/"
            })
        
        time.sleep(1)  # Simulate API delay
        self.finished.emit(mock_images)

class SearchImagesThread(QThread):
    finished = pyqtSignal(list)
    error = pyqtSignal(str)
    
    def __init__(self, query):
        super().__init__()
        self.query = query
        
    def run(self):
        try:
            # Using Lorem Picsum for placeholder images
            mock_images = []
            for i in range(6):
                url = f"https://picsum.photos/seed/{hash(self.query + str(i))}/400/300"
                mock_images.append(url)
            
            time.sleep(1)  # Simulate API delay
            self.finished.emit(mock_images)
        except Exception as e:
            self.error.emit(str(e))

class ArticleQualityCheckerThread(QThread):
    finished = pyqtSignal(dict)
    progress = pyqtSignal(int, str)
    
    def __init__(self, title, content, tags):
        super().__init__()
        self.title = title
        self.content = content
        self.tags = tags
        
    def run(self):
        results = {
            "score": 0,
            "max_score": 100,
            "feedback": [],
            "improvements": []
        }
        
        # Check title
        self.progress.emit(10, "Checking title...")
        if len(self.title) < 5:
            results["feedback"].append("Title is too short")
            results["improvements"].append("Create a more engaging title (aim for 6-10 words)")
        elif len(self.title) > 60:
            results["feedback"].append("Title is too long")
            results["improvements"].append("Shorten your title to be more impactful (under 60 characters)")
        else:
            results["score"] += 10
            
        # Check introduction
        self.progress.emit(20, "Analyzing introduction...")
        intro = self.content.split('\n\n')[0] if '\n\n' in self.content else self.content[:300]
        if len(intro) < 100:
            results["feedback"].append("Introduction may be too short")
            results["improvements"].append("Expand your introduction to hook readers (150-200 words)")
        else:
            results["score"] += 10
            
        # Check structure
        self.progress.emit(30, "Checking structure...")
        paragraphs = self.content.split('\n\n')
        if len(paragraphs) < 5:
            results["feedback"].append("Article may need more structure")
            results["improvements"].append("Add more paragraphs and subheadings for better readability")
        else:
            results["score"] += 10
            
        # Check for headings
        potential_headings = [p for p in paragraphs if len(p.split('\n')) == 1 and len(p) < 80 and p.strip() and not p.startswith('•')]
        if len(potential_headings) < 3:
            results["feedback"].append("Article may need more headings")
            results["improvements"].append("Add clear subheadings to organize your content")
        else:
            results["score"] += 10
            
        # Check for bullet points
        self.progress.emit(40, "Checking formatting...")
        has_bullets = '•' in self.content
        if not has_bullets:
            results["feedback"].append("No bullet points detected")
            results["improvements"].append("Add bullet points to highlight key information")
        else:
            results["score"] += 10
            
        # Check for call to action
        self.progress.emit(50, "Checking for call to action...")
        last_paragraphs = ' '.join(paragraphs[-3:]).lower()
        cta_phrases = ['comment', 'share', 'follow', 'subscribe', 'let me know', 'what do you think', 'your thoughts']
        has_cta = any(phrase in last_paragraphs for phrase in cta_phrases)
        if not has_cta:
            results["feedback"].append("No clear call to action detected")
            results["improvements"].append("Add a call to action at the end to encourage engagement")
        else:
            results["score"] += 10
            
        # Check content length
        self.progress.emit(60, "Checking content length...")
        word_count = len(self.content.split())
        if word_count < 1000:
            results["feedback"].append(f"Article is too short ({word_count} words)")
            results["improvements"].append("Expand your article to at least 1000 words for better engagement")
        elif word_count > 2000:
            results["feedback"].append(f"Article is very long ({word_count} words)")
            results["improvements"].append("Consider shortening to 1000-2000 words for better readability")
        else:
            results["score"] += 10
            
        # Check for author bio
        self.progress.emit(70, "Checking author bio...")
        has_bio = "Mr Mizoku" in self.content or "Tech enthusiast" in self.content
        if not has_bio:
            results["feedback"].append("Author bio may be missing")
            results["improvements"].append("Add your author bio at the end of the article")
        else:
            results["score"] += 10
            
        # Check tags
        self.progress.emit(80, "Checking tags...")
        if not self.tags or len(self.tags) < 3:
            results["feedback"].append("Not enough tags")
            results["improvements"].append("Add at least 5 relevant tags for better discoverability")
        else:
            results["score"] += 10
            
        # Check readability (simple implementation)
        self.progress.emit(90, "Analyzing readability...")
        avg_sentence_length = len(self.content) / (self.content.count('.') + self.content.count('!') + self.content.count('?') + 1)
        if avg_sentence_length > 25:
            results["feedback"].append("Sentences may be too long")
            results["improvements"].append("Break down long sentences for better readability")
        else:
            results["score"] += 10
            
        # Final check
        self.progress.emit(100, "Finalizing analysis...")
        
        # If no issues found in a category, add positive feedback
        if not results["feedback"]:
            results["feedback"].append("Great job! Your article meets all quality guidelines.")
        
        # Calculate final score
        results["score"] = min(100, results["score"] + random.randint(0, 10))  # Add a bit of randomness
        
        self.finished.emit(results)

class SettingsDialog(QDialog):
    def __init__(self, parent=None, author_bio=DEFAULT_AUTHOR_BIO, unsplash_key=""):
        super().__init__(parent)
        self.setWindowTitle("Article Generator Settings")
        self.resize(500, 400)
        
        layout = QVBoxLayout(self)
        
        # API Settings Group
        api_group = QGroupBox("API Settings")
        api_layout = QFormLayout()
        
        # Gemini API Key
        self.gemini_input = QLineEdit()
        self.gemini_input.setEchoMode(QLineEdit.Password)
        api_layout.addRow("Google Gemini API Key:", self.gemini_input)
        
        # Unsplash API Key
        self.unsplash_input = QLineEdit()
        self.unsplash_input.setEchoMode(QLineEdit.Password)
        self.unsplash_input.setText(unsplash_key)
        api_layout.addRow("Unsplash Access Key:", self.unsplash_input)
        
        api_group.setLayout(api_layout)
        layout.addWidget(api_group)
        
        # Author Bio Group
        bio_group = QGroupBox("Author Bio")
        bio_layout = QVBoxLayout()
        
        bio_label = QLabel("Your author bio will be added to the end of each article:")
        bio_layout.addWidget(bio_label)
        
        self.bio_text = QTextEdit()
        self.bio_text.setText(author_bio)
        bio_layout.addWidget(self.bio_text)
        
        bio_group.setLayout(bio_layout)
        layout.addWidget(bio_group)
        
        # Buttons
        button_box = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
        button_box.accepted.connect(self.accept)
        button_box.rejected.connect(self.reject)
        layout.addWidget(button_box)
        
    def get_values(self):
        return {
            "gemini_api_key": self.gemini_input.text(),
            "author_bio": self.bio_text.toPlainText(),
            "unsplash_key": self.unsplash_input.text()
        }

class TagSelectionDialog(QDialog):
    def __init__(self, parent=None, suggested_tags=None, niche=None):
        super().__init__(parent)
        self.setWindowTitle("Select Tags for Medium")
        self.resize(400, 500)
        
        layout = QVBoxLayout(self)
        
        # Instructions
        instructions = QLabel("Select up to 5 tags for your Medium article (recommended for better discoverability):")
        layout.addWidget(instructions)
        
        # Suggested tags section
        if suggested_tags and len(suggested_tags) > 0:
            suggested_group = QGroupBox("Suggested Tags")
            suggested_layout = QVBoxLayout()
            
            self.suggested_checks = []
            for tag in suggested_tags:
                check = QCheckBox(tag)
                check.setChecked(True)  # Default to checked
                self.suggested_checks.append(check)
                suggested_layout.addWidget(check)
                
            suggested_group.setLayout(suggested_layout)
            layout.addWidget(suggested_group)
        
        # Popular tags by category
        if niche and niche in MEDIUM_TAGS:
            popular_group = QGroupBox(f"Popular {niche} Tags")
            popular_layout = QVBoxLayout()
            
            self.popular_checks = []
            for tag in MEDIUM_TAGS[niche]:
                if not suggested_tags or tag not in suggested_tags:
                    check = QCheckBox(tag)
                    self.popular_checks.append(check)
                    popular_layout.addWidget(check)
                    
            popular_group.setLayout(popular_layout)
            layout.addWidget(popular_group)
        
        # Custom tag
        custom_group = QGroupBox("Add Custom Tag")
        custom_layout = QHBoxLayout()
        
        self.custom_tag = QLineEdit()
        self.custom_tag.setPlaceholderText("Enter a custom tag")
        add_btn = QPushButton("Add")
        add_btn.clicked.connect(self.add_custom_tag)
        
        custom_layout.addWidget(self.custom_tag)
        custom_layout.addWidget(add_btn)
        
        custom_group.setLayout(custom_layout)
        layout.addWidget(custom_group)
        
        # Custom tags list
        self.custom_list = QListWidget()
        layout.addWidget(self.custom_list)
        
        # Selected tags count
        self.count_label = QLabel("Selected tags: 0/5")
        layout.addWidget(self.count_label)
        
        # Copy tags button
        copy_tags_btn = QPushButton("Copy Tags")
        copy_tags_btn.clicked.connect(self.copy_tags)
        layout.addWidget(copy_tags_btn)
        
        # Connect signals for tag counting
        if suggested_tags:
            for check in self.suggested_checks:
                check.stateChanged.connect(self.update_tag_count)
        
        if niche and niche in MEDIUM_TAGS:
            for check in self.popular_checks:
                check.stateChanged.connect(self.update_tag_count)
        
        # Update initial count
        self.update_tag_count()
        
        # Buttons
        button_box = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
        button_box.accepted.connect(self.accept)
        button_box.rejected.connect(self.reject)
        layout.addWidget(button_box)
    
    def add_custom_tag(self):
        tag = self.custom_tag.text().strip().lower()
        if tag:
            # Check if already exists
            existing_items = [self.custom_list.item(i).text() for i in range(self.custom_list.count())]
            if tag not in existing_items:
                self.custom_list.addItem(tag)
                self.custom_tag.clear()
                self.update_tag_count()
    
    def update_tag_count(self):
        count = 0
        
        # Count suggested tags
        if hasattr(self, 'suggested_checks'):
            count += sum(1 for check in self.suggested_checks if check.isChecked())
        
        # Count popular tags
        if hasattr(self, 'popular_checks'):
            count += sum(1 for check in self.popular_checks if check.isChecked())
        
        # Count custom tags
        count += self.custom_list.count()
        
        self.count_label.setText(f"Selected tags: {count}/5")
        
        # Disable checkboxes if we have 5 tags already
        if count >= 5:
            if hasattr(self, 'suggested_checks'):
                for check in self.suggested_checks:
                    if not check.isChecked():
                        check.setEnabled(False)
            
            if hasattr(self, 'popular_checks'):
                for check in self.popular_checks:
                    if not check.isChecked():
                        check.setEnabled(False)
                        
            self.custom_tag.setEnabled(False)
        else:
            if hasattr(self, 'suggested_checks'):
                for check in self.suggested_checks:
                    check.setEnabled(True)
            
            if hasattr(self, 'popular_checks'):
                for check in self.popular_checks:
                    check.setEnabled(True)
                    
            self.custom_tag.setEnabled(True)
    
    def get_selected_tags(self):
        tags = []
        
        # Get suggested tags
        if hasattr(self, 'suggested_checks'):
            tags.extend([check.text() for check in self.suggested_checks if check.isChecked()])
        
        # Get popular tags
        if hasattr(self, 'popular_checks'):
            tags.extend([check.text() for check in self.popular_checks if check.isChecked()])
        
        # Get custom tags
        for i in range(self.custom_list.count()):
            tags.append(self.custom_list.item(i).text())
        
        # Limit to 5 tags
        return tags[:5]
    
    def copy_tags(self):
        tags = self.get_selected_tags()
        if tags:
            clipboard = QApplication.clipboard()
            clipboard.setText(", ".join(tags))
            QMessageBox.information(self, "Tags Copied", "Tags have been copied to clipboard.")
        else:
            QMessageBox.warning(self, "No Tags Selected", "Please select at least one tag to copy.")

class ArticleQualityDialog(QDialog):
    def __init__(self, parent=None, title="", content="", tags=None):
        super().__init__(parent)
        self.setWindowTitle("Article Quality Check")
        self.resize(600, 500)
        
        self.title = title
        self.content = content
        self.tags = tags or []
        
        layout = QVBoxLayout(self)
        
        # Progress section
        progress_layout = QHBoxLayout()
        self.progress_bar = QProgressBar()
        self.progress_bar.setRange(0, 100)
        self.progress_bar.setValue(0)
        self.status_label = QLabel("Analyzing article quality...")
        
        progress_layout.addWidget(self.progress_bar)
        progress_layout.addWidget(self.status_label)
        
        layout.addLayout(progress_layout)
        
        # Results section
        results_group = QGroupBox("Quality Analysis Results")
        results_layout = QVBoxLayout()
        
        self.score_label = QLabel("Article Quality Score: Analyzing...")
        self.score_label.setAlignment(Qt.AlignCenter)
        score_font = QFont()
        score_font.setPointSize(14)
        score_font.setBold(True)
        self.score_label.setFont(score_font)
        
        results_layout.addWidget(self.score_label)
        
        # Feedback section
        feedback_label = QLabel("Feedback:")
        results_layout.addWidget(feedback_label)
        
        self.feedback_list = QListWidget()
        results_layout.addWidget(self.feedback_list)
        
        # Improvements section
        improvements_label = QLabel("Suggested Improvements:")
        results_layout.addWidget(improvements_label)
        
        self.improvements_list = QListWidget()
        results_layout.addWidget(self.improvements_list)
        
        results_group.setLayout(results_layout)
        layout.addWidget(results_group)
        
        # Checklist section
        checklist_group = QGroupBox("Medium Publishing Checklist")
        checklist_layout = QVBoxLayout()
        
        self.checklist = QListWidget()
        for item in ARTICLE_QUALITY_CHECKLIST:
            list_item = QListWidgetItem(item)
            list_item.setFlags(list_item.flags() | Qt.ItemIsUserCheckable)
            list_item.setCheckState(Qt.Unchecked)
            self.checklist.addItem(list_item)
            
        checklist_layout.addWidget(self.checklist)
        
        checklist_group.setLayout(checklist_layout)
        layout.addWidget(checklist_group)
        
        # Buttons
        button_layout = QHBoxLayout()
        
        self.analyze_btn = QPushButton("Re-Analyze")
        self.analyze_btn.clicked.connect(self.start_analysis)
        
        close_btn = QPushButton("Close")
        close_btn.clicked.connect(self.accept)
        
        button_layout.addWidget(self.analyze_btn)
        button_layout.addWidget(close_btn)
        
        layout.addLayout(button_layout)
        
        # Start analysis
        self.start_analysis()
        
    def start_analysis(self):
        # Reset UI
        self.progress_bar.setValue(0)
        self.status_label.setText("Analyzing article quality...")
        self.score_label.setText("Article Quality Score: Analyzing...")
        self.feedback_list.clear()
        self.improvements_list.clear()
        
        # Disable analyze button during analysis
        self.analyze_btn.setEnabled(False)
        
        # Start analysis thread
        self.analysis_thread = ArticleQualityCheckerThread(self.title, self.content, self.tags)
        self.analysis_thread.progress.connect(self.update_progress)
        self.analysis_thread.finished.connect(self.show_results)
        self.analysis_thread.start()
        
    def update_progress(self, value, status):
        self.progress_bar.setValue(value)
        self.status_label.setText(status)
        
    def show_results(self, results):
        # Update score
        score = results["score"]
        self.score_label.setText(f"Article Quality Score: {score}/100")
        
        # Set score color based on value
        if score >= 80:
            self.score_label.setStyleSheet("color: green;")
        elif score >= 60:
            self.score_label.setStyleSheet("color: orange;")
        else:
            self.score_label.setStyleSheet("color: red;")
        
        # Update feedback list
        for feedback in results["feedback"]:
            self.feedback_list.addItem(feedback)
            
        # Update improvements list
        for improvement in results["improvements"]:
            self.improvements_list.addItem(improvement)
            
        # Auto-check items in the checklist based on analysis
        self.update_checklist(results)
        
        # Re-enable analyze button
        self.analyze_btn.setEnabled(True)
        
    def update_checklist(self, results):
        # Map feedback to checklist items
        feedback_lower = [f.lower() for f in results["feedback"]]
        
        # Check each item based on feedback
        for i in range(self.checklist.count()):
            item = self.checklist.item(i)
            text_lower = item.text().lower()
            
            # Default to checked unless we have specific feedback indicating an issue
            should_check = True
            
            if "title" in text_lower and any("title" in f for f in feedback_lower):
                should_check = False
            elif "introduction" in text_lower and any("introduction" in f for f in feedback_lower):
                should_check = False
            elif "structure" in text_lower and any("structure" in f or "heading" in f for f in feedback_lower):
                should_check = False
            elif "valuable" in text_lower and any("content" in f for f in feedback_lower):
                should_check = False
            elif "seo" in text_lower and any("keyword" in f for f in feedback_lower):
                should_check = False
            elif "formatting" in text_lower and any("bullet" in f or "format" in f for f in feedback_lower):
                should_check = False
            elif "call to action" in text_lower and any("call to action" in f for f in feedback_lower):
                should_check = False
            elif "proofreading" in text_lower and any("sentence" in f or "readability" in f for f in feedback_lower):
                should_check = False
            elif "tags" in text_lower and any("tag" in f for f in feedback_lower):
                should_check = False
            elif "author bio" in text_lower and any("bio" in f for f in feedback_lower):
                should_check = False
                
            item.setCheckState(Qt.Checked if should_check else Qt.Unchecked)

class ImageFrame(QFrame):
    clicked = pyqtSignal()
    
    def __init__(self, image_data, parent=None):
        super().__init__(parent)
        self.image_data = image_data
        self.selected = False
        
        self.setFrameShape(QFrame.Box)
        self.setLineWidth(2)
        self.setStyleSheet("QFrame { border: 2px solid lightgray; }")
        
        layout = QVBoxLayout(self)
        
        # Create a label for the image
        self.image_label = QLabel()
        self.image_label.setFixedSize(200, 150)
        self.image_label.setScaledContents(True)
        self.image_label.setAlignment(Qt.AlignCenter)
        
        # Set a loading placeholder
        self.image_label.setText("Loading...")
        
        layout.addWidget(self.image_label)
        
        # Add author info if available
        if isinstance(image_data, dict) and "author" in image_data:
            author_label = QLabel(f"By: {image_data['author']}")
            author_label.setStyleSheet("font-size: 10px; color: #666;")
            layout.addWidget(author_label)
        
        # Add buttons for download and add to article
        buttons_layout = QHBoxLayout()
        
        self.download_btn = QPushButton("Download")
        self.download_btn.setFixedHeight(25)
        self.download_btn.clicked.connect(self.download_image)
        
        self.add_btn = QPushButton("Add")
        self.add_btn.setFixedHeight(25)
        self.add_btn.clicked.connect(self.clicked)
        
        buttons_layout.addWidget(self.download_btn)
        buttons_layout.addWidget(self.add_btn)
        
        layout.addLayout(buttons_layout)
        
        # Load the image in a separate thread
        url = image_data["url"] if isinstance(image_data, dict) else image_data
        self.load_image_thread = ImageLoaderThread(url)
        self.load_image_thread.imageLoaded.connect(self.set_image)
        self.load_image_thread.start()
        
    def set_image(self, pixmap):
        self.image_label.setPixmap(pixmap)
        
    def mousePressEvent(self, event):
        self.clicked.emit()
        super().mousePressEvent(event)
        
    def set_selected(self, selected):
        self.selected = selected
        if selected:
            self.setStyleSheet("QFrame { border: 3px solid blue; }")
        else:
            self.setStyleSheet("QFrame { border: 2px solid lightgray; }")
    
    def download_image(self):
        try:
            url = self.image_data["download_url"] if isinstance(self.image_data, dict) else self.image_data
            
            # Get save location from user
            file_name = url.split("/")[-1]
            if "?" in file_name:
                file_name = file_name.split("?")[0]
            if not file_name.endswith((".jpg", ".jpeg", ".png")):
                file_name += ".jpg"
                
            save_path, _ = QFileDialog.getSaveFileName(
                self, "Save Image", file_name, "Images (*.jpg *.jpeg *.png)"
            )
            
            if save_path:
                # Download the image
                response = requests.get(url, stream=True)
                with open(save_path, 'wb') as out_file:
                    out_file.write(response.content)
                
                QMessageBox.information(self, "Download Complete", f"Image saved to {save_path}")
        except Exception as e:
            QMessageBox.warning(self, "Download Failed", f"Failed to download image: {str(e)}")

class ImageLoaderThread(QThread):
    imageLoaded = pyqtSignal(QPixmap)
    
    def __init__(self, url):
        super().__init__()
        self.url = url
        
    def run(self):
        try:
            # Download the image
            data = urllib.request.urlopen(self.url).read()
            
            # Convert to QPixmap
            image = QImage()
            image.loadFromData(data)
            pixmap = QPixmap(image)
            
            self.imageLoaded.emit(pixmap)
        except Exception as e:
            print(f"Error loading image: {e}")
            # Emit an empty pixmap
            self.imageLoaded.emit(QPixmap())

class MediumPreviewDialog(QDialog):
    def __init__(self, title, content, image_urls=None, tags=None, parent=None):
        super().__init__(parent)
        self.setWindowTitle("Medium Preview")
        self.resize(800, 600)
        
        layout = QVBoxLayout(self)
        
        # Create a preview that mimics Medium's appearance
        preview_html = """
        <html>
        <head>
            <style>
                body {
                    font-family: 'Helvetica Neue', Helvetica, Arial, sans-serif;
                    line-height: 1.6;
                    color: #292929;
                    max-width: 700px;
                    margin: 0 auto;
                    padding: 20px;
                }
                h1 {
                    font-size: 32px;
                    margin-bottom: 10px;
                    font-weight: bold;
                }
                img {
                    max-width: 100%;
                    height: auto;
                    margin: 20px 0;
                }
                p {
                    font-size: 18px;
                    margin-bottom: 20px;
                }
                .medium-preview {
                    border: 1px solid #e6e6e6;
                    background-color: white;
                    padding: 40px;
                }
                .tags {
                    display: flex;
                    flex-wrap: wrap;
                    margin-top: 20px;
                    padding-top: 20px;
                    border-top: 1px solid #e6e6e6;
                }
                .tag {
                    background-color: #f2f2f2;
                    border-radius: 3px;
                    padding: 5px 10px;
                    margin-right: 10px;
                    margin-bottom: 10px;
                    font-size: 14px;
                    color: #666;
                }
            </style>
        </head>
        <body>
            <div class="medium-preview">
                <h1>""" + html.escape(title) + """</h1>
                """
        
        # Add images if provided
        if image_urls:
            for img_url in image_urls:
                url = img_url["url"] if isinstance(img_url, dict) else img_url
                preview_html += f'<img src="{html.escape(url)}" alt="Featured Image">'
        
        preview_html += """
                <div>
                    """ + content.replace('\n', '<br>') + """
                </div>
                """ + ("""
                <div class="tags">
                    """ + ''.join([f'<span class="tag">{html.escape(tag)}</span>' for tag in (tags or [])]) + """
                </div>
                """ if tags else '') + """
            </div>
        </body>
        </html>
        """
        
        self.preview_browser = QTextEdit()
        self.preview_browser.setReadOnly(True)
        self.preview_browser.setHtml(preview_html)
        layout.addWidget(self.preview_browser)
        
        # Buttons
        button_layout = QHBoxLayout()
        
        copy_btn = QPushButton("Copy to Clipboard")
        copy_btn.clicked.connect(lambda: self.copy_to_clipboard(title, content))
        
        open_medium_btn = QPushButton("Open in Medium")
        open_medium_btn.clicked.connect(self.open_in_medium)
        
        close_btn = QPushButton("Close")
        close_btn.clicked.connect(self.accept)
        
        button_layout.addWidget(copy_btn)
        button_layout.addWidget(open_medium_btn)
        button_layout.addWidget(close_btn)
        
        layout.addLayout(button_layout)
    
    def copy_to_clipboard(self, title, content):
        clipboard = QApplication.clipboard()
        # Format for clipboard - title and content
        clipboard_text = f"{title}\n\n{content}"
        clipboard.setText(clipboard_text)
        QMessageBox.information(self, "Copied", "Article copied to clipboard. You can now paste it directly into Medium's editor.")
    
    def open_in_medium(self):
        webbrowser.open('https://medium.com/new-story')
        QMessageBox.information(self, "Medium Opened", 
            "Medium's editor has been opened in your browser.\n\n"
            "1. Sign in with your Google account if needed\n"
            "2. Paste the article content from your clipboard\n"
            "3. Add the image manually if needed\n"
            "4. Add the tags for better discoverability\n"
            "5. Review and publish your article")

class GenerationProgressDialog(QProgressDialog):
    def __init__(self, parent=None):
        super().__init__("Generating article...", "Cancel", 0, 100, parent)
        self.setWindowTitle("Article Generation")
        self.setMinimumDuration(0)  # Show immediately
        self.setWindowModality(Qt.WindowModal)
        self.setAutoClose(False)
        self.setAutoReset(False)
        self.setCancelButton(None)  # Remove cancel button
        
        # Set a fixed size
        self.setMinimumWidth(400)
        
        # Add more detailed status
        self.setLabelText("Initializing article generation...")
        
    def update_progress(self, value, message=None):
        self.setValue(value)
        if message:
            self.setLabelText(message)
        
        # Update status messages based on progress
        if not message:
            if value < 20:
                self.setLabelText("Preparing to generate article...")
            elif value < 40:
                self.setLabelText("Crafting engaging title and introduction...")
            elif value < 60:
                self.setLabelText("Developing main content with clear subheadings...")
            elif value < 80:
                self.setLabelText("Adding bullet points and formatting...")
            elif value < 95:
                self.setLabelText("Finalizing article with call to action...")
            else:
                self.setLabelText("Article generation complete!")

class MainWindow(QMainWindow):
    def __init__(self):
        super().__init__()
        self.setWindowTitle("AI Article Generator for Medium")
        self.setMinimumSize(1000, 800)
        
        # Set application icon
        self.set_app_icon()
        
        # Initialize API key and author bio
        self.gemini_api_key = os.environ.get("GEMINI_API_KEY", "")
        self.author_bio = DEFAULT_AUTHOR_BIO
        self.unsplash_key = ""
        
        # Initialize variables
        self.selected_topic = ""
        self.selected_niche = ""
        self.article_title = ""
        self.article_content = ""
        self.article_tags = []
        self.images = []
        self.selected_images = []
        self.image_frames = []
        
        # Show branding window first
        self.show_branding_window()
        
        # Create the main layout
        self.central_widget = QWidget()
        self.setCentralWidget(self.central_widget)
        self.main_layout = QVBoxLayout(self.central_widget)
        
        # Create settings button
        settings_layout = QHBoxLayout()
        settings_btn = QPushButton("Settings")
        settings_btn.clicked.connect(self.show_settings)
        settings_layout.addStretch()
        settings_layout.addWidget(settings_btn)
        self.main_layout.addLayout(settings_layout)
        
        # Create tab widget
        self.tab_widget = QTabWidget()
        self.main_layout.addWidget(self.tab_widget)
        
        # Create tabs
        self.setup_topic_tab()
        self.setup_article_tab()
        self.setup_publish_tab()
        
        # Set initial state
        self.tab_widget.setTabEnabled(1, False)  # Disable article tab initially
        self.tab_widget.setTabEnabled(2, False)  # Disable publish tab initially
    
    def show_branding_window(self):
        """Show the branding window when the app starts"""
        branding_dialog = BrandingWindow(self, bool(self.gemini_api_key))
        if branding_dialog.exec_() == QDialog.Accepted and not self.gemini_api_key:
            # If user clicked "Set Up API Key" and doesn't have an API key yet
            self.show_settings()
    
    def set_app_icon(self):
        """Set the application icon from a file"""
        icon_path = os.path.join("assets", "android-chrome-192x192.png")
        if os.path.exists(icon_path):
            icon = QIcon(icon_path)
            self.setWindowIcon(icon)
            # Also set the application icon
            QApplication.setWindowIcon(icon)
        else:
            print(f"Warning: Icon file {icon_path} not found")
        
    def show_settings(self):
        dialog = SettingsDialog(self, self.author_bio, self.unsplash_key)
        
        # Pre-fill existing values
        if self.gemini_api_key:
            dialog.gemini_input.setText(self.gemini_api_key)
            
        if dialog.exec_() == QDialog.Accepted:
            values = dialog.get_values()
            self.gemini_api_key = values["gemini_api_key"]
            self.author_bio = values["author_bio"]
            self.unsplash_key = values["unsplash_key"]
            
            # In a real app, you might want to save this to a config file
            QMessageBox.information(self, "Settings Saved", "Settings have been saved.")
        
    def setup_topic_tab(self):
        topic_tab = QWidget()
        topic_layout = QVBoxLayout(topic_tab)
        
        # Trending topics section
        trending_group = QGroupBox("Trending Topics")
        trending_layout = QVBoxLayout()
        
        # Refresh button
        refresh_btn = QPushButton("Refresh Trending Topics")
        trending_layout.addWidget(refresh_btn)
        
        # Topics grid
        topics_grid = QGridLayout()
        self.topic_buttons = QButtonGroup()
        self.topic_buttons.setExclusive(True)
        
        for i, topic in enumerate(TRENDING_TOPICS):
            radio = QRadioButton(topic)
            self.topic_buttons.addButton(radio)
            topics_grid.addWidget(radio, i // 2, i % 2)
            
        trending_layout.addLayout(topics_grid)
        trending_group.setLayout(trending_layout)
        topic_layout.addWidget(trending_group)
        
        # Custom topic section
        custom_group = QGroupBox("Custom Topic")
        custom_layout = QVBoxLayout()
        
        self.custom_topic_input = QLineEdit()
        self.custom_topic_input.setPlaceholderText("Enter your own topic")
        custom_layout.addWidget(self.custom_topic_input)
        
        custom_group.setLayout(custom_layout)
        topic_layout.addWidget(custom_group)
        
        # Niche selection section
        niche_group = QGroupBox("Select Niche")
        niche_layout = QVBoxLayout()
        
        self.niche_combo = QComboBox()
        self.niche_combo.addItems(NICHES)
        niche_layout.addWidget(self.niche_combo)
        
        niche_group.setLayout(niche_layout)
        topic_layout.addWidget(niche_group)
        
        # Medium formatting option
        format_group = QGroupBox("Formatting Options")
        format_layout = QVBoxLayout()
        
        self.medium_format_check = QCheckBox("Optimize for Medium (recommended)")
        self.medium_format_check.setChecked(True)
        self.medium_format_check.setToolTip("Generates content that can be directly pasted into Medium's editor without formatting issues")
        format_layout.addWidget(self.medium_format_check)
        
        format_group.setLayout(format_layout)
        topic_layout.addWidget(format_group)
        
        # Generate button
        generate_btn = QPushButton("Generate Article")
        generate_btn.clicked.connect(self.generate_article)
        topic_layout.addWidget(generate_btn)
        
        # Add the tab
        self.tab_widget.addTab(topic_tab, "1. Select Topic")
        
        # Connect signals
        refresh_btn.clicked.connect(self.refresh_trending_topics)
        self.topic_buttons.buttonClicked.connect(self.on_topic_selected)
        self.custom_topic_input.textChanged.connect(self.on_custom_topic_changed)
        
    def setup_article_tab(self):
        article_tab = QWidget()
        article_layout = QVBoxLayout(article_tab)
        
        # Title section
        title_group = QGroupBox("Article Title")
        title_layout = QVBoxLayout()
        
        title_help = QLabel("A good Medium title should be catchy, clear, and relevant to your audience (6-10 words recommended)")
        title_help.setStyleSheet("color: #666;")
        title_layout.addWidget(title_help)
        
        self.title_input = QLineEdit()
        title_layout.addWidget(self.title_input)
        
        title_group.setLayout(title_layout)
        article_layout.addWidget(title_group)
        
        # Content section
        content_group = QGroupBox("Article Content")
        content_layout = QVBoxLayout()
        
        content_help = QLabel("Edit your article content below. Remember to maintain a clear structure with headings, short paragraphs, and a call to action.")
        content_help.setStyleSheet("color: #666;")
        content_layout.addWidget(content_help)
        
        self.content_text = QTextEdit()
        content_layout.addWidget(self.content_text)
        
        content_group.setLayout(content_layout)
        article_layout.addWidget(content_group)
        
        # Tags section
        tags_group = QGroupBox("Article Tags")
        tags_layout = QVBoxLayout()
        
        tags_help = QLabel("Select up to 5 tags for better discoverability on Medium")
        tags_help.setStyleSheet("color: #666;")
        tags_layout.addWidget(tags_help)
        
        tags_btn_layout = QHBoxLayout()
        self.tags_label = QLabel("No tags selected")
        edit_tags_btn = QPushButton("Edit Tags")
        edit_tags_btn.clicked.connect(self.edit_tags)
        
        tags_btn_layout.addWidget(self.tags_label)
        tags_btn_layout.addWidget(edit_tags_btn)
        
        tags_layout.addLayout(tags_btn_layout)
        tags_group.setLayout(tags_layout)
        article_layout.addWidget(tags_group)
        
        # Navigation buttons
        nav_layout = QHBoxLayout()
        back_btn = QPushButton("Back")
        next_btn = QPushButton("Next: Select Image & Preview")
        
        nav_layout.addWidget(back_btn)
        nav_layout.addWidget(next_btn)
        
        article_layout.addLayout(nav_layout)
        
        # Add the tab
        self.tab_widget.addTab(article_tab, "2. Generate Article")
        
        # Connect signals
        back_btn.clicked.connect(lambda: self.tab_widget.setCurrentIndex(0))
        next_btn.clicked.connect(self.prepare_publish)
        self.title_input.textChanged.connect(self.on_title_changed)
        self.content_text.textChanged.connect(self.on_content_changed)
        
    def setup_publish_tab(self):
        publish_tab = QWidget()
        publish_layout = QVBoxLayout(publish_tab)
        
        # Create a splitter for resizable sections
        splitter = QSplitter(Qt.Vertical)
        
        # Image selection section
        image_widget = QWidget()
        image_layout = QVBoxLayout(image_widget)
        
        image_header_layout = QHBoxLayout()
        image_label = QLabel("Select Featured Images:")
        image_header_layout.addWidget(image_label)
        
        # Add checkbox to allow unselecting images
        self.use_images_check = QCheckBox("Use Featured Images")
        self.use_images_check.setChecked(True)
        self.use_images_check.stateChanged.connect(self.toggle_images)
        image_header_layout.addWidget(self.use_images_check)
        
        image_layout.addLayout(image_header_layout)
        
        self.image_scroll = QScrollArea()
        self.image_scroll.setWidgetResizable(True)
        self.image_container = QWidget()
        self.image_grid = QGridLayout(self.image_container)
        self.image_scroll.setWidget(self.image_container)
        
        image_layout.addWidget(self.image_scroll)
        splitter.addWidget(image_widget)
        
        # Preview section
        preview_widget = QWidget()
        preview_layout = QVBoxLayout(preview_widget)
        
        preview_label = QLabel("Article Preview:")
        preview_layout.addWidget(preview_label)
        
        self.preview_text = QTextEdit()
        self.preview_text.setReadOnly(True)
        preview_layout.addWidget(self.preview_text)
        
        splitter.addWidget(preview_widget)
        
        # Add the splitter to the main layout
        publish_layout.addWidget(splitter)
        
        # Quality check section
        quality_layout = QHBoxLayout()
        
        quality_btn = QPushButton("Check Article Quality")
        quality_btn.clicked.connect(self.check_article_quality)
        
        quality_layout.addWidget(quality_btn)
        publish_layout.addLayout(quality_layout)
        
        # Action buttons
        action_layout = QHBoxLayout()
        
        back_btn = QPushButton("Back")
        self.copy_btn = QPushButton("Copy to Clipboard")
        self.medium_preview_btn = QPushButton("Medium Preview")
        self.publish_btn = QPushButton("Open in Medium")
        
        action_layout.addWidget(back_btn)
        action_layout.addWidget(self.copy_btn)
        action_layout.addWidget(self.medium_preview_btn)
        action_layout.addWidget(self.publish_btn)
        
        publish_layout.addLayout(action_layout)
        
        # Add the tab
        self.tab_widget.addTab(publish_tab, "3. Preview & Publish")
        
        # Connect signals
        back_btn.clicked.connect(lambda: self.tab_widget.setCurrentIndex(1))
        self.copy_btn.clicked.connect(self.copy_to_clipboard)
        self.medium_preview_btn.clicked.connect(self.show_medium_preview)
        self.publish_btn.clicked.connect(self.open_in_medium)
        
    def toggle_images(self, state):
        """Toggle whether to use featured images in the article"""
        if state == Qt.Checked:
            # Re-enable image selection
            for frame in self.image_frames:
                frame.setEnabled(True)
        else:
            # Disable image selection and clear selected images
            self.selected_images = []
            for frame in self.image_frames:
                frame.set_selected(False)
                frame.setEnabled(False)
        
        # Update preview
        self.update_preview()
        
    def refresh_trending_topics(self):
        # In a real app, you would fetch from Google Trends API
        # For this example, we'll just use our mock data
        QMessageBox.information(self, "Trending Topics", "Trending topics refreshed!")
        
    def on_topic_selected(self, button):
        self.selected_topic = button.text()
        self.custom_topic_input.clear()  # Clear custom topic when selecting a trending topic
        
    def on_custom_topic_changed(self, text):
        if text:
            self.selected_topic = text
            # Uncheck any selected trending topic
            if self.topic_buttons.checkedButton():
                self.topic_buttons.checkedButton().setChecked(False)
                
    def on_title_changed(self, text):
        self.article_title = text
        
    def on_content_changed(self):
        self.article_content = self.content_text.toPlainText()
        
    def edit_tags(self):
        dialog = TagSelectionDialog(self, self.article_tags, self.niche_combo.currentText())
        if dialog.exec_() == QDialog.Accepted:
            self.article_tags = dialog.get_selected_tags()
            self.update_tags_label()
            
    def update_tags_label(self):
        if not self.article_tags:
            self.tags_label.setText("No tags selected")
        else:
            self.tags_label.setText(", ".join(self.article_tags))
        
    def generate_article(self):
        # Get the selected topic and niche
        topic = self.selected_topic
        niche = self.niche_combo.currentText()
        
        if not topic:
            QMessageBox.warning(self, "Missing Information", "Please select or enter a topic.")
            return
            
        # Check if API key is set
        if not self.gemini_api_key:
            QMessageBox.warning(self, "API Key Required", 
                               "Please set your Google Gemini API Key in the settings.")
            return
        
        # Create progress dialog
        progress_dialog = GenerationProgressDialog(self)
        progress_dialog.show()
        
        # Create and start the worker thread
        medium_format = self.medium_format_check.isChecked()
        self.generate_thread = GenerateArticleThread(topic, niche, self.gemini_api_key, medium_format, self.author_bio)
        self.generate_thread.progress.connect(progress_dialog.update_progress)
        self.generate_thread.finished.connect(lambda result: self.on_article_generated(result, progress_dialog))
        self.generate_thread.error.connect(lambda error: self.on_generation_error(error, progress_dialog))
        self.generate_thread.start()
        
    def on_article_generated(self, result, progress_dialog=None):
        # Close progress dialog if it exists
        if progress_dialog:
            progress_dialog.close()
            
        # Update the article tab with the generated content
        self.article_title = result.get("title", "")
        self.article_content = result.get("content", "")
        self.article_tags = result.get("tags", [])
        
        self.title_input.setText(self.article_title)
        self.content_text.setText(self.article_content)
        self.update_tags_label()
        
        # Enable the article tab and switch to it
        self.tab_widget.setTabEnabled(1, True)
        self.tab_widget.setCurrentIndex(1)
        
        # Search for images
        if self.unsplash_key:
            self.search_unsplash_images(self.article_title)
        else:
            self.search_images(self.article_title)
        
    def on_generation_error(self, error_msg, progress_dialog=None):
        # Close progress dialog if it exists
        if progress_dialog:
            progress_dialog.close()
            
        QMessageBox.critical(self, "Error Generating Article", f"An error occurred: {error_msg}")
        
    def search_images(self, query):
        # Create and start the worker thread
        self.search_thread = SearchImagesThread(query)
        self.search_thread.finished.connect(self.on_images_found)
        self.search_thread.error.connect(self.on_image_search_error)
        self.search_thread.start()
    
    def search_unsplash_images(self, query):
        # Create and start the worker thread with Unsplash API key
        self.search_thread = UnsplashImageSearchThread(query, self.unsplash_key)
        self.search_thread.finished.connect(self.on_images_found)
        self.search_thread.error.connect(self.on_image_search_error)
        self.search_thread.start()
        
    def on_images_found(self, image_data):
        self.images = image_data
        self.image_frames = []
        self.selected_images = []
        
        # Clear the existing images
        for i in reversed(range(self.image_grid.count())): 
            widget = self.image_grid.itemAt(i).widget()
            if widget:
                widget.setParent(None)
        
        # Add the new images
        for i, img_data in enumerate(self.images):
            frame = ImageFrame(img_data)
            frame.clicked.connect(lambda f=frame: self.toggle_image_selection(f))
            
            self.image_frames.append(frame)
            self.image_grid.addWidget(frame, i // 3, i % 3)
        
        # Enable the publish tab
        self.tab_widget.setTabEnabled(2, True)
        
    def on_image_search_error(self, error_msg):
        QMessageBox.warning(self, "Error Searching Images", f"An error occurred: {error_msg}")
        
    def toggle_image_selection(self, frame):
        """Toggle selection of an image, allowing multiple selections"""
        if not self.use_images_check.isChecked():
            return
            
        # Get the image URL
        img_data = frame.image_data
        
        # Toggle selection
        if frame.selected:
            frame.set_selected(False)
            if img_data in self.selected_images:
                self.selected_images.remove(img_data)
        else:
            frame.set_selected(True)
            if img_data not in self.selected_images:
                self.selected_images.append(img_data)
            
        # Update preview
        self.update_preview()
                    
    def prepare_publish(self):
        if not self.article_title or not self.article_content:
            QMessageBox.warning(self, "Missing Content", "Please generate an article first.")
            return
            
        # Switch to the publish tab
        self.tab_widget.setCurrentIndex(2)
        
        # Update preview
        self.update_preview()
        
    def update_preview(self):
        preview = f"<h1>{html.escape(self.article_title)}</h1>\n\n"
        
        # Add selected images if enabled
        if self.use_images_check.isChecked() and self.selected_images:
            for img_data in self.selected_images:
                url = img_data["url"] if isinstance(img_data, dict) else img_data
                preview += f"<img src='{html.escape(url)}' width='100%' />\n\n"
        
        # Format the content for the preview
        content_html = self.article_content.replace('\n', '<br>')
        
        preview += content_html
        
        # Add tags if available
        if self.article_tags:
            preview += "<div style='margin-top: 20px; padding-top: 10px; border-top: 1px solid #ccc;'>"
            for tag in self.article_tags:
                preview += f"<span style='background-color: #f2f2f2; padding: 3px 8px; margin-right: 5px; border-radius: 3px;'>{html.escape(tag)}</span> "
            preview += "</div>"
        
        self.preview_text.setHtml(preview)
        
    def copy_to_clipboard(self):
        """Copies the article to clipboard in a format ready for Medium"""
        clipboard = QApplication.clipboard()
        
        # Format for clipboard - just title and content, no markdown
        clipboard_text = f"{self.article_title}\n\n{self.article_content}"
        clipboard.setText(clipboard_text)
        
        QMessageBox.information(self, "Copied", 
            "Article copied to clipboard. You can now paste it directly into Medium's editor.")
    
    def show_medium_preview(self):
        """Shows a preview dialog that mimics Medium's appearance"""
        if not self.article_title or not self.article_content:
            QMessageBox.warning(self, "Missing Content", "Please generate an article first.")
            return
            
        # Only pass selected images if the checkbox is checked
        images_to_show = self.selected_images if self.use_images_check.isChecked() else None
            
        dialog = MediumPreviewDialog(
            self.article_title, 
            self.article_content, 
            images_to_show,
            self.article_tags,
            self
        )
        dialog.exec_()
        
    def check_article_quality(self):
        """Opens the article quality checker dialog"""
        if not self.article_title or not self.article_content:
            QMessageBox.warning(self, "Missing Content", "Please generate an article first.")
            return
            
        dialog = ArticleQualityDialog(
            self,
            self.article_title,
            self.article_content,
            self.article_tags
        )
        dialog.exec_()
        
    def open_in_medium(self):
        """Opens Medium's write story page in the default web browser"""
        try:
            # First copy the content to clipboard for easy pasting
            self.copy_to_clipboard()
            
            # Open Medium's new story page
            webbrowser.open('https://medium.com/new-story')
            
            # Show instructions to the user
            QMessageBox.information(self, "Open in Medium", 
                "Medium's editor has been opened in your browser.\n\n"
                "1. Sign in with your Google account if needed\n"
                "2. Paste the article content from your clipboard\n"
                "3. Add the selected image manually\n"
                "4. Add the tags: " + ", ".join(self.article_tags) + "\n"
                "5. Review and publish your article")
            
        except Exception as e:
            QMessageBox.critical(self, "Error", f"Could not open Medium: {str(e)}")

if __name__ == "__main__":
    app = QApplication(sys.argv)
    window = MainWindow()
    window.show()
    sys.exit(app.exec_())