<?php
namespace JVBase\managers;

use JVBase\managers\UploadManager;
use WP_Error;
use Imagick;
use ImagickPixel;
use Exception;
use ImagickDrawException;
use ImagickPixelException;
use ImagickDraw;
use ImagickException;
use GdImage;

if (!defined('ABSPATH')) {
    exit; // Exit if accessed directly
}

/**
 * ImageGenerator
 *
 * Generates artist feature cards as webp images with artist information
 * Uses Imagick with GD fallback and leverages FileUploadManager storage
 */
class ImageGenerator
{
    // Configuration options
    protected array $config = [
        'width' => 2400,
        'height' => 1260,
        'padding' => 80,
        'portrait_width' => 1200,
        'text_area_width' => 800,
        'background_color' => '#151515',
        'text_color' => '#F9F9F9',
        'accent_color' => '#FF0080',
        'fonts' => [
            'title' => [
                'file' => 'courier-prime-v9-latin-regular.ttf',
                'size' => 28,
            ],
            'name' => [
                'file' => 'mitr-v11-latin-700.ttf',
                'size' => 100,
            ],
            'info' => [
                'file' => 'courier-prime-v9-latin-regular.ttf',
                'size' => 24,
            ],
        ],
        'output_quality' => 95,
        'use_imagick' => null, // Will be set in constructor
    ];

    // Instance variables
    protected array $data;
    protected string $fontsDir;

    protected UploadManager|null $fileManager;
    protected string $outputDir;
    protected string $outputFilename;
    protected int $textTop;
    protected string $type;

    /**
     * Constructor
     */
    /**
     * @param array $data
     * @param UploadManager|null $fileManager
     */
    public function __construct(array $data, UploadManager|null $fileManager = null)
    {
        $this->data = $data;

        $this->type = $data['imageType'];

        // Set paths
        $this->fontsDir = JVB_DIR. '/assets/fonts/';

        // Check for Imagick support
        $this->config['use_imagick'] = extension_loaded('imagick');
        $this->textTop = (int)$this->config['height'] / 2;

        // Set file manager if provided
        $this->fileManager = $fileManager;

        // Set default output directory if file manager not provided
        if (!$this->fileManager) {
            $this->outputDir = wp_upload_dir()['basedir'] . '/artists/';
            if (!is_dir($this->outputDir)) {
                wp_mkdir_p($this->outputDir);
            }
        }
    }

    /**
     * Generate the artist card
     */
    /**
     * @return array
     */
    public function generate():array
    {
        // Generate appropriate filename
        $this->generateFilename();

        // Generate image using appropriate method
        $result = $this->config['use_imagick'] ?
            $this->imagickGenerator() :
            $this->GDGenerator();

        if (!$result['success']) {
            return $result;
        }

        // Create WordPress attachment
        $attachment_id = $this->createAttachment($result['path']);

        if (is_wp_error($attachment_id)) {
            return [
                'success' => false,
                'error' => $attachment_id->get_error_message()
            ];
        }

        return [
            'success' => true,
            'attachment_id' => $attachment_id,
            'url' => wp_get_attachment_url($attachment_id),
            'path' => $result['path']
        ];
    }

