from typing import List, Optional
from pptx.util import Pt

from PIL import Image, ImageDraw

from ppt_generator.models.pptx_models import PptxObjectFitEnum, PptxObjectFitModel


def pt_from_optional_int(num: Optional[int]):
    if not num:
        return Pt(0)
    return Pt(num)


def clip_image(
    image: Image.Image,
    width: int,
    height: int,
    focus_x: float = 50.0,
    focus_y: float = 50.0,
) -> Image.Image:
    img_width, img_height = image.size

    img_aspect = img_width / img_height
    box_aspect = width / height

    if img_aspect > box_aspect:
        new_height = height
        new_width = int(new_height * img_aspect)
    else:
        new_width = width
        new_height = int(new_width / img_aspect)

    resized_image = image.resize((new_width, new_height), Image.LANCZOS)

    # Calculate clipping position based on focus
    # Convert focus percentages (0-100) to position in the resized image
    focus_x = max(0.0, min(100.0, focus_x))  # Clamp to 0-100 range
    focus_y = max(0.0, min(100.0, focus_y))  # Clamp to 0-100 range

    # Calculate the center point based on focus
    center_x = int((new_width - width) * (focus_x / 100.0))
    center_y = int((new_height - height) * (focus_y / 100.0))

    # Calculate clipping box
    left = center_x
    top = center_y
    right = left + width
    bottom = top + height

    clipped_image = resized_image.crop((left, top, right, bottom))

    return clipped_image


def round_image_corners(image: Image.Image, radii: List[int]) -> Image.Image:
    if len(radii) != 4:
        raise ValueError(
            "Image Border Radius - radii must contain exactly 4 values for each corner"
        )

    w, h = image.size
    # Ensure the image has an alpha channel (RGBA)
    if image.mode != "RGBA":
        image = image.convert("RGBA")

    # Create a mask for the rounded corners (start with fully transparent)
    rounded_mask = Image.new("L", image.size, 0)

    # Create a rectangular mask (fully opaque)
    rectangular_mask = Image.new("L", image.size, 255)

    # Process each corner
    for i, radius in enumerate(radii):
        if radius > 0:  # Only process if radius is positive
            # Create a circle for this radius
            circle = Image.new("L", (radius * 2, radius * 2), 0)
            draw = ImageDraw.Draw(circle)
            draw.ellipse((0, 0, radius * 2 - 1, radius * 2 - 1), fill=255)

            # Calculate position based on corner index
            if i == 0:  # top-left
                rounded_mask.paste(circle.crop((0, 0, radius, radius)), (0, 0))
                rectangular_mask.paste(0, (0, 0, radius, radius))
            elif i == 1:  # top-right
                rounded_mask.paste(
                    circle.crop((radius, 0, radius * 2, radius)), (w - radius, 0)
                )
                rectangular_mask.paste(0, (w - radius, 0, w, radius))
            elif i == 2:  # bottom-right
                rounded_mask.paste(
                    circle.crop((radius, radius, radius * 2, radius * 2)),
                    (w - radius, h - radius),
                )
                rectangular_mask.paste(0, (w - radius, h - radius, w, h))
            else:  # bottom-left
                rounded_mask.paste(
                    circle.crop((0, radius, radius, radius * 2)), (0, h - radius)
                )
                rectangular_mask.paste(0, (0, h - radius, radius, h))

    # Get the original alpha channel
    original_alpha = image.getchannel("A")

    # Combine the rectangular mask with the rounded corners
    corner_mask = Image.composite(rounded_mask, rectangular_mask, rounded_mask)

    # Combine the corner mask with the original alpha channel
    final_alpha = Image.composite(
        original_alpha, Image.new("L", image.size, 0), corner_mask
    )

    # Create a new image with the modified alpha channel
    result = Image.new("RGBA", image.size)
    result.paste(image.convert("RGB"), (0, 0))
    result.putalpha(final_alpha)

    return result


