<?php
class DocumentProcessor {
    private $srcImage;
    private $processedImage;
    private $outputPath;
    private $imageQualityMetrics;
    private $processingParams = []; // Declarar propriedade explicitamente
    
    public function __construct() {
        if (!extension_loaded('gd')) {
            throw new Exception('GD extension is required');
        }
    }

    public function processDocument($imagePath, $outputPath) {
        $this->outputPath = $outputPath;
        
        // Detecta o tipo da imagem e carrega
        $imageInfo = getimagesize($imagePath);
        if ($imageInfo === false) {
            throw new Exception('Failed to load image');
        }

        switch ($imageInfo[2]) {
            case IMAGETYPE_JPEG:
                $this->srcImage = imagecreatefromjpeg($imagePath);
                break;
            case IMAGETYPE_PNG:
                $this->srcImage = imagecreatefrompng($imagePath);
                break;
            default:
                throw new Exception('Unsupported image type');
        }

        if ($this->srcImage === false) {
            throw new Exception('Failed to create image resource');
        }

        // Analisa qualidade da imagem e define parâmetros
        $this->analyzeImageQuality()
             ->determineOptimalParameters();

        // Pipeline de processamento adaptativo
        $this->detectAndCropDocument()
             ->convertToGrayscale()
             ->applyAdaptiveEnhancements()
             ->saveResult();

        return $this->outputPath;
    }

    private function detectAndCropDocument() {
        $width = imagesx($this->srcImage);
        $height = imagesy($this->srcImage);
        
        // Cria cópia para processamento de detecção
        $work = imagecreatetruecolor($width, $height);
        imagecopy($work, $this->srcImage, 0, 0, 0, 0, $width, $height);
        
        // Prepara imagem para detecção de bordas
        imagefilter($work, IMG_FILTER_GAUSSIAN_BLUR);
        imagefilter($work, IMG_FILTER_GRAYSCALE);
        imagefilter($work, IMG_FILTER_CONTRAST, -10);
        
        // Detecta bordas com Sobel mais sensível
        $edges = $this->detectEdgesSobel($work);
        
        // Melhora a detecção de contornos
        $contourPoints = $this->findSignificantContours($edges);
        
        // Encontra os cantos do documento
        $corners = $this->findCornerPoints($contourPoints);
        
        if ($corners && $this->isValidQuadrilateral($corners)) {
            // Aplica transformação perspectiva mantendo cores
            $this->processedImage = $this->cropAndTransformColor($this->srcImage, $corners);
        } else {
            $this->processedImage = $this->srcImage;
        }
        
        imagedestroy($work);
        imagedestroy($edges);
        
        return $this;
    }

    private function findSignificantContours($edges) {
        $width = imagesx($edges);
        $height = imagesy($edges);
        $contourPoints = [];
        $threshold = 200; // Ajuste de sensibilidade
        
        // Passo adaptativo baseado no tamanho da imagem
        $step = max(1, min(3, (int)($width * $height / 1000000)));
        
        for ($x = 0; $x < $width; $x += $step) {
            for ($y = 0; $y < $height; $y += $step) {
                $rgb = imagecolorat($edges, $x, $y);
                if ($rgb > $threshold) {
                    $strength = $this->getEdgeStrength($edges, $x, $y);
                    if ($strength > 100) { // Filtro de força da borda
                        $contourPoints[] = [$x, $y];
                    }
                }
            }
        }
        
        return $contourPoints;
    }

    private function getEdgeStrength($img, $x, $y) {
        $sum = 0;
        $count = 0;
        
        // Analisa vizinhança 3x3
        for ($i = -1; $i <= 1; $i++) {
            for ($j = -1; $j <= 1; $j++) {
                if ($x + $i >= 0 && $x + $i < imagesx($img) && 
                    $y + $j >= 0 && $y + $j < imagesy($img)) {
                    $rgb = imagecolorat($img, $x + $i, $y + $j);
                    $colors = imagecolorsforindex($img, $rgb);
                    $sum += $colors['red'];
                    $count++;
                }
            }
        }
        
        return $count > 0 ? $sum / $count : 0;
    }

    private function isValidQuadrilateral($corners) {
        if (count($corners) !== 4) return false;
        
        // Verifica se os cantos formam um quadrilátero razoável
        $minArea = 1000; // Área mínima em pixels
        $area = $this->calculateQuadArea($corners);
        
        // Verifica proporções
        $width = max(abs($corners[1][0] - $corners[0][0]), abs($corners[2][0] - $corners[3][0]));
        $height = max(abs($corners[3][1] - $corners[0][1]), abs($corners[2][1] - $corners[1][1]));
        $ratio = $width / $height;
        
        return $area > $minArea && $ratio > 0.2 && $ratio < 5;
    }

