<?php 

namespace Gogs\Lib\Curl {

    /** 
     * A trait used for every class referencing the api-url and token.
     *
     * @author Joachim M. Giaever (joachim[]giaever.org)
     * @package curl
     * @version 0.1.1
     */
    trait Client {
        private static $log = array();

        protected $url;
        protected $token;

        protected $user_agent = "Gogs PHP Api Curl\\Client/0.1 (compatible; LINUX)";
        protected $timeout = 30;
        protected $max_redirects = 4;

        /** 
         * array_2_params takes an array and converts it into a
         * query string (e.g param=val&param2=val2).
         *
         * @param array $params parameters to pass
         * @return string
         */
        private function array_2_params(array $params) {
            return join("&", array_map(function($k, $v) {
                return sprintf("%s=%s", $k, rawurlencode(is_bool($v) ? ($v ? "true" : "false") : $v ));
            }, array_keys($params), $params));
        }

        /** 
         * array_2_json takes an array and converts it into a
         * json-string (e.g {'name': 'This'}) which is typically
         * used in a request body.
         * 
         * @param array $params paramters to pass
         * @return string
         */
        private function array_2_json(array $params) {
            return count($params) == 0 ? null : json_encode($params);
        }

        /** 
         * Initializes a curl request of different kinds, depending
         * on the specified method. This can be
         *
         * DELETE, PATCH, POST or GET. An unidentified value will
         * become a GET-request.
         * 
         * @param string $method either DELETE, PATCH, POST, GET
         * @param string &$req variable to store request body in
         * @param string $scope scope within the API (e.g /user/repos)
         * @param array $params parameters to pass
         * @param bool $ret return transfer
         * @return int the status code
         */
        protected function method(string $method, string &$req, string $scope, array $params, bool $ret) {

            $c = curl_init();

            if (!$c) {
                return false;
            }

            $headers = array(
                sprintf("Authorization: token %s", $this->token),
            );

            $url = sprintf("%s%s", $this->url, $scope);

            self::$log[] = sprintf(
                "%s:[%s] %s, %s, %s", 
                date("y-m-d H:i:s"), 
                $method, 
                $url, 
                !empty($p = $this->array_2_json($params)) ? $p : "none",
                get_class($this)
            );

            if (in_array($method, array("DELETE", "PATCH", "POST"))) {
                $json = $this->array_2_json($params);
                curl_setopt($c, CURLOPT_CUSTOMREQUEST, $method);
                curl_setopt($c, CURLOPT_POSTFIELDS, $json);
                array_unshift($headers, "Content-Type: application/json");
                array_push($headers, "Content-Length: " . strlen($json));
            } else {
                $url .= "?" . $this->array_2_params($params);
            }

            curl_setopt($c, CURLOPT_USERAGENT, $this->user_agent);
            curl_setopt($c, CURLOPT_URL, $url);
            curl_setopt($c, CURLOPT_HTTPHEADER, $headers);
            curl_setopt($c, CURLOPT_RETURNTRANSFER, $ret);
            curl_setopt($c, CURLOPT_TIMEOUT, $this->timeout);
            curl_setopt($c, CURLOPT_MAXREDIRS, $this->max_redirects);
            curl_setopt($c, CURLOPT_FOLLOWLOCATION, true);

            $req = curl_exec($c);

            $status_code = curl_getinfo($c, CURLINFO_HTTP_CODE);

            curl_close($c);

            array_push(
                self::$log,
                sprintf(
                    "%s:[%s] %s, %d, %s", 
                    date("y-m-d H:i:s"), 
                    $method, 
                    $url,
                    $status_code,
                    substr($req, 0, 100) . (strlen($req) > 100 ? "..." : ".")
                )
            );

            return $status_code;
        }

        /** 
         * Checks if the user is authorized for the scope. Shouldn't
         * be used frequently. One test for one scope should be enough,
         * but if you know for sure thats you're programming with the
         * use of an authorized user you should leave this and just
         * handle the NotAuthorizedExeption whenever thrown.
         *
         * @param $scope the scope, a relative uri.
         * @throws Not AuthorizedException if server responde with a 401
         * @return bool
         */
        protected function authorized(string $scope = "") {
            $ret = "";
            if (in_array(($code = $this->method("GET", $ret, $scope, array(), false)),
                array(400, 401, 402, 403)
            )) {
                throw new NotAuthorizedException("Not authorized", 401);
            }
            return true;
        }

        /**
         * Post method.
         *
         * @param string $scope the scope, a relative uri.
         * @param array $params the parameters to post.
         * @throws NotAuthorizedException on 401, 403
         * @throws HTTPUnexpectedResponse when not 200,201,401,403
         * @return string the request content.
         */
        private function post(string $scope = "", array $params = array()) {
            $req = "";

            $code = $this->method("POST", $req, $scope, $params, true);

            switch ($code) {
            case 200:
            case 201:
                return $req;
            case 400:
            case 401:
            case 403:
                throw new Exception\NotAuthorizedException($req, $code);
            default:
                throw new Exception\HTTPUnexpectedResponse($req, $code);
            }
        }

        /**
         * Delete method.
         *
         * @param string $scope the scope, a relative uri.
         * @throws NotAuthorizedException on 401, 403
         * @throws HTTPUnexpectedResponse when not 200,204,401,403
         * @return string the request content.
         */
        private function delete(string $scope = "") {
            $req = "";

            $code = $this->method("DELETE", $req, $scope, array(), true);

            switch ($code) {
            case 200:
            case 204:
                return true;
            case 401:
            case 403:
                throw new Exception\NotAuthorizedException($req, $code);
            default:
                throw new Exception\HTTPUnexpectedResponse($req, $code);
            }
        }

        /**
         * GET method.
         *
         * @param string $scope the scope, a relative uri.
         * @param array $params the parameters to post.
         * @throws NotAuthorizedException on 401, 403
         * @throws HTTPUnexpectedResponse when not 200,401,403
         * @return string the request content.
         */
        private function get($scope = "", $params = array()) {
            $req = "";

            $code = $this->method("GET", $req, $scope, $params, true);

            switch ($code) {
            case 200:
                return $req;
            case 401:
            case 403:
                throw new Exception\NotAuthorizedException($req, $code);
            default:
                throw new Exception\HTTPUnexpectedResponse($req, $code);

            }
        }

        /**
         * Returns log entries for the client.
         * 
         * @return array
         */
        public static function get_log() {
            if (empty(self::$log))
                return self::$log;

            return array_merge(self::$log, array("\n"));
        }

    }

}
?>