def change_image_color(img: Image.Image, color: str) -> Image.Image:
    # r, g, b, alpha = img.split()

    # color_overlay = Image.new("RGBA", img.size, color=f"#{color}")
    # return Image.composite(color_overlay, img, alpha)
    if color.startswith("#"):
        color = color[1:]
    r_new = int(color[:2], 16)
    g_new = int(color[2:4], 16)
    b_new = int(color[4:], 16)

    # Get image data
    data = img.getdata()

    # Process each pixel
    new_data = []
    for item in data:
        # Get current pixel values
        r, g, b, a = item

        # Apply new color while preserving transparency
        if a != 0:  # Skip fully transparent pixels
            new_data.append((r_new, g_new, b_new, a))
        else:
            new_data.append((0, 0, 0, 0))

    # Create new image with modified data
    new_img = Image.new("RGBA", img.size)
    new_img.putdata(new_data)
    return new_img


def create_circle_image(
    image: Image.Image,
) -> Image.Image:
    # Convert to RGBA if not already
    img = image.convert("RGBA")
    # Get the original image size
    size = img.size
    # Use the smaller dimension for the circle
    circle_size = min(size)
    # Create a transparent image of the same size as original
    mask = Image.new("RGBA", size, color=(0, 0, 0, 0))
    draw = ImageDraw.Draw(mask)

    # Calculate center position
    center_x = size[0] // 2
    center_y = size[1] // 2
    radius = circle_size // 2

    # Create a circular mask
    draw.ellipse(
        (
            center_x - radius,
            center_y - radius,
            center_x + radius,
            center_y + radius,
        ),
        fill=(255, 255, 255, 255),
    )

    # Apply the circular mask
    result = Image.composite(img, mask, mask)
    return result


def fit_image(
    image: Image.Image, width: int, height: int, object_fit: PptxObjectFitModel
) -> Image.Image:
    if not object_fit.fit:
        return image

    img_width, img_height = image.size
    img_aspect = img_width / img_height
    box_aspect = width / height

    if object_fit.fit == PptxObjectFitEnum.CONTAIN:
        # Scale image to fit within the box while maintaining aspect ratio
        if img_aspect > box_aspect:
            new_width = width
            new_height = int(width / img_aspect)
        else:
            new_height = height
            new_width = int(height * img_aspect)
        resized_image = image.resize((new_width, new_height), Image.LANCZOS)
        
        # Use focus point for positioning if available
        focus_x = 50.0
        focus_y = 50.0
        if object_fit.focus and len(object_fit.focus) == 2:
            focus_x, focus_y = object_fit.focus[0], object_fit.focus[1]
        
        # Calculate paste position based on focus
        paste_x = int((width - new_width) * (focus_x / 100.0))
        paste_y = int((height - new_height) * (focus_y / 100.0))
        
        result = Image.new("RGBA", (width, height), (0, 0, 0, 0))
        result.paste(resized_image, (paste_x, paste_y))
        return result

    elif object_fit.fit == PptxObjectFitEnum.COVER:
        # Scale image to cover the box while maintaining aspect ratio
        if img_aspect > box_aspect:
            new_height = height
            new_width = int(height * img_aspect)
        else:
            new_width = width
            new_height = int(width / img_aspect)
        resized_image = image.resize((new_width, new_height), Image.LANCZOS)
        
        # Use focus point for positioning if available
        focus_x = 50.0
        focus_y = 50.0
        if object_fit.focus and len(object_fit.focus) == 2:
            focus_x, focus_y = object_fit.focus[0], object_fit.focus[1]
        
        # Calculate paste position based on focus
        paste_x = int((new_width - width) * (focus_x / 100.0))
        paste_y = int((new_height - height) * (focus_y / 100.0))
        
        # Clip the image to the box size
        return resized_image.crop((paste_x, paste_y, paste_x + width, paste_y + height))

    elif object_fit.fit == PptxObjectFitEnum.FILL:
        # Stretch image to fill the box exactly
        return image.resize((width, height), Image.LANCZOS)

    return image
