import requests
import json
import os

# Ensure you have your API keys set as environment variables
# GOOGLE_TRENDS_API_KEY = os.getenv("GOOGLE_TRENDS_API_KEY") # Placeholder, see Note below
SERPAPI_API_KEY = os.getenv("SERPAPI_API_KEY")

def get_trending_topics(geo='US'):
    """
    Simulates fetching trending search queries.
    In a real scenario, you'd use a specific Google Trends API (often indirect) or a custom scraper.
    """
    print(f"Fetching trending topics for {geo}...")
    # This is a conceptual example. Direct Google Trends API access is limited.
    # For a real implementation, explore libraries like pytrends or commercial SEO tool APIs.
    mock_trends = [
        {"topic": "AI-powered indie games 2025", "search_volume_index": 95},
        {"topic": "Sustainable urban farming tech", "search_volume_index": 88},
        {"topic": "No-code automation for SMEs", "search_volume_index": 92}
    ]
    return mock_trends

def get_serp_data(api_key, query):
    """
    Fetches SERP data using SerpAPI.
    """
    print(f"Fetching SERP data for '{query}'...")
    url = "https://serpapi.com/search"
    params = {
        "api_key": api_key,
        "engine": "google",
        "q": query,
        "hl": "en",
        "gl": "us",
    }
    try:
        response = requests.get(url, params=params)
        response.raise_for_status() # Raise an exception for HTTP errors
        return response.json()
    except requests.exceptions.RequestException as e:
        print(f"Error fetching SERP data: {e}")
        return None

# --- Workflow ---
if __name__ == "__main__":
    # 1. Discover trending broad topics
    trending_topics = get_trending_topics()
    print("\nDiscovered Trending Topics:")
    for trend in trending_topics:
        print(f"- {trend['topic']} (Trend Index: {trend['search_volume_index']})")

    # 2. Pick a promising topic and dig deeper with SERP analysis
    target_topic = trending_topics[0]['topic'] # Let's pick the first one

    serp_results = get_serp_data(SERPAPI_API_KEY, target_topic)

    if serp_results and "organic_results" in serp_results:
        print(f"\nTop 5 Organic Results for '{target_topic}':")
        for i, result in enumerate(serp_results["organic_results"][:5]):
            print(f"{i+1}. {result.get('title')}")
            print(f"   URL: {result.get('link')}")
            print(f"   Snippet: {result.get('snippet')[:100]}...") # Truncate snippet
            print("-" * 20)

        # Use GPT-5 via OpenAI API to analyze these SERP results for content gaps
        # (This part would typically follow, integrating with OpenAI's API to analyze SERP data)
        print("\n(Next step: Feed these SERP results into GPT-5 for content gap analysis and outline generation.)")

import openai
from langchain_openai import ChatOpenAI
from langchain.prompts import PromptTemplate
from langchain.chains import LLMChain
import os

# Set your OpenAI API key
os.environ["OPENAI_API_KEY"] = os.getenv("OPENAI_API_KEY")

# Initialize the OpenAI LLM (assuming GPT-5 equivalent is available)
# "gpt-5-turbo" is a placeholder for the latest powerful model in 2025
llm = ChatOpenAI(model_name="gpt-5-turbo", temperature=0.7)

def generate_blog_outline(topic, serps_summary=""):
    prompt = PromptTemplate(
        input_variables=["topic", "serps_summary"],
        template="""You are an expert SEO content strategist.
        Generate a detailed blog post outline for the topic: "{topic}".
        Consider the following competitive insights from top-ranking articles:
        {serps_summary}

        Ensure the outline includes:
        - A compelling title and subtitle.
        - 3-5 main sections (H2s).
        - 2-3 sub-sections (H3s) for each main section.
        - A clear introduction and conclusion.
        - Potential FAQs or actionable tips.
        Focus on providing unique value and covering content gaps.
        """
    )
    chain = LLMChain(llm=llm, prompt=prompt)
    response = chain.run(topic=topic, serps_summary=serps_summary)
    return response