    private function calculateQuadArea($corners) {
        // Calcula área usando fórmula do trapézio
        $area = 0;
        $n = count($corners);
        
        for ($i = 0; $i < $n; $i++) {
            $j = ($i + 1) % $n;
            $area += $corners[$i][0] * $corners[$j][1];
            $area -= $corners[$j][0] * $corners[$i][1];
        }
        
        return abs($area / 2);
    }

    private function cropAndTransformColor($img, $corners) {
        // Calcula dimensões baseadas nos cantos detectados
        $width = max(
            abs($corners[1][0] - $corners[0][0]),
            abs($corners[2][0] - $corners[3][0])
        );
        $height = max(
            abs($corners[3][1] - $corners[0][1]),
            abs($corners[2][1] - $corners[1][1])
        );
        
        $dest = imagecreatetruecolor($width, $height);
        
        // Mantém transparência se existir
        imagealphablending($dest, false);
        imagesavealpha($dest, true);
        
        // Pontos de origem e destino para a transformação
        $src_points = [];
        foreach ($corners as $corner) {
            $src_points[] = $corner[0];
            $src_points[] = $corner[1];
        }
        
        $dst_points = [
            0, 0,
            $width - 1, 0,
            $width - 1, $height - 1,
            0, $height - 1
        ];
        
        // Aplica transformação perspectiva mantendo cores
        if (function_exists('imagecreatetruecolor')) {
            $result = imagecopyresampled(
                $dest, $img,
                0, 0, min($src_points[0], $src_points[6]), min($src_points[1], $src_points[3]),
                $width, $height,
                max($src_points[2], $src_points[4]) - min($src_points[0], $src_points[6]),
                max($src_points[5], $src_points[7]) - min($src_points[1], $src_points[3])
            );
            
            if (!$result) {
                return $img; // Fallback para imagem original se falhar
            }
        }
        
        return $dest;
    }

    private function detectEdgesSobel($image) {
        $width = imagesx($image);
        $height = imagesy($image);
        $edges = imagecreatetruecolor($width, $height);
        
        // Kernels Sobel
        $sobelX = [[-1, 0, 1], [-2, 0, 2], [-1, 0, 1]];
        $sobelY = [[-1, -2, -1], [0, 0, 0], [1, 2, 1]];
        
        for ($x = 1; $x < $width-1; $x++) {
            for ($y = 1; $y < $height-1; $y++) {
                $pixelX = $pixelY = 0;
                
                // Aplica kernels
                for ($i = -1; $i <= 1; $i++) {
                    for ($j = -1; $j <= 1; $j++) {
                        $rgb = imagecolorat($image, $x + $i, $y + $j);
                        $colors = imagecolorsforindex($image, $rgb);
                        $gray = $colors['red'];
                        
                        $pixelX += $gray * $sobelX[$i+1][$j+1];
                        $pixelY += $gray * $sobelY[$i+1][$j+1];
                    }
                }
                
                // Magnitude do gradiente
                $magnitude = min(255, sqrt($pixelX * $pixelX + $pixelY * $pixelY));
                
                // Aplica threshold para reduzir ruído
                $magnitude = ($magnitude > 50) ? 255 : 0;
                
                $color = imagecolorallocate($edges, $magnitude, $magnitude, $magnitude);
                imagesetpixel($edges, $x, $y, $color);
            }
        }
        
        return $edges;
    }

    private function findDocumentBounds($binary) {
        $width = imagesx($binary);
        $height = imagesy($binary);
        $left = $width;
        $right = 0;
        $top = $height;
        $bottom = 0;

        // Encontra os limites do documento
        for ($x = 0; $x < $width; $x++) {
            for ($y = 0; $y < $height; $y++) {
                $rgb = imagecolorat($binary, $x, $y);
                if ($rgb == 0) { // Pixel preto
                    $left = min($left, $x);
                    $right = max($right, $x);
                    $top = min($top, $y);
                    $bottom = max($bottom, $y);
                }
            }
        }

        if ($left < $right && $top < $bottom) {
            return [
                'left' => $left,
                'right' => $right,
                'top' => $top,
                'bottom' => $bottom
            ];
        }

        return null;
    }

    private function isEdgePoint($img, $x, $y) {
        $threshold = 30;
        
        // Verifica pixels vizinhos
        $center = $this->getPixelIntensity($img, $x, $y);
        $left = $this->getPixelIntensity($img, $x - 1, $y);
        $right = $this->getPixelIntensity($img, $x + 1, $y);
        $top = $this->getPixelIntensity($img, $x, $y - 1);
        $bottom = $this->getPixelIntensity($img, $x, $y + 1);
        
        return (abs($center - $left) > $threshold ||
                abs($center - $right) > $threshold ||
                abs($center - $top) > $threshold ||
                abs($center - $bottom) > $threshold);
    }

