import pandas as pd
from pytrends.request import TrendReq
from serpapi import GoogleSearch
import os
import openai

# Set your API keys from environment variables
# For production, always use secure environment variables or a secrets manager
OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
SERPAPI_API_KEY = os.getenv("SERPAPI_API_KEY")

openai.api_key = OPENAI_API_KEY

def get_google_trends(keyword, geo='US', time_frame='today 3-m'):
    """Fetches Google Trends data for a given keyword."""
    pytrends = TrendReq(hl='en-US', tz=360)
    kw_list = [keyword]
    pytrends.build_payload(kw_list, cat=0, timeframe=time_frame, geo=geo)
    data = pytrends.interest_by_region(resolution='COUNTRY', inc_low_vol=True)
    return data.sort_values(by=keyword, ascending=False).head(5)

def get_serp_data(query, num_results=5):
    """Fetches top organic search results for a query using SerpApi."""
    params = {
        "q": query,
        "api_key": SERPAPI_API_KEY,
        "num": num_results
    }
    search = GoogleSearch(params)
    results = search.get_dict()
    organic_results = []
    if "organic_results" in results:
        for r in results["organic_results"]:
            organic_results.append({
                "title": r.get("title"),
                "link": r.get("link"),
                "snippet": r.get("snippet")
            })
    return organic_results

def analyze_niche_with_gpt5(keyword, trends_data, serp_data):
    """Uses GPT-5 to analyze niche potential based on trends and SERP data."""
    trends_str = trends_data.to_string()
    serp_str = "\n".join([f"Title: {r['title']}\nLink: {r['link']}\nSnippet: {r['snippet']}\n---" for r in serp_data])

    prompt = f"""
    Analyze the following data for the keyword "{keyword}" to identify content opportunities for a solo blogger aiming for monetization:

    Google Trends Data:
    {trends_str}

    Top Search Results (SERP data):
    {serp_str}

    Based on this, provide:
    1.  **Niche Potential Score (1-10):** How strong is the demand vs. competition?
    2.  **Identified Gaps/Opportunities:** What content is missing or could be improved?
    3.  **Recommended Content Angle:** A specific angle for a new blog post.
    4.  **Monetization Strategy Ideas:** How could a blog post on this topic be monetized?
    """
    try:
        response = openai.chat.completions.create(
            model="gpt-5-turbo", # Assuming GPT-5 is 'gpt-5-turbo' or similar in 2025
            messages=[
                {"role": "system", "content": "You are a content strategy expert."},
                {"role": "user", "content": prompt}
            ],
            temperature=0.7
        )
        return response.choices[0].message.content
    except openai.APIError as e:
        print(f"OpenAI API Error: {e}")
        return "Error analyzing niche."

# Example Usage:
if __name__ == "__main__":
    query_keyword = "sustainable AI hardware 2025"
    
    print(f"Fetching Google Trends for '{query_keyword}'...")
    trends = get_google_trends(query_keyword)
    print("\nGoogle Trends Data:")
    print(trends)

    print(f"\nFetching SERP data for '{query_keyword}'...")
    serp_results = get_serp_data(query_keyword)
    print("\nSERP Data (Top 3 Snippets):")
    for i, res in enumerate(serp_results[:3]):
        print(f"{i+1}. Title: {res['title']}")
        print(f"   Snippet: {res['snippet'][:100]}...") # Truncate for display

    print(f"\nAnalyzing niche with GPT-5 for '{query_keyword}'...")
    analysis = analyze_niche_with_gpt5(query_keyword, trends, serp_results)
    print("\nGPT-5 Niche Analysis:")
    print(analysis)

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

# Set your OpenAI API key
os.environ["OPENAI_API_KEY"] = "YOUR_OPENAI_API_KEY" # Replace with your actual key or env var setup
openai.api_key = os.getenv("OPENAI_API_KEY")

def generate_blog_post_draft(topic, target_audience, main_points, word_count=1000):
    """
    Generates a full blog post draft using LangChain and GPT-5.
    """
    llm = ChatOpenAI(model="gpt-5-turbo", temperature=0.7) # Use the latest GPT-5 model

    prompt_template = PromptTemplate(
        input_variables=["topic", "audience", "points", "word_count"],
        template="""
        You are an expert technical blogger writing for {audience}.
        Write a detailed and engaging blog post draft on the topic: "{topic}".
        Include the following key points:
        {points}

        Ensure the tone is clear, energetic, and smart. Aim for approximately {word_count} words.
        Include an engaging introduction, several sub-sections (using Markdown H2 headings), and a strong conclusion with a call to action.
        Suggest internal links where appropriate (use [Anchor Text](/internal-link-placeholder) format).
        Suggest external links to relevant open-source projects or official documentation (use [Anchor Text](https://external-link-placeholder.com) format).
        Focus on practical advice and monetization opportunities for solo creators/developers.
        """
    )

    chain = LLMChain(llm=llm, prompt=prompt_template)

    response = chain.run(
        topic=topic,
        audience=target_audience,
        points="\n".join([f"- {p}" for p in main_points]),
        word_count=word_count
    )
    return response

