# utils/reddit_monitor.py

import praw
import os
from dotenv import load_dotenv
import logging

# Configure logging
logging.basicConfig(
    filename='reddit_monitor.log',
    level=logging.INFO,
    format='%(asctime)s %(levelname)s:%(message)s'
)

load_dotenv()

class RedditMonitor:
    def __init__(self):
        try:
            self.reddit = praw.Reddit(
                client_id=os.getenv("REDDIT_CLIENT_ID"),
                client_secret=os.getenv("REDDIT_CLIENT_SECRET"),
                user_agent=os.getenv("REDDIT_USER_AGENT"),
                username=os.getenv("REDDIT_USERNAME"),
                password=os.getenv("REDDIT_PASSWORD")
            )
            user = self.reddit.user.me()
            if user is None:
                raise ValueError("Authentication failed. Check your Reddit credentials.")
            self.username = user.name
            logging.info(f"Authenticated as: {self.username}")
            print(f"Authenticated as: {self.username}")
        except Exception as e:
            logging.error(f"Error during Reddit authentication: {e}", exc_info=True)
            print(f"Error during Reddit authentication: {e}")
            self.username = None

    def fetch_recent_posts(self, limit=10):
        if not self.username:
            logging.warning("Cannot fetch posts: User is not authenticated.")
            print("Cannot fetch posts: User is not authenticated.")
            return []
        user = self.reddit.redditor(self.username)
        posts = []
        try:
            for submission in user.submissions.new(limit=limit):
                posts.append({
                    "type": "post",
                    "title": submission.title,
                    "selftext": submission.selftext,
                    "created_utc": submission.created_utc,
                    "url": submission.url
                })
            logging.info(f"Fetched {len(posts)} recent posts.")
        except Exception as e:
            logging.error(f"Error fetching posts: {e}", exc_info=True)
            print(f"Error fetching posts: {e}")
        return posts

    def fetch_recent_comments(self, limit=10):
        if not self.username:
            logging.warning("Cannot fetch comments: User is not authenticated.")
            print("Cannot fetch comments: User is not authenticated.")
            return []
        user = self.reddit.redditor(self.username)
        comments = []
        try:
            for comment in user.comments.new(limit=limit):
                comments.append({
                    "type": "comment",
                    "body": comment.body,
                    "created_utc": comment.created_utc,
                    "link_id": comment.link_id
                })
            logging.info(f"Fetched {len(comments)} recent comments.")
        except Exception as e:
            logging.error(f"Error fetching comments: {e}", exc_info=True)
            print(f"Error fetching comments: {e}")
        return comments

    def fetch_all_recent_activity(self, limit=10):
        posts = self.fetch_recent_posts(limit)
        comments = self.fetch_recent_comments(limit)
        total = posts + comments
        logging.info(f"Total recent activities fetched: {len(total)}")
        return total

# agents/persona_storage_agent.py

import json
import os
from datetime import datetime
from utils.file_utils import create_backup
import logging

# Configure logging
logging.basicConfig(
    filename='persona_storage.log',
    level=logging.INFO,
    format='%(asctime)s %(levelname)s:%(message)s'
)

