* ?action=permanently_delete&path=
* ?action=upload&path=

The provided  values are joined to 'ROOT_FOLDER' class constant.

Can't create folders or download files.

Needs PHP 5.5+ for `finally` clauses.
 */

error_reporting(0);
require_once('../lib/StorageAPI/Controler.php');
require_once('../lib/StorageAPI/Exception.php');
StorageAPIControler::run('files/'); // IMPORTANT(nico) '/' at the end

getResult();
        }
        catch (Exception $exception) {
            $storage_api_exception = new StorageAPIException('Internal Server Error - '.$exception->getMessage(), 500);
            $result = $storage_api_exception->getResult();
        }

        self::output($result);
    }
    public static function output($result) {
        if(!isset($result['http_status_code']))
            $result['http_status_code'] = 200;
        if(!isset($result['http_status_message']))
            $result['http_status_message'] = 'OK';

        header('Access-Control-Allow-Origin: *');
        header('Cache-Control: no-cache, must-revalidate');
        header('Content-Type:application/json; charset=utf-8');
        echo json_encode($result);
    }

    public static function api_list_folder() {
        $path = self::readGET('path');
        $entries = self::list_folder($path);
        return [ 'entries'=> $result, 'has_more'=> false ];
    }
    public static function list_folder($path) {
        $abspath = self::abspath($path);
        $names = array_diff(scandir($abspath), array('..', '.'));
        $result = [];
        foreach ($names as $name) {
            $path = self::path_join($abspath, $name);

            $metadata = self::metadata($name, $path);
            if ($metadata['.tag'] != null) {
                // NOTE(nico) do not include info on 'undefined' filesystem items
                $result[] = $metadata;
            }
        }
        return $entries;
    }

    public static function api_permanently_delete() {
        $path = self::readGET('path');
        $status = self::permanently_delete($path);
        return []; // TODO
    }
    public static function permanently_delete($path) {
        $abspath = self::abspath($path);
        if (unlink($abspath)) {         // FIXME(nico) can trigger a warning, check file_exists first, and improve error reporting
            return true;
        }
        throw new StorageAPIException('Could not unlink file');
    }

    public static function api_upload() {
        $path = self::readGET('path');
        $result = self::upload($path);
    }
    public static function upload($path) {
        if ($_SERVER['REQUEST_METHOD'] !== 'POST') {
            throw new StorageAPIException('Bad Request - POST expected', 400);
        }

        $abspath = self::abspath($path);

        $temppath = tempnam(dirname($abspath), 'temp');
        if (!$temppath) {
            throw new StorageAPIException('"tempnam" failed', 500);
        }

        try {
            $dst = fopen($temppath, 'wb');
            $src = fopen('php://input', 'r'); // POST raw data

            try {
                if (!$src || !$dst) {
                    throw new StorageAPIException('Could not create file', 500);
                }
                // copy streams
                while ($data = fread($src, 1024))
                {
                    if ($data === false) {
                        throw new StorageAPIException('Could not read source data', 500);     // FIXME(nico) endpoint error ?
                    }
                    $written = fwrite($dst, $data, 1024);
                    if ($written != strlen($written)) {
                        throw new StorageAPIException('Could not write to file', 500);
                    }
                }

            }
            finally {
                fclose($src);
                fclose($dst);
            }

            // finalize destination file
            if (!rename($temppath, $abspath)) {
                throw new StorageAPIException('Could not finalize file', 500);
            }
        }
        finally {
            if (file_exists($temppath)) {
                unlink($temppath);
            }
        }

        $name = basename($abspath);
        $result = self::metadata($name, $abspath);
        return $result;
    }

    public static function api_default() {
        throw new StorageAPIException('Bad Request - Unknown action', 400);
    }

    public static function readGET($varname) {
        if (!isset($_GET[$varname])) {
            throw new StorageAPIException('Bad Request - Missing parameter "'.$varname.'"', 400);
        }
        return $_GET[$varname];
    }
    public static function metadata($name, $path) {
        $size = filesize($path);
        $server_modified = date(DATE_ISO8601, filemtime($path));
        $tag = null;
        if (is_dir($path)) {
            $tag = 'folder';
        }
        elseif (is_file($path)) {
            $tag = 'file';
        }
        return [ '.tag'=>$tag, 'name'=>$name, 'server_modified'=>$server_modified, 'size'=>$size];
    }
    public static function abspath($path) {
        return self::$ROOT_FOLDER . $path;       // FIXME(nico) security check, path should be absolute starting with '/'
    }
    public static function path_join($root, $path) {
        return $root . $path;            // FIXME(nico) check '/' & stuff
    }
}

['.tag'=>'other'], 'http_status_code'=>$this->getCode(), 'http_status_message'=>$this->getMessage()];
    }
}