    /**
     * Create WordPress attachment from generated image
     * @param string $file_path
     *
     * @return int|WP_Error
     */
    protected function createAttachment(string $file_path):int|WP_Error
    {
        // Get upload directory based on user/content structure
        $upload_dir = wp_upload_dir();
        $base_dir = $upload_dir['basedir'];

        // Get directory structure from FileUploadManager if available
        if ($this->fileManager) {
            $user_dir = $this->fileManager->getUploadDirectory();
            $relative_dir = str_replace($base_dir, '', dirname($file_path));
            $destination_dir = $base_dir . '/' . $relative_dir;
        } else {
            // Fallback to default user/artist structure
            $user_data = get_userdata($this->data['user_id']);
            switch ($this->type) {
                case 'shop':
                    $root = 'shops';
                    $ID = $this->data['shop'];
                    break;
                default:
                    $root = 'artists';
                    $ID = $this->data['user_id'];
                    break;
            }
            $destination_dir = $base_dir . '/'.$root.'/' . sanitize_file_name($ID);
        }

        // Create directory structure if it doesn't exist
        if (!is_dir($destination_dir)) {
            wp_mkdir_p($destination_dir);
        }

        // Move file to final location
        $filename = basename($file_path);
        $new_file = $destination_dir . '/' . $filename;

        if (@copy($file_path, $new_file)) {
            @unlink($file_path); // Delete original
            $file_path = $new_file; // Update path reference
        }

        // Prepare attachment data
        $artist_name = $this->data['display_name'];
        $city = $this->data['city'];

        switch ($this->type) {
            case 'shop':
                $title = 'Featured Shop Image';
                break;
            default:
                $title = 'Featured Artist Image';
        }

        $attachment = [
            'post_mime_type' => 'image/webp',
            'post_title' => sprintf('%s - %s - %s', $artist_name, $title, $city),
            'post_content' => '',
            'post_status' => 'inherit',
            'guid' => str_replace($base_dir, $upload_dir['baseurl'], $file_path)
        ];

        // Insert attachment
        $attachment_id = wp_insert_attachment($attachment, $file_path);

        if (is_wp_error($attachment_id)) {
            return $attachment_id;
        }

        // Make sure we have media functions
        require_once(ABSPATH . 'wp-admin/includes/image.php');
        require_once(ABSPATH . 'wp-admin/includes/file.php');
        require_once(ABSPATH . 'wp-admin/includes/media.php');


        switch ($this->type) {
            case 'shop':
                $type = 'Tattoo Studio';
                break;
            default:
                $type = $this->data['type'];
                break;
        }
        // Set alt text
        $alt_text = sprintf(
            'Featured image for %s - %sin %s',
            $artist_name,
            $type,
            $city
        );
        update_post_meta($attachment_id, '_wp_attachment_image_alt', $alt_text);

        return $attachment_id;
    }

    /**
     * Generate filename using FileUploadManager pattern or a fallback
     * @return void
     */
    protected function generateFilename():void
    {
        if ($this->fileManager) {
            switch ($this->type) {
                case 'shop':
                    $title = 'tattoo-shop';
                    break;
                default:
                    $title = 'artist';
                    break;
            }
            // Use FileUploadManager to generate a filename

            $user_data = get_userdata($this->data['user_id']);
            $this->outputFilename = $this->fileManager->generateFilename(
                $title.'.webp',
                $user_data
            );
        } else {
            // Fallback filename generation
            $safeCity = sanitize_title($this->data['city']);
            $timestamp = date('YmdHis');

            switch ($this->type) {
                case 'shop':
                    $safeName = sanitize_title($this->data['name']);
                    $base = 'shop';
                    break;
                default:
                    $safeName = sanitize_title($this->data['display_name']);
                    $base = 'artist';
                    break;
            }
            $this->outputFilename = "{$safeCity}-{$base}-{$safeName}-{$timestamp}.webp";
        }
    }

