Update app.py

app.py

@@ -8,7 +8,11 @@ import asyncio
 from concurrent.futures import ThreadPoolExecutor
 from typing import List, Optional, Tuple
 
+# Attempt to load environment variables from .env file for local testing
+# In Hugging Face, secrets are injected directly as environment variables
 from dotenv import load_dotenv
+load_dotenv() # Load .env file if it exists
+
 from PIL import Image, ImageDraw, ImageFont, ImageOps, ImageFilter, ImageEnhance, UnidentifiedImageError
 import numpy as np
 from telegram import Update, InputFile
@@ -18,12 +22,12 @@ from telegram.error import TelegramError
 
 # --- Configuration ---
 class Config:
-    # Load environment variables - essential for Hugging Face secrets
-    load_dotenv()
+    # Read Telegram token from environment variable (set in HF Secrets)
     TELEGRAM_TOKEN = os.getenv('TELEGRAM_TOKEN')
     if not TELEGRAM_TOKEN:
-        # Use logger here if already configured, otherwise print/raise
-        # logger.critical("TELEGRAM_TOKEN environment variable not set!")
+        # Log critical error if token is missing
+        logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+        logging.critical("TELEGRAM_TOKEN environment variable not set! Please set it in Hugging Face Space secrets.")
         raise ValueError("TELEGRAM_TOKEN environment variable not set! Please set it in Hugging Face Space secrets.")
 
     # Directories (relative paths for container compatibility)
@@ -33,7 +37,6 @@ class Config:
     FONT_PATH = "arial.ttf"
 
     # Predefined Template Settings
-    # Assuming templates are e.g., 1200x900 and have a space for the user image
     TEMPLATE_SIZE = (1200, 900) # Expected size of predefined template canvas
     PLACEHOLDER_SIZE = (700, 500)  # Size to fit user image into within the template
     PLACEHOLDER_POSITION = (50, 50) # Top-left corner to paste user image in template
@@ -56,24 +59,29 @@ logging.basicConfig(
     level=logging.INFO,
     format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
 )
-# Reduce verbosity of httpx logger used by python-telegram-bot
+# Reduce verbosity of underlying HTTP library logger used by python-telegram-bot
 logging.getLogger("httpx").setLevel(logging.WARNING)
 logger = logging.getLogger(__name__)
 
 # --- Setup ---
 # Ensure necessary directories exist within the container's filesystem
+# This runs when the script starts inside the container
 try:
+    # These paths are relative to the WORKDIR /app set in the Dockerfile
     os.makedirs(Config.PREDEFINED_TEMPLATES_DIR, exist_ok=True)
     os.makedirs(Config.OUTPUT_DIR, exist_ok=True)
     logger.info(f"Ensured directories exist: {Config.PREDEFINED_TEMPLATES_DIR}, {Config.OUTPUT_DIR}")
 except OSError as e:
-    logger.error(f"Error creating directories: {e}", exc_info=True)
-    # Depending on the error, you might want to exit or handle differently
+    logger.error(f"FATAL: Error creating essential directories: {e}", exc_info=True)
+    # If directories cannot be created, the app likely cannot function
+    raise SystemExit(f"FATAL: Cannot create directories {Config.PREDEFINED_TEMPLATES_DIR} or {Config.OUTPUT_DIR}") from e
 
-# Check for font file availability
+# Check for font file availability after setup
+# FONT_PATH is relative to WORKDIR /app
 if not os.path.exists(Config.FONT_PATH):
-    logger.warning(f"Font file not found at '{Config.FONT_PATH}'. Text rendering might use default system font or fail if Pillow cannot find a fallback.")
-    # Pillow might find system fonts installed by Dockerfile's `apt-get install fontconfig ttf-mscorefonts-installer`
+    logger.warning(f"Font file specified in Config ('{Config.FONT_PATH}') not found in the container's /app directory. Text rendering might use a system default font if available via fontconfig (installed via Dockerfile), or fail if Pillow finds no fallback.")
+else:
+    logger.info(f"Font file '{Config.FONT_PATH}' found.")
 
 # --- Helper Functions ---
 def add_noise_to_image(img: Image.Image, intensity: float = 0.02) -> Image.Image:
@@ -108,13 +116,15 @@ def apply_template(user_image_path: str, caption: str, template_path: str) -> Op
     Returns:
         Path to the generated image (in OUTPUT_DIR), or None if an error occurred.
     """
-    # Generate a unique-ish output filename
+    # Generate a unique-ish output filename to avoid conflicts
     base_name = os.path.basename(template_path).split('.')[0]
-    output_filename = f"result_{base_name}_{random.randint(1000, 9999)}.jpg"
+    # Include a random element to prevent overwriting if called rapidly
+    output_filename = f"result_{base_name}_{random.randint(10000, 99999)}.jpg"
     output_path = os.path.join(Config.OUTPUT_DIR, output_filename)
+    logger.debug(f"Applying template '{os.path.basename(template_path)}' to user image '{os.path.basename(user_image_path)}'. Output: {output_path}")
 
     try:
-        # Use 'with' statement for automatic resource cleanup
+        # Use 'with' statement for automatic resource cleanup (file closing)
         with Image.open(template_path).convert("RGBA") as template, \
              Image.open(user_image_path).convert("RGBA") as user_image_orig:
 
@@ -123,6 +133,7 @@ def apply_template(user_image_path: str, caption: str, template_path: str) -> Op
                  logger.warning(f"Template {os.path.basename(template_path)} size {template.size} differs from expected {Config.TEMPLATE_SIZE}. Results may vary.")
 
             # Resize user image to fit the placeholder area using Lanczos resampling for quality
+            logger.debug(f"Resizing user image to placeholder size {Config.PLACEHOLDER_SIZE}")
             user_image_resized = ImageOps.fit(user_image_orig, Config.PLACEHOLDER_SIZE, Image.Resampling.LANCZOS)
 
             # Create a working copy of the template to paste onto
@@ -130,29 +141,35 @@ def apply_template(user_image_path: str, caption: str, template_path: str) -> Op
 
             # Paste the resized user image into the placeholder position
             # The third argument (mask) uses the alpha channel of the user image for smooth edges if it has transparency
+            logger.debug(f"Pasting resized user image at {Config.PLACEHOLDER_POSITION}")
             combined.paste(user_image_resized, Config.PLACEHOLDER_POSITION, user_image_resized if user_image_resized.mode == 'RGBA' else None)
 
             # --- Add Caption ---
+            logger.debug("Adding caption to template image")
             draw = ImageDraw.Draw(combined)
             try:
                 # Use a medium font size relative to config
                 font_size = Config.MAX_FONT_SIZE // 2
+                logger.debug(f"Loading font '{Config.FONT_PATH}' with size {font_size}")
                 font = ImageFont.truetype(Config.FONT_PATH, font_size)
             except IOError:
-                logger.warning(f"Failed to load font: {Config.FONT_PATH}. Using Pillow's default.")
+                logger.warning(f"Failed to load font '{Config.FONT_PATH}'. Using Pillow's default.")
                 font = ImageFont.load_default()
 
             # Wrap text according to configured width
             wrapped_text = textwrap.fill(caption, width=Config.MAX_CAPTION_WIDTH)
+            logger.debug(f"Wrapped caption text: \"{wrapped_text[:50]}...\"")
 
             # Calculate text position (e.g., centered below the placeholder area)
+            # Use textbbox for more accurate positioning
             text_bbox = draw.textbbox((0, 0), wrapped_text, font=font, align="center")
             text_width = text_bbox[2] - text_bbox[0]
             text_height = text_bbox[3] - text_bbox[1]
             # Center horizontally
             text_x = (combined.width - text_width) // 2
             # Position below placeholder, add some padding
-            text_y = Config.PLACEHOLDER_POSITION[1] + Config.PLACEHOLDER_SIZE[1] + 20
+            text_y = Config.PLACEHOLDER_POSITION[1] + Config.PLACEHOLDER_SIZE[1] + 20 # Adjust padding as needed
+            logger.debug(f"Calculated text position: ({text_x}, {text_y})")
 
             # Draw text with a simple shadow/stroke for better visibility
             # Draw shadow slightly offset
@@ -162,16 +179,19 @@ def apply_template(user_image_path: str, caption: str, template_path: str) -> Op
             draw.text((text_x, text_y), wrapped_text, font=font, fill="white", align="center")
 
             # Convert to RGB before saving as JPG (removes alpha channel)
+            logger.debug("Converting final image to RGB")
             combined_rgb = combined.convert("RGB")
+            logger.debug(f"Saving final image to {output_path} with quality {Config.JPEG_QUALITY}")
             combined_rgb.save(output_path, "JPEG", quality=Config.JPEG_QUALITY)
             logger.info(f"Generated image using template '{os.path.basename(template_path)}': {output_path}")
             return output_path
 
     except FileNotFoundError:
-        logger.error(f"Template or user image not found. Template: {template_path}, User Image: {user_image_path}")
+        logger.error(f"Template or user image not found. Template: '{template_path}', User Image: '{user_image_path}'")
     except UnidentifiedImageError:
-        logger.error(f"Could not identify image file (corrupted or unsupported format?). Template: {template_path}, User Image: {user_image_path}")
+        logger.error(f"Could not identify image file (corrupted or unsupported format?). Template: '{template_path}', User Image: '{user_image_path}'")
     except Exception as e:
+        # Log detailed error including traceback
         logger.error(f"Error applying template '{os.path.basename(template_path)}': {e}", exc_info=True)
 
     # Explicitly return None on any error during the process
@@ -190,13 +210,15 @@ def create_auto_template(user_image_path: str, caption: str, variant: int) -> Op
     Returns:
         Path to the generated image (in OUTPUT_DIR), or None if an error occurred.
     """
