<?php
declare(strict_types=1);

namespace Cundd\Rest\Handler;

use Cundd\Rest\DataProvider\DataProviderInterface;
use Cundd\Rest\DataProvider\Utility;
use Cundd\Rest\Exception;
use Cundd\Rest\Http\RestRequestInterface;
use Cundd\Rest\Log\LoggerInterface;
use Cundd\Rest\ObjectManagerInterface;
use Cundd\Rest\ResponseFactoryInterface;
use Cundd\Rest\Router\Route;
use Cundd\Rest\Router\RouterInterface;
use Iterator;
use IteratorAggregate;
use LimitIterator;
use Psr\Http\Message\ResponseInterface;
use TYPO3\CMS\Core\Http\UploadedFile;
use TYPO3\CMS\Core\Resource\DuplicationBehavior;
use TYPO3\CMS\Core\Resource\ResourceFactory;
use TYPO3\CMS\Core\Resource\ResourceStorage;
use TYPO3\CMS\Core\Utility\GeneralUtility;
use TYPO3\CMS\Core\Database\ConnectionPool;
use TYPO3\CMS\Core\Resource\Folder;


/**
 * Handler for default CRUD requests
 */
class PortalHandler implements CrudHandlerInterface, HandlerDescriptionInterface
{
    /**
     * Object Manager
     *
     * @var ObjectManagerInterface
     */
    protected ObjectManagerInterface $objectManager;

    protected ResponseFactoryInterface $responseFactory;

    private LoggerInterface $logger;

    private ResourceFactory $resourceFactory;

    /**
     * Handler constructor
     *
     * @param ObjectManagerInterface   $objectManager
     * @param ResponseFactoryInterface $responseFactory
     * @param LoggerInterface          $logger
     * @param ResourceFactory          $resourceFactory
     */
    public function __construct(
        ObjectManagerInterface $objectManager,
        ResponseFactoryInterface $responseFactory,
        LoggerInterface $logger,
        ResourceFactory $resourceFactory
    ) {
        $this->objectManager = $objectManager;
        $this->responseFactory = $responseFactory;
        $this->logger = $logger;
        $this->resourceFactory = $resourceFactory;
    }

    public function getDescription(): string
    {
        return 'Default Handler for Portal CRUD requests';
    }

    public function create(RestRequestInterface $request)
    {
        $storage = $this->resourceFactory->getStorageObject(1); // 1 = fileadmin uid => [ Table = sys_file_storage ]
        $folder = null;
        $response = array();
        $response["request"] = $_REQUEST;
        try {
            if ($_SERVER["REQUEST_METHOD"] == "POST") {
                $type = $_REQUEST['type']; // create [ create , edit ], delete , rename [ delete old => create new ]
                if(!empty($_REQUEST['path'])) {
                    $filePath = $this->decodeBase64($_REQUEST['path']);
                    // split path
                    $paths = preg_split("#/#", $filePath);
                    foreach ($paths as $value) {
                        // check if Folder exist
                        if($folder == null) {
                            if(!$storage->hasFolder($value)){
                                // create the Folder
                                $folder = $storage->createFolder($value);
                            }else{
                                $folder = $storage->getFolder($value);
                            }
                        }else{
                            if(!$storage->hasFolderInFolder($value,$folder)){
                                // create the Folder
                                $folder = $storage->createFolder($value,$folder);
                            }else{
                                $folder = $storage->getFolderInFolder($value,$folder);
                            }
                        }
                    }
                    if($folder == null) {
                        $response["exception"] = "(error) folder of path '$filePath' should not be null";
                        return $response;
                    }
                }

                switch ($type) {
                    case "create";
                        $response = $this->requestCreate($storage, $folder);
                        break;
                    case "rename";
                        $response = $this->requestRename($storage, $folder);
                        break;
                    case "move";
                        $response = $this->requestMove($storage, $folder);
                        break;
                    case "update";
                        $response = $this->requestUpdate();
                        break;
                    case "get";
                        $response = $this->requestGet($storage);
                        break;
                    case "delete";
                        $response = $this->requestDelete($storage);
                }
            }
        } catch (Exception $ex) {
            $response["exception"] = "(error) $ex->getMessage()";
        }
        if (empty($response)) {
            $response["message"] = "(error) Invalid request";
        }
        return $response;
    }