    /**
     * Generate artist card using Imagick
     * @return array
     */
    protected function imagickGenerator():array
    {
        if ($this->type === 'shop') {
            return $this->generateShopImagick();
        }
        try {
            // Create a new image with background color
            $card = new Imagick();
            $card->newImage(
                $this->config['width'],
                $this->config['height'],
                new ImagickPixel($this->config['background_color'])
            );
            $card->setImageFormat('webp');

            // Load portrait image
            $portrait = new Imagick(wp_get_attachment_image_src($this->data['image'], 'full')[0]);

            // Resize portrait to fit the left side
            $portrait->resizeImage(
                $this->config['portrait_width'],
                $this->config['height'],
                Imagick::FILTER_LANCZOS,
                1,
                true
            );

            // Apply sepia and grayscale effects
            $portrait->modulateImage(100, 60, 100); // Keep 60% of saturation (40% grayscale)
            $portrait->sepiaToneImage(60); // 60% sepia

            // Composite portrait onto card
            $card->compositeImage(
                $portrait,
                Imagick::COMPOSITE_COPY,
                0,
                0
            );

            // Free portrait memory
            $portrait->clear();

            // Text positioning
            $textX = $this->config['portrait_width'] + $this->config['padding'];
            $textY = $this->config['padding'] * 2;

            // Add "EDMONTON'S BEST TATTOO ARTISTS:" text
            $title = "{$this->data['city']}'S BEST {$this->data['type']}:";
            $this->drawImagickText(
                $card,
                $title,
                $textX,
                $textY,
                $this->config['fonts']['title']['file'],
                $this->config['fonts']['title']['size']
            );

            // Add artist name
            $textY += $this->config['fonts']['title']['size'] + 30;
            $this->drawImagickText(
                $card,
                strtoupper($this->data['display_name']),
                $textX,
                $textY,
                $this->config['fonts']['name']['file'],
                $this->config['fonts']['name']['size']
            );

            $icons = $this->getIcons();

            // Add shop info with icon
            $textY += $this->config['fonts']['name']['size'] + 40;

            foreach ($icons as $i) {
                $icon = new Imagick(JVB_DIR.'/assets/icons/'.$i['icon'].'.png');
                $icon->resizeImage(36, 36, Imagick::FILTER_LANCZOS, 1);

                $card->compositeImage($icon, Imagick::COMPOSITE_OVER, $textX, $textY - 15);
                $this->drawImagickText(
                    $card,
                    " " . trim($i['name']),
                    $textX + 25,
                    $textY,
                    $this->config['fonts']['info']['file'],
                    $this->config['fonts']['info']['size']
                );
                $textY += $i['textY'];
            }

            // Set webp quality
            $card->setImageCompressionQuality($this->config['output_quality']);

            // Save the image
            if ($this->fileManager) {
                $outputPath = $this->fileManager->getUploadDirectory(
                    $this->data['user_id']
                ) . '/' . $this->outputFilename;
            } else {
                $outputPath = $this->outputDir . $this->outputFilename;
            }

            // Make sure the filename ends with .webp
            if (!str_ends_with(strtolower($outputPath), '.webp')) {
                $outputPath .= '.webp';
            }
            $card->writeImage($outputPath);

            // Clean up
            $card->clear();

            return [
                'success' => true,
                'path' => $outputPath,
                'url' => str_replace(wp_upload_dir()['basedir'], wp_upload_dir()['baseurl'], $outputPath),
                'filename' => $this->outputFilename
            ];
        } catch (Exception $e) {
            return [
                'success' => false,
                'error' => $e->getMessage()
            ];
        }
    }

    /**
     * Draw text on Imagick image
     * @param Imagick $image
     * @param string $text
     * @param int $x
     * @param int $y
     * @param string $fontFile
     * @param int $fontSize
     *
     * @return void
     * @throws ImagickDrawException
     * @throws ImagickException
     * @throws ImagickPixelException
     */
    protected function drawImagickText(
        Imagick $image,
        string $text,
        int $x,
        int $y,
        string $fontFile,
        int $fontSize
    ):void {
        $draw = new ImagickDraw();
        $draw->setFont($this->fontsDir . $fontFile);
        $draw->setFontSize($fontSize);
        $draw->setFillColor(new ImagickPixel($this->config['text_color']));
        $draw->setTextAntialias(true);

        $image->annotateImage($draw, $x, $y, 0, $text);
    }

    /**
     * Generate logo preview with Imagick
     * @return array
     */
    protected function generateShopImagick():array
    {
        try {
            // Create a new square image with background
            $width = 1200;
            $height = 630;
            $card = new Imagick();
            $card->newImage(
                $width,
                $height,
                new ImagickPixel($this->config['background_color'])
            );
            $card->setImageFormat('webp');

            // Load logo image
            $logo = new Imagick(wp_get_attachment_image_src($this->data['image'], 'full')[0]);

            // Get dominant color from logo for background gradient
            $dominantColor = $this->getDominantColorImagick($logo);

            // Create gradient background
            $this->createGradientBackgroundImagick($card, $dominantColor);

            // Resize logo to fit in center (max 70% of width/height)
            $logoWidth = $logo->getImageWidth();
            $logoHeight = $logo->getImageHeight();
            $maxLogoWidth = $width * 0.7;
            $maxLogoHeight = $height * 0.7;

            // Calculate scaling factor to fit within bounds
            $scale = min($maxLogoWidth / $logoWidth, $maxLogoHeight / $logoHeight);

            // Resize logo
            $logo->resizeImage(
                intval($logoWidth * $scale),
                intval($logoHeight * $scale),
                Imagick::FILTER_LANCZOS,
                1
            );

            // Center logo on canvas
            $x = ($width - $logo->getImageWidth()) / 2;
            $y = ($height - $logo->getImageHeight()) / 2;

            // Composite logo onto card
            $card->compositeImage(
                $logo,
                Imagick::COMPOSITE_OVER,
                intval($x),
                intval($y)
            );

            // Free logo memory
            $logo->clear();

            // Set webp quality
            $card->setImageCompressionQuality($this->config['output_quality']);

            // Save the image
            if ($this->fileManager) {
                $outputPath = $this->fileManager->getUploadDirectory(
                    $this->data['user_id']
                ) . '/' . $this->outputFilename;
            } else {
                $outputPath = $this->outputDir . $this->outputFilename;
            }

            // Make sure the filename ends with .webp
            if (!str_ends_with(strtolower($outputPath), '.webp')) {
                $outputPath .= '.webp';
            }
            $card->writeImage($outputPath);

            // Clean up
            $card->clear();

            return [
                'success' => true,
                'path' => $outputPath,
                'url' => str_replace(wp_upload_dir()['basedir'], wp_upload_dir()['baseurl'], $outputPath),
                'filename' => $this->outputFilename
            ];
        } catch (Exception $e) {
            return [
                'success' => false,
                'error' => $e->getMessage()
            ];
        }
    }