    private function getPixelIntensity($img, $x, $y) {
        if ($x < 0 || $y < 0 || $x >= imagesx($img) || $y >= imagesy($img)) {
            return 0;
        }
        
        $rgb = imagecolorat($img, $x, $y);
        $colors = imagecolorsforindex($img, $rgb);
        return ($colors['red'] + $colors['green'] + $colors['blue']) / 3;
    }

    private function findCornerPoints($points) {
        // Encontra os pontos mais extremos
        $topLeft = null;
        $topRight = null;
        $bottomLeft = null;
        $bottomRight = null;
        $minSum = PHP_FLOAT_MAX;
        $maxSum = PHP_FLOAT_MIN;
        $minDiff = PHP_FLOAT_MAX;
        $maxDiff = PHP_FLOAT_MIN;
        
        foreach ($points as $point) {
            $sum = $point[0] + $point[1];
            $diff = $point[0] - $point[1];
            
            if ($sum < $minSum) {
                $minSum = $sum;
                $topLeft = $point;
            }
            if ($sum > $maxSum) {
                $maxSum = $sum;
                $bottomRight = $point;
            }
            if ($diff < $minDiff) {
                $minDiff = $diff;
                $bottomLeft = $point;
            }
            if ($diff > $maxDiff) {
                $maxDiff = $diff;
                $topRight = $point;
            }
        }
        
        if ($topLeft && $topRight && $bottomLeft && $bottomRight) {
            return [$topLeft, $topRight, $bottomRight, $bottomLeft];
        }
        
        return null;
    }

    private function cropAndTransform($img, $corners) {
        $width = abs($corners[1][0] - $corners[0][0]);
        $height = abs($corners[3][1] - $corners[0][1]);
        
        $dest = imagecreatetruecolor($width, $height);
        
        // Preserva transparência
        imagealphablending($dest, false);
        imagesavealpha($dest, true);
        
        // Define pontos de destino
        $dest_points = [
            0, 0,
            $width - 1, 0,
            $width - 1, $height - 1,
            0, $height - 1
        ];
        
        // Define pontos de origem
        $src_points = [];
        foreach ($corners as $corner) {
            $src_points[] = $corner[0];
            $src_points[] = $corner[1];
        }
        
        // Aplica transformação perspectiva
        imagecopyresampled(
            $dest, $img,
            0, 0, min($src_points[0], $src_points[6]), min($src_points[1], $src_points[3]),
            $width, $height,
            max($src_points[2], $src_points[4]) - min($src_points[0], $src_points[6]),
            max($src_points[5], $src_points[7]) - min($src_points[1], $src_points[3])
        );
        
        return $dest;
    }

    private function convertToGrayscale() {
        if (!isset($this->processedImage)) {
            $this->processedImage = $this->srcImage;
        }
        
        imagefilter($this->processedImage, IMG_FILTER_GRAYSCALE);
        return $this;
    }

    private function enhanceContrast() {
        $width = imagesx($this->processedImage);
        $height = imagesy($this->processedImage);
        
        // Calcula histograma
        $histogram = array_fill(0, 256, 0);
        for ($x = 0; $x < $width; $x++) {
            for ($y = 0; $y < $height; $y++) {
                $rgb = imagecolorat($this->processedImage, $x, $y);
                $colors = imagecolorsforindex($this->processedImage, $rgb);
                $histogram[$colors['red']]++;
            }
        }
        
        // Encontra limites para stretch
        $min = 0;
        $max = 255;
        $pixelCount = $width * $height;
        $cutoffPercent = 0.005; // 0.5%
        
        $sum = 0;
        for ($i = 0; $i < 256; $i++) {
            $sum += $histogram[$i];
            if ($sum >= $pixelCount * $cutoffPercent) {
                $min = $i;
                break;
            }
        }
        
        $sum = 0;
        for ($i = 255; $i >= 0; $i--) {
            $sum += $histogram[$i];
            if ($sum >= $pixelCount * $cutoffPercent) {
                $max = $i;
                break;
            }
        }
        
        // Aplica contrast stretching
        for ($x = 0; $x < $width; $x++) {
            for ($y = 0; $y < $height; $y++) {
                $rgb = imagecolorat($this->processedImage, $x, $y);
                $colors = imagecolorsforindex($this->processedImage, $rgb);
                $gray = $colors['red'];
                
                // Normaliza valor
                $newGray = ($gray - $min) * (255 / ($max - $min));
                $newGray = min(255, max(0, $newGray));
                
                $color = imagecolorallocate($this->processedImage, $newGray, $newGray, $newGray);
                imagesetpixel($this->processedImage, $x, $y, $color);
            }
        }
        
        return $this;
    }

