# content_discovery.py
import pandas as pd
from pytrends.request import TrendReq
from serpapi import GoogleSearch
import os

# --- Google Trends ---
def get_google_trends(keywords, timeframe='today 3-m'):
    """
    Fetches Google Trends data for specified keywords.
    Keywords should be a list of strings.
    """
    pytrends = TrendReq(hl='en-US', tz=360) # US timezone
    pytrends.build_payload(keywords, cat=0, timeframe=timeframe, geo='')
    data = pytrends.interest_over_time()
    if not data.empty:
        data = data.drop(columns=['isPartial'])
    return data

# --- SerpAPI for Real-time Search ---
def get_serpapi_results(query, api_key):
    """
    Fetches real-time search results using SerpAPI.
    """
    params = {
        "api_key": api_key,
        "engine": "google",
        "q": query,
        "gl": "us", # Global location for search (could be 'in' for India)
        "hl": "en"
    }
    search = GoogleSearch(params)
    results = search.get_dict()
    return results

if __name__ == "__main__":
    # Example 1: Google Trends
    trending_keywords = ['AI in India', 'LLM US development', 'Generative AI monetization 2025']
    trend_data = get_google_trends(trending_keywords)
    print("--- Google Trends Data (Past 3 Months) ---")
    print(trend_data.tail())

    # Example 2: SerpAPI for current search insights
    # Replace with your actual SerpAPI_KEY from os.environ or directly
    SERPAPI_KEY = os.environ.get("SERPAPI_KEY", "YOUR_SERPAPI_KEY_HERE")
    if "YOUR_SERPAPI_KEY_HERE" in SERPAPI_KEY:
        print("\nNote: Please set your SERPAPI_KEY environment variable or replace the placeholder.")
    else:
        search_query = "google's AI factories india"
        search_results = get_serpapi_results(search_query, SERPAPI_KEY)

        print(f"\n--- SerpAPI Results for '{search_query}' ---")
        if 'organic_results' in search_results:
            for i, result in enumerate(search_results['organic_results'][:3]):
                print(f"{i+1}. Title: {result['title']}")
                print(f"   Link: {result['link']}")
                print(f"   Snippet: {result.get('snippet', '')[:100]}...\n")
        if 'related_questions' in search_results:
            print("Related Questions:")
            for q in search_results['related_questions'][:3]:
                print(f"- {q['question']}")

# ai_content_generator.py
from langchain.llms import OpenAI
from langchain.prompts import PromptTemplate
from langchain.chains import LLMChain
import os

# Ensure you have your OpenAI API key set as an environment variable
# export OPENAI_API_KEY="your_key_here"
# Or use Google's equivalent API key if using Gemini directly
# from langchain_google_genai import ChatGoogleGenerativeAI
# llm = ChatGoogleGenerativeAI(model="gemini-pro")

def generate_blog_section(topic_query, current_insights, api_key):
    """
    Generates a blog section based on a topic query and current insights.
    Uses GPT-5 via LangChain.
    """
    os.environ["OPENAI_API_KEY"] = api_key # Make sure this is set

    # Initialize the LLM (using OpenAI for demonstration)
    llm = OpenAI(temperature=0.7, model_name="gpt-4o-2024-05-13") # Assuming gpt-4o as current best, GPT-5 later

    # Craft a precise prompt using LangChain's PromptTemplate
    template = """
    You are an expert technical blogger in 2025, specializing in AI automation and monetization.
    Write a detailed, engaging, and smart 300-word section for a blog post about "{topic_query}".
    Incorporate the following current search insights to make the content timely and relevant:
    {insights}

    Focus on how these developments create opportunities for solo content creators.
    Maintain a clear, energetic, but not hyped tone. Use Markdown formatting.
    Start with a relevant heading.
    """
    prompt = PromptTemplate(template=template, input_variables=["topic_query", "insights"])

    llm_chain = LLMChain(prompt=prompt, llm=llm)

    # Format insights for the prompt
    formatted_insights = "\n".join([f"- {s}" for s in current_insights])

    response = llm_chain.run(topic_query=topic_query, insights=formatted_insights)
    return response