    /**
     * Extract dominant color from image using Imagick
     * @param Imagick $image
     * @return string Hex color
     */
    protected function getDominantColorImagick(Imagick $image): string
    {
        try {
            // Create a copy for analysis
            $copy = clone $image;

            // Resize to a small image for faster processing
            $copy->resizeImage(50, 50, Imagick::FILTER_LANCZOS, 1);

            // Reduce to one pixel to get average color
            $copy->resizeImage(1, 1, Imagick::FILTER_LANCZOS, 1);

            // Get the color of that pixel
            $pixel = $copy->getImagePixelColor(0, 0);
            $colorArray = $pixel->getColor();

            // Convert to hex
            $hexColor = sprintf(
                "#%02x%02x%02x",
                $colorArray['r'],
                $colorArray['g'],
                $colorArray['b']
            );

            $copy->clear();

            // Ensure we have sufficient color intensity
            $brightness = ($colorArray['r'] + $colorArray['g'] + $colorArray['b']) / 3;
            if ($brightness < 30 || $brightness > 225) {
                // If too dark or too light, use accent color instead
                return $this->config['accent_color'];
            }

            return $hexColor;
        } catch (Exception $e) {
            // On error, return default accent color
            return $this->config['accent_color'];
        }
    }

    /**
     * Create gradient background with Imagick
     * @param Imagick $canvas
     * @param string $color Center color
     * @return void
     */
    protected function createGradientBackgroundImagick(Imagick &$canvas, string $color): void
    {
        $width = $canvas->getImageWidth();
        $height = $canvas->getImageHeight();
        $centerX = $width / 2;
        $centerY = $height / 2;
        $radius = max($width, $height) * 0.6; // Gradient radius

        // Create radial gradient for background
        $gradient = new Imagick();
        $gradient->newPseudoImage(
            $width,
            $height,
            "radial-gradient:$color-" . $this->config['background_color']
        );

        // Apply gradient to canvas
        $canvas->compositeImage(
            $gradient,
            Imagick::COMPOSITE_OVER,
            0,
            0
        );

        $gradient->clear();
    }