class PersonaStorageAgent:
    def __init__(self, persona_file='personas.json'):
        self.persona_file = persona_file
        # Initialize the persona file if it doesn't exist
        if not os.path.exists(self.persona_file):
            with open(self.persona_file, 'w') as f:
                json.dump({}, f)
            logging.info(f"Initialized empty persona file: {self.persona_file}")

    def save_persona(self, persona_name: str, persona_data: dict) -> bool:
        try:
            create_backup(self.persona_file)
            with open(self.persona_file, 'r+') as f:
                data = json.load(f)
                data[persona_name] = persona_data
                f.seek(0)
                json.dump(data, f, indent=4)
                f.truncate()
            logging.info(f"Persona '{persona_name}' saved successfully.")
            return True
        except Exception as e:
            logging.error(f"Error saving persona '{persona_name}': {e}", exc_info=True)
            print(f"Error saving persona: {e}")
            return False

    def load_persona(self, persona_name: str) -> dict:
        try:
            with open(self.persona_file, 'r') as f:
                data = json.load(f)
                persona = data.get(persona_name, {})
                if not persona:
                    logging.warning(f"Persona '{persona_name}' not found.")
                    print(f"Persona '{persona_name}' not found.")
                return persona
        except Exception as e:
            logging.error(f"Error loading persona '{persona_name}': {e}", exc_info=True)
            print(f"Error loading persona: {e}")
            return {}

    def list_personas(self) -> list:
        try:
            with open(self.persona_file, 'r') as f:
                data = json.load(f)
                persona_list = list(data.keys())
                logging.info(f"Retrieved persona list: {persona_list}")
                return persona_list
        except Exception as e:
            logging.error(f"Error listing personas: {e}", exc_info=True)
            print(f"Error listing personas: {e}")
            return []

# agents/persona_agent.py

import openai
import json
import os
from agents.persona_storage_agent import PersonaStorageAgent
import logging

# Configure logging
logging.basicConfig(
    filename='persona_agent.log',
    level=logging.INFO,
    format='%(asctime)s %(levelname)s:%(message)s'
)

class PersonaAgent:
    def __init__(self, openai_api_key: str, storage_agent: PersonaStorageAgent):
        openai.api_key = openai_api_key
        self.storage_agent = storage_agent

    def generate_persona(self, sample_text: str) -> dict:
        prompt = (
            "Analyze the following text and create a persona profile that captures the writing style "
            "and personality characteristics of the author. Respond with a valid JSON object only, "
            "following this exact structure:\n\n"
            "{\n"
            "  \"name\": \"[Author/Character Name]\",\n"
            "  \"vocabulary_complexity\": [1-10],\n"
            "  \"sentence_structure\": \"[simple/complex/varied]\",\n"
            "  \"tone\": \"[formal/informal/academic/conversational/etc.]\",\n"
            "  \"contraction_usage\": [1-10],\n"
            "  \"humor_usage\": [1-10],\n"
            "  \"emotional_expressiveness\": [1-10],\n"
            "  \"language_abstraction\": \"[concrete/abstract/mixed]\",\n"
            "  \"age\": \"[age or age range]\",\n"
            "  \"gender\": \"[gender]\",\n"
            "  \"education_level\": \"[highest level of education]\"\n"
            "}\n\n"
            f"Sample Text:\n{sample_text}"
        )
        try:
            response = openai.ChatCompletion.create(
                model="gpt-4",
                messages=[{"role": "user", "content": prompt}],
                temperature=0.7
            )
            content = response.choices[0].message.content.strip()
            start_idx = content.find('{')
            end_idx = content.rfind('}') + 1
            if start_idx == -1 or end_idx == 0:
                logging.error("No JSON structure found in response.")
                print("Error: No JSON structure found in response.")
                return {}
            json_str = content[start_idx:end_idx]
            persona = json.loads(json_str)
            logging.info(f"Generated persona: {persona}")
            return persona
        except Exception as e:
            logging.error(f"Error during persona generation: {e}", exc_info=True)
            print(f"Error during persona generation: {e}")
            return {}

    def create_and_save_persona(self, persona_name: str, sample_text: str) -> bool:
        persona = self.generate_persona(sample_text)
        if persona:
            return self.storage_agent.save_persona(persona_name, persona)
        return False

# agents/content_generator.py

import openai
import json
import time
import logging

# Configure logging
logging.basicConfig(
    filename='content_generator.log',
    level=logging.INFO,
    format='%(asctime)s %(levelname)s:%(message)s'
)