def generate_section_content(topic, section_title, outline, existing_content=""):
    prompt = PromptTemplate(
        input_variables=["topic", "section_title", "outline", "existing_content"],
        template="""You are a professional blogger writing an in-depth article on "{topic}".
        Write a detailed and engaging section for the title: "{section_title}".
        Here is the overall outline for context:
        {outline}

        Here is previous content if any (to ensure flow and avoid repetition):
        {existing_content}

        Ensure the section is at least 300 words, informative, and incorporates relevant keywords naturally.
        Use clear, concise language.
        """
    )
    chain = LLMChain(llm=llm, prompt=prompt)
    response = chain.run(topic=topic, section_title=section_title, outline=outline, existing_content=existing_content)
    return response

# --- Workflow ---
if __name__ == "__main__":
    blog_topic = "AI-powered indie games in 2025: Revolutionizing Development & Play"
    serp_summary_mock = """
    Top competitors focus on:
    - AI for procedural generation (environments, quests).
    - AI for smarter NPCs and adaptive difficulty.
    - AI tools for asset creation (art, music).
    - Impact on game design workflows.
    - Examples of current breakthrough games.
    Content gaps: monetization strategies for AI-powered indie games, ethical considerations, future trends beyond 2025.
    """

    print("Generating blog outline...")
    outline = generate_blog_outline(blog_topic, serp_summary_mock)
    print("\n--- Generated Outline ---")
    print(outline)

    # Example: Generate content for one section
    section_to_generate = "The Rise of AI in Indie Game Development"
    print(f"\nGenerating content for: {section_to_generate}...")
    section_content = generate_section_content(blog_topic, section_to_generate, outline)
    print("\n--- Generated Section Content ---")
    print(section_content[:500] + "...") # Print first 500 chars for brevity
    # In a full system, you'd iterate through all sections, assemble, and refine.

import xmlrpc.client
import os

# Your WordPress credentials
WP_URL = os.getenv("WORDPRESS_URL") # e.g., "https://yourblog.com/xmlrpc.php"
WP_USERNAME = os.getenv("WORDPRESS_USERNAME")
WP_PASSWORD = os.getenv("WORDPRESS_PASSWORD")

def post_to_wordpress(title, content, categories=[], tags=[], status='publish'):
    """
    Posts content to WordPress using XML-RPC API.
    """
    if not WP_URL or not WP_USERNAME or not WP_PASSWORD:
        print("WordPress credentials not set as environment variables. Please set WP_URL, WP_USERNAME, WP_PASSWORD.")
        return False

    try:
        # Use xmlrpc.client for XML-RPC communication
        wp = xmlrpc.client.ServerProxy(WP_URL)

        # Prepare the post data
        post = {
            'post_type': 'post',
            'post_status': status,
            'post_title': title,
            'post_content': content,
            'post_author': 1, # Default author ID (adjust if needed)
            'post_date_gmt': xmlrpc.client.DateTime(),
            'terms_names': {
                'category': categories,
                'post_tag': tags
            }
        }

        # Publish the post
        post_id = wp.wp.newPost(
            0, # blog_id for single site is always 0
            WP_USERNAME,
            WP_PASSWORD,
            post,
            True # publish
        )
        print(f"Successfully posted! New post ID: {post_id}")
        print(f"View post at: {WP_URL.replace('/xmlrpc.php', '')}/?p={post_id}")
        return post_id

    except xmlrpc.client.Fault as fault:
        print(f"XML-RPC Fault: {fault.faultCode} - {fault.faultString}")
        return False
    except Exception as e:
        print(f"An error occurred: {e}")
        return False

# --- Workflow ---
if __name__ == "__main__":
    mock_title = "AI-Powered Indie Games: A 2025 Deep Dive"
    mock_content = """
    This is the full blog post content generated by GPT-5 and refined.
    It includes sections on AI in game development, monetization strategies,
    and future outlook. The content is formatted with Markdown,
    which WordPress will interpret for HTML.
    <p>This paragraph demonstrates how you might include HTML directly.</p>
    <h2>Monetization Strategies</h2>
    <p>AI can help identify profitable niches and optimize ad placement or affiliate offers.</p>
    """
    mock_categories = ["AI", "Gaming", "Monetization"]
    mock_tags = ["indie games", "AI 2025", "game development", "GPT-5"]

    print("Attempting to post to WordPress...")
    post_id = post_to_wordpress(mock_title, mock_content, mock_categories, mock_tags, status='draft') # Post as draft first
    if post_id:
        print("WordPress posting process initiated successfully (check your site for draft).")
    else:
        print("Failed to post to WordPress.")