    /**
     * Generate artist card using GD
     */
    /**
     * @return array
     * @throws Exception
     */
    protected function GDGenerator():array
    {
        if ($this->type === 'shop') {
            return $this->generateShopGD();
        }
        // Create a new image with background color
        $card = imagecreatetruecolor($this->config['width'], $this->config['height']);

        // Convert hex color to RGB
        $bgColor = $this->hexToRgb($this->config['background_color']);
        $textColor = $this->hexToRgb($this->config['text_color']);

        // Allocate colors
        $bgColorAllocated = imagecolorallocate($card, $bgColor['r'], $bgColor['g'], $bgColor['b']);
        $textColorAllocated = imagecolorallocate($card, $textColor['r'], $textColor['g'], $textColor['b']);

        // Fill background
        imagefill($card, 0, 0, $bgColorAllocated);

        // Load and resize portrait
        $portrait = $this->loadAndResizeImage(
            (int)$this->data['image'],
            $this->config['portrait_width'],
            $this->config['height']
        );

        // Apply sepia and grayscale effects to portrait
        $this->applyGDSepiaTone($portrait);

        // Copy portrait to card
        imagecopy($card, $portrait, 0, 0, 0, 0, imagesx($portrait), imagesy($portrait));

        // Free portrait memory
        imagedestroy($portrait);

        // Text positioning
        $textX = $this->config['portrait_width'] + $this->config['padding'];

        // Text positioning constants
        $headerY = $this->textTop; // "EDMONTON'S BEST TATTOO ARTIST:"
        $nameY = $this->textTop + 135;  // Artist name
        $detailsStartY = $this->textTop + 160; // Start Y for shop/location/styles
        $detailsLineHeight = 45; // Space between detail lines

        // Add title with courier font
        $this->drawGDText(
            $card,
            strtoupper("{$this->data['city']}'S BEST TATTOO ARTISTS:"),
            $textX,
            $headerY,
            $this->config['fonts']['title']['file'],
            $this->config['fonts']['title']['size'],
            $textColorAllocated
        );

        // Add artist name in larger, bolder font
        $this->drawGDText(
            $card,
            strtoupper($this->data['display_name']),
            $textX,
            $nameY,
            $this->config['fonts']['name']['file'],
            $this->config['fonts']['name']['size'],
            $textColorAllocated
        );

        // Current Y position for details
        $currentY = $detailsStartY + 50;

        // Add shop info with icon
        $shopIcon = $this->loadAndResizeImage(JVB_DIR.'/assets/icons/shop.png', 36, 36);
        $this->copyImageWithTransparency($card, $shopIcon, $textX, $currentY - 27);
        $this->drawGDText(
            $card,
            "  {$this->data['shop']}",
            $textX + 15,
            $currentY,
            $this->config['fonts']['info']['file'],
            $this->config['fonts']['info']['size'],
            $textColorAllocated
        );

        $currentY += $detailsLineHeight;

        // Add location with icon
        $locationIcon = $this->loadAndResizeImage(JVB_DIR.'/assets/icons/city.png', 36, 36);
        $this->copyImageWithTransparency($card, $locationIcon, $textX, $currentY - 25);
        $this->drawGDText(
            $card,
            "  {$this->data['city']}",
            $textX + 15,
            $currentY,
            $this->config['fonts']['info']['file'],
            $this->config['fonts']['info']['size'],
            $textColorAllocated
        );
        $currentY += $detailsLineHeight;

        // Add styles with hashtags
        $styles = explode(',', strtolower($this->data['styles']));
        $styleIcon = $this->loadAndResizeImage(JVB_DIR.'/assets/icons/style.png', 36, 36);
        foreach ($styles as $style) {
            $this->copyImageWithTransparency($card, $styleIcon, $textX, $currentY - 25);
            $this->drawGDText(
                $card,
                "  {$style}",
                $textX + 15,
                $currentY,
                $this->config['fonts']['info']['file'],
                $this->config['fonts']['info']['size'],
                $textColorAllocated
            );
            $currentY += $detailsLineHeight;
        }

        // Save the image
        if ($this->fileManager) {
            $outputPath = $this->fileManager->getUploadDirectory($this->data['user_id']) . '/' . $this->outputFilename;
        } else {
            $outputPath = $this->outputDir . $this->outputFilename;
        }

        // Make sure the filename ends with .webp
        if (!str_ends_with(strtolower($outputPath), '.webp')) {
            $outputPath .= '.webp';
        }

        // Make sure the directory exists
        wp_mkdir_p(dirname($outputPath));

        // Create WebP
        imagewebp($card, $outputPath, $this->config['output_quality']);

        // Clean up
        imagedestroy($card);

        return [
            'success' => true,
            'path' => $outputPath,
            'url' => str_replace(wp_upload_dir()['basedir'], wp_upload_dir()['baseurl'], $outputPath),
            'filename' => $this->outputFilename
        ];
    }

    /**
     * Draw text on GD image
     * @param GdImage $image
     * @param string $text
     * @param int $x
     * @param int $y
     * @param string $fontFile
     * @param int $fontSize
     * @param mixed $color
     *
     * @return void
     */
    protected function drawGDText(
        GdImage $image,
        string $text,
        int $x,
        int $y,
        string $fontFile,
        int $fontSize,
        mixed $color
    ):void {
        imagettftext(
            $image,
            $fontSize,
            0,
            $x,
            $y,
            $color,
            $this->fontsDir . $fontFile,
            $text
        );
    }

