core/visual_engine.py

# core/visual_engine.py
from PIL import Image, ImageDraw, ImageFont # Pillow should be >= 10.0.0
from moviepy.editor import (ImageClip, concatenate_videoclips, TextClip, 
                            CompositeVideoClip)
import moviepy.video.fx.all as vfx # For effects like resize, fadein, fadeout
import numpy as np
import os
import openai
import requests
import io

class VisualEngine:
    def __init__(self, output_dir="temp_generated_media"):
        self.output_dir = output_dir
        os.makedirs(self.output_dir, exist_ok=True)
        
        self.font_filename = "arial.ttf" 
        self.font_path_in_container = f"/usr/local/share/fonts/truetype/mycustomfonts/{self.font_filename}"
        self.font_size_pil = 24 
        self.video_overlay_font_size = 36 
        self.video_overlay_font_color = 'white'
        # For video overlays, TextClip will use ImageMagick. 'Arial' is a common system font name.
        # If issues, use self.font_path_in_container (if ImageMagick can access it via moviepy)
        self.video_overlay_font = 'Arial' 

        try:
            self.font = ImageFont.truetype(self.font_path_in_container, self.font_size_pil)
            print(f"Successfully loaded font: {self.font_path_in_container} for placeholders.")
        except IOError:
            print(f"Warning: Could not load font from '{self.font_path_in_container}'. Placeholders will use default font.")
            self.font = ImageFont.load_default()
            self.font_size_pil = 11

        self.openai_api_key = None
        self.USE_AI_IMAGE_GENERATION = False
        self.dalle_model = "dall-e-3" 
        self.image_size = "1024x1024" # DALL-E 3 output size
        # Target video frame size (e.g., 16:9 aspect ratio)
        # DALL-E 3 images (1024x1024) will be letter/pillar-boxed to fit this.
        self.video_frame_size = (1280, 720) 

    def set_openai_api_key(self, api_key):
        if api_key:
            self.openai_api_key = api_key
            self.USE_AI_IMAGE_GENERATION = True
            print("OpenAI API key set. AI Image Generation Enabled with DALL-E.")
        else:
            self.USE_AI_IMAGE_GENERATION = False
            print("OpenAI API key not provided. AI Image Generation Disabled. Using placeholders.")

    def _get_text_dimensions(self, text_content, font_obj):
        if text_content == "" or text_content is None:
            return 0, self.font_size_pil 
        try:
            if hasattr(font_obj, 'getbbox'): # Pillow >= 8.0.0
                bbox = font_obj.getbbox(text_content)
                width = bbox[2] - bbox[0]
                height = bbox[3] - bbox[1]
                return width, height if height > 0 else self.font_size_pil
            elif hasattr(font_obj, 'getsize'): # Older Pillow
                width, height = font_obj.getsize(text_content)
                return width, height if height > 0 else self.font_size_pil
            else: 
                avg_char_width = self.font_size_pil * 0.6 
                height_estimate = self.font_size_pil * 1.2
                return int(len(text_content) * avg_char_width), int(height_estimate if height_estimate > 0 else self.font_size_pil)
        except Exception as e:
            print(f"Warning: Error getting text dimensions for '{text_content}': {e}. Using estimates.")
            avg_char_width = self.font_size_pil * 0.6
            height_estimate = self.font_size_pil * 1.2
            return int(len(text_content) * avg_char_width), int(height_estimate if height_estimate > 0 else self.font_size_pil)

    def _create_placeholder_image_content(self, text_description, filename, size=(1024, 576)): # Default placeholder size
        img = Image.new('RGB', size, color=(30, 30, 60))
        draw = ImageDraw.Draw(img)
        padding = 30 
        max_text_width = size[0] - (2 * padding)
        lines = []
        if not text_description: text_description = "(No description provided for placeholder)"
        words = text_description.split()
        current_line = ""
        for word in words:
            test_line_candidate = current_line + word + " "
            line_width, _ = self._get_text_dimensions(test_line_candidate.strip(), self.font)
            if line_width <= max_text_width and current_line != "": current_line = test_line_candidate
            elif line_width <= max_text_width and current_line == "": current_line = test_line_candidate
            elif current_line != "":
                lines.append(current_line.strip())
                current_line = word + " "
            else:
                temp_word = word
                while self._get_text_dimensions(temp_word, self.font)[0] > max_text_width and len(temp_word) > 0: temp_word = temp_word[:-1]
                lines.append(temp_word)
                current_line = ""
        if current_line.strip(): lines.append(current_line.strip())
        if not lines: lines.append("(Text error in placeholder)")
        _, single_line_height = self._get_text_dimensions("Tg", self.font)
        if single_line_height == 0: single_line_height = self.font_size_pil 
        line_spacing_factor = 1.3
        estimated_line_block_height = len(lines) * single_line_height * line_spacing_factor
        y_text = (size[1] - estimated_line_block_height) / 2.0
        if y_text < padding: y_text = float(padding)
        for line_idx, line in enumerate(lines):
            if line_idx >= 7 and len(lines) > 8: 
                draw.text(xy=(float(padding), y_text), text="...", fill=(200, 200, 130), font=self.font)
                break
            line_width, _ = self._get_text_dimensions(line, self.font)
            x_text = (size[0] - line_width) / 2.0
            if x_text < padding: x_text = float(padding)
            draw.text(xy=(x_text, y_text), text=line, fill=(220, 220, 150), font=self.font)
            y_text += single_line_height * line_spacing_factor
        filepath = os.path.join(self.output_dir, filename)
        try:
            img.save(filepath)
        except Exception as e:
            print(f"Error saving placeholder image {filepath}: {e}")
            return None
        return filepath

    def generate_image_visual(self, image_prompt_text, scene_identifier_filename):
        filepath = os.path.join(self.output_dir, scene_identifier_filename)
        if self.USE_AI_IMAGE_GENERATION and self.openai_api_key:
            try:
                print(f"Generating DALL-E ({self.dalle_model}) image for: {image_prompt_text[:100]}...")
                client = openai.OpenAI(api_key=self.openai_api_key)
                response = client.images.generate(
                    model=self.dalle_model, prompt=image_prompt_text, n=1,
                    size=self.image_size, quality="standard", response_format="url" 
                    # style="vivid" # or "natural" for DALL-E 3, optional
                )
                image_url = response.data[0].url
                revised_prompt_dalle3 = getattr(response.data[0], 'revised_prompt', None) # Safely access
                if revised_prompt_dalle3: print(f"DALL-E 3 revised prompt: {revised_prompt_dalle3[:150]}...")
                
                image_response = requests.get(image_url, timeout=60)
                image_response.raise_for_status()
                
                img_data = Image.open(io.BytesIO(image_response.content))
                if img_data.mode == 'RGBA': # Ensure RGB for consistency, PNG can be RGBA
                    img_data = img_data.convert('RGB')
                
                # Save the AI generated image (typically 1024x1024 from DALL-E)
                img_data.save(filepath) 
                print(f"AI Image (DALL-E) saved: {filepath}")
                return filepath
            except openai.APIError as e: 
                print(f"OpenAI API Error: {e}")
            except requests.exceptions.RequestException as e:
                print(f"Requests Error downloading DALL-E image: {e}")
            except Exception as e:
                print(f"Generic error during DALL-E image generation: {e}")
            
            print("Falling back to placeholder image due to DALL-E error.")
            # Fallback uses video_frame_size to match what video expects if AI fails
            return self._create_placeholder_image_content(
                f"[DALL-E Failed] Prompt: {image_prompt_text[:150]}...", 
                scene_identifier_filename, size=self.video_frame_size
            )
        else: # AI not enabled or key missing
            # print(f"AI image generation not enabled/ready. Creating placeholder.")
            # Placeholder also uses video_frame_size for consistency in video pipeline
            return self._create_placeholder_image_content(
                image_prompt_text, scene_identifier_filename, size=self.video_frame_size
            )

    def create_video_from_images(self, image_data_list, output_filename="final_video.mp4", fps=24, duration_per_image=3):
        if not image_data_list:
            print("No image data provided to create video.")
            return None
        
        print(f"Attempting to create video from {len(image_data_list)} images.")
        processed_clips = []

        for i, data in enumerate(image_data_list):
            img_path = data.get('path')
            scene_num = data.get('scene_num', i + 1)
            key_action = data.get('key_action', '')

            if not (img_path and os.path.exists(img_path)):
                print(f"Image path invalid or not found: {img_path}. Skipping for video.")
                continue
            try:
                pil_image_original = Image.open(img_path)
                
                if pil_image_original.mode != 'RGB': # Ensure RGB for video
                    pil_image_original = pil_image_original.convert('RGB')

                # Create a copy to resize (thumbnail modifies in-place)
                pil_image_for_frame = pil_image_original.copy()
                # Resize image to fit within self.video_frame_size, maintaining aspect ratio
                pil_image_for_frame.thumbnail(self.video_frame_size, Image.Resampling.LANCZOS)

                # Create a background canvas of the exact video_frame_size (e.g., 1280x720)
                # This will letterbox/pillarbox the image if its aspect ratio differs from video_frame_size
                background_canvas = Image.new('RGB', self.video_frame_size, (0,0,0)) # Black background
                paste_x = (self.video_frame_size[0] - pil_image_for_frame.width) // 2
                paste_y = (self.video_frame_size[1] - pil_image_for_frame.height) // 2
                background_canvas.paste(pil_image_for_frame, (paste_x, paste_y))
                
                frame_np = np.array(background_canvas) # Convert final PIL image to numpy array
                
                # Base image clip
                img_clip = ImageClip(frame_np).set_duration(duration_per_image)

                # Ken Burns Effect (Simple Zoom In)
                end_scale = 1.08 # Zoom to 108% of original size by the end
                img_clip = img_clip.fx(vfx.resize, lambda t: 1 + (end_scale - 1) * (t / duration_per_image))
                img_clip = img_clip.set_position('center') # Keep centered during zoom

                # Text Overlay
                overlay_text = f"Scene {scene_num}: {key_action}"
                # Ensure font path is used if 'Arial' isn't found by ImageMagick/MoviePy
                # For TextClip, moviepy relies on ImageMagick which has its own font discovery.
                # Using a common font name like 'Arial' is often okay if mscorefonts are installed.
                # If not, you might need to point to self.font_path_in_container
                # Check if ImageMagick is installed in Docker, moviepy might need it for TextClip.
                # `apt-get install imagemagick` in Dockerfile if TextClip has issues.
                txt_clip = TextClip(
                    overlay_text, 
                    fontsize=self.video_overlay_font_size, 
                    color=self.video_overlay_font_color,
                    font=self.video_overlay_font, # Or self.font_path_in_container
                    bg_color='rgba(0,0,0,0.6)', 
                    size=(self.video_frame_size[0] * 0.9, None), # Width 90% of video, height auto
                    method='caption', 
                    align='West',
                    kerning=-1 
                ).set_duration(duration_per_image - 0.5).set_start(0.25) # Start after 0.25s, end 0.25s before clip end
                
                txt_clip = txt_clip.set_position(('center', 0.88), relative=True) # Position near bottom

                video_with_text_overlay = CompositeVideoClip([img_clip, txt_clip], size=self.video_frame_size)
                processed_clips.append(video_with_text_overlay)

            except Exception as e_clip:
                print(f"Error processing image/creating clip for {img_path}: {e_clip}. Skipping.")
        
        if not processed_clips:
            print("No clips could be processed for the video.")
            return None
            
        # Concatenate with crossfade (0.5s)
        final_video_clip = concatenate_videoclips(processed_clips, padding=-0.5, method="compose")
        # Add fade in/out for the whole video
        if final_video_clip.duration > 1: # Ensure video is long enough for fades
            final_video_clip = final_video_clip.fx(vfx.fadein, 0.5).fx(vfx.fadeout, 0.5)

        output_path = os.path.join(self.output_dir, output_filename)
        print(f"Writing final video to: {output_path}")
        try:
            final_video_clip.write_videofile(
                output_path, fps=fps, codec='libx264', audio_codec='aac',
                temp_audiofile=os.path.join(self.output_dir, f'temp-audio-{os.urandom(4).hex()}.m4a'), 
                remove_temp=True, threads=os.cpu_count() or 2, logger='bar'
            )
            print(f"Video successfully created: {output_path}")
            return output_path
        except Exception as e:
            print(f"Error writing final video file: {e}")
            return None
        finally: 
            for clip_item in processed_clips: 
                if hasattr(clip_item, 'close'): clip_item.close()
            if hasattr(final_video_clip, 'close'): final_video_clip.close()