    private function sharpenImage() {
        $sharpenMatrix = [
            [-1, -1, -1],
            [-1, 16, -1],
            [-1, -1, -1]
        ];
        
        $this->applyConvolution($sharpenMatrix);
        
        // Ajuste fino pós-sharpening
        imagefilter($this->processedImage, IMG_FILTER_CONTRAST, -5);
        
        return $this;
    }

    private function applyConvolution($matrix) {
        if (!$this->processedImage) {
            return $this;
        }

        $width = imagesx($this->processedImage);
        $height = imagesy($this->processedImage);
        $temp = imagecreatetruecolor($width, $height);
        
        if (!$temp) {
            return $this;
        }

        imagecopy($temp, $this->processedImage, 0, 0, 0, 0, $width, $height);

        $matrixSize = count($matrix);
        $halfSize = floor($matrixSize / 2);

        for ($x = $halfSize; $x < $width - $halfSize; $x++) {
            for ($y = $halfSize; $y < $height - $halfSize; $y++) {
                $r = $g = $b = 0;
                
                for ($i = -$halfSize; $i <= $halfSize; $i++) {
                    for ($j = -$halfSize; $j <= $halfSize; $j++) {
                        $rgb = imagecolorat($temp, $x + $i, $y + $j);
                        $colors = imagecolorsforindex($temp, $rgb);
                        
                        $weight = $matrix[$i + $halfSize][$j + $halfSize];
                        $r += $colors['red'] * $weight;
                        $g += $colors['green'] * $weight;
                        $b += $colors['blue'] * $weight;
                    }
                }

                $r = min(255, max(0, $r));
                $g = min(255, max(0, $g));
                $b = min(255, max(0, $b));

                $color = imagecolorallocate($this->processedImage, $r, $g, $b);
                imagesetpixel($this->processedImage, $x, $y, $color);
            }
        }

        imagedestroy($temp);
        return $this;
    }

    private function removeNoise() {
        // Aplica filtro mediano
        $temp = imagecreatetruecolor(imagesx($this->processedImage), imagesy($this->processedImage));
        imagecopy($temp, $this->processedImage, 0, 0, 0, 0, imagesx($this->processedImage), imagesy($this->processedImage));
        
        for ($x = 1; $x < imagesx($this->processedImage) - 1; $x++) {
            for ($y = 1; $y < imagesy($this->processedImage) - 1; $y++) {
                $values = array();
                // Coleta valores dos pixels vizinhos
                for ($i = -1; $i <= 1; $i++) {
                    for ($j = -1; $j <= 1; $j++) {
                        $rgb = imagecolorat($temp, $x + $i, $y + $j);
                        $colors = imagecolorsforindex($temp, $rgb);
                        $values[] = $colors['red'];
                    }
                }
                sort($values);
                $median = $values[4]; // Valor mediano
                $color = imagecolorallocate($this->processedImage, $median, $median, $median);
                imagesetpixel($this->processedImage, $x, $y, $color);
            }
        }
        
        imagedestroy($temp);
        return $this;
    }

    private function adjustBrightnessContrast() {
        // Ajustes mais suaves
        imagefilter($this->processedImage, IMG_FILTER_BRIGHTNESS, 5);
        imagefilter($this->processedImage, IMG_FILTER_CONTRAST, -8);
        return $this;
    }

    private function normalizeBackground() {
        if (!$this->processedImage) {
            return $this;
        }

        $width = imagesx($this->processedImage);
        $height = imagesy($this->processedImage);
        
        // Corrigir loop infinito na amostragem das bordas
        $samples = [];
        $borderSize = 10;
        
        // Amostra pixels das bordas com índice y corrigido
        for ($x = 0; $x < $width; $x++) {
            for ($y = 0; $y < $borderSize; $y++) {
                $rgb = imagecolorat($this->processedImage, $x, $y);
                $colors = imagecolorsforindex($this->processedImage, $rgb);
                $samples[] = $colors['red'];
            }
            // Corrigir incremento do y
            for ($y = $height - $borderSize; $y < $height; $y++) {
                $rgb = imagecolorat($this->processedImage, $x, $y);
                $colors = imagecolorsforindex($this->processedImage, $rgb);
                $samples[] = $colors['red'];
            }
        }
        
        $mean = array_sum($samples) / count($samples);
        $stdDev = sqrt(array_sum(array_map(function($x) use ($mean) {
            return pow($x - $mean, 2);
        }, $samples)) / count($samples));
        
        // Normaliza fundo usando estatísticas
        $threshold = $mean - ($stdDev * 2.5);
        for ($x = 0; $x < $width; $x++) {
            for ($y = 0; $y < $height; $y++) {
                $rgb = imagecolorat($this->processedImage, $x, $y);
                $colors = imagecolorsforindex($this->processedImage, $rgb);
                
                if ($colors['red'] > $threshold) {
                    $color = imagecolorallocate($this->processedImage, 255, 255, 255);
                    imagesetpixel($this->processedImage, $x, $y, $color);
                }
            }
        }
        
        return $this;
    }