class ContentGenerator:
    def __init__(self, openai_api_key: str):
        openai.api_key = openai_api_key

    def generate_blog_post(self, persona: dict, reddit_content: list) -> str:
        """
        Generates a blog post based on the persona and Reddit content.
        :param persona: Dictionary containing persona traits.
        :param reddit_content: List of Reddit posts/comments.
        :return: Generated blog post as a string.
        """
        # Aggregate Reddit content
        content_summary = self.summarize_reddit_content(reddit_content)

        # Create a prompt incorporating persona traits
        prompt = (
            f"Using the following persona profile, write a comprehensive blog post about the user's recent "
            f"Reddit activity.\n\nPersona Profile:\n{json.dumps(persona, indent=2)}\n\n"
            f"Reddit Activity Summary:\n{content_summary}\n\n"
            f"Blog Post:"
        )

        try:
            response = self._make_request_with_retries(
                model="gpt-4",
                messages=[{"role": "user", "content": prompt}],
                temperature=0.8,
                max_tokens=1000  # Adjusted for token efficiency
            )
            blog_post = response.choices[0].message.content.strip()
            logging.info("Blog post generated successfully.")
            return blog_post
        except Exception as e:
            logging.error(f"Error during blog post generation: {e}", exc_info=True)
            print(f"Error during blog post generation: {e}")
            return ""

    def summarize_reddit_content(self, reddit_content: list) -> str:
        """
        Summarizes Reddit content into a cohesive overview.
        :param reddit_content: List of Reddit posts/comments.
        :return: Summary string.
        """
        summaries = []
        for item in reddit_content:
            if item['type'] == 'post':
                summaries.append(f"Post titled '{item['title']}': {item['selftext']}")
            elif item['type'] == 'comment':
                summaries.append(f"Comment: {item['body']}")
        summary = "\n".join(summaries)
        logging.info("Reddit content summarized.")
        return summary

    def _make_request_with_retries(self, **kwargs):
        max_retries = 5
        backoff_factor = 2
        for attempt in range(max_retries):
            try:
                logging.info(f"Making API call attempt {attempt + 1}")
                return openai.ChatCompletion.create(**kwargs)
            except openai.error.RateLimitError as e:
                wait_time = backoff_factor ** attempt
                logging.warning(f"Rate limit exceeded. Retrying in {wait_time} seconds...")
                time.sleep(wait_time)
            except openai.error.APIError as e:
                logging.warning(f"OpenAI API error: {e}. Retrying in {backoff_factor} seconds...")
                time.sleep(backoff_factor)
            except openai.error.APIConnectionError as e:
                logging.warning(f"OpenAI API connection error: {e}. Retrying in {backoff_factor} seconds...")
                time.sleep(backoff_factor)
            except openai.error.InvalidRequestError as e:
                logging.error(f"Invalid request: {e}. Not retrying.")
                raise e
            except Exception as e:
                logging.error(f"Unexpected error: {e}", exc_info=True)
                raise e
        raise Exception("Max retries exceeded.")

# agents/local_blog_publisher.py

import os
from datetime import datetime
import logging

# Configure logging
logging.basicConfig(
    filename='local_blog_publisher.log',
    level=logging.INFO,
    format='%(asctime)s %(levelname)s:%(message)s'
)

class LocalBlogPublisher:
    def __init__(self, save_directory='blog_posts'):
        self.save_directory = save_directory
        os.makedirs(self.save_directory, exist_ok=True)
        logging.info(f"Initialized LocalBlogPublisher with directory: {self.save_directory}")

    def publish_post(self, title: str, content: str) -> bool:
        try:
            # Sanitize the title to create a valid filename
            filename = self._sanitize_filename(title) + '.md'
            filepath = os.path.join(self.save_directory, filename)
            
            # Write the blog post to a Markdown file
            with open(filepath, 'w', encoding='utf-8') as f:
                f.write(f"# {title}\n\n")
                f.write(content)
            
            logging.info(f"Blog post saved successfully at {filepath}")
            print(f"Blog post saved successfully at {filepath}")
            return True
        except Exception as e:
            logging.error(f"Error saving blog post: {e}", exc_info=True)
            print(f"Error saving blog post: {e}")
            return False

    def _sanitize_filename(self, title: str) -> str:
        # Replace or remove characters that are invalid in filenames
        invalid_chars = ['<', '>', ':', '"', '/', '\\', '|', '?', '*']
        sanitized = ''.join(c for c in title if c not in invalid_chars)
        sanitized = sanitized.replace(' ', '_')  # Replace spaces with underscores
        return sanitized.lower()

