pip install google-generativeai python-dotenv

PROMPT_TEMPLATE = """
You are an expert tech blogger specializing in cloud computing and AI. Your task is to generate a detailed, engaging, and well-structured blog post in Markdown format.

**Topic:** "Optimizing Serverless Deployments with Google Cloud Run"
**Angle:** Focus on practical tips, best practices, and common pitfalls for developers deploying applications on Cloud Run.
**Target Audience:** Experienced developers and DevOps engineers familiar with cloud concepts but looking to deepen their Cloud Run expertise.
**Tone:** Smart, clear, highly informative, and practical. Use a professional yet approachable voice.
**Length:** Approximately 1000-1500 words.

**Output Structure and Formatting (Strictly adhere to this Markdown format):**

1.  **Front Matter:**
    Include the following YAML front matter at the very beginning of the file. Replace placeholders with appropriate generated content:
    ```
    ---
    title: [GENERATED_TITLE_FOR_THE_POST]
    date: [CURRENT_ISO_8601_DATE_TIME_E.G._YYYY-MM-DDTHH:MM:SS-07:00]
    description: [CONCISE_SUMMARY_OF_THE_POST]
    tags: [comma, separated, tags, relevant, to, content]
    categories: [comma, separated, categories, like, Cloud, DevOps, AI]
    comments: true
    ---
    ```
    *Ensure the `date` is dynamically set to the current date and time in ISO 8601 format, including timezone.*

2.  **Blog Post Body:**
    *   **Introduction (H1, i.e., `#`):** Start with a compelling H1 title. Below the H1, have an introductory paragraph (no H2 for intro). Briefly set the stage for Cloud Run optimization.
    *   **Main Sections (H2, i.e., `##`):** Include at least 4 main sections, each covering a distinct aspect of Cloud Run optimization. Examples include:
        *   "Understanding Cold Starts and Mitigation Strategies"
        *   "Optimizing Container Images for Performance"
        *   "Effective Resource Allocation and Concurrency"
        *   "Leveraging Integrations: VPC Connectors, Managed Instances"
        *   "Monitoring and Troubleshooting Best Practices"
    *   **Sub-sections (H3, i.e., `###`):** Within each H2 section, include relevant H3 sub-sections to break down complex topics.
    *   **Code Examples:** Where appropriate, include small, illustrative code snippets (e.g., Dockerfile lines, gcloud commands, Python/Node.js examples) formatted in triple-backtick code blocks.
    *   **Bullet Points and Numbered Lists:** Use Markdown bullet points (`-`) and numbered lists (`1.`) for readability when presenting lists of items or steps.
    *   **Bold Text:** Use `**text**` for emphasis.
    *   **Images:** Suggest `![Alt text](path/to/image.png)` placeholders where an image would be beneficial, but do not create the images.
    *   **Conclusion (H2):** Summarize the key takeaways and reinforce the importance of optimization.
    *   **Call to Action (H2):** A concluding H2 section that encourages reader engagement or further exploration.

**Important Constraints:**
*   Do NOT include a table of contents.
*   Do NOT include any phrases like "As an AI language model..."
*   Do NOT include real-time external links or specific references that require current web browsing. Focus on general concepts and best practices.
*   Ensure the output is pure Markdown, ready to be saved as a `.md` file.
*   The title in the front matter MUST be the same as the H1 title of the post.
"""

import os
import google.generativeai as genai
from datetime import datetime
import re # For cleaning title for filename
from dotenv import load_dotenv

# Load environment variables from .env file
load_dotenv()

# --- Configuration ---
# Get API key from environment variable
GOOGLE_API_KEY = os.getenv("GOOGLE_API_KEY")
if not GOOGLE_API_KEY:
    raise ValueError("GOOGLE_API_KEY environment variable not set.")

genai.configure(api_key=GOOGLE_API_KEY)

# Choose a model. 'gemini-pro' is generally suitable for text generation.
# Note: As of my last update, specific Gemini model names and availability might evolve.
# Always check Google's official documentation for the latest recommended models.
# [Google AI Studio Models](https://aistudio.google.com/app/models/gemini-pro)
MODEL_NAME = "gemini-pro"

# Generation configuration for controlling output
# temperature: Controls randomness. Lower for more focused, higher for more creative.
# max_output_tokens: Limits the length of the generated response.
# top_p, top_k: Advanced controls for sampling.
GENERATION_CONFIG = {
    "temperature": 0.7,
    "max_output_tokens": 4000, # Adjust based on desired blog post length
    "top_p": 1,
    "top_k": 1,
}