    private function saveResult() {
        if (!isset($this->processedImage)) {
            throw new Exception('No processed image to save');
        }

        $extension = strtolower(pathinfo($this->outputPath, PATHINFO_EXTENSION));
        
        switch ($extension) {
            case 'jpg':
            case 'jpeg':
                imagejpeg($this->processedImage, $this->outputPath, 90);
                break;
            case 'png':
                imagepng($this->processedImage, $this->outputPath, 9);
                break;
            default:
                throw new Exception('Unsupported output image type');
        }

        if (is_resource($this->srcImage)) {
            imagedestroy($this->srcImage);
        }
        if (is_resource($this->processedImage)) {
            imagedestroy($this->processedImage);
        }

        return $this;
    }

    private function getAdaptiveThreshold($image) {
        $width = imagesx($image);
        $height = imagesy($image);
        $blockSize = 40; // Tamanho do bloco para threshold adaptativo
        $C = 10; // Constante de ajuste
        
        // Cria imagem para o resultado
        $result = imagecreatetruecolor($width, $height);
        
        // Para cada bloco
        for ($x = 0; $x < $width; $x += $blockSize) {
            for ($y = 0; $y < $height; $y += $blockSize) {
                // Calcula média do bloco
                $sum = 0;
                $count = 0;
                
                $blockW = min($blockSize, $width - $x);
                $blockH = min($blockSize, $height - $y);
                
                for ($bx = 0; $bx < $blockW; $bx++) {
                    for ($by = 0; $by < $blockH; $by++) {
                        $rgb = imagecolorat($image, $x + $bx, $y + $by);
                        $colors = imagecolorsforindex($image, $rgb);
                        $gray = $colors['red']; // Já está em escala de cinza
                        $sum += $gray;
                        $count++;
                    }
                }
                
                // Calcula threshold local
                $threshold = ($count > 0) ? ($sum / $count) - $C : 128;
                
                // Aplica threshold ao bloco
                for ($bx = 0; $bx < $blockW; $bx++) {
                    for ($by = 0; $by < $blockH; $by++) {
                        $rgb = imagecolorat($image, $x + $bx, $y + $by);
                        $colors = imagecolorsforindex($image, $rgb);
                        $gray = $colors['red'];
                        
                        if ($gray > $threshold) {
                            $color = imagecolorallocate($result, 255, 255, 255);
                        } else {
                            $color = imagecolorallocate($result, 0, 0, 0);
                        }
                        
                        imagesetpixel($result, $x + $bx, $color);
                    }
                }
            }
        }
        
        return $threshold;
    }

    private function analyzeImageQuality() {
        if (!$this->srcImage) {
            $this->imageQualityMetrics = [
                'brightness' => 0,
                'contrast' => 0,
                'noise' => 0,
                'blur' => 0
            ];
            return $this;
        }

        $width = imagesx($this->srcImage);
        $height = imagesy($this->srcImage);
        
        // Reduz a amostragem para análise mais rápida
        $sampleStep = max(1, (int)($width * $height / 100000));
        $histogram = array_fill(0, 256, 0);
        $totalSamples = 0;
        
        // Amostragem reduzida para cálculo mais rápido
        for ($x = 0; $x < $width; $x += $sampleStep) {
            for ($y = 0; $y < $height; $y += $sampleStep) {
                $rgb = imagecolorat($this->srcImage, $x, $y);
                $colors = imagecolorsforindex($this->srcImage, $rgb);
                $gray = (int)(($colors['red'] + $colors['green'] + $colors['blue']) / 3);
                $histogram[$gray]++;
                $totalSamples++;
            }
        }
        
        $this->imageQualityMetrics = [
            'brightness' => $this->calculateAverageBrightness($histogram, $totalSamples),
            'contrast' => $this->calculateImageContrast($histogram, $totalSamples),
            'noise' => $this->estimateImageNoise(50), // Reduz número de amostras
            'blur' => $this->estimateBlurLevel(100)   // Reduz número de amostras
        ];
        
        return $this;
    }

    private function determineOptimalParameters() {
        // Define parâmetros baseados nas métricas
        $this->processingParams = [
            'contrast_adjustment' => $this->calculateContrastAdjustment(),
            'brightness_adjustment' => $this->calculateBrightnessAdjustment(),
            'sharpen_intensity' => $this->calculateSharpenIntensity(),
            'noise_reduction' => $this->calculateNoiseReduction()
        ];
        
        return $this;
    }