if __name__ == "__main__":
    # Your OpenAI API key
    OPENAI_API_KEY = os.environ.get("OPENAI_API_KEY", "YOUR_OPENAI_KEY_HERE")
    if "YOUR_OPENAI_KEY_HERE" in OPENAI_API_KEY:
        print("Note: Please set your OPENAI_API_KEY environment variable or replace the placeholder.")
    else:
        # Example topic and insights from SerpAPI
        topic = "Google's AI Factories in India and US LLM Race"
        insights = [
            "Google is significantly ramping up its AI research and development efforts in India, positioning the country as a major hub.",
            "India's contribution to LLM development is growing, positioning it as a key player in global AI dominance.",
            "Google's strategy to decentralize AI development includes major investments in India."
        ]
        generated_content = generate_blog_section(topic, insights, OPENAI_API_KEY)
        print("\n--- Generated Blog Section ---")
        print(generated_content)

# auto_publisher.py
from wordpress_xmlrpc import Client, WordPressPost
from wordpress_xmlrpc.methods.posts import NewPost
from wordpress_xmlrpc.methods.media import UploadFile
from wordpress_xmlrpc.compat import xmlrpc_client
import os

def publish_to_wordpress(title, content, categories, tags, wordpress_url, username, password):
    """
    Publishes a new post to WordPress using XML-RPC.
    """
    try:
        # Initialize client
        client = Client(wordpress_url + '/xmlrpc.php', username, password)

        # Create a new post object
        post = WordPressPost()
        post.title = title
        post.content = content
        post.post_status = 'publish'  # 'draft' or 'publish'
        post.categories = categories
        post.tags = tags

        # Publish the post
        post_id = client.call(NewPost(post))
        print(f"Successfully published post with ID: {post_id}")
        return post_id

    except xmlrpc_client.Fault as err:
        print(f"XML-RPC Fault: {err.faultCode} - {err.faultString}")
        return None
    except Exception as e:
        print(f"An error occurred: {e}")
        return None

if __name__ == "__main__":
    # Your WordPress credentials and URL
    WP_URL = os.environ.get("WP_URL", "https://yourblog.com")
    WP_USERNAME = os.environ.get("WP_USERNAME", "your_wp_user")
    WP_PASSWORD = os.environ.get("WP_PASSWORD", "your_wp_password") # Use application password for better security

    if "yourblog.com" in WP_URL:
        print("Note: Please configure your WordPress URL, username, and password.")
    else:
        post_title = "Google's AI Factories: US Leads, India Follows in LLM Race"
        post_content = """
        This is the full blog post content, including the AI-generated sections.
        [Paste your full generated blog post here, after human review and editing]

        ### Google's Decentralized AI Power: A Win for Creators

        The notion of Google's "AI Factories" isn't just a metaphor; it's a strategic decentralization of cutting-edge AI development. While the US continues to lead in foundational LLM breakthroughs, a profound pivot sees India emerging as a formidable force. Google is not merely expanding operations; it's embedding deep R&D efforts in India, recognizing its burgeoning talent pool and robust tech ecosystem. This isn't just about scaling; it's about diversifying the very fabric of AI creation.

        For us, the solo content creators and technical bloggers, this geographical spread is gold. It means a wider array of localized insights, a more granular understanding of global AI adoption, and a richer tapestry of AI applications tailored to diverse markets. Imagine accessing fine-tuned models trained on Indian linguistic nuances, or gaining early insights into AI's impact on emerging economies. This dual-continent approach accelerates innovation, fostering a dynamic environment where new tools and capabilities are constantly emerging. By leveraging this global innovation, we can craft highly targeted content, identify niche monetization opportunities, and stay ahead of the curve. Your automated pipelines can now tap into a broader, richer stream of AI-driven intelligence.
        """
        post_categories = ['AI Blogging', 'Automation']
        post_tags = ['AI_2025', 'LLM', 'Google', 'India_AI', 'US_AI', 'Automation_2025']

        post_id = publish_to_wordpress(post_title, post_content, post_categories, post_tags, WP_URL, WP_USERNAME, WP_PASSWORD)
        if post_id:
            print(f"Check your blog: {WP_URL}/?p={post_id}")