AI Video 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, VIDEO_LOCATION
import os
import time
import textwrap
from instagram import Instagram
from youtube import YouTubeShortsUploader
from video_handling import VideoCreator
class Generatepost:

    def __init__(self):
        self.post = OpenAIAssistant()
        self.images = Images(self.post)
        self.videos =VideoCreator()
        self.wppost = wordPress()
        self.IGPost = Instagram()
        self.youtube = YouTubeShortsUploader()
        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 one short image description for Dalle to generate a relevent and beautiful 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_reel_script(self, topic):
            scriptAI = OpenAIAssistant()
            prompt = f"Provide an inspiring and factual 30-50 word speech on the topic, '{topic}'. Your response should be surrounded by brackets in python list format such as: [this is text for short inspirational speech]."
            response = scriptAI.ask_gpt(prompt)            
            try:
                # Removing brackets and quotes, and trimming whitespace
                cleaned_response = response.replace('[', '').replace(']', '').replace("'", "").replace('"', '').strip()
                print(cleaned_response)
                return cleaned_response
            except Exception as e:
                print(f"Could not generate script: {e}")
                # Handle the error appropriately
                return "Follow us @NeuralNetNews for more content like this!"

    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 more 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,content_type='image')
            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(page_item)
                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 generate_video_post(self, topic):
            original_image_directory, post_videos_directory = self.create_folders(topic, content_type='video')
        
            # Generate an image description
            image_description = self.generate_post_img_desc(topic)
            image_url = self.post.generate_image(image_description, size = "1024x1792")

            # Save the original image
            original_image = self.save_image(image_url, original_image_directory, topic)

            # Generate a script for the reel
            script = self.generate_reel_script(topic)

            # Create and save the video
            output_video_path=os.path.join(post_videos_directory, self.generate_video_name(topic))
            output_video_path=self.videos.create_zooming_video_with_subtitles(image_path=original_image, script=script, output_video_path=output_video_path)

            # Generate a caption for the post
            caption = self.generate_caption(topic)
            reel_id = self.IGPost.post_to_instagram(output_video_path, topic, caption, media_type='REELS')
            short_id = self.youtube.upload_video(output_video_path,topic, caption, "24", ["AI", "Education"])
            #short_id = 1234

            # Here you can add logic to post the video to a platform or store it
            # For example, post to Instagram, save to a database, etc.

            return reel_id, short_id  # or other relevant information

    def create_folders(self, topic, content_type='image'):
        # Choose the base location depending on content type
        base_location = VIDEO_LOCATION if content_type == 'video' else IMAGE_LOCATION

        # 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(base_location, sanitized_topic).replace('\\', '/')
        os.makedirs(topic_directory, exist_ok=True)

        # Create subdirectories based on content type
        if content_type == 'video':
            original_image_directory = os.path.join(topic_directory, "Original_Image").replace('\\', '/')            
            post_videos_directory = os.path.join(topic_directory, "Post_Videos").replace('\\', '/')
            os.makedirs(original_image_directory, exist_ok=True)            
            os.makedirs(post_videos_directory, exist_ok=True)
            return original_image_directory,post_videos_directory
    
        else:
            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 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(' ', '_')

        # Limit the sanitized name to a maximum of 15 characters
        max_length = 15
        truncated_name = sanitized_name[:max_length]

        return truncated_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_video_name(self, topic):
        # Generate a unique video name using the topic and current time
        sanitized_topic = self.sanitize_topic_name(topic)
        timestamp = int(time.time())
        return f"{sanitized_topic}_{timestamp}.mp4"

        
    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)

        matching_topics = set(topics).intersection(database_topics)
        utils.delete_matching_rows(worksheet, matching_topics)
        utils.save_workbook(workbook, DATABASE_LOCATION + POSTS)

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

        for row in utils.iterate_rows(worksheet, ["Topic", "Type"]):
            topic = row["Topic"].strip()
            post_type = row["Type"].strip().lower()

            if topic and topic not in matching_topics:
                if post_type == "image":
                    # Split topic by delimiters and create a list
                    topic_list = [t.strip() for d in delimiters for t in topic.split(d) if t.strip()]
                    print(topic_list)
                    self._generate_and_process_image_post(topic_list, topic, database_worksheet, database_workbook, worksheet, workbook, post_type)
                elif post_type == "video":
                    self._generate_and_process_video_post(topic, database_worksheet, database_workbook, worksheet, workbook, post_type)

        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_image_post(self, topic_list, topic, database_worksheet, database_workbook, worksheet, workbook, post_type):
        Image_generator = Generatepost()
        PostID = Image_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)
            
    def _generate_and_process_video_post(self, topic, database_worksheet, database_workbook, worksheet, workbook, post_type):
        Video_generator = Generatepost()
        ReelID,ShortID = Video_generator.generate_video_post(topic)
        if ReelID:
            # Append the topic to the database worksheet
            database_worksheet.append([topic])
            print(f"Video for topic '{topic}' has been generated and posted with ID {ReelID}.")

            # 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)