# Example Usage:
if __name__ == "__main__":
    blog_topic = "Sustainable AI Hardware for Solo Devs & Small Businesses in 2025: A Practical Guide"
    audience = "solo content creators, developers, and small business owners"
    key_points = [
        "Why sustainable AI matters now more than ever",
        "Practical tips for reducing AI energy consumption (model choice, cloud optimization)",
        "Emerging eco-friendly hardware trends for 2025",
        "Monetization opportunities from green AI expertise"
    ]

    print(f"Generating draft for: {blog_topic}...")
    draft = generate_blog_post_draft(blog_topic, audience, key_points, word_count=1200)
    print("\n--- Generated Blog Post Draft ---")
    print(draft)

import xmlrpc.client
import os

def publish_to_wordpress(
    title: str,
    content: str,
    categories: list = None,
    tags: list = None,
    status: str = 'publish', # 'publish', 'draft', 'pending'
    username: str = None,
    password: str = None,
    xmlrpc_url: str = None
):
    """
    Publishes a new post to WordPress using XML-RPC.

    Args:
        title (str): The title of the post.
        content (str): The HTML content of the post.
        categories (list, optional): List of category names. Defaults to None.
        tags (list, optional): List of tag names. Defaults to None.
        status (str, optional): The status of the post. Defaults to 'publish'.
        username (str): WordPress username.
        password (str): WordPress application password.
        xmlrpc_url (str): The URL to your WordPress XML-RPC endpoint (e.g., "https://yourdomain.com/xmlrpc.php").
    """
    if not all([username, password, xmlrpc_url]):
        raise ValueError("WordPress username, password, and XML-RPC URL must be provided.")

    server = xmlrpc.client.ServerProxy(xmlrpc_url)

    # Prepare post data
    data = {
        'post_type': 'post',
        'post_status': status,
        'post_title': title,
        'post_content': content,
        'mt_allow_comments': 1, # Allow comments
        'mt_allow_pings': 1,    # Allow pings
    }

    if categories:
        data['mt_keywords'] = ','.join(categories) # For categories in some XML-RPC versions
        data['categories'] = [{'name': cat} for cat in categories] # For newer versions/better compatibility

    if tags:
        data['mt_tags'] = ','.join(tags) # For tags

    try:
        # The 'wp.newPost' method is common for WordPress
        post_id = server.wp.newPost(
            0, # blog_id (0 for single blog installations)
            username,
            password,
            data,
            True # publish (True to publish immediately if status is 'publish')
        )
        print(f"Successfully published post with ID: {post_id}")
        return post_id
    except xmlrpc.client.Fault as err:
        print(f"A fault occurred: {err.faultCode}, {err.faultString}")
    except Exception as err:
        print(f"An error occurred: {err}")
    return None

# Example Usage:
if __name__ == "__main__":
    # Ensure these are set as environment variables or securely retrieved
    WP_USERNAME = os.getenv("WP_USERNAME")
    WP_APP_PASSWORD = os.getenv("WP_APP_PASSWORD") # Use an application password for security!
    WP_XMLRPC_URL = os.getenv("WP_XMLRPC_URL", "https://yourdomain.com/xmlrpc.php")

    # Replace with the actual generated title and content from Workflow 2
    post_title_example = "Sustainable AI Hardware for Solo Devs & Small Businesses in 2025: A Practical Guide"
    post_content_example = """
    # Sustainable AI Hardware for Solo Devs & Small Businesses in 2025: A Practical Guide

    As we charge further into 2025, the AI revolution isn't just about bigger models and faster processing; it's increasingly about smarter, greener computing. For solo content creators, developers, and small business owners, the push for sustainable AI hardware isn't just an ethical imperative—it's a burgeoning opportunity.

    ## Why Sustainable AI Matters Now More Than Ever
    The computational demands of Large Language Models (LLMs) and other AI applications are astronomical...

    ## Practical Tips for Reducing AI Energy Consumption
    You don't need a massive budget to make a difference...

    ---
    *This content was automatically generated using GPT-5 and Python automation.*
    """
    post_categories_example = ["AI Blogging", "Sustainability", "Automation"]
    post_tags_example = ["AI", "Hardware", "2025", "GreenTech", "Monetization"]

    # Only run this if you have your WordPress credentials set up and understand the implications
    # of auto-publishing. Always test with 'draft' status first!
    # Note: Use a dedicated application password in WordPress for automation, not your main user password.
    # Go to WordPress Dashboard -> Users -> Your Profile -> Application Passwords.
    if WP_USERNAME and WP_APP_PASSWORD and WP_XMLRPC_URL != "https://yourdomain.com/xmlrpc.php":
        print(f"Attempting to publish '{post_title_example}' to WordPress...")
        new_post_id = publish_to_wordpress(
            title=post_title_example,
            content=post_content_example,
            categories=post_categories_example,
            tags=post_tags_example,
            status='draft', # Start with 'draft' for safety
            username=WP_USERNAME,
            password=WP_APP_PASSWORD,
            xmlrpc_url=WP_XMLRPC_URL
        )
        if new_post_id:
            print(f"Post created successfully with ID: {new_post_id}. Check your WordPress dashboard (it's currently a draft).")
    else:
        print("WordPress credentials or XML-RPC URL not properly configured. Skipping publish example.")
        print("Please set WP_USERNAME, WP_APP_PASSWORD, and WP_XMLRPC_URL environment variables.")