AI Post Generator

import pandas as pd
from wordpress import wordPress
from aiassistant import OpenAIAssistant
from image_handling import Images
from PIL import Image, ImageDraw, ImageFont
from io import BytesIO
import requests
from gui import CustomDialog, show_post_dialog
import openpyxl
import json
import utils
import re
from config import DATABASE_LOCATION, POST_DATABASE, POSTS, IMAGE_LOCATION, FONT, META_ACCESS_TOKEN, INSTAGRAM_USER_ID
import os
import time
import textwrap
from instagram import Instagram

class Generatepost:

    def __init__(self):
        self.post = OpenAIAssistant()
        self.images = Images(self.post)
        self.wppost = wordPress()
        self.IGPost = Instagram()
        self.image_counter = 1  # Initialize a counter for image naming
    def generate_image_description(self, post_text):
        prompt = f"Based on the following post, provide a short description for a relevant image:\n\n{post_text}"
        return self.post.ask_gpt(prompt)

    def generate_post_img_desc(self, topic):
            prompt = f"""Provide an image description for Dalle to generate an interesting image on the topic '{topic}' in a python list format like: ["Image Description"] """
            response = self.post.ask_gpt(prompt)            
            try:
                # Parsing the string response into a Python list
                image_keywords_list = eval(response)  # Use eval() cautiously
                print(image_keywords_list)
                
                # Joining the list into a comma-separated string
                image_keywords = ', '.join(image_keywords_list)
                print(image_keywords)
                return image_keywords
            except Exception as e:
                print(f"Could not generate image keywords: {e}")
                # Handle the error appropriately
                return []
            
                """ def generate_post_img_desc(self, topic):
                prompt = "Provide an image description for Dalle to generate an interesting image on the topic '{topic}' in a python list format like: ["Keyword1","Keyword2","Keyword3"] 
                response = self.post.ask_gpt(prompt)            
                try:
                # Parsing the string response into a Python list
                image_keywords_list = eval(response)  # Use eval() cautiously
                print(image_keywords_list)
                
                # Joining the list into a comma-separated string
                image_keywords = ', '.join(image_keywords_list)
                print(image_keywords)
                return image_keywords
                except Exception as e:
                print(f"Could not generate image keywords: {e}")
                # Handle the error appropriately
                return []"""
                
    def generate_post_img_desc(self, topic):
            prompt = f"""Provide one short image description for Dalle to generate an interesting image on the topic '{topic}'. The description should be surrounded by brackets in a python list format like: ["an intersting desciription for featured image of post"] """
            response = self.post.ask_gpt(prompt)            
            try:
                # Parsing the string response into a Python list
                image_keywords_list = eval(response)  # Use eval() cautiously
                print(image_keywords_list)
                
                # Joining the list into a comma-separated string
                image_keywords = ', '.join(image_keywords_list)
                print(image_keywords)
                return image_keywords
            except Exception as e:
                print(f"Could not generate image keywords: {e}")
                # Handle the error appropriately
                return []

    def generate_caption(self, topic):
        captionAI = OpenAIAssistant()
        prompt = f"Provide an inspiring and factual 150 to 1500 character paragraph on the topic, '{topic}'. This will be used as an Instagram caption. Your response should be surrounded by brackets in python list format such as: [this is the caption for instagram]."
        response = captionAI.ask_gpt(prompt)
        print(f"\nCaption is {response}\n")
        # Attempt to parse the response
        try:
            # Removing brackets and quotes, and trimming whitespace
            cleaned_response = response.replace('[', '').replace(']', '').replace("'", "").replace('"', '').strip()
            # Splitting the string into a list based on commas
            #category_list = cleaned_response.split(',')
            # Get the first item in the list as the category, or default to "Uncategorized"
            #category = category_list[0].strip() if category_list else "No Caption"
            cleaned_response = cleaned_response + "\nFollow us @NeuralNetNews for my Content like this!"
            return cleaned_response
        except Exception as e:
            print(f"An error occurred: {e}")
            # Handle the error appropriately
            return "No Caption"

    def generate_post(self,topic_list, topic):
            page_list = []
            original_image_directory, post_images_directory = self.create_folders(topic)
            if topic_list:
                page_list = topic_list
            else:
                page_list.append(topic)
            for page_item in page_list:
                image_description = self.generate_post_img_desc(topic)
                image_url = self.post.generate_image(image_description)
                #image_url = 'https://m.media-amazon.com/images/W/MEDIAX_792452-T2/images/I/71PQ8F9jyOL.jpg'

                # overlay image with txt
                # Overlay text on the image
                original_image = self.save_image(image_url,original_image_directory, topic)
                # Check if the post is less than 50 words
                image_with_text = self.images.overlay_text_on_image(original_image, page_item)
                
                # Save or store the image
                finished_image_path = self.save_image(image_with_text,post_images_directory, topic)
                
                
                # Insert images into the post
            caption = self.generate_caption(topic)
            media_id = self.IGPost.post_to_instagram(post_images_directory,topic,caption)
            return media_id
                #featured_media_id, _ = self.images.insert_featured_images(image_keywords, topic)
                #text
    def create_folders(self,topic):
        # Sanitize the topic name and limit it to 20 characters
        sanitized_topic = self.sanitize_topic_name(topic)[:20]
        # Create the top directory for the topic
        topic_directory = os.path.join(IMAGE_LOCATION, sanitized_topic).replace('\\', '/')
        os.makedirs(topic_directory, exist_ok=True)

        # Create subdirectories for both original and post images
        original_image_directory = os.path.join(topic_directory, "Original_Image").replace('\\', '/')
        post_images_directory = os.path.join(topic_directory, "Post_Images").replace('\\', '/')

        os.makedirs(original_image_directory, exist_ok=True)
        os.makedirs(post_images_directory, exist_ok=True)

        return original_image_directory, post_images_directory
    
    def overlay_text_on_image2(self, image_location, text, font_path=FONT, font_size=80, line_width=20):
        if not os.path.exists(image_location):
            raise FileNotFoundError(f"Image file not found at {image_location}")

        img = Image.open(image_location)
        draw = ImageDraw.Draw(img)
        font = ImageFont.truetype(font_path, font_size)
        shadow_offset = 2

        # Function to calculate the height of a single line of text
        def get_text_height(text_line):
            return font.getbbox(text_line)[3] - font.getbbox(text_line)[1]

        # Wrap text
        lines = textwrap.wrap(text, width=line_width)

        # Calculate text height
        text_height = sum([get_text_height(line) for line in lines])

        # Check if text height is too tall for the image, and reduce line width if necessary
        while text_height > img.height and line_width > 10:
            line_width -= 1
            lines = textwrap.wrap(text, width=line_width)
            text_height = sum([get_text_height(line) for line in lines])

        y = (img.height - text_height) / 2
        for line in lines:
            text_width = font.getlength(line)
            x = (img.width - text_width) / 2

            # Draw shadow or outline first
            draw.text((x + shadow_offset, y + shadow_offset), line, font=font, fill=(0, 0, 0))  # Black shadow
            # Draw main text
            draw.text((x, y), line, font=font, fill=(255, 255, 255))  # White text
            y += get_text_height(line)

        return img
    
    def save_image(self, image_input, image_folder, topic):
        image_name = self.generate_image_name(topic)
        image_path = os.path.join(image_folder, image_name).replace('\\', '/')

        # Check if the input is a URL or an Image object
        if isinstance(image_input, str):
            # Assuming it's a URL, download and save the image
            response = requests.get(image_input)
            if response.status_code == 200:
                image = Image.open(BytesIO(response.content))
            else:
                print(f"Failed to download image from {image_input}")
                return None
        elif isinstance(image_input, Image.Image):
            # If it's an Image object, use it directly
            image = image_input
        else:
            raise ValueError("Invalid image input type.")

        image.save(image_path)
        print(f"Image saved at {image_path}")
        return image_path
        
    def sanitize_topic_name(self, topic):
        # Replace spaces with underscores and remove special characters
        sanitized_name = ''.join(e for e in topic if e.isalnum() or e == ' ').replace(' ', '_')
        return sanitized_name

    def generate_image_name(self, topic):
        # Generate a unique image name using the topic and current time
        sanitized_topic = self.sanitize_topic_name(topic)
        timestamp = int(time.time())
        return f"{sanitized_topic}_{timestamp}.jpg"

    def _generate_title(self, topic):
        prompt = f"""Write me an interesting title for the {topic} in the form: ["title"]"""
        response = self.post.ask_gpt(prompt)
        try:
            # Removing brackets and quotes, and trimming whitespace
            cleaned_response = response.replace('[', '').replace(']', '').replace("'", "").replace('"', '').strip()
            # Splitting the string into a list based on commas
            title_list = cleaned_response.split(',')
            # Get the first item in the list as the category, or default to "Uncategorized"
            title = title_list[0].strip() if title_list else "No Title"
            return title
        except Exception as e:
            print(f"An error occurred: {e}")
            # Handle the error appropriately
            return "No Title"
        
    def _clean_post(self, post):
        # Add your cleaning logic here
        cleaned_post = post  # Replace this with actual cleaning operations
        return cleaned_post


