<?php

namespace Aweos\Resizer\Classes;

use Aweos\Resizer\Exceptions\ResizerException;
use Aweos\Resizer\Lib\MediaPath;
use Aweos\Resizer\Models\Setting;
use Illuminate\Filesystem\FilesystemAdapter;
use Illuminate\Support\Collection;
use Media\Classes\MediaLibrary;
use October\Rain\Resize\Resizer;
use Storage;

class ImageResizer
{

    private FilesystemAdapter $disk;
    private string $uploadDir;
    private MediaLibrary $media;
    private MediaPath $file;

    public function __construct(FilesystemAdapter $disk, string $uploadDir, MediaLibrary $media)
    {
        $this->disk = $disk;
        $this->uploadDir = $uploadDir;
        $this->media = $media;
    }

    public function generate(MediaPath $file): void
    {
        $this->file = $file;

        if (!$file->exists()) {
            throw new ResizerException('File versions cannot be generated. Root file "'.$file->root().'" doesnt exist.');
        }

        if ($this->file->compressor()->shouldGenerateVersions()) {
            $this->generateVersions();
        }
    }

    private function dimensions(): Collection
    {
        [$width, $height] = $this->file->compressor()->originalSize();

        return collect(compact('width', 'height'));
    }

    private function sizes(): Collection
    {
        $sizes = Setting::get('sizes');

        return collect(array_column($sizes, 'aspect_ratio'))->map(
            fn ($ratio) => collect(array_combine(['width', 'height'], explode('x', $ratio))),
        );
    }

    private function possibleSizes(): Collection
    {
        $return = collect([]);
        $ratios = collect();
        $ratios->push($this->dimensions());
        $ratios = $ratios->merge($this->sizes());

        foreach (collect(Setting::get('breakpoints'))->push($this->dimensions()->get('width'))->unique() as $size) {
            foreach ($ratios as $ratio) {
                $width = $size;
                $height = $size * $ratio->get('height') / $ratio->get('width');

                if ($height > $this->dimensions()->get('height')) {
                    $width = $width * $this->dimensions()->get('height') / $height;
                    $height = $this->dimensions()->get('height');
                }

                if (ceil($width) > $this->dimensions()->get('width') || ceil($height) > $this->dimensions()->get('height')) {
                    continue;
                }

                $return->push(collect([
                    'width' => round($width),
                    'height' => round($height),
                ]));
            }
        }

        return $return;
    }

    private function generateVersions(): void
    {
        foreach ($this->possibleSizes() as $size) {
            $this->file->compressor()->resize($this->file->root(), $this->file->versionsDirPath(), $size);
        }

        foreach ($this->file->versions() as $version) {
            if (!$this->disk->exists($version->get('path'))) {
                throw new ResizerException('File versions cannot be generated. Version file "'.$version->get('path').'" of "'.$this->file->root().'" doesnt exist.');
            }
            $this->file->compressor()->make($this->disk->path($version->get('path')));
        }
    }

}