    private function requestCreate(ResourceStorage $storage, Folder $folder) {

        $response = array();

        $fileError = $_FILES['file']['error'];
        if ($fileError == UPLOAD_ERR_OK) {
            $fileName = $this->decodeBase64($_REQUEST['fileName']);
            if (is_uploaded_file($_FILES["file"]["tmp_name"])) {
                // upload Image
                $result = $storage->addUploadedFile($_FILES["file"], $folder, $fileName, DuplicationBehavior::REPLACE);
                $response["object"]["properties"] = $result->getProperties();
                $response["message"] = "(create) (info) '$fileName' was Upload success";
            } else {
                $response["message"] = "(create) (error) couldn't upload '$fileName'";
            }
        } else {
            $response["message"] = "(create) (error) Upload failed : $fileError";
        }
        return $response;
    }

    private function requestGet(ResourceStorage $storage){
        $response = array();

        $fileUid = $_REQUEST['uid'];
        if(!empty($fileUid)){
            $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)->getQueryBuilderForTable('sys_file');
            $statement = $queryBuilder
                ->select("identifier")
                ->from('sys_file')
                ->where(
                    $queryBuilder->expr()->eq('uid', $queryBuilder->createNamedParameter($fileUid))
                )
                ->execute();
            $identifier = '';
            while ($row = $statement->fetch()) {
                $identifier = $row['identifier'];
            }
            if(!empty($identifier)) {
                $result = $storage->getFile($identifier);
                $response["object"]["properties"] = $result->getProperties();
                $response["message"] = "(get) (info) get success";
            }else{
                $response["message"] = "(get) (error) 'identifier' can not be empty.";
            }
        }else{
            $response["message"] = "(get) (error) 'uid' can not be empty '$fileUid'";
        }
        return $response;
    }

    private function requestRename(ResourceStorage $storage, Folder $folder) {
        $response = array();

        $fileUid = $_REQUEST['uid'];
        $newName = $this->decodeBase64($_REQUEST['newName']);
        if(!empty($fileUid) && !empty($newName)) {
            $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)->getQueryBuilderForTable('sys_file');
            $statement = $queryBuilder
                ->select("identifier")
                ->from('sys_file')
                ->where(
                    $queryBuilder->expr()->eq('uid', $queryBuilder->createNamedParameter($fileUid))
                )
                ->execute();
            $identifier = '';
            while ($row = $statement->fetch()) {
                $identifier = $row['identifier'];
            }
            if(!empty($identifier)) {
                $renamedFile = $storage->getFile($identifier);
                $result = $storage->renameFile($renamedFile, $newName,DuplicationBehavior::RENAME);
                $response["object"]["properties"] = $result->getProperties();
                $response["message"] = "(rename) (info) renamed success";
            }else{
                $response["message"] = "(rename) (error) couldn't rename '$identifier' to '$newName' -> file does not exist ";
            }
        }else{
            $response["message"] = "(rename) (error) couldn't rename, 'uid' and 'newName' can not be empty ('$fileUid','$newName')";
        }
        return $response;
    }

    private function requestUpdate(){
        $response = array();

        $decodedData = $this->decodeBase64($_REQUEST['data']);
        $dataArray = json_decode($decodedData, true);
        $fileUid = $_REQUEST['uid'];
        $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)->getQueryBuilderForTable('sys_file_metadata');
        if(!empty($fileUid) && !empty($dataArray)){
            foreach ($dataArray as $key => $value) {
                $queryBuilder
                    ->update('sys_file_metadata')
                    ->where(
                        $queryBuilder->expr()->eq('uid', $queryBuilder->createNamedParameter($fileUid))
                    )
                    ->set($key, $value)
                    ->execute();
            }
            $response["message"] = "(update) (info) update success";
        }else{
            $response["message"] = "(update) (warn) couldn't update, 'uid' and 'metadata' must be provided.";
        }
        return $response;
    }

    private function requestMove(ResourceStorage $storage, Folder $folder) {
        $response = array();

        $fileUid = $_REQUEST['uid'];
        $newName = $this->decodeBase64($_REQUEST['newName']);

        if(!empty($fileUid)) {
            $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)->getQueryBuilderForTable('sys_file');
            $statement = $queryBuilder
                ->select("identifier")
                ->from('sys_file')
                ->where(
                    $queryBuilder->expr()->eq('uid', $queryBuilder->createNamedParameter($fileUid))
                )
                ->execute();
            $identifier = '';
            while ($row = $statement->fetch()) {
                $identifier = $row['identifier'];
            }
            if(!empty($identifier)) {
                $movedFile = $storage->getFile($identifier);
                $oldParentFolder = $movedFile->getParentFolder();
                if(!empty($newName)) {
                    $result = $movedFile->moveTo($folder, $newName, $conflictMode=DuplicationBehavior::REPLACE);
                    $response["object"]["properties"] = $result->getProperties();
                    $response["message"] = "(move) (info) moved success";
                }else {
                    $result = $movedFile->moveTo($folder,  $movedFile->getName(), $conflictMode=DuplicationBehavior::REPLACE);
                    $response["object"]["properties"] = $result->getProperties();
                    $response["message"] = "(move) (info) moved success";
                }
                $this->deleteEmptyFolders($storage, $oldParentFolder);
            }else{
                $response["message"] = "(move) (error) couldn't move '$identifier' -> file does not exist ";
            }
        }else{
            $response["message"] = "(move) (error) couldn't move, 'uid' is empty ('$fileUid')";
        }
        return $response;
    }

    private function requestDelete(ResourceStorage $storage) {
        $response = array();

        $fileUid = $_REQUEST['uid'];
        if(!empty($fileUid)) {
            $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)->getQueryBuilderForTable('sys_file');
            $statement = $queryBuilder
                ->select("identifier")
                ->from('sys_file')
                ->where(
                    $queryBuilder->expr()->eq('uid', $queryBuilder->createNamedParameter($fileUid))
                )
                ->execute();
            $identifier = '';
            while ($row = $statement->fetch()) {
                $identifier = $row['identifier'];
            }
            if(!empty($identifier)) {
                $deleteFile = $storage->getFile($identifier);
                $parentFolder = $deleteFile->getParentFolder();
                $storage->deleteFile($deleteFile);
                $this->deleteEmptyFolders($storage, $parentFolder);
                $response["message"] = "(delete) (info) File deleted successfully";
            }else{
                $response["message"] = "(delete) (info) File already deleted or not found";
            }
        }else{
            $response["message"] = "(delete) (error) couldn't delete, 'uid' is empty ('$fileUid')";
        }
        return $response;
    }

    private function deleteEmptyFolders(ResourceStorage $storage, Folder $folder) {
        if ($folder == null) {
            return;
        }
        if ($folder->getFileCount() == 0 && count($folder->getSubfolders()) == 0) {
            $storage->deleteFolder($folder, true);
        }
        if ($folder->getParentFolder() != null && $folder !=$folder->getParentFolder() ) {
            $this->deleteEmptyFolders($storage, $folder->getParentFolder());
        }
    }

    private function decodeBase64($value): string {
        if(!empty($value)) {
            return base64_decode($value);
        }
        return $value;
    }

    public function show(RestRequestInterface $request, string $identifier)
    {
        $dataProvider = $this->getDataProvider($request);
        $model = $dataProvider->fetchModel($identifier, $request->getResourceType());
        if (!$model) {
            return $this->responseFactory->createErrorResponse(null, 404, $request);
        }
        $result = $dataProvider->getModelData($model);

        return $this->prepareResult($request, $result);
    }
    public function listAll(RestRequestInterface $request): iterable
    {
        $response = array();
        try{
            $dataProvider = $this->getDataProvider($request);
            $allModels = $dataProvider->fetchAllModels($request->getResourceType());

            $response = $this->prepareResult(
                $request,
                array_map([$dataProvider, 'getModelData'], $this->sliceResults($allModels)),
                false
            );
        } catch (Exception $exceptionex) {
            $response["exception"] = $exceptionex->getMessage();
        }
        if (empty($response)) {
            $response["message"] = "Invalid request";
        }
        return $response;
    }
    public function getProperty(RestRequestInterface $request, string $identifier, string $propertyKey)
    {
        $resourceType = $request->getResourceType();
        $dataProvider = $this->getDataProvider($request);
        $model = $dataProvider->fetchModel($identifier, $resourceType);
        if (!$model) {
            return $this->responseFactory->createErrorResponse(null, 404, $request);
        }

        return $dataProvider->getModelProperty($model, $propertyKey);
    }
    protected function sliceResults($models)
    {
        $limit = $this->getListLimit();
        if (is_array($models)) {
            return array_slice($models, 0, $limit, true);
        }
        if ($models instanceof IteratorAggregate) {
            $models = $models->getIterator();
        }
        if ($models instanceof Iterator) {
            return iterator_to_array(new LimitIterator($models, 0, $limit));
        }
        return $models;
    }
    protected function getListLimit(): int
    {
        return PHP_INT_MAX;
    }

    public
    function delete(RestRequestInterface $request, string $identifier)
    {
        $response = array();
        $response["request"] = $request;
        $response["data"] = $request->getSentData();
        $response["identifier"] = $identifier;
        return $response;
    }

    /**
     * @return bool
     */
    public
    function options()
    {
        // TODO: Respond with the correct preflight headers
        return true;
    }

    public
    function configureRoutes(RouterInterface $router, RestRequestInterface $request)
    {
        $resourceType = $request->getResourceType();
//        $router->add(Route::get($resourceType . '/?', [$this, 'listAll']));
//        $router->add(Route::get($resourceType . '/{slug}/?', [$this, 'show']));
//        $router->add(Route::get($resourceType . '/{slug}/{slug}/?', [$this, 'getProperty']));
        $router->add(Route::post($resourceType . '/?', [$this, 'create']));
    }

    /**
     * Return the Data Provider
     *
     * @param RestRequestInterface $request
     * @return DataProviderInterface
     */
    protected
    function getDataProvider(RestRequestInterface $request)
    {
        return $this->objectManager->getDataProvider($request);
    }

    /**
     * Add the root object key if configured
     *
     * @param RestRequestInterface $request
     * @param mixed $result
     * @param bool $singularize
     * @return mixed|array
     */
    protected
    function prepareResult(RestRequestInterface $request, $result, $singularize = true)
    {
        if ($this->getAddRootObjectForCollection()) {
            $key = $singularize ? Utility::singularize($request->getRootObjectKey()) : $request->getRootObjectKey();

            return [$key => $result];
        }

        return $result;
    }

    /**
     * Return if the root object key should be added to the response data
     *
     * @return bool
     */
    protected
    function getAddRootObjectForCollection()
    {
        return (bool)$this->objectManager->getConfigurationProvider()->getSetting('addRootObjectForCollection');
    }

    /**
     * @inheritDoc
     */
    public
    function update(RestRequestInterface $request, string $identifier)
    {
        // TODO: Implement update() method.
    }

    /**
     * @inheritDoc
     */
    public
    function countAll(RestRequestInterface $request): int
    {
        // TODO: Implement countAll() method.
        return -1;
    }
}