class ProcessPosts:
    def __init__(self):
        self.topic_ai = OpenAIAssistant()
    
    def generate_topc(self, n_topics=1):
        topics = []
        for _ in range(n_topics):
            response = self.topic_ai.ask_gpt(self._topic_prompt())
            response_dict, error = utils.parse_json_string(utils.clean_response_string(response))

            if error:
                # Handle the error appropriately
                continue
            topics.append(response_dict)
            utils.append_data_to_excel(pd.DataFrame(response_dict), POSTS)
        return topics 
       

    def process_post(self):
        workbook, worksheet = utils.load_or_initialize_workbook(DATABASE_LOCATION + POSTS, ["Topic"])
        database_workbook, database_worksheet = utils.load_or_initialize_workbook(DATABASE_LOCATION + POST_DATABASE, ["Topic"])

        topics = utils.read_worksheet(worksheet)
        database_topics = utils.read_worksheet(database_worksheet)
        print(f"Topics: {topics}")
        print(f"Database Topics: {database_topics}")

        matching_topics = set(topics).intersection(database_topics)
        print(f"Matching set: {matching_topics}")
        utils.delete_matching_rows(worksheet, matching_topics)
        utils.save_workbook(workbook, DATABASE_LOCATION + POSTS)

        # Define delimiters for splitting topics
        delimiters = ["?"]

        # Process only the first topic
        topic_data = next(utils.iterate_rows(worksheet, ["Topic"]), None)
        if topic_data:
            original_topic = topic_data["Topic"]
            topic_list = []

            # Split the topic by defined delimiters
            split_topics = re.split('|'.join(map(re.escape, delimiters)), original_topic)

            for topic_page in split_topics:
                topic_page = topic_page.strip()  # Remove leading/trailing whitespace
                if topic_page and topic_page not in matching_topics:
                    topic_list.append(topic_page)

            if topic_list:
                # Generate and process post for the first topic
                self._generate_and_process_post(topic_list, original_topic, database_worksheet,database_workbook, worksheet,workbook)

        utils.save_workbook(database_workbook, DATABASE_LOCATION + POST_DATABASE)


    def _topic_prompt(self):
        return("""
            create a nested dictionary of interesting topics for POSTS, 
            keywords for images to represent that post, and a 
            category for that post in the format shown below:
            topic_dict = {
                "topic1": {
                    "Topic": "interesting topic",
                    "Image Search": [keyword1, keyword2, keyword3],
                    "Category": "website category"
                },
                "topic2": {
                    "Topic": "interesting topic",
                    "Image Search": [keyword1, keyword2, keyword3],
                    "Category": "website category"
                },
                "topic3": {
                    "Topic": "interesting topic",
                    "Image Search": [keyword1, keyword2, keyword3],
                    "Category": "website category"
                }
            }
            please don't write anything else but the dictionary
            """)

    def _generate_and_process_post(self, topic_list, topic, database_worksheet, database_workbook, worksheet, workbook):
        post_generator = Generatepost()
        PostID = post_generator.generate_post(topic_list, topic)
        if PostID:
            # Append the topic to the database worksheet
            database_worksheet.append([topic])
            print(f"Post for topic '{topic}' has been generated and posted with ID {PostID}.")

            # Save changes to the database workbook
            utils.save_workbook(database_workbook, DATABASE_LOCATION + POST_DATABASE)

            # Delete the row from the posttopics worksheet that was used to generate the topic and save changes
            utils.delete_topic_row(worksheet, topic)
            utils.save_workbook(workbook, DATABASE_LOCATION + POSTS)