-    output_filename = f"auto_template_{variant}_{random.randint(1000, 9999)}.jpg"
+    output_filename = f"auto_template_{variant}_{random.randint(10000, 99999)}.jpg"
     output_path = os.path.join(Config.OUTPUT_DIR, output_filename)
+    logger.debug(f"Creating auto template variant {variant}. Output: {output_path}")
 
     try:
         # --- Create Background ---
         # Generate a random somewhat dark color for the background
         bg_color = (random.randint(0, 150), random.randint(0, 150), random.randint(0, 150))
+        logger.debug(f"Auto template {variant}: Background color {bg_color}")
         bg = Image.new('RGB', Config.AUTO_TEMPLATE_SIZE, color=bg_color)
 
         # --- Process User Image ---
@@ -204,47 +226,65 @@ def create_auto_template(user_image_path: str, caption: str, variant: int) -> Op
             # Work on a copy
             user_img = user_img_orig.copy()
             # Resize to fit the designated area within the auto-template
+            logger.debug(f"Auto template {variant}: Resizing user image to {Config.AUTO_USER_IMAGE_SIZE}")
             user_img = ImageOps.fit(user_img, Config.AUTO_USER_IMAGE_SIZE, Image.Resampling.LANCZOS)
 
-            # Apply random effects based on the variant index
-            effect_choice = random.choice(['blur', 'noise', 'color', 'contrast', 'none']) # Add more variety
-            logger.debug(f"Auto template variant {variant}: Applying effect '{effect_choice}'")
+            # Apply random effects based on a random choice (not just variant index)
+            effect_choice = random.choice(['blur', 'noise', 'color', 'contrast', 'sharpness', 'none'])
+            logger.debug(f"Auto template {variant}: Applying effect '{effect_choice}'")
 
             if effect_choice == 'blur':
-                user_img = user_img.filter(ImageFilter.GaussianBlur(random.uniform(0.5, 1.5)))
+                blur_radius = random.uniform(0.5, 1.8)
+                logger.debug(f"Applying GaussianBlur with radius {blur_radius:.2f}")
+                user_img = user_img.filter(ImageFilter.GaussianBlur(blur_radius))
             elif effect_choice == 'noise':
+                logger.debug(f"Applying noise with intensity {Config.NOISE_INTENSITY:.2f}")
                 user_img = add_noise_to_image(user_img, Config.NOISE_INTENSITY)
             elif effect_choice == 'color': # Enhance or reduce color saturation
+                color_factor = random.uniform(0.3, 1.7)
+                logger.debug(f"Enhancing color with factor {color_factor:.2f}")
                 enhancer = ImageEnhance.Color(user_img)
-                user_img = enhancer.enhance(random.uniform(0.3, 1.7))
+                user_img = enhancer.enhance(color_factor)
             elif effect_choice == 'contrast': # Enhance or reduce contrast
+                contrast_factor = random.uniform(0.7, 1.4)
+                logger.debug(f"Enhancing contrast with factor {contrast_factor:.2f}")
                 enhancer = ImageEnhance.Contrast(user_img)