# Safety settings (optional, but good practice)
# These block content that might be harmful. Adjust as per your application's needs.
# [Google AI Studio Safety Settings](https://aistudio.google.com/app/safety)
SAFETY_SETTINGS = [
    {"category": "HARM_CATEGORY_HARASSMENT", "threshold": "BLOCK_MEDIUM_AND_ABOVE"},
    {"category": "HARN_CATEGORY_HATE_SPEECH", "threshold": "BLOCK_MEDIUM_AND_ABOVE"},
    {"category": "HARM_CATEGORY_SEXUALLY_EXPLICIT", "threshold": "BLOCK_MEDIUM_AND_ABOVE"},
    {"category": "HARM_CATEGORY_DANGEROUS_CONTENT", "threshold": "BLOCK_MEDIUM_AND_ABOVE"},
]

# --- Prompt Definition ---
# This is where you put your comprehensive prompt as designed above.
# Use f-string to insert dynamic elements like current date.
def get_blog_post_prompt(topic, angle, audience, length_guidance):
    current_iso_date = datetime.now().isoformat(timespec='seconds')
    # Replace colon in timezone offset with empty string for ISO 8601 compatibility in some systems (e.g., Jekyll)
    # Example: 2023-10-27T10:00:00-07:00 becomes 2023-10-27T10:00:00-0700
    # Or, if you want simple Z for UTC: current_iso_date = datetime.now(timezone.utc).isoformat(timespec='seconds') + 'Z'
    # For local timezone, it's more complex, but isoformat() usually handles it or returns naive.
    # Let's ensure it has timezone info if possible, or state local.
    # A simpler approach for local time with offset:
    local_now = datetime.now().astimezone()
    current_iso_date_with_offset = local_now.isoformat(timespec='seconds')
    # Some SSGs prefer no colon in timezone offset, so let's adjust:
    # Example: '2023-10-27T10:00:00-07:00' -> '2023-10-27T10:00:00-0700'
    current_iso_date_formatted = re.sub(r'([+-]\d{2}):(\d{2})$', r'\1\2', current_iso_date_with_offset)


    return f"""
    You are an expert tech blogger specializing in cloud computing and AI. Your task is to generate a detailed, engaging, and well-structured blog post in Markdown format.

    **Topic:** "{topic}"
    **Angle:** {angle}
    **Target Audience:** {audience}
    **Tone:** Smart, clear, highly informative, and practical. Use a professional yet approachable voice.
    **Length:** Approximately {length_guidance} words.

    **Output Structure and Formatting (Strictly adhere to this Markdown format):**

    1.  **Front Matter:**
        Include the following YAML front matter at the very beginning of the file. Replace placeholders with appropriate generated content:
        ```
        ---
        title: [GENERATED_TITLE_FOR_THE_POST]
        date: {current_iso_date_formatted}
        description: [CONCISE_SUMMARY_OF_THE_POST]
        tags: [comma, separated, tags, relevant, to, content]
        categories: [comma, separated, categories, like, Cloud, DevOps, AI]
        comments: true
        ---
        ```
        *Ensure the `date` is dynamically set to the current date and time in ISO 8601 format, including timezone.*

    2.  **Blog Post Body:**
        *   **Introduction (H1, i.e., `#`):** Start with a compelling H1 title. Below the H1, have an introductory paragraph (no H2 for intro). Briefly set the stage for {topic}.
        *   **Main Sections (H2, i.e., `##`):** Include at least 4 main sections, each covering a distinct aspect of {topic} optimization. Provide relevant, practical advice.
        *   **Sub-sections (H3, i.e., `###`):** Within each H2 section, include relevant H3 sub-sections to break down complex topics.
        *   **Code Examples:** Where appropriate, include small, illustrative code snippets (e.g., Dockerfile lines, gcloud commands, Python/Node.js examples) formatted in triple-backtick code blocks.
        *   **Bullet Points and Numbered Lists:** Use Markdown bullet points (`-`) and numbered lists (`1.`) for readability when presenting lists of items or steps.
        *   **Bold Text:** Use `**text**` for emphasis.
        *   **Images:** Suggest `![Alt text](path/to/image.png)` placeholders where an image would be beneficial, but do not create the images.
        *   **Conclusion (H2):** Summarize the key takeaways and reinforce the importance of {topic}.
        *   **Call to Action (H2):** A concluding H2 section that encourages reader engagement or further exploration.

    **Important Constraints:**
    *   Do NOT include a table of contents.
    *   Do NOT include any phrases like "As an AI language model..."
    *   Do NOT include real-time external links or specific references that require current web browsing. Focus on general concepts and best practices.
    *   Ensure the output is pure Markdown, ready to be saved as a `.md` file.
    *   The title in the front matter MUST be the same as the H1 title of the post.
    *   The generated content should be original and insightful, not generic boilerplate.
    """