    private function applyAdaptiveEnhancements() {
        if (!$this->processedImage || !isset($this->processingParams)) {
            return $this;
        }

        $params = $this->processingParams;
        
        // Verifica e aplica ajustes com validação de parâmetros
        if (isset($params['brightness_adjustment']) || isset($params['contrast_adjustment'])) {
            $brightness = isset($params['brightness_adjustment']) ? (int)$params['brightness_adjustment'] : 0;
            $contrast = isset($params['contrast_adjustment']) ? (int)$params['contrast_adjustment'] : 0;
            $this->applyBrightnessContrastOptimized($brightness, $contrast);
        }

        if (isset($params['noise_reduction']) && $params['noise_reduction'] > 0) {
            $this->applyFastNoiseReduction((int)$params['noise_reduction']);
        }

        if (isset($params['sharpen_intensity']) && $params['sharpen_intensity'] > 0) {
            $this->applyFastSharpening((int)$params['sharpen_intensity']);
        }

        return $this;
    }

    private function calculateAverageBrightness($histogram, $totalPixels) {
        $sum = 0;
        for ($i = 0; $i < 256; $i++) {
            $sum += $i * $histogram[$i];
        }
        return $sum / $totalPixels;
    }

    private function calculateImageContrast($histogram, $totalPixels) {
        $mean = $this->imageQualityMetrics['brightness'];
        $variance = 0;
        
        for ($i = 0; $i < 256; $i++) {
            $variance += pow($i - $mean, 2) * ($histogram[$i] / $totalPixels);
        }
        
        return sqrt($variance);
    }

    private function estimateImageNoise($samples = 50) {
        $width = imagesx($this->srcImage);
        $height = imagesy($this->srcImage);
        $noise = 0;
        
        // Reduz número de amostras e otimiza cálculo
        for ($i = 0; $i < $samples; $i++) {
            $x = rand(1, $width - 2);
            $y = rand(1, $height - 2);
            $noise += $this->fastLocalVariance($x, $y);
        }
        
        return $noise / $samples;
    }

    private function estimateBlurLevel() {
        if (!$this->processedImage) {
            return 0;
        }

        // Cria uma cópia temporária para aplicar o Laplaciano
        $width = imagesx($this->processedImage);
        $height = imagesy($this->processedImage);
        $temp = imagecreatetruecolor($width, $height);
        
        if (!$temp) {
            return 0;
        }
        
        imagecopy($temp, $this->processedImage, 0, 0, 0, 0, $width, $height);
        
        $laplacian = [
            [0, 1, 0],
            [1, -4, 1],
            [0, 1, 0]
        ];
        
        $blurValue = $this->applyConvolutionSafe($temp, $laplacian);
        imagedestroy($temp);
        
        return $blurValue;
    }

    private function calculateContrastAdjustment() {
        $contrast = $this->imageQualityMetrics['contrast'];
        $optimal = 128; // Valor ideal de contraste
        
        if ($contrast < $optimal * 0.7) {
            return (int)round(min(50, (1 - $contrast/$optimal) * 100));
        } elseif ($contrast > $optimal * 1.3) {
            return (int)round(max(-50, ($optimal/$contrast - 1) * 100));
        }
        
        return 0;
    }

    private function calculateBrightnessAdjustment() {
        $brightness = $this->imageQualityMetrics['brightness'];
        $optimal = 128; // Valor ideal de brilho
        
        // Forçar conversão explícita para inteiro
        return (int)round(($optimal - $brightness) * 0.5);
    }

    private function calculateSharpenIntensity() {
        $blurLevel = $this->imageQualityMetrics['blur'];
        return (int)round(min(100, $blurLevel * 50));
    }

    private function calculateNoiseReduction() {
        $noise = $this->imageQualityMetrics['noise'];
        return (int)round(min(5, $noise * 2));
    }

    private function calculateLocalVariance($x, $y) {
        $values = [];
        $windowSize = 3;
        $halfWindow = floor($windowSize / 2);
        
        // Coleta valores na janela
        for ($i = -$halfWindow; $i <= $halfWindow; $i++) {
            for ($j = -$halfWindow; $j <= $halfWindow; $j++) {
                $px = $x + $i;
                $py = $y + $j;
                
                if ($px >= 0 && $px < imagesx($this->srcImage) && 
                    $py >= 0 && $py < imagesy($this->srcImage)) {
                    $rgb = imagecolorat($this->srcImage, $px, $py);
                    $colors = imagecolorsforindex($this->srcImage, $rgb);
                    $values[] = ($colors['red'] + $colors['green'] + $colors['blue']) / 3;
                }
            }
        }
        
        // Calcula variância local
        if (count($values) > 0) {
            $mean = array_sum($values) / count($values);
            $variance = array_sum(array_map(function($v) use ($mean) {
                return pow($v - $mean, 2);
            }, $values)) / count($values);
            return $variance;
        }
        
        return 0;
    }