-                user_img = enhancer.enhance(random.uniform(0.7, 1.3))
+                user_img = enhancer.enhance(contrast_factor)
+            elif effect_choice == 'sharpness': # Enhance sharpness
+                sharpness_factor = random.uniform(1.1, 2.0)
+                logger.debug(f"Enhancing sharpness with factor {sharpness_factor:.2f}")
+                enhancer = ImageEnhance.Sharpness(user_img)
+                user_img = enhancer.enhance(sharpness_factor)
             # 'none' applies no extra filter
 
             # Add a decorative border with a random light color
             border_color = (random.randint(180, 255), random.randint(180, 255), random.randint(180, 255))
             border_width = random.randint(8, 20)
+            logger.debug(f"Adding border width {border_width} color {border_color}")
             user_img = ImageOps.expand(user_img, border=border_width, fill=border_color)
 
         # --- Paste User Image onto Background ---
         # Calculate position to center the (bordered) user image horizontally, and place it in the upper part vertically
         paste_x = (bg.width - user_img.width) // 2
         paste_y = (bg.height - user_img.height) // 3 # Position slightly above vertical center
+        logger.debug(f"Pasting processed user image at ({paste_x}, {paste_y})")
         bg.paste(user_img, (paste_x, paste_y))
 
         # --- Add Styled Text ---
+        logger.debug("Adding caption to auto template")
         draw = ImageDraw.Draw(bg)
         try:
             # Random font size within configured range
             font_size = random.randint(Config.MIN_FONT_SIZE, Config.MAX_FONT_SIZE)
+            logger.debug(f"Loading font '{Config.FONT_PATH}' with size {font_size}")
             font = ImageFont.truetype(Config.FONT_PATH, font_size)
         except IOError:
-            logger.warning(f"Failed to load font: {Config.FONT_PATH}. Using Pillow's default.")
+            logger.warning(f"Failed to load font '{Config.FONT_PATH}'. Using Pillow's default.")
             font = ImageFont.load_default() # Fallback font
 
         # Wrap text
         wrapped_text = textwrap.fill(caption, width=Config.MAX_CAPTION_WIDTH)
+        logger.debug(f"Wrapped caption text: \"{wrapped_text[:50]}...\"")
 
         # Calculate text position (centered horizontally, below the pasted image)
         text_bbox = draw.textbbox((0, 0), wrapped_text, font=font, align="center")
@@ -253,24 +293,28 @@ def create_auto_template(user_image_path: str, caption: str, variant: int) -> Op
         text_x = (bg.width - text_width) // 2
         # Position below the image + border, add padding
         text_y = paste_y + user_img.height + 30
+        logger.debug(f"Calculated text position: ({text_x}, {text_y})")
+
 
         # Random bright text color and dark stroke color
         text_color = (random.randint(200, 255), random.randint(200, 255), random.randint(200, 255))
         stroke_color = (random.randint(0, 50), random.randint(0, 50), random.randint(0, 50))
+        logger.debug(f"Text color {text_color}, stroke color {stroke_color}")
 
         # Draw text with stroke
         draw.text((text_x, text_y), wrapped_text, font=font, fill=text_color,
                   stroke_width=Config.TEXT_STROKE_WIDTH, stroke_fill=stroke_color, align="center")
 
         # Save the final image
+        logger.debug(f"Saving final auto template image to {output_path} with quality {Config.JPEG_QUALITY}")
         bg.save(output_path, "JPEG", quality=Config.JPEG_QUALITY)
         logger.info(f"Generated auto-template image (variant {variant}): {output_path}")
         return output_path
 
     except FileNotFoundError:
-        logger.error(f"User image not found during auto-template creation: {user_image_path}")
+        logger.error(f"User image not found during auto-template creation: '{user_image_path}'")
     except UnidentifiedImageError:
-        logger.error(f"Could not identify user image file during auto-template creation: {user_image_path}")
+        logger.error(f"Could not identify user image file during auto-template creation: '{user_image_path}'")
     except Exception as e:
         logger.error(f"Error creating auto-template variant {variant}: {e}", exc_info=True)
 
@@ -280,19 +324,32 @@ def create_auto_template(user_image_path: str, caption: str, variant: int) -> Op
 def load_predefined_templates() -> List[str]:
     """Loads paths of all valid template images from the predefined directory."""
     templates = []
-    logger.debug(f"Searching for templates in: {os.path.abspath(Config.PREDEFINED_TEMPLATES_DIR)}")
+    template_dir = Config.PREDEFINED_TEMPLATES_DIR
+    logger.debug(f"Searching for templates in directory: {os.path.abspath(template_dir)}")
     try:
-        if not os.path.isdir(Config.PREDEFINED_TEMPLATES_DIR):
-            logger.warning(f"Predefined templates directory not found: {Config.PREDEFINED_TEMPLATES_DIR}")
-            return []
-        for file in os.listdir(Config.PREDEFINED_TEMPLATES_DIR):
+        if not os.path.isdir(template_dir):
+            logger.warning(f"Predefined templates directory not found: '{template_dir}'")
+            return [] # Return empty list if directory doesn't exist
+
+        files = os.listdir(template_dir)
+        logger.debug(f"Found {len(files)} files/dirs in template directory.")
+        for file in files:
             # Check for common image extensions
             if file.lower().endswith(('.png', '.jpg', '.jpeg')):
-                full_path = os.path.join(Config.PREDEFINED_TEMPLATES_DIR, file)
-                templates.append(full_path)
-        logger.info(f"Loaded {len(templates)} predefined templates.")
+                full_path = os.path.join(template_dir, file)
+                if os.path.isfile(full_path): # Ensure it's actually a file
+                    templates.append(full_path)
+                    logger.debug(f"Found template: {full_path}")
+                else:
+                     logger.warning(f"Found item with image extension but is not a file: {full_path}")
+
+        if not templates:
+            logger.warning(f"No valid template image files found in '{template_dir}'.")
+        else:
+             logger.info(f"Loaded {len(templates)} predefined templates.")
+
     except Exception as e:
-        logger.error(f"Error loading predefined templates from {Config.PREDEFINED_TEMPLATES_DIR}: {e}", exc_info=True)
+        logger.error(f"Error loading predefined templates from '{template_dir}': {e}", exc_info=True)
     return templates
 
 # This function orchestrates the image processing. It contains blocking Pillow calls,
