import os
import csv
from dotenv import load_dotenv
from openai import OpenAI

# Load environment variables
load_dotenv()
client = OpenAI(api_key=os.getenv('OPENAI_API_KEY'))

def generate_meta_description(title, content_sample):
    """
    Generate SEO-optimized meta description
    
    Args:
        title (str): Page title
        content_sample (str): First 200-300 words of content
    
    Returns:
        str: Meta description (150-160 chars)
    """
    
    prompt = f"""Generate an SEO-optimized meta description for this page.

Requirements:
- 150-160 characters (strict)
- Include primary keyword naturally
- Compelling call-to-action
- Accurately summarize content

Page Title: {title}

Content Sample:
{content_sample[:500]}

Output only the meta description, no explanation."""

    try:
        response = client.chat.completions.create(
            model="gpt-4o-mini",  # Cheapest, fastest
            messages=[
                {"role": "system", "content": "You are an expert SEO copywriter."},
                {"role": "user", "content": prompt}
            ],
            max_tokens=100,
            temperature=0.7  # Some creativity
        )
        
        meta_description = response.choices[0].message.content.strip()
        
        # Validate length
        if len(meta_description) > 160:
            meta_description = meta_description[:157] + "..."
        
        return meta_description
    
    except Exception as e:
        return f"Error: {str(e)}"

def process_bulk_meta_descriptions(input_csv, output_csv):
    """
    Process CSV of pages and generate meta descriptions
    
    Input CSV format:
    url,title,content_sample
    
    Output CSV format:
    url,title,meta_description
    """
    
    results = []
    
    with open(input_csv, 'r', encoding='utf-8') as f:
        reader = csv.DictReader(f)
        
        for i, row in enumerate(reader, 1):
            print(f"Processing {i}: {row['title'][:50]}...")
            
            meta_desc = generate_meta_description(
                row['title'],
                row['content_sample']
            )
            
            results.append({
                'url': row['url'],
                'title': row['title'],
                'meta_description': meta_desc
            })
    
    # Write results
    with open(output_csv, 'w', encoding='utf-8', newline='') as f:
        writer = csv.DictWriter(f, fieldnames=['url', 'title', 'meta_description'])
        writer.writeheader()
        writer.writerows(results)
    
    print(f"\n✅ Complete! Generated {len(results)} meta descriptions")
    print(f"Output saved to: {output_csv}")

# Usage
if __name__ == "__main__":
    process_bulk_meta_descriptions(
        input_csv='pages_to_process.csv',
        output_csv='meta_descriptions_output.csv'
    )

url,title,content_sample
https://example.com/page1,Complete SEO Guide 2026,"This comprehensive guide covers..."
https://example.com/page2,WordPress SEO Tips,"WordPress powers 43% of websites..."

import os
import json
from dotenv import load_dotenv
from openai import OpenAI

load_dotenv()
client = OpenAI(api_key=os.getenv('OPENAI_API_KEY'))

def generate_article_schema(title, author_name, publish_date, description, image_url, article_url):
    """
    Generate Article Schema (JSON-LD)
    
    Returns:
        dict: Complete Article Schema
    """
    
    prompt = f"""Generate complete JSON-LD Article Schema with these details:

Title: {title}
Author: {author_name}
Published: {publish_date}
Description: {description}
Image: {image_url}
URL: {article_url}

Requirements:
- Use proper Schema.org Article type
- Include all required fields
- Use correct date format (ISO 8601)
- Include author as Person
- Output ONLY valid JSON, no markdown or explanation"""

    try:
        response = client.chat.completions.create(
            model="gpt-4o-mini",
            messages=[
                {"role": "system", "content": "You are a Schema.org expert. Output only valid JSON-LD."},
                {"role": "user", "content": prompt}
            ],
            max_tokens=500,
            temperature=0.3  # Low for accuracy
        )
        
        schema_json = response.choices[0].message.content.strip()
        
        # Remove markdown code fences if present
        schema_json = schema_json.replace('```json', '').replace('```', '').strip()
        
        # Validate JSON
        schema = json.loads(schema_json)
        
        return schema
    
    except json.JSONDecodeError:
        return {"error": "Invalid JSON generated"}
    except Exception as e:
        return {"error": str(e)}