    private function calculateVariance($image) {
        $width = imagesx($image);
        $height = imagesy($image);
        $values = [];
        
        // Amostra de pixels para cálculo
        $sampleSize = min(1000, $width * $height);
        for ($i = 0; $i < $sampleSize; $i++) {
            $x = rand(0, $width - 1);
            $y = rand(0, $height - 1);
            $rgb = imagecolorat($image, $x, $y);
            $colors = imagecolorsforindex($image, $rgb);
            $values[] = ($colors['red'] + $colors['green'] + $colors['blue']) / 3;
        }
        
        if (count($values) > 0) {
            $mean = array_sum($values) / count($values);
            return array_sum(array_map(function($v) use ($mean) {
                return pow($v - $mean, 2);
            }, $values)) / count($values);
        }
        
        return 0;
    }

    private function applyAdaptiveNoiseReduction($intensity) {
        $width = imagesx($this->processedImage);
        $height = imagesy($this->processedImage);
        $temp = imagecreatetruecolor($width, $height);
        imagecopy($temp, $this->processedImage, 0, 0, 0, 0, $width, $height);
        
        // Garantir que intensity seja inteiro
        $intensity = (int)$intensity;
        $windowSize = 2 * $intensity + 1;
        $halfWindow = (int)floor($windowSize / 2);
        
        for ($x = $halfWindow; $x < $width - $halfWindow; $x++) {
            for ($y = $halfWindow; $y < $height - $halfWindow; $y++) {
                $values = [];
                
                for ($i = -$halfWindow; $i <= $halfWindow; $i++) {
                    for ($j = -$halfWindow; $j <= $halfWindow; $j++) {
                        $rgb = imagecolorat($temp, $x + $i, $y + $j);
                        $colors = imagecolorsforindex($temp, $rgb);
                        $values[] = $colors['red'];
                    }
                }
                
                sort($values);
                // Garantir índice inteiro para o valor mediano
                $medianIndex = (int)floor(count($values) / 2);
                $median = $values[$medianIndex];
                $color = imagecolorallocate($this->processedImage, $median, $median, $median);
                imagesetpixel($this->processedImage, $x, $y, $color);
            }
        }
        
        imagedestroy($temp);
        return $this;
    }

    private function applyAdaptiveSharpening($intensity) {
        $matrix = [
            [-1, -1, -1],
            [-1, 8 + $intensity, -1],
            [-1, -1, -1]
        ];
        
        $this->applyConvolution($matrix);
        return $this;
    }

    private function applyConvolutionSafe($image, $matrix) {
        if (!$image) {
            return 0;
        }

        $width = imagesx($image);
        $height = imagesy($image);
        $temp = imagecreatetruecolor($width, $height);
        
        if (!$temp) {
            return 0;
        }

        imagecopy($temp, $image, 0, 0, 0, 0, $width, $height);
        $variance = 0;
        
        $matrixSize = count($matrix);
        $halfSize = floor($matrixSize / 2);

        // Calcula apenas uma amostra para performance
        $sampleSize = min(1000, $width * $height);
        $values = [];

        for ($i = 0; $i < $sampleSize; $i++) {
            $x = rand($halfSize, $width - $halfSize - 1);
            $y = rand($halfSize, $height - $halfSize - 1);
            
            $sum = 0;
            for ($mx = -$halfSize; $mx <= $halfSize; $mx++) {
                for ($my = -$halfSize; $my <= $halfSize; $my++) {
                    $rgb = imagecolorat($temp, $x + $mx, $y + $my);
                    $colors = imagecolorsforindex($temp, $rgb);
                    $gray = ($colors['red'] + $colors['green'] + $colors['blue']) / 3;
                    $sum += $gray * $matrix[$mx + $halfSize][$my + $halfSize];
                }
            }
            $values[] = abs($sum);
        }

        imagedestroy($temp);
        
        if (count($values) > 0) {
            return array_sum($values) / count($values);
        }
        
        return 0;
    }

    // Método auxiliar para verificar recursos de imagem
    private function isValidImage($image) {
        return $image && is_resource($image) || (is_object($image) && $image instanceof GdImage);
    }

    private function ensureProcessedImage() {
        if (!$this->processedImage) {
            $this->processedImage = $this->srcImage;
        }
        return $this->isValidImage($this->processedImage);
    }

    // Adicionar método para garantir valores inteiros
    private function ensureInteger($value) {
        return (int)round($value);
    }