# --- File Handling Utilities ---
def sanitize_filename(title):
    """Converts a title into a slug-like filename."""
    title = title.lower()
    # Replace non-alphanumeric characters with hyphens
    title = re.sub(r'[^a-z0-9\s-]', '', title)
    # Replace spaces and multiple hyphens with a single hyphen
    title = re.sub(r'[\s-]+', '-', title).strip('-')
    return title

def save_markdown_post(content, output_dir="generated_posts"):
    """
    Saves the generated Markdown content to a file.
    Extracts title from front matter for filename.
    """
    os.makedirs(output_dir, exist_ok=True)

    # Try to extract title from front matter for filename
    title_match = re.search(r'^title: (.+)$', content, re.MULTILINE)
    if title_match:
        title = title_match.group(1).strip()
        filename_slug = sanitize_filename(title)
        # Add date prefix for static site generators like Jekyll/Hugo
        date_prefix = datetime.now().strftime("%Y-%m-%d")
        filename = f"{date_prefix}-{filename_slug}.md"
    else:
        print("Warning: Could not extract title from front matter. Using generic filename.")
        filename = f"post_{datetime.now().strftime('%Y%m%d%H%M%S')}.md"

    filepath = os.path.join(output_dir, filename)

    with open(filepath, "w", encoding="utf-8") as f:
        f.write(content)
    print(f"Blog post saved to: {filepath}")

# --- Main Generation Logic ---
def generate_blog_post(topic, angle, audience, length_guidance):
    model = genai.GenerativeModel(
        model_name=MODEL_NAME,
        generation_config=GENERATION_CONFIG,
        safety_settings=SAFETY_SETTINGS
    )

    prompt = get_blog_post_prompt(topic, angle, audience, length_guidance)
    print("Sending request to Gemini...")

    try:
        response = model.generate_content(prompt)
        # Check if response has parts and text
        if response and response.parts:
            # Join parts to get the full text content
            generated_text = "".join([part.text for part in response.parts if hasattr(part, 'text')])
            if generated_text:
                return generated_text
            else:
                print("Error: Generated text is empty.")
                if hasattr(response, 'prompt_feedback') and response.prompt_feedback:
                    print(f"Prompt feedback: {response.prompt_feedback}")
                return None
        else:
            print("Error: No content generated or response parts are missing.")
            if hasattr(response, 'prompt_feedback') and response.prompt_feedback:
                print(f"Prompt feedback: {response.prompt_feedback}")
            return None

    except Exception as e:
        print(f"An error occurred during content generation: {e}")
        # Check if error is due to safety settings
        if hasattr(e, 'response') and hasattr(e.response, 'prompt_feedback') and e.response.prompt_feedback.safety_ratings:
            print(f"Safety ratings that blocked content: {e.response.prompt_feedback.safety_ratings}")
        return None

# --- Example Usage ---
if __name__ == "__main__":
    print("--- Gemini Markdown Blog Post Generator ---")
    user_topic = input("Enter the blog post topic (e.g., 'Optimizing Serverless Deployments with Google Cloud Run'): ")
    user_angle = input("Enter the specific angle or focus (e.g., 'practical tips and best practices for developers'): ")
    user_audience = input("Enter the target audience (e.g., 'Experienced developers and DevOps engineers'): ")
    user_length = input("Enter desired word count guidance (e.g., '1000-1500'): ")

    # Ensure output directory exists
    output_directory = "generated_posts"
    os.makedirs(output_directory, exist_ok=True)

    generated_post = generate_blog_post(user_topic, user_angle, user_audience, user_length)

    if generated_post:
        save_markdown_post(generated_post, output_dir=output_directory)
        print("\nGeneration complete! Remember to review and refine the content.")
    else:
        print("\nFailed to generate blog post.")