# workflows/persona_workflow.py

from agents.persona_agent import PersonaAgent
from agents.persona_storage_agent import PersonaStorageAgent
import logging

# Configure logging
logging.basicConfig(
    filename='persona_workflow.log',
    level=logging.INFO,
    format='%(asctime)s %(levelname)s:%(message)s'
)

class PersonaWorkflow:
    def __init__(self, openai_api_key: str, storage_file: str = 'personas.json'):
        self.storage_agent = PersonaStorageAgent(storage_file)
        self.persona_agent = PersonaAgent(openai_api_key, self.storage_agent)
        logging.info("Initialized PersonaWorkflow.")

    def create_new_persona(self, persona_name: str, sample_text: str) -> bool:
        logging.info(f"Creating new persona: {persona_name}")
        return self.persona_agent.create_and_save_persona(persona_name, sample_text)

    def list_personas(self) -> list:
        return self.storage_agent.list_personas()

    def get_persona(self, persona_name: str) -> dict:
        return self.storage_agent.load_persona(persona_name)

# workflows/response_workflow.py

from agents.content_generator import ContentGenerator
from agents.local_blog_publisher import LocalBlogPublisher
from agents.persona_storage_agent import PersonaStorageAgent
import logging

# Configure logging
logging.basicConfig(
    filename='response_workflow.log',
    level=logging.INFO,
    format='%(asctime)s %(levelname)s:%(message)s'
)

class ResponseWorkflow:
    def __init__(self, openai_api_key: str, save_directory: str = 'blog_posts', storage_file: str = 'personas.json'):
        self.content_generator = ContentGenerator(openai_api_key)
        self.blog_publisher = LocalBlogPublisher(save_directory)
        self.storage_agent = PersonaStorageAgent(storage_file)
        logging.info("Initialized ResponseWorkflow.")

    def generate_and_publish_post(self, persona_name: str, reddit_content: list, post_title: str) -> bool:
        logging.info(f"Generating blog post with persona: {persona_name}")
        persona = self.storage_agent.load_persona(persona_name)
        if not persona:
            print(f"Persona '{persona_name}' not found.")
            logging.warning(f"Persona '{persona_name}' not found.")
            return False
        blog_post = self.content_generator.generate_blog_post(persona, reddit_content)
        if not blog_post:
            print("Failed to generate blog post.")
            logging.error("Failed to generate blog post.")
            return False
        return self.blog_publisher.publish_post(post_title, blog_post)

# utils/file_utils.py

import os
import json
from datetime import datetime
import shutil
import logging

# Configure logging
logging.basicConfig(
    filename='file_utils.log',
    level=logging.INFO,
    format='%(asctime)s %(levelname)s:%(message)s'
)

def create_backup(filename: str):
    try:
        if os.path.exists(filename):
            timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
            backup_filename = f"{filename}.{timestamp}.backup"
            shutil.copy2(filename, backup_filename)
            logging.info(f"Created backup: {backup_filename}")
    except Exception as e:
        logging.error(f"Error creating backup: {e}", exc_info=True)

# main.py

import os
from dotenv import load_dotenv
from utils.reddit_monitor import RedditMonitor
from workflows.persona_workflow import PersonaWorkflow
from workflows.response_workflow import ResponseWorkflow
import logging