    private function fastLocalVariance($x, $y) {
        $sum = 0;
        $sumSq = 0;
        $count = 0;
        
        // Analisa apenas 4 pixels vizinhos em vez de 9
        $positions = [
            [$x, $y],
            [$x-1, $y],
            [$x+1, $y],
            [$x, $y-1],
            [$x, $y+1]
        ];
        
        foreach ($positions as [$px, $py]) {
            $rgb = imagecolorat($this->srcImage, $px, $py);
            $colors = imagecolorsforindex($this->srcImage, $rgb);
            $value = ($colors['red'] + $colors['green'] + $colors['blue']) / 3;
            $sum += $value;
            $sumSq += $value * $value;
            $count++;
        }
        
        $mean = $sum / $count;
        return ($sumSq / $count) - ($mean * $mean);
    }

    private function applyBrightnessContrastOptimized($brightness, $contrast) {
        $width = imagesx($this->processedImage);
        $height = imagesy($this->processedImage);
        
        // Pré-calcula tabela de lookup para otimizar
        $lookup = array_fill(0, 256, 0);
        for ($i = 0; $i < 256; $i++) {
            $value = $i;
            if ($brightness != 0) {
                $value += $brightness;
            }
            if ($contrast != 0) {
                $value = (($value - 128) * (1 + $contrast/100)) + 128;
            }
            $lookup[$i] = min(255, max(0, (int)$value));
        }
        
        // Aplica lookup table em uma única passagem
        for ($x = 0; $x < $width; $x++) {
            for ($y = 0; $y < $height; $y++) {
                $rgb = imagecolorat($this->processedImage, $x, $y);
                $colors = imagecolorsforindex($this->processedImage, $rgb);
                $newColor = imagecolorallocate(
                    $this->processedImage,
                    $lookup[$colors['red']],
                    $lookup[$colors['green']],
                    $lookup[$colors['blue']]
                );
                imagesetpixel($this->processedImage, $x, $y, $newColor);
            }
        }
    }

    private function applyFastNoiseReduction($intensity) {
        if (!$this->processedImage) {
            return $this;
        }

        $width = imagesx($this->processedImage);
        $height = imagesy($this->processedImage);
        
        // Otimização: processa apenas uma parte dos pixels
        $step = max(1, (int)($intensity / 2));
        
        for ($x = 0; $x < $width - 2; $x += $step) {
            for ($y = 0; $y < $height - 2; $y += $step) {
                $values = [];
                
                // Coleta 5 pixels em vez de 9 para maior velocidade
                $pixels = [
                    [$x, $y],
                    [$x + 1, $y],
                    [$x, $y + 1],
                    [$x + 1, $y + 1],
                    [$x + 2, $y + 2]
                ];
                
                foreach ($pixels as [$px, $py]) {
                    if ($px < $width && $py < $height) {
                        $rgb = imagecolorat($this->processedImage, $px, $py);
                        $colors = imagecolorsforindex($this->processedImage, $rgb);
                        $values[] = $colors['red'];
                    }
                }
                
                if (!empty($values)) {
                    sort($values);
                    $median = $values[(int)(count($values) / 2)];
                    $color = imagecolorallocate($this->processedImage, $median, $median, $median);
                    if ($color !== false) {
                        imagesetpixel($this->processedImage, $x, $y, $color);
                    }
                }
            }
        }
        
        return $this;
    }

    private function applyFastSharpening($intensity) {
        if (!$this->processedImage) {
            return $this;
        }

        // Matriz de sharpening otimizada
        $matrix = [
            [-0.5, -0.5, -0.5],
            [-0.5, 6 + ($intensity * 0.1), -0.5],
            [-0.5, -0.5, -0.5]
        ];

        $width = imagesx($this->processedImage);
        $height = imagesy($this->processedImage);
        $temp = imagecreatetruecolor($width, $height);
        
        if (!$temp) {
            return $this;
        }

        imagecopy($temp, $this->processedImage, 0, 0, 0, 0, $width, $height);
        
        // Processamento otimizado com passo variável
        $step = max(1, min(3, (int)($width * $height / 1000000)));
        
        for ($x = 1; $x < $width - 1; $x += $step) {
            for ($y = 1; $y < $height - 1; $y += $step) {
                $r = $g = $b = 0;
                
                for ($i = -1; $i <= 1; $i++) {
                    for ($j = -1; $j <= 1; $j++) {
                        $rgb = imagecolorat($temp, $x + $i, $y + $j);
                        $colors = imagecolorsforindex($temp, $rgb);
                        $weight = $matrix[$i + 1][$j + 1];
                        
                        $r += $colors['red'] * $weight;
                        $g += $colors['green'] * $weight;
                        $b += $colors['blue'] * $weight;
                    }
                }

                $r = min(255, max(0, (int)$r));
                $g = min(255, max(0, (int)$g));
                $b = min(255, max(0, (int)$b));

                $color = imagecolorallocate($this->processedImage, $r, $g, $b);
                if ($color !== false) {
                    imagesetpixel($this->processedImage, $x, $y, $color);
                }
            }
        }

        imagedestroy($temp);
        return $this;
    }
}