    /**
     * Generate logo preview with GD
     * @return array
     */
    protected function generateShopGD():array
    {
        try {
            // Create dimensions
            $width = 1200;
            $height = 630;

            // Create a new image
            $card = imagecreatetruecolor($width, $height);

            // Convert hex color to RGB
            $bgColor = $this->hexToRgb($this->config['background_color']);

            // Allocate background color
            $bgColorAllocated = imagecolorallocate($card, $bgColor['r'], $bgColor['g'], $bgColor['b']);

            // Fill background
            imagefill($card, 0, 0, $bgColorAllocated);

            // Load logo
            $logoImage = $this->loadAndResizeImage(
                (int)$this->data['image'],
                $width,
                $height
            );

            // Get dominant color from logo
            $dominantColor = $this->getDominantColorGD($logoImage);

            // Create gradient background
            $this->createGradientBackgroundGD($card, $dominantColor);

            // Calculate new dimensions (max 70% of width/height)
            $logoWidth = imagesx($logoImage);
            $logoHeight = imagesy($logoImage);
            $maxLogoWidth = $width * 0.7;
            $maxLogoHeight = $height * 0.7;

            // Calculate scaling factor
            $scale = min($maxLogoWidth / $logoWidth, $maxLogoHeight / $logoHeight);

            // Create resized logo
            $resizedLogo = imagecreatetruecolor(
                intval($logoWidth * $scale),
                intval($logoHeight * $scale)
            );

            // Handle transparency
            imagealphablending($resizedLogo, false);
            imagesavealpha($resizedLogo, true);
            $transparent = imagecolorallocatealpha($resizedLogo, 255, 255, 255, 127);
            imagefilledrectangle($resizedLogo, 0, 0, $logoWidth * $scale, $logoHeight * $scale, $transparent);

            // Resize logo
            imagecopyresampled(
                $resizedLogo,
                $logoImage,
                0,
                0,
                0,
                0,
                intval($logoWidth * $scale),
                intval($logoHeight * $scale),
                $logoWidth,
                $logoHeight
            );

            // Calculate position to center the logo
            $x = intval(($width - imagesx($resizedLogo)) / 2);
            $y = intval(($height - imagesy($resizedLogo)) / 2);

            // Copy logo to card with transparency
            imagealphablending($card, true);
            imagecopy(
                $card,
                $resizedLogo,
                $x,
                $y,
                0,
                0,
                imagesx($resizedLogo),
                imagesy($resizedLogo)
            );

            // Clean up
            imagedestroy($logoImage);
            imagedestroy($resizedLogo);

            // Save the image
            if ($this->fileManager) {
                $outputPath = $this->fileManager->getUploadDirectory(
                    $this->data['user_id']
                ) .'/' . $this->outputFilename;
            } else {
                $outputPath = $this->outputDir . $this->outputFilename;
            }

            // Make sure the filename ends with .webp
            if (!str_ends_with(strtolower($outputPath), '.webp')) {
                $outputPath .= '.webp';
            }

            // Make sure the directory exists
            wp_mkdir_p(dirname($outputPath));

            // Create WebP
            imagewebp($card, $outputPath, $this->config['output_quality']);

            // Clean up
            imagedestroy($card);

            return [
                'success' => true,
                'path' => $outputPath,
                'url' => str_replace(wp_upload_dir()['basedir'], wp_upload_dir()['baseurl'], $outputPath),
                'filename' => $this->outputFilename
            ];
        } catch (Exception $e) {
            return [
                'success' => false,
                'error' => $e->getMessage()
            ];
        }
    }

    /**
     * Extract dominant color from image using GD
     * @param GdImage $image
     * @return string Hex color
     */
    protected function getDominantColorGD(GdImage $image): string
    {
        // Resize image to 1x1 to get average color
        $tmp = imagecreatetruecolor(1, 1);
        imagecopyresampled($tmp, $image, 0, 0, 0, 0, 1, 1, imagesx($image), imagesy($image));

        // Get the color index of the pixel
        $rgb = imagecolorat($tmp, 0, 0);

        // Extract the RGB values
        $r = ($rgb >> 16) & 0xFF;
        $g = ($rgb >> 8) & 0xFF;
        $b = $rgb & 0xFF;

        // Clean up
        imagedestroy($tmp);

        // Generate hex color
        $hexColor = sprintf("#%02x%02x%02x", $r, $g, $b);

        // Check if the color is too dark or too light
        $brightness = ($r + $g + $b) / 3;
        if ($brightness < 30 || $brightness > 225) {
            // If too dark or too light, use accent color
            return $this->config['accent_color'];
        }

        return $hexColor;
    }

