<?php

namespace App\Http\Controllers;

use App\Repositories\MediaCategoriesRepository;
use App\Traits\PureAjaxMethodProtectable;
use App\Traits\UploadedFileProccessable;
use App\MediaFile;
use App\Repositories\MediaFileRepository;
use Illuminate\Database\Eloquent\Collection;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Http\Request;
use Storage;
use Str;
use Auth;
use Gate;
use Validator;

/**
 * 媒體檔案
 *
 * Class MediaLibraryController
 * @package App\Http\Controllers
 */
class MediaLibraryController extends Controller
{
    use PureAjaxMethodProtectable;

    use UploadedFileProccessable;

    private $mediaFileRepository;

    private $mediaCategoriesRepository;

    public function __construct(MediaFileRepository $mediaFileRepository, MediaCategoriesRepository $mediaCategoriesRepository)
    {
        $this->mediaFileRepository = $mediaFileRepository;
        $this->mediaCategoriesRepository = $mediaCategoriesRepository;
    }

    /**
     * 建立response資料
     *
     * @param MediaFile $mediaFile
     * @return array
     */
    private function createResponseMediaFile(MediaFile $mediaFile)
    {
        $mediaCategory = $mediaFile->mediaCategory;
        return [
            'id'          => $mediaFile->id,
            'fileName'    => $mediaFile->file_name,
            'url'         => $mediaFile->url,
            'date'        => $mediaFile->created_at->format('Y-m-d H:i:s'),
            'mimeType'    => $mediaFile->mime_type,
            'description' => $mediaFile->description,
            'sizeInBytes' => $mediaFile->size,
            'width'       => $mediaFile->width,
            'height'      => $mediaFile->height,
            'category'    => [
                'id' => $mediaCategory ? $mediaCategory->id : 'uncategorized',
                'name' => $mediaCategory ? $mediaCategory->name : ''
            ]
        ];
    }

    private function hasAppMediaPermission()
    {
        return Gate::allows("permission:manage-app-medias");
    }

    public function hasAppMediaCategoryPermission()
    {
        return Gate::allows('permission:manage-app-media-categories');
    }

    /**
     * 新增媒體檔案
     *
     * @param Request $request
     * @return \Illuminate\Http\JsonResponse
     * @throws \Exception
     */
    public function fileUpload(Request $request)
    {
        $this->protectFromNoneAjaxRequest($request);

        if(Auth::check()) {
            /** @var \Symfony\Component\HttpFoundation\File\UploadedFile $file */
            $file = $request->files->get('media_file');
            if($file) {
                $userId = Auth::id();
                if($this->hasAppMediaPermission()) {
                    $uploadedMediaFile = $this->uploadMediaFile($file, 1, $userId, null, true);
                } else {
                    $uploadedMediaFile = $this->uploadMediaFile($file, 2, $userId, $userId);
                }

                $success = false;

                if($uploadedMediaFile) {
                    $category = $request->get('category');
                    if($this->mediaCategoriesRepository->hasCategory($category)) {
                        $uploadedMediaFile->media_category_id = $category;
                        $uploadedMediaFile->save();
                    }
                    $success = true;
                }

                if($success) {
                    return response()->json([
                        'media' => $this->createResponseMediaFile($uploadedMediaFile),
                        'category' => $category
                    ]);
                } else {
                    return response()->json([], 400);
                }
            }
        } else {
            return response()->json([], 401);
        }
    }

    /**
     * 取得媒體檔案
     *
     * @param Request $request
     * @param null $page
     * @return \Illuminate\Http\JsonResponse
     * @throws \Illuminate\Validation\ValidationException
     */
    public function getMedias(Request $request, $page = null)
    {
        $this->protectFromNoneAjaxRequest($request);

        $this->validate($request, [
            'category_id' => 'required'
        ]);

        $responseData = [
            'medias' => []
        ];

        $lastQueryId = $request->get('last_fetched_media_id');
        $category = $request->get('category_id');
        $limit = $request->get('limit');
        $mediaFiles = [];
        if(Auth::check()) {
            $userId = Auth::id();
            if($this->hasAppMediaPermission()) {
                if($lastQueryId) {
                    $mediaFiles = $this->mediaFileRepository->getAppMediasWithLastQueryIdAndCategory($lastQueryId, $category, $limit ? $limit : 14);
                } else {
                    $mediaFiles = $this->mediaFileRepository->getAppMediasWithCategory($category, $limit ? $limit : 35);
                }
            } else {
                if($lastQueryId) {
                    $mediaFiles = $this->mediaFileRepository->getUserMediasWithLastQueryIdAndCategory($userId, $category, $lastQueryId, $limit ? $limit : 14);
                } else {
                    $mediaFiles = $this->mediaFileRepository->getUserMediasWithCategory($userId, $category, $limit ? $limit : 35);
                }
            }
            foreach ($mediaFiles as $mediaFile) {
                $responseData['medias'][] = $this->createResponseMediaFile($mediaFile);
            }
            return response()->json($responseData);
        } else {
            return response()->json($responseData, 401);
        }
    }

