import requests
import pandas as pd
import json

# --- Config (replace with your actual API keys) ---
SERPAPI_API_KEY = "YOUR_SERPAPI_API_KEY"
OPENAI_API_KEY = "YOUR_OPENAI_API_KEY" # For later use

def get_serp_data(query):
    """Fetches Google search results for a given query using SerpAPI."""
    url = "https://serpapi.com/search"
    params = {
        "engine": "google",
        "q": query,
        "api_key": SERPAPI_API_KEY
    }
    response = requests.get(url, params=params)
    response.raise_for_status() # Raise an exception for HTTP errors
    return response.json()

def analyze_search_results(query):
    """Analyzes SERP data to identify top competitors and related keywords."""
    print(f"[*] Analyzing SERP for: '{query}'")
    serp_data = get_serp_data(query)

    # Extract top organic results
    organic_results = []
    if 'organic_results' in serp_data:
        for result in serp_data['organic_results'][:5]: # Top 5
            organic_results.append({
                "title": result.get('title'),
                "link": result.get('link'),
                "snippet": result.get('snippet')
            })

    # Extract related searches (often good for long-tail keywords)
    related_searches = []
    if 'related_searches' in serp_data:
        for search in serp_data['related_searches']:
            related_searches.append(search.get('query'))

    return {
        "organic_results": organic_results,
        "related_searches": related_searches
    }

# Example Usage
keyword_idea = "AI content workflow automation"
analysis = analyze_search_results(keyword_idea)

print("\n--- Top Competitors (Organic Results) ---")
for i, result in enumerate(analysis['organic_results']):
    print(f"{i+1}. Title: {result['title']}")
    print(f"   Link: {result['link']}")
    print(f"   Snippet: {result['snippet'][:100]}...") # Truncate snippet
    print("-" * 20)

print("\n--- Related Search Queries ---")
for query in analysis['related_searches']:
    print(f"- {query}")

# Note: For Google Trends, you'd typically use 'pytrends' for historical data or a direct API if available.
# In 2025, direct programmatic access to real-time trend data is becoming more common.

from openai import OpenAI
import os

# --- Ensure your API key is set ---
# os.environ["OPENAI_API_KEY"] = "YOUR_OPENAI_API_KEY" # Uncomment if not set globally
client = OpenAI()

def generate_blog_post_draft(topic, keywords, word_count_target=1000):
    """Generates a blog post draft using GPT-5 based on topic and keywords."""
    prompt = f"""
    You are an expert technical blogger in 2025 specializing in content automation and monetization.
    Write a comprehensive blog post draft on the topic: "{topic}".
    Incorporate the following keywords naturally throughout the text: {', '.join(keywords)}.

    The post should be structured with an introduction, several main sections with subheadings,
    and a conclusion. Focus on practical advice for solo content creators, bloggers, and developers.
    Include concrete examples of tools and workflows where possible (e.g., Python, APIs, specific AI models).
    Aim for a tone that is clear, energetic, and smart, but avoid hype.
    Target word count: {word_count_target} words.

    Start with a compelling introduction and use Markdown for headings.
    """

    try:
        response = client.chat.completions.create(
            model="gpt-5-turbo-2025-04-23", # Fictional GPT-5 model name for 2025
            messages=[
                {"role": "system", "content": "You are a helpful assistant specialized in content creation and automation."},
                {"role": "user", "content": prompt}
            ],
            temperature=0.7, # Adjust for creativity vs. coherence
            max_tokens=int(word_count_target * 1.5) # Allow buffer for token limit
        )
        return response.choices[0].message.content
    except Exception as e:
        print(f"Error generating content: {e}")
        return None

# Example Usage based on previous analysis
blog_topic = "Automating Your Content Workflow with AI in 2025"
target_keywords = analysis['related_searches'][:3] + ["GPT-5 automation 2025", "WordPress auto-post"] # Add more relevant keywords

print(f"\n[*] Generating draft for: '{blog_topic}' with keywords: {', '.join(target_keywords)}")
draft_content = generate_blog_post_draft(blog_topic, target_keywords)

if draft_content:
    print("\n--- Generated Blog Post Draft ---")
    print(draft_content[:1500]) # Print first 1500 characters for brevity
    print("\n... [Full draft continues] ...")
else:
    print("Failed to generate content.")

from wordpress_xmlrpc import Client, WordPressPost
from wordpress_xmlrpc.methods.posts import NewPost
from wordpress_xmlrpc.methods.media import UploadFile
import mimetypes
import os

# --- Config (replace with your actual WordPress details) ---
WP_URL = "https://yourblog.com/xmlrpc.php"
WP_USERNAME = "your_wordpress_username"
WP_PASSWORD = "your_wordpress_password"

def auto_publish_post(title, content, categories=[], tags=[], featured_image_path=None):
    """Publishes a new post to WordPress via XML-RPC."""
    try:
        client = Client(WP_URL, WP_USERNAME, WP_PASSWORD)
        post = WordPressPost()
        post.title = title
        post.content = content
        post.post_status = 'publish' # Use 'draft' for review first

        # Set categories
        if categories:
            post.terms_names = {'category': categories}

        # Set tags
        if tags:
            post.terms_names['post_tag'] = tags

        # Handle featured image (optional)
        if featured_image_path and os.path.exists(featured_image_path):
            data = {
                'name': os.path.basename(featured_image_path),
                'type': mimetypes.guess_type(featured_image_path)[0], # e.g., 'image/jpeg'
                'bits': open(featured_image_path, 'rb').read()
            }
            response = client.call(UploadFile(data))
            post.thumbnail = response['id'] # Set featured image

        post_id = client.call(NewPost(post))
        print(f"[*] Post '{title}' successfully published! Post ID: {post_id}")
        return post_id

    except Exception as e:
        print(f"Error publishing post: {e}")
        return None

# Example Usage (assuming you have a generated draft and a placeholder image)
# Create a dummy image file for demonstration
with open("dummy_image.jpg", "w") as f:
    f.write("This is a dummy image file.") # Placeholder content

post_title = "Automating Your Content Workflow with AI in 2025: Scale Your Influence"
post_content = "This is the amazing content generated by GPT-5. [Add more of the generated content here.]"
post_categories = ["AI Blogging", "Automation"]
post_tags = ["AI 2025", "GPT-5 automation 2025", "WordPress auto-post", "Monetization"]
featured_img = "dummy_image.jpg" # Replace with a real path to a JPG/PNG if testing

# post_id = auto_publish_post(post_title, post_content, post_categories, post_tags, featured_img)
# if post_id:
#     print(f"View your post at: {WP_URL.replace('/xmlrpc.php', '')}/?p={post_id}")

# Note: Commented out the actual call to avoid unintended publishing during testing.
# Uncomment and replace with your WordPress details to try it!
print("\n--- Publishing Automation Snippet ---")
print("Python script ready to auto-publish to WordPress.")
print("Uncomment the `auto_publish_post` call and fill in your WP_URL, WP_USERNAME, WP_PASSWORD to try.")