    /**
     * Create gradient background with GD
     * @param GdImage $canvas
     * @param string $color Center color
     * @return void
     */
    protected function createGradientBackgroundGD(GdImage &$canvas, string $color):void
    {
        $width   = imagesx($canvas);
        $height  = imagesy($canvas);
        $centerX = $width / 2;
        $centerY = $height / 2;

        // Convert hex to RGB
        $centerColor = $this->hexToRgb($color);
        $edgeColor   = $this->hexToRgb($this->config['background_color']);

        // Create gradient
        $maxDist = sqrt(pow($width / 2, 2) + pow($height / 2, 2));

        for ($y = 0; $y < $height; $y++) {
            for ($x = 0; $x < $width; $x++) {
                // Calculate distance from center (0-1 range)
                $distX = abs($x - $centerX);
                $distY = abs($y - $centerY);
                $dist  = sqrt(pow($distX, 2) + pow($distY, 2)) / $maxDist;

                // Adjust for more center focus
                $dist = pow($dist, 0.8);

                // Blend colors based on distance
                $r = intval($centerColor['r'] * (1 - $dist) + $edgeColor['r'] * $dist);
                $g = intval($centerColor['g'] * (1 - $dist) + $edgeColor['g'] * $dist);
                $b = intval($centerColor['b'] * (1 - $dist) + $edgeColor['b'] * $dist);

                // Set pixel
                $pixelColor = imagecolorallocate($canvas, $r, $g, $b);
                imagesetpixel($canvas, $x, $y, $pixelColor);
            }
        }
    }

    /**
     * Load and resize an image with GD
     * @param string|int $imagePath
     * @param int $width
     * @param int $height
     *
     * @return false|GdImage
     * @throws Exception
     */
    protected function loadAndResizeImage(string|int $imagePath, int $width, int $height):GdImage|false
    {
        // Get image info
        if (is_int($imagePath)) {
            $imagePath = get_attached_file($imagePath);
        }

        if (empty($imagePath)) {
            return false;
        }
        $imageInfo = getimagesize($imagePath);

        // Create image from source based on file type
        switch ($imageInfo[2]) {
            case IMAGETYPE_JPEG:
                $sourceImage = imagecreatefromjpeg($imagePath);
                break;
            case IMAGETYPE_PNG:
                $sourceImage = imagecreatefrompng($imagePath);
                break;
            case IMAGETYPE_GIF:
                $sourceImage = imagecreatefromgif($imagePath);
                break;
            case IMAGETYPE_WEBP:
                $sourceImage = imagecreatefromwebp($imagePath);
                break;
            default:
                throw new Exception("Unsupported image type");
        }

        // Calculate dimensions while maintaining aspect ratio
        $sourceWidth = imagesx($sourceImage);
        $sourceHeight = imagesy($sourceImage);

        $sourceRatio = $sourceWidth / $sourceHeight;
        $targetRatio = $width / $height;

        if ($sourceRatio > $targetRatio) {
            // Image is wider than target, adjust width
            $newWidth = $height * $sourceRatio;
            $newHeight = $height;
        } else {
            // Image is taller than target, adjust height
            $newWidth = $width;
            $newHeight = $width / $sourceRatio;
        }

        // Create resized image
        $resizedImage = imagecreatetruecolor($width, $height);

        // Preserve transparency for PNG
        if ($imageInfo[2] === IMAGETYPE_PNG) {
            imagealphablending($resizedImage, false);
            imagesavealpha($resizedImage, true);
            $transparent = imagecolorallocatealpha($resizedImage, 255, 255, 255, 127);
            imagefilledrectangle($resizedImage, 0, 0, $width, $height, $transparent);
        }

        // Resize and crop to the center
        $srcX = (int)($sourceWidth - $width * ($sourceHeight / $height)) / 2;
        $srcY = (int)($sourceHeight - $height * ($sourceWidth / $width)) / 2;

        $srcX = ($srcX <0) ? 0 : $srcX;
        $srcY = ($srcY <0) ? 0 : $srcY;

        // Calculate source dimensions
        $srcWidth = (int)($sourceWidth - (2 * $srcX));
        $srcHeight = (int)($sourceHeight - (2 * $srcY));

        imagecopyresampled(
            $resizedImage,
            $sourceImage,
            0,
            0,
            $srcX,
            $srcY,
            $width,
            $height,
            $srcWidth,
            $srcHeight
        );

        // Free original image memory
        imagedestroy($sourceImage);

        return $resizedImage;
    }

