# handlers.py
import os
import asyncio
import logging
from typing import List

from hydrogram import Client, filters
from hydrogram.types import Message
from hydrogram.errors import FloodWait, RPCError
from hydrogram.handlers import MessageHandler # Explicit import for add_handler

from config import Config
from utils import is_admin
from processing import process_images_sync
from main import executor # Import executor from main.py

logger = logging.getLogger(__name__)

async def handle_photo_message_impl(client: Client, message: Message):
    user = message.from_user
    user_id = user.id
    user_info = f"user_id={user_id}" + (f", username={user.username}" if user.username else "")
    caption = message.caption if message.caption else ""
    message_id = message.id
    chat_id = message.chat.id

    logger.info(f"ADMIN ACTION (Bot): Received photo with caption from {user_info} (msg_id={message_id}).")

    temp_user_image_path = os.path.join(Config.OUTPUT_DIR, f"bot_user_{user_id}_{message_id}.jpg")
    file_downloaded = False
    processing_status_message = None

    try:
        if not message.photo: return
        download_start_time = asyncio.get_running_loop().time()
        logger.info(f"Attempting download photo (file_id: {message.photo.file_id})...")
        downloaded_path = await client.download_media(message.photo.file_id, file_name=temp_user_image_path)

        if downloaded_path and os.path.exists(downloaded_path):
             download_time = asyncio.get_running_loop().time() - download_start_time
             logger.info(f"Photo downloaded to '{downloaded_path}' in {download_time:.2f}s.")
             temp_user_image_path = downloaded_path
             file_downloaded = True
        else:
             logger.error(f"Download failed or file not found: '{temp_user_image_path}'. Path: {downloaded_path}")
             await message.reply_text("❌ Internal error after download attempt.")
             return
    except FloodWait as e:
        logger.warning(f"Flood wait: {e.value}s during download (msg_id={message_id}).")
        await asyncio.sleep(e.value + 2)
        await message.reply_text(f"⏳ Telegram limits hit. Wait {e.value}s & try again.")
        return
    except RPCError as e:
        logger.error(f"RPC error downloading photo (msg_id={message_id}): {e}", exc_info=True)
        await message.reply_text("❌ Telegram API error downloading image.")
        return
    except Exception as e:
        logger.error(f"Unexpected error downloading photo (msg_id={message_id}): {e}", exc_info=True)
        await message.reply_text("❌ Unexpected error downloading image.")
        return

    try:
        processing_status_message = await message.reply_text("⏳ Processing your image...", quote=True)
    except Exception as e: logger.warning(f"Could not send 'Processing...' message: {e}")

    message_to_delete_id = processing_status_message.id if processing_status_message else None
    loop = asyncio.get_running_loop()
    generated_images: List[str] = []
    processing_failed = False
    
    try:
        logger.info(f"Submitting image processing for '{os.path.basename(temp_user_image_path)}'")
        generated_images = await loop.run_in_executor(
            executor, process_images_sync, temp_user_image_path, caption
        )
    except Exception as e:
         processing_failed = True
         logger.error(f"Error during image processing executor call: {e}", exc_info=True)
         error_message = "❌ Unexpected error during processing."
         if message_to_delete_id:
             try: await client.edit_message_text(chat_id, message_to_delete_id, error_message)
             except Exception as edit_e: logger.warning(f"Could not edit status msg: {edit_e}")
             message_to_delete_id = None
         else: await message.reply_text(error_message)

    if message_to_delete_id:
        try: await client.delete_messages(chat_id, message_to_delete_id)
        except Exception as del_e: logger.warning(f"Could not delete status msg: {del_e}")

    if not processing_failed:
        if not generated_images:
            await message.reply_text("😕 No styled images generated. Check templates?")
        else:
            logger.info(f"Sending {len(generated_images)} images for message {message_id}.")
            for i, img_path in enumerate(generated_images):
                if not os.path.exists(img_path): continue
                caption_text = f"Style {i+1}" if len(generated_images) > 1 else "🖼️ Styled image:"
                try:
                    await message.reply_photo(photo=img_path, caption=caption_text, quote=True)
                except Exception as e: logger.error(f"Error sending photo '{os.path.basename(img_path)}': {e}", exc_info=True)
                finally:
                     try:
                         if os.path.exists(img_path): os.remove(img_path)
                     except OSError as e: logger.error(f"Error deleting file '{img_path}': {e}")
    
    try:
        if file_downloaded and os.path.exists(temp_user_image_path):
            os.remove(temp_user_image_path)
    except OSError as e: logger.error(f"Error cleaning user image '{temp_user_image_path}': {e}")

def register_handlers(app: Client):
    admin_photo_filter = filters.photo & filters.caption & filters.private & is_admin
    app.add_handler(MessageHandler(handle_photo_message_impl, filters=admin_photo_filter))
    logger.info("Registered admin photo handler for bot.")