    /**
     * 更新媒體檔案
     *
     * @param Request $request
     * @param $mediaId
     * @return \Illuminate\Http\JsonResponse
     */
    public function updateMedia(Request $request, $mediaId)
    {
        $this->protectFromNoneAjaxRequest($request);

        $status = 200;
        if(Auth::check()) {
            $media = $this->mediaFileRepository->getMedia($mediaId);
            if($media) {
                if($this->hasAppMediaPermission()) {
                    if(!$media->is_app_media) {
                        $status = 403;
                    }
                } else {
                    if(!$media->user->id == Auth::id()) {
                        $status = 403;
                    }
                }
            } else {
                $status = 404;
            }
        } else {
            $status = 401;
        }

        if($status == 200) {
            $media->description = $request->get('description');
            $mediaCategoryId = $request->get('category_id');
            $mediaCategoryId = $mediaCategoryId == 'uncategorized' ? null : $mediaCategoryId;
            $media->media_category_id = $mediaCategoryId;
            $saved = $media->save();
            if($saved) {
                return response()->json([
                    'message' => trans('message.descriptionHasBeenUpdated')
                ]);
            } else {
                return response()->json([
                    'message' => trans('message.failToUpdateDescription')
                ], 400);
            }
        } else {
            return response()->json([
                'message' => trans('message.failToUpdateDescription')
            ], $status);
        }
    }

    /**
     * 刪除媒體檔案
     *
     * @param Request $request
     * @param $mediaId
     * @return \Illuminate\Http\JsonResponse
     * @throws \Exception
     */
    public function deleteMedia(Request $request, $mediaId)
    {
        $this->protectFromNoneAjaxRequest($request);

        $status = 200;
        if(Auth::check()) {
            $media = $this->mediaFileRepository->getMedia($mediaId);
            if($media) {
                if($this->hasAppMediaPermission()) {
                    if(!$media->is_app_media) {
                        $status = 403;
                    }
                } else {
                    if(!$media->user->id == Auth::id()) {
                        $status = 403;
                    }
                }
            } else {
                $status = 404;
            }
        } else {
            $status = 401;
        }

        if($status == 200) {
            $deleted = $media->delete();
            if($deleted) {
                return response()->json([
                    'id' => $media->id,
                    'categoryId' => $media->media_category_id ? $media->media_category_id : 'uncategorized',
                    'message' => trans('message.mediaHasBeenDeleted')
                ]);
            } else {
                return response()->json([
                    'message' => trans('message.failToDeleteMedia')
                ], 400);
            }
        } else {
            return response()->json([
                'message' => trans('message.failToDeleteMedia')
            ], $status);
        }
    }

    /**
     * 更新媒體檔案的分類
     *
     * @param Request $request
     * @return \Illuminate\Http\JsonResponse
     * @throws \Illuminate\Validation\ValidationException
     */
    public function updateCategory(Request $request)
    {
        $this->protectFromNoneAjaxRequest($request);

        $this->validate($request, [
            'category_id' => 'required',
            'media_ids' => 'required'
        ]);

        $status = 200;
        if(Auth::check()) {
            $userId = Auth::id();
            $categoryId = $request->get('category_id');
            $mediaIds = $request->get('media_ids');
            $mediaIds = is_array($mediaIds) ? $mediaIds : explode(',', $request->get('media_ids'));
            $mediaFiles = collect($mediaIds)->map(function($mediaId){
                return $this->mediaFileRepository->getMedia($mediaId);
            });
            $mediaCategory = $this->mediaCategoriesRepository->getCategory($categoryId);

            $existenceCheck = true;
            if($categoryId != 'uncategorized') {
                $existenceCheck = $existenceCheck && $mediaCategory;
            }

            foreach ($mediaFiles as $mediaFile) {
                $existenceCheck = $existenceCheck && $mediaFile;
            }

            if($existenceCheck) {
                $permissionCheck = true;
                $hasAppMediaCategoryPermission = $this->hasAppMediaCategoryPermission();
                $hasAppMediaPermisssion = $this->hasAppMediaPermission();
                foreach ($mediaFiles as $mediaFile) {
                    if($hasAppMediaPermisssion) {
                        $permissionCheck = $permissionCheck && $mediaFile->is_app_media;
                    } else {
                        $permissionCheck = $permissionCheck && ($mediaFile->user_id == $userId);
                    }
                }
                if($mediaCategory) {
                    if($hasAppMediaCategoryPermission) {
                        $permissionCheck = $permissionCheck && $mediaCategory->is_app_media_category;
                    } else {
                        $permissionCheck = $permissionCheck && ($mediaCategory->user_id == $userId);
                    }
                }


                if($permissionCheck) {
                    $categorySources = [];
                    $mediaCategoryId = $mediaCategory ? $mediaCategory->id : null;
                    foreach ($mediaFiles as $mediaFile) {
                        $oldCategoryId = $mediaFile->media_category_id ? $mediaFile->media_category_id : 'uncategorized';
                        if(!isset($categorySources[$oldCategoryId])) {
                            $categorySources[$oldCategoryId] = 0;
                        }
                        $categorySources[$oldCategoryId]++;

                        $mediaFile->media_category_id = $mediaCategoryId;
                        $mediaFile->save();
                    }
                } else {
                    $status = 403;
                }

            } else {
                $status = 403;
            }

        } else {
            $status = 401;
        }

        if($status == 200) {
            $message = $mediaCategory
                ? trans('message.mediaHasBeenMoveToCategory', ['name' => $mediaCategory->name])
                : trans('message.mediaHasBeenSetToUncategorized');
            return response()->json([
                'mediaIds' => $mediaIds,
                'categoryId' => $categoryId,
                'categorySources' => $categorySources,
                'message' => $message
            ]);
        } else {
            return response()->json([
                'message' => trans('message.failToMoveMediaToCategory')
            ], $status);
        }
    }
}