def generate_product_schema(name, description, brand, price, currency, availability, image_url, product_url):
    """
    Generate Product Schema (JSON-LD)
    """
    
    prompt = f"""Generate complete JSON-LD Product Schema:

Product: {name}
Description: {description}
Brand: {brand}
Price: {price} {currency}
Availability: {availability}
Image: {image_url}
URL: {product_url}

Requirements:
- Use Schema.org Product type
- Include offers with price, currency, availability
- Include aggregateRating if applicable (use 4.5/5 with 89 reviews as default)
- Output ONLY valid JSON"""

    try:
        response = client.chat.completions.create(
            model="gpt-4o-mini",
            messages=[
                {"role": "system", "content": "You are a Schema.org expert. Output only valid JSON-LD."},
                {"role": "user", "content": prompt}
            ],
            max_tokens=600,
            temperature=0.3
        )
        
        schema_json = response.choices[0].message.content.strip()
        schema_json = schema_json.replace('```json', '').replace('```', '').strip()
        schema = json.loads(schema_json)
        
        return schema
    
    except json.JSONDecodeError:
        return {"error": "Invalid JSON generated"}
    except Exception as e:
        return {"error": str(e)}

# Example usage
if __name__ == "__main__":
    # Generate Article Schema
    article_schema = generate_article_schema(
        title="Complete WordPress SEO Guide",
        author_name="Jane Smith",
        publish_date="2024-12-28",
        description="Learn how to optimize WordPress for search engines",
        image_url="https://example.com/images/wordpress-seo.jpg",
        article_url="https://example.com/wordpress-seo-guide"
    )
    
    print("Article Schema:")
    print(json.dumps(article_schema, indent=2))
    
    # Generate Product Schema
    product_schema = generate_product_schema(
        name="Pro SEO Tool Subscription",
        description="Complete SEO analysis and tracking tool",
        brand="SEO Pro Tools",
        price="99.00",
        currency="USD",
        availability="InStock",
        image_url="https://example.com/product.jpg",
        product_url="https://example.com/products/pro-subscription"
    )
    
    print("\nProduct Schema:")
    print(json.dumps(product_schema, indent=2))

import os
import csv
import json
from dotenv import load_dotenv
from openai import OpenAI

load_dotenv()
client = OpenAI(api_key=os.getenv('OPENAI_API_KEY'))

def cluster_keywords(keywords_list, num_clusters=10):
    """
    Group keywords into semantic clusters
    
    Args:
        keywords_list (list): List of keywords to cluster
        num_clusters (int): Target number of clusters
    
    Returns:
        dict: Clusters with keywords and metadata
    """
    
    # Join keywords for prompt
    keywords_text = "\n".join(keywords_list)
    
    prompt = f"""Analyze these {len(keywords_list)} keywords and group them into {num_clusters} semantic clusters.

Keywords:
{keywords_text}

For each cluster, provide:
1. Cluster name (2-4 words describing topic)
2. Primary search intent (informational, commercial, navigational, transactional)
3. Keywords in this cluster
4. Suggested content type (blog post, product page, guide, comparison, etc.)

Output as JSON array:
[
  {{
    "cluster_name": "...",
    "intent": "...",
    "keywords": [...],
    "content_type": "...",
    "priority": "high/medium/low"
  }}
]

Output ONLY valid JSON, no explanation."""

    try:
        response = client.chat.completions.create(
            model="gpt-4o",  # Use GPT-4o for better reasoning
            messages=[
                {"role": "system", "content": "You are an SEO keyword clustering expert."},
                {"role": "user", "content": prompt}
            ],
            max_tokens=2000,
            temperature=0.3
        )
        
        result = response.choices[0].message.content.strip()
        result = result.replace('```json', '').replace('```', '').strip()
        
        clusters = json.loads(result)
        
        return {
            "total_keywords": len(keywords_list),
            "num_clusters": len(clusters),
            "clusters": clusters
        }
    
    except json.JSONDecodeError:
        return {"error": "Invalid JSON generated"}
    except Exception as e:
        return {"error": str(e)}

