<?php

declare(strict_types=1);

namespace Leadlion\Autogedal\Cron;

use Amasty\ImageOptimizer\Api\ImageQueueServiceInterface;
use Amasty\ImageOptimizer\Model\Image\ForceOptimization;
use Amasty\ImageOptimizer\Model\Image\GenerateQueue;
use Amasty\ImageOptimizer\Model\Image\ImageSetting;
use Amasty\ImageOptimizer\Model\ImageProcessor;
use Amasty\ImageOptimizer\Model\Queue\Queue;
use Amasty\ImageOptimizerUi\Model\Image\ResourceModel\CollectionFactory;
use Leadlion\Autogedal\Logger\ImageOptimizer as ImageOptimizerLogger;

class ImageOptimizerCron
{
    private const BATCH_SIZE = 50;
    private const MAX_EXECUTION_SECONDS = 1800;

    public function __construct(
        private CollectionFactory $collectionFactory,
        private GenerateQueue $generateQueue,
        private ImageQueueServiceInterface $queueService,
        private ImageProcessor $imageProcessor,
        private ImageOptimizerLogger $logger
    ) {
    }

    public function execute(): void
    {
        return;
        $this->logger->info('ImageOptimizerCron: Starting.');

        $cronQueueSize = $this->queueService->getQueueSize(Queue::CRON);

        if ($cronQueueSize === 0) {
            $imageSettings = $this->getEnabledImageSettings();

            if (empty($imageSettings)) {
                $this->logger->warning('ImageOptimizerCron: No enabled image settings found in Amasty Image Optimizer admin.');
                return;
            }

            $added = $this->generateQueue->generateQueueByType($imageSettings, Queue::CRON);
            $this->logger->info(sprintf('ImageOptimizerCron: Queue generated — %d images queued.', $added));

            if ($added === 0) {
                $this->logger->info('ImageOptimizerCron: All images already optimized, nothing to do.');
                return;
            }
        } else {
            $this->logger->info(sprintf('ImageOptimizerCron: Resuming from previous run — %d images remaining.', $cronQueueSize));
        }

        $processed = 0;
        $failed = 0;
        $startTime = time();

        while ($this->queueService->getQueueSize(Queue::CRON) > 0) {
            if (time() - $startTime > self::MAX_EXECUTION_SECONDS) {
                $remaining = $this->queueService->getQueueSize(Queue::CRON);
                $this->logger->info(sprintf(
                    'ImageOptimizerCron: Time limit (30min) reached. Processed: %d, Failed: %d, Remaining: %d. Will continue next run.',
                    $processed,
                    $failed,
                    $remaining
                ));
                return;
            }

            $batch = $this->queueService->shuffleQueues(self::BATCH_SIZE, [Queue::CRON]);

            if (empty($batch)) {
                break;
            }

            foreach ($batch as $queue) {
                $filename = $queue->getFilename();
                try {
                    $this->imageProcessor->process($queue);
                    $processed++;
                    $this->logger->info(sprintf('OK: %s', $filename));
                } catch (\Exception $e) {
                    $failed++;
                    $this->logger->error(sprintf('FAIL: %s — %s', $filename, $e->getMessage()));
                }
            }
        }

        $this->logger->info(sprintf(
            'ImageOptimizerCron: Done. Processed: %d, Failed: %d.',
            $processed,
            $failed
        ));
    }

    private function getEnabledImageSettings(): array
    {
        $collection = $this->collectionFactory->create();
        $collection->addFilter(ImageSetting::IS_ENABLED, true);
        return $collection->getItems();
    }
}