@@ -309,6 +366,7 @@ def process_images(user_image_path: str, caption: str) -> List[str]:
     Returns:
         A list of paths to the generated images.
     """
+    logger.info("Starting image processing task...")
     generated_image_paths: List[str] = []
     predefined_templates = load_predefined_templates()
 
@@ -319,8 +377,10 @@ def process_images(user_image_path: str, caption: str) -> List[str]:
             result_path = apply_template(user_image_path, caption, template_path)
             if result_path:
                 generated_image_paths.append(result_path)
+            else:
+                 logger.warning(f"Failed to generate image for template: {os.path.basename(template_path)}")
     else:
-        logger.info("No predefined templates found or loaded.")
+        logger.info("Skipping predefined templates (none found or loaded).")
 
     # 2. Generate auto templates
     logger.info(f"Generating {Config.AUTO_TEMPLATES_COUNT} auto-templates...")
@@ -328,8 +388,11 @@ def process_images(user_image_path: str, caption: str) -> List[str]:
         result_path = create_auto_template(user_image_path, caption, i)
         if result_path:
             generated_image_paths.append(result_path)
+        else:
+             logger.warning(f"Failed to generate auto-template variant {i}")
 
-    logger.info(f"Finished processing. Generated {len(generated_image_paths)} images in total.")
+
+    logger.info(f"Image processing task finished. Generated {len(generated_image_paths)} images in total.")
     return generated_image_paths
 
 
@@ -339,56 +402,65 @@ async def handle_message(update: Update, context: ContextTypes.DEFAULT_TYPE):
     """Handles incoming messages with photos and captions."""
     # Basic check for essential message components
     if not update.message or not update.message.photo or not update.message.caption:
-        # This case should ideally be filtered out by MessageHandler filters, but check just in case
-        logger.warning("Handler invoked for message without photo or caption.")
-        # Optionally reply, but filter should prevent this
-        # await update.message.reply_text("⚠️ Please send an image with a caption text!")
+        logger.warning("Handler invoked for message missing photo or caption. This shouldn't happen with the current filters.")
         return
 
     user = update.message.from_user
+    # Use 'UnknownUser' or similar if user info isn't available
     user_id = user.id if user else "UnknownUser"
+    user_info = f"user_id={user_id}" + (f", username={user.username}" if user and user.username else "")
     caption = update.message.caption
     message_id = update.message.message_id
     chat_id = update.message.chat_id
 
-    logger.info(f"Received photo with caption from user {user_id} in chat {chat_id}.")
+    logger.info(f"Received photo with caption from {user_info} in chat {chat_id} (message_id={message_id}).")
 
     # --- Download User Image ---
-    # Create a unique temporary path for the downloaded image
+    # Create a unique temporary path for the downloaded image within the OUTPUT_DIR
     temp_user_image_path = os.path.join(Config.OUTPUT_DIR, f"user_{user_id}_{message_id}.jpg")
     file_downloaded = False
+    download_start_time = asyncio.get_running_loop().time()
     try:
         photo = update.message.photo[-1] # Get the highest resolution photo available
-        logger.info(f"Downloading photo (file_id: {photo.file_id}, size: {photo.width}x{photo.height})...")
+        logger.info(f"Attempting download photo (file_id: {photo.file_id}, size: {photo.width}x{photo.height})...")
         photo_file = await photo.get_file()
         await photo_file.download_to_drive(temp_user_image_path)
-        logger.info(f"Photo downloaded successfully to {temp_user_image_path}")
+        download_time = asyncio.get_running_loop().time() - download_start_time
+        logger.info(f"Photo downloaded successfully to '{temp_user_image_path}' in {download_time:.2f} seconds.")
         file_downloaded = True
     except TelegramError as e:
-        logger.error(f"Telegram error downloading photo: {e}", exc_info=True)
-        await update.message.reply_text("❌ Sorry, there was a Telegram error downloading the image. Please try again.")
-        return
+        logger.error(f"Telegram error downloading photo for message {message_id}: {e}", exc_info=True)
+        await update.message.reply_text("❌ Sorry, there was a Telegram error downloading the image. Please try sending it again.")
+        return # Stop processing if download fails
     except Exception as e:
-        logger.error(f"Unexpected error downloading photo: {e}", exc_info=True)
+        logger.error(f"Unexpected error downloading photo for message {message_id}: {e}", exc_info=True)
         await update.message.reply_text("❌ Sorry, I couldn't download the image due to an unexpected error.")
-        return
+        return # Stop processing if download fails
 
-    if not file_downloaded: # Should not happen if exceptions are caught, but as safety
+    # Safety check, though exceptions should prevent reaching here if download failed
+    if not file_downloaded or not os.path.exists(temp_user_image_path):
+        logger.error(f"Download reported success but file '{temp_user_image_path}' does not exist.")
+        await update.message.reply_text("❌ An internal error occurred after downloading the image.")
         return
 
     # --- Process Images in Executor ---
     # Notify user that processing has started
+    processing_message = None
     try:
+        # Quote the original message for context
         processing_message = await update.message.reply_text("⏳ Processing your image with different styles...", quote=True)
-        message_to_delete = processing_message.message_id
     except TelegramError as e:
-        logger.warning(f"Could not send 'Processing...' message: {e}")
-        message_to_delete = None # Cannot delete if sending failed
+        logger.warning(f"Could not send 'Processing...' message to chat {chat_id}: {e}")
+        # Continue processing even if status message fails
+
+    message_to_delete = processing_message.message_id if processing_message else None
 
     loop = asyncio.get_running_loop()
     generated_images = []
-    start_time = loop.time()
+    processing_failed = False
+    processing_start_time = loop.time()
     try:
+        logger.info(f"Submitting image processing task to executor for user image '{os.path.basename(temp_user_image_path)}'")
         # Run the blocking image processing function in the default thread pool executor
         generated_images = await loop.run_in_executor(
             None, # Use default ThreadPoolExecutor
@@ -396,83 +468,94 @@ async def handle_message(update: Update, context: ContextTypes.DEFAULT_TYPE):
             temp_user_image_path, # Argument 1 for process_images
             caption # Argument 2 for process_images
         )
-        processing_time = loop.time() - start_time
-        logger.info(f"Image processing completed in {processing_time:.2f} seconds.")
+        processing_time = loop.time() - processing_start_time
+        logger.info(f"Image processing task completed in {processing_time:.2f} seconds.")
 
     except Exception as e:
-         logger.error(f"Error during image processing executor call: {e}", exc_info=True)
+         processing_failed = True
+         logger.error(f"Error during image processing executor call for message {message_id}: {e}", exc_info=True)
+         error_message = "❌ An unexpected error occurred during processing. Please try again later."
          # Try to edit the "Processing..." message to show error
          if message_to_delete:
              try:
                  await context.bot.edit_message_text(
                      chat_id=chat_id,
                      message_id=message_to_delete,
-                     text="❌ An unexpected error occurred during processing."
+                     text=error_message
                  )
-                 message_to_delete = None # Don't try to delete it again later
+                 message_to_delete = None # Mark as handled, don't delete later
              except TelegramError as edit_err:
-                 logger.warning(f"Could not edit processing message to show error: {edit_err}")
+                 logger.warning(f"Could not edit processing message {message_to_delete} to show error: {edit_err}")
                  # Fallback reply if editing failed
-                 await update.message.reply_text("❌ An unexpected error occurred during processing.")
-         else:
-            await update.message.reply_text("❌ An unexpected error occurred during processing.")
+                 await update.message.reply_text(error_message)
+         else: # If sending initial status failed, just send error as new message
+            await update.message.reply_text(error_message)
 
-    finally:
-        # Delete the "Processing..." message if it was sent and not edited to show error
-        if message_to_delete:
-            try:
-                 await context.bot.delete_message(
-                     chat_id=chat_id,
-                     message_id=message_to_delete
-                 )
-            except TelegramError as del_err:
-                 logger.warning(f"Could not delete 'Processing...' message ({message_to_delete}): {del_err}")
+    # Delete the "Processing..." message if it was sent and processing didn't fail or error wasn't edited in
+    if message_to_delete:
+        try:
+             await context.bot.delete_message(
+                 chat_id=chat_id,
+                 message_id=message_to_delete
+             )
+             logger.debug(f"Deleted 'Processing...' message {message_to_delete}")
+        except TelegramError as del_err:
+             # Log warning, but don't bother user if deleting status message fails
+             logger.warning(f"Could not delete 'Processing...' message ({message_to_delete}): {del_err}")
 
 
     # --- Send Results ---
-    if not generated_images:
-        logger.warning("No images were generated successfully.")
-        # Avoid sending redundant message if error was already reported
-        if 'e' not in locals(): # Check if processing failed with exception 'e'
-             await update.message.reply_text("😕 Sorry, I couldn't generate any styled images this time. Please check the templates or try again.")
-    else:
-        logger.info(f"Sending {len(generated_images)} generated images back to user {user_id}.")
-        sent_count = 0
-        for i, img_path in enumerate(generated_images):
-            caption_text = f"Style variant {i+1}" if len(generated_images) > 1 else "Here's your styled image!"
-            try:
-                # Send the photo from the generated path
-                with open(img_path, 'rb') as photo_data:
+    # Only proceed if processing didn't explicitly fail with an exception
+    if not processing_failed:
+        if not generated_images:
+            logger.warning(f"Image processing finished but generated 0 images for message {message_id}.")
+            # Inform user if no images were created (e.g., no templates found, or all failed internally)
+            await update.message.reply_text("😕 Sorry, I couldn't generate any styled images this time. There might be an issue with the templates.")
+        else:
+            send_start_time = loop.time()
+            logger.info(f"Sending {len(generated_images)} generated images back to user {user_id} for message {message_id}.")
+            sent_count = 0
+            for i, img_path in enumerate(generated_images):
+                # Check if file exists before attempting to send
+                if not os.path.exists(img_path):
+                    logger.error(f"Generated image file not found before sending: '{img_path}'")
+                    if len(generated_images) > 1:
+                         await update.message.reply_text(f"⚠️ Couldn't send style variant {i+1} (internal file missing).")
+                    continue # Skip to next image
+
+                caption_text = f"Style variant {i+1}" if len(generated_images) > 1 else "🖼️ Here's your styled image!"
+                try:
+                    # Send the photo from the generated path using InputFile
                     await update.message.reply_photo(
-                        photo=InputFile(photo_data, filename=os.path.basename(img_path)),
-                        caption=caption_text
+                        photo=InputFile(img_path), # PTB handles opening/closing when path is given
+                        caption=caption_text,
+                        # Consider adding reply_to_message_id=message_id for clearer context in group chats
+                        # reply_to_message_id=message_id
                     )
-                sent_count += 1
-                logger.debug(f"Sent photo {os.path.basename(img_path)}")
-
-            except FileNotFoundError:
-                 logger.error(f"Generated image file not found for sending: {img_path}")
-                 # Try to inform user about partial failure if multiple images were expected
-                 if len(generated_images) > 1:
-                      await update.message.reply_text(f"⚠️ Couldn't send style variant {i+1} (file missing).")
-            except TelegramError as e:
-                 logger.error(f"Telegram error sending photo {os.path.basename(img_path)}: {e}", exc_info=True)
-                 if len(generated_images) > 1:
-                      await update.message.reply_text(f"⚠️ Couldn't send style variant {i+1} due to a Telegram error.")
-            except Exception as e:
-                logger.error(f"Unexpected error sending photo {os.path.basename(img_path)}: {e}", exc_info=True)
-                if len(generated_images) > 1:
-                      await update.message.reply_text(f"⚠️ Couldn't send style variant {i+1} due to an unexpected error.")
-            finally:
-                 # Clean up the generated image file regardless of sending success
-                 try:
-                     if os.path.exists(img_path):
-                         os.remove(img_path)
-                         logger.debug(f"Cleaned up generated image: {os.path.basename(img_path)}")
-                 except OSError as e:
-                     logger.error(f"Error deleting generated image file {img_path}: {e}")
-
-        logger.info(f"Finished sending {sent_count}/{len(generated_images)} images.")
+                    sent_count += 1
+                    logger.debug(f"Sent photo {os.path.basename(img_path)}")
+
+                except TelegramError as e:
+                     # Log specific Telegram errors (e.g., file too large, chat not found, blocked by user)
+                     logger.error(f"Telegram error sending photo {os.path.basename(img_path)}: {e}", exc_info=True)
+                     if len(generated_images) > 1:
+                          await update.message.reply_text(f"⚠️ Couldn't send style variant {i+1} due to a Telegram error.")
+                except Exception as e:
+                    # Catch other potential errors during sending
+                    logger.error(f"Unexpected error sending photo {os.path.basename(img_path)}: {e}", exc_info=True)
+                    if len(generated_images) > 1:
+                          await update.message.reply_text(f"⚠️ Couldn't send style variant {i+1} due to an unexpected error.")
+                finally:
+                     # Clean up the generated image file after attempting to send it
+                     try:
+                         if os.path.exists(img_path):
+                             os.remove(img_path)
+                             logger.debug(f"Cleaned up generated image: {os.path.basename(img_path)}")
+                     except OSError as e:
+                         logger.error(f"Error deleting generated image file '{img_path}': {e}")
+
+            send_time = loop.time() - send_start_time
+            logger.info(f"Finished sending results for message {message_id}. Sent {sent_count}/{len(generated_images)} images in {send_time:.2f} seconds.")
 
     # --- Final Cleanup ---
     # Clean up the originally downloaded user image
@@ -481,30 +564,30 @@ async def handle_message(update: Update, context: ContextTypes.DEFAULT_TYPE):
             os.remove(temp_user_image_path)
             logger.info(f"Cleaned up temporary user image: {os.path.basename(temp_user_image_path)}")
     except OSError as e:
-        logger.error(f"Error cleaning up user image {temp_user_image_path}: {e}", exc_info=True)
+        # Log error but don't bother user if temporary file cleanup fails
+        logger.error(f"Error cleaning up user image '{temp_user_image_path}': {e}", exc_info=True)
 
 
 # --- Main Execution ---
 if __name__ == "__main__":
-    logger.info("Starting Telegram Bot...")
+    logger.info("Initializing Telegram Bot Application...")
 
-    if not Config.TELEGRAM_TOKEN:
-         logger.critical("TELEGRAM_TOKEN is not set in environment variables or .env file. Bot cannot start.")
-         exit(1) # Exit if token is missing
+    # Token check is done in Config class now, exiting if it fails there.
 
     try:
         # Build the application instance
         app = Application.builder().token(Config.TELEGRAM_TOKEN).build()
 
         # Add the handler for messages containing both a photo and a caption
-        # Filters.PHOTO checks for `message.photo` being non-empty
-        # Filters.CAPTION checks for `message.caption` being non-empty
+        # This ensures the 'handle_message' function only receives relevant updates
         app.add_handler(MessageHandler(filters.PHOTO & filters.CAPTION, handle_message))
 
-        logger.info("Bot application built. Starting polling...")
-        # Start the bot polling for updates
-        app.run_polling(allowed_updates=Update.ALL_TYPES) # Specify allowed updates if needed
+        logger.info("Bot application built successfully. Starting polling for updates...")
+        # Start the bot polling for updates indefinitely
+        app.run_polling(allowed_updates=Update.ALL_TYPES) # Consider specifying only needed updates
 
     except Exception as e:
-        logger.critical(f"Fatal error initializing or running the bot application: {e}", exc_info=True)
+        # Catch potential errors during application build or startup
+        logger.critical(f"FATAL error initializing or running the bot application: {e}", exc_info=True)
+        # Exit with a non-zero code to indicate failure
         exit(1)