def process_keyword_csv(input_csv, output_json, num_clusters=10):
    """
    Read keywords from CSV and generate clusters
    
    Input CSV format:
    keyword,volume,difficulty
    
    Outputs JSON file with clusters
    """
    
    keywords = []
    
    with open(input_csv, 'r', encoding='utf-8') as f:
        reader = csv.DictReader(f)
        for row in reader:
            keywords.append(row['keyword'])
    
    print(f"Clustering {len(keywords)} keywords into ~{num_clusters} groups...")
    
    result = cluster_keywords(keywords, num_clusters)
    
    with open(output_json, 'w', encoding='utf-8') as f:
        json.dump(result, f, indent=2)
    
    print(f"\n✅ Clustering complete!")
    print(f"Found {result.get('num_clusters', 0)} clusters")
    print(f"Output saved to: {output_json}")
    
    return result

# Example usage
if __name__ == "__main__":
    result = process_keyword_csv(
        input_csv='keywords.csv',
        output_json='keyword_clusters.json',
        num_clusters=8
    )
    
    # Print summary
    if 'clusters' in result:
        for i, cluster in enumerate(result['clusters'], 1):
            print(f"\nCluster {i}: {cluster['cluster_name']}")
            print(f"  Intent: {cluster['intent']}")
            print(f"  Keywords: {len(cluster['keywords'])}")
            print(f"  Content Type: {cluster['content_type']}")

import os
import time
from dotenv import load_dotenv
from openai import OpenAI

load_dotenv()
client = OpenAI(api_key=os.getenv('OPENAI_API_KEY'))

def call_openai_with_retry(prompt, model="gpt-4o-mini", max_retries=3):
    """
    Robust API call with error handling and retry logic
    """
    
    for attempt in range(max_retries):
        try:
            response = client.chat.completions.create(
                model=model,
                messages=[
                    {"role": "system", "content": "You are an expert SEO professional."},
                    {"role": "user", "content": prompt}
                ],
                max_tokens=500,
                temperature=0.7
            )
            
            return {
                'success': True,
                'content': response.choices[0].message.content,
                'tokens': response.usage.total_tokens,
                'cost': calculate_cost(response.usage, model)
            }
        
        except Exception as e:
            if attempt < max_retries - 1:
                wait_time = 2 ** attempt  # Exponential backoff
                print(f"Error: {str(e)}. Retrying in {wait_time}s...")
                time.sleep(wait_time)
            else:
                return {
                    'success': False,
                    'error': str(e)
                }

def calculate_cost(usage, model):
    """
    Calculate actual cost of API call
    """
    # Pricing per 1M tokens (update as needed)
    pricing = {
        'gpt-4o-mini': {'input': 0.150, 'output': 0.600},
        'gpt-4o': {'input': 2.50, 'output': 10.00},
        'gpt-4-turbo': {'input': 10.00, 'output': 30.00}
    }
    
    if model in pricing:
        input_cost = (usage.prompt_tokens / 1_000_000) * pricing[model]['input']
        output_cost = (usage.completion_tokens / 1_000_000) * pricing[model]['output']
        return input_cost + output_cost
    
    return 0

def batch_process_with_rate_limit(items, process_func, delay=1):
    """
    Process items in batch with rate limiting
    
    Args:
        items (list): Items to process
        process_func (callable): Function to apply to each item
        delay (float): Seconds to wait between requests
    """
    
    results = []
    total_cost = 0
    
    for i, item in enumerate(items, 1):
        print(f"Processing {i}/{len(items)}...")
        
        result = process_func(item)
        results.append(result)
        
        if result.get('cost'):
            total_cost += result['cost']
        
        # Rate limiting
        if i < len(items):
            time.sleep(delay)
    
    print(f"\n✅ Processed {len(results)} items")
    print(f"💰 Total cost: ${total_cost:.4f}")
    
    return results

# Example usage
if __name__ == "__main__":
    # Test single call
    result = call_openai_with_retry(
        prompt="Generate a meta description for 'Complete SEO Guide 2026'",
        model="gpt-4o-mini"
    )
    
    print(f"Success: {result['success']}")
    print(f"Content: {result.get('content', 'N/A')}")
    print(f"Cost: ${result.get('cost', 0):.6f}")