    /**
     * Apply sepia and grayscale effect to GD image
     * @param GdImage $image
     *
     * @return void
     */
    protected function applyGDSepiaTone(GdImage $image):void
    {
        // First apply grayscale at 40%
        // To do this, we'll create a copy of the image, grayscale it completely,
        // then merge back at 40% opacity
        $width = imagesx($image);
        $height = imagesy($image);

        // Create a grayscale copy
        $gray = imagecreatetruecolor($width, $height);
        imagecopy($gray, $image, 0, 0, 0, 0, $width, $height);
        imagefilter($gray, IMG_FILTER_GRAYSCALE);

        // Merge back at 40%
        $this->imageCopyMergeAlpha($image, $gray, 0, 0, 0, 0, $width, $height, 40);
        imagedestroy($gray);

        // Now apply sepia at 60%
        // Sepia is essentially a color shift towards brown/yellow
        // We'll use colorize to achieve this, but at 60% strength
        imagefilter($image, IMG_FILTER_COLORIZE, 112, 66, 20, 60);
    }

    /**
     * @param GdImage $dst_im
     * @param GdImage $src_im
     * @param int $dst_x
     * @param int $dst_y
     * @param int $src_x
     * @param int $src_y
     * @param int $src_w
     * @param int $src_h
     * @param int $pct
     *
     * @return void
     */
    protected function imageCopyMergeAlpha(
        GdImage $dst_im,
        GdImage $src_im,
        int $dst_x,
        int $dst_y,
        int $src_x,
        int $src_y,
        int $src_w,
        int $src_h,
        int $pct
    ):void {
        // Creating a cut resource
        $cut = imagecreatetruecolor($src_w, $src_h);

        // Copying relevant section from destination image
        imagecopy($cut, $dst_im, 0, 0, $dst_x, $dst_y, $src_w, $src_h);

        // Copying relevant section from source image
        imagecopy($cut, $src_im, 0, 0, $src_x, $src_y, $src_w, $src_h);

        // Insert merged image at destination
        imagecopymerge($dst_im, $cut, $dst_x, $dst_y, 0, 0, $src_w, $src_h, $pct);

        imagedestroy($cut);
    }

    /**
     * Copy an image while preserving transparency
     * @param GdImage $destination
     * @param GdImage $source
     * @param int $destX
     * @param int $destY
     *
     * @return void
     */
    protected function copyImageWithTransparency(GdImage $destination, GdImage $source, int $destX, int $destY):void
    {
        $width = imagesx($source);
        $height = imagesy($source);

        imagecopy($destination, $source, $destX, $destY, 0, 0, $width, $height);

        // Free source memory
        imagedestroy($source);
    }

    /**
     * Convert hex color to RGB array
     * @param string $hexColor
     *
     * @return array
     */
    protected function hexToRgb(string $hexColor):array
    {
        $hex = ltrim($hexColor, '#');

        return [
            'r' => hexdec(substr($hex, 0, 2)),
            'g' => hexdec(substr($hex, 2, 2)),
            'b' => hexdec(substr($hex, 4, 2))
        ];
    }

    /**
     * Gets an array of icon data to loop over
     * @return array
     */
    protected function getIcons():array
    {
        $icons = [
            [
                'textY'         => 30,
                'icon'          => 'shop',
                'name'          => $this->data['shop']
            ],
            [
                'textY'         => 40,
                'icon'          => 'city',
                'name'          => $this->data['city']
            ],
        ];
        $styles = explode(',', $this->data['styles']);
        foreach ($styles as $style) {
            $icons[] = [
                'textY'         => 30,
                'icon'          => 'style',
                'name'          => $style
            ];
        }

        return $icons;
    }
}