<?php

namespace Zoomyboy\MedialibraryHelper;

use Illuminate\Foundation\Auth\Access\AuthorizesRequests;
use Illuminate\Http\JsonResponse;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Storage;
use Illuminate\Support\Str;
use Illuminate\Validation\Rule;
use Illuminate\Validation\ValidationException;
use Spatie\MediaLibrary\HasMedia;
use Spatie\MediaLibrary\MediaCollections\Models\Media;

class MediaController
{
    use AuthorizesRequests;

    public function store(Request $request)
    {
        $request->validate([
            'name' => 'string',
            'model' => ['required', 'string', Rule::in(app('media-library-helpers')->keys())],
        ]);

        $model = $this->validateModel($request);
        $this->authorize('storeMedia', $model);
        $collection = $model->getMediaCollection($request->input('collection'));
        $isSingle = 1 === $collection->collectionSizeLimit;

        $request->validate($isSingle ? [
            'payload' => 'array',
            'payload.name' => 'string|max:255',
            'payload.content' => 'string',
        ] : [
            'payload' => 'required|array|min:1',
            'payload.*' => 'array',
            'payload.*.name' => 'string',
            'payload.*.content' => 'string',
        ]);

        $content = $isSingle ? [$request->input('payload')] : $request->input('payload');

        $medias = collect([]);
        foreach ($content as $c) {
            if (property_exists($collection, 'forceFileRenamer')) {
                $fileRenamer = $collection->forceFileRenamer;
                $path = $fileRenamer($model, pathinfo($c['name'], PATHINFO_FILENAME)).'.'.pathinfo($c['name'], PATHINFO_EXTENSION);
            } else {
                $path = $c['name'];
            }
            Storage::disk('public')->put($path, base64_decode($c['content']));

            $adder = $model->addMedia(Storage::disk('public')->path($path));
            if (property_exists($collection, 'storingCallback')) {
                $callback = $collection->storingCallback;
                $adder = $callback($adder, $path);
            }
            $media = $adder->toMediaCollection($collection->name);
            $medias->push($media);

            if ($isSingle) {
                return MediaData::fromMedia($media);
            }
        }

        return MediaData::collection($medias);
    }

    public function index(Request $request, $parentModel, int $parentId, string $collection): JsonResponse
    {
        $model = app('media-library-helpers')->get($parentModel);
        $model = $model::find($parentId);
        $isSingle = $model->getMediaCollection($collection)->collectionSizeLimit;

        return response()->json([
            'data' => $isSingle ? $model->getFirstMedia($collection) : $model->getMedia($collection)->map(fn ($c) => $c->toArray()),
        ]);
    }

    public function destroy(Media $media, Request $request): JsonResponse
    {
        $this->authorize('destroyMedia', $media->model);
        $media->delete();

        return response()->json([]);
    }

    private function validateModel(Request $request): HasMedia
    {
        $model = app('media-library-helpers')->get($request->input('model'));

        $request->validate([
            'collection' => ['required', 'string', Rule::in((new $model())->getRegisteredMediaCollections()->map(fn ($collection) => $collection->name)->toArray())],
        ]);

        if (!$model::find($request->input('id'))) {
            throw ValidationException::withMessages(['model' => 'nicht gefunden']);
        }

        return $model::find($request->input('id'));
    }
}