# Configure logging
logging.basicConfig(
    filename='main.log',
    level=logging.INFO,
    format='%(asctime)s %(levelname)s:%(message)s'
)

def main():
    load_dotenv()

    # Initialize Modules
    reddit_monitor = RedditMonitor()
    if not reddit_monitor.username:
        logging.error("Reddit authentication failed. Exiting application.")
        return

    persona_workflow = PersonaWorkflow(
        openai_api_key=os.getenv("OPENAI_API_KEY")
    )
    response_workflow = ResponseWorkflow(
        openai_api_key=os.getenv("OPENAI_API_KEY"),
        save_directory='blog_posts',
        storage_file='personas.json'
    )

    print("\n=== Reddit to Blog Post Generator ===")

    # Fetch recent Reddit activity
    reddit_content = reddit_monitor.fetch_all_recent_activity(limit=10)
    if not reddit_content:
        print("No recent Reddit activity found.")
        logging.info("No recent Reddit activity found.")
        return

    # Choose a persona
    personas = persona_workflow.list_personas()
    if not personas:
        print("No personas found. Please create a persona first.")
        logging.info("No personas found. Prompting user to create one.")
        create_persona_flow(persona_workflow)
        personas = persona_workflow.list_personas()
        if not personas:
            print("Persona creation failed. Exiting.")
            logging.error("Persona creation failed.")
            return

    print("\nAvailable Personas:")
    for idx, persona in enumerate(personas, start=1):
        print(f"{idx}. {persona}")

    # Prompt user to select a persona
    while True:
        choice = input("\nSelect a persona by number: ").strip()
        if choice.isdigit() and 1 <= int(choice) <= len(personas):
            selected_persona = personas[int(choice) - 1]
            logging.info(f"Selected persona: {selected_persona}")
            break
        else:
            print("Invalid selection. Please enter a valid number.")
            logging.warning(f"Invalid persona selection attempt: {choice}")

    # Prompt user to enter a blog post title
    while True:
        post_title = input("Enter the blog post title: ").strip()
        if post_title:
            logging.info(f"Entered blog post title: {post_title}")
            break
        else:
            print("Post title cannot be empty. Please enter a valid title.")
            logging.warning("Empty blog post title entered.")

    # Generate and publish blog post
    success = response_workflow.generate_and_publish_post(
        persona_name=selected_persona,
        reddit_content=reddit_content,
        post_title=post_title
    )

    if success:
        print("Blog post generated and saved successfully.")
        logging.info("Blog post generated and saved successfully.")
    else:
        print("Failed to generate and save blog post.")
        logging.error("Failed to generate and save blog post.")

def create_persona_flow(persona_workflow: PersonaWorkflow):
    print("\n--- Create a New Persona ---")
    persona_name = input("Enter a name for the new persona: ").strip()
    if not persona_name:
        print("Persona name cannot be empty. Skipping persona creation.")
        logging.warning("Empty persona name entered. Skipping persona creation.")
        return
    print("\nEnter a writing sample for the persona (press Enter twice to finish):")
    sample_text = get_multiline_input()
    if not sample_text:
        print("Writing sample cannot be empty. Skipping persona creation.")
        logging.warning("Empty writing sample entered. Skipping persona creation.")
        return
    success = persona_workflow.create_new_persona(persona_name, sample_text)
    if success:
        print(f"Persona '{persona_name}' created successfully.")
        logging.info(f"Persona '{persona_name}' created successfully.")
    else:
        print(f"Failed to create persona '{persona_name}'.")
        logging.error(f"Failed to create persona '{persona_name}'.")

def get_multiline_input():
    import sys
    lines = []
    try:
        while True:
            line = input()
            if line == "":
                break
            lines.append(line)
    except KeyboardInterrupt:
        print("\nInput cancelled by user.")
        return ""
    return "\n".join(lines)

if __name__ == "__main__":
    main()