http.kx

_namespace Net {

    _class Http {
        var curl_ = Net.createCurlHandler();
        var dbgCallback_;
        var postData_;
        var buf_ = new String.Buffer();
        var hdr_ = new String.Buffer();

        public clear() {
            buf_.clear();
            hdr_.clear();
        }

        public reset() {
            curl_.resetHandler();
            dbgCallback_ = null;
            curl_.debugDetail = false;
            return this;
        }

        public sslVerifyPeer(tf) {
            curl_.setOptionInt(Net.CURLOPT_SSL_VERIFYPEER, tf);
            return this;
        }

        public sslVerifyHost(verify) {
            curl_.setOptionInt(Net.CURLOPT_SSL_VERIFYHOST, verify ? 2 : 0);
            return this;
        }

        public sslSetCaInfo(path) {
            curl_.setOptionString(Net.CURLOPT_CAINFO, path);
            return this;
        }

        public sslSetCaPath(path) {
            curl_.setOptionString(Net.CURLOPT_CAPATH, path);
            return this;
        }

        public setDebugDetail(tf, opts) {
            curl_.debugDetail = tf && ((opts.hex ?? 1) << 1) | tf;
            return this;
        }

        public setUserPassword(user, pass) {
            curl_.setOptionInt(Net.CURLOPT_USERPWD, user + ":" + pass);
            return this;
        }

        public setProxy(url) {
            curl_.setOptionInt(Net.CURLOPT_PROXY, url);
            return this;
        }

        public setProxyUserPassword(user, pass) {
            curl_.setOptionInt(Net.CURLOPT_PROXYUSERPWD, user + ":" + pass);
            return this;
        }

        public setTimeout(millisec) {
            curl_.setOptionInt(Net.CURLOPT_TIMEOUT_MS, millisec);
            curl_.setOptionInt(Net.CURLOPT_CONNECTTIMEOUT_MS, millisec);
            curl_.setOptionInt(Net.CURLOPT_ACCEPTTIMEOUT_MS, millisec);
            curl_.setOptionInt(Net.CURLOPT_EXPECT_100_TIMEOUT_MS, millisec);
            curl_.setOptionInt(Net.CURLOPT_HAPPY_EYEBALLS_TIMEOUT_MS, millisec);
            return this;
        }

        public setDebug(callback) {
            dbgCallback_ = callback;
            curl_.setOptionInt(Net.CURLOPT_VERBOSE, 1);
            return this;
        }

        public addHeader(key, value) {
            if (value.isUndefined) {
                curl_.appendSlist("%{key};");
            } else {
                curl_.appendSlist("%{key}: %{value}");
            }
            return this;
        }

        public removeHeader(key) {
            curl_.appendSlist("%{key}:");
            return this;
        }

        public setRedirect(tf, opts) {
            curl_.setOptionInt(Net.CURLOPT_FOLLOWLOCATION, tf);
            if (opts.max.isInteger) {
                curl_.setOptionInt(Net.CURLOPT_MAXREDIRS, opts.max);
            }
            return this;
        }

        public setPostData(data) {
            # Use this only when POST, otherwise ignore it.
            if (data.isObject) {
                data = data.toJsonString();
            }
            postData_ = data;
            return this;
        }

        public makeResponse(data) {
            var b, h = data.find(/((?:.|\r?\n)+?)\r?\n\r?\n/);
            if (h) {
                b = data.subString(h[0].end);
                h = h[1].string;
            } else {
                b = data;
                h = "";
            }
            var r = h.isDefined && h.split(/\r?\n/).map(&(l) => l.split(/:\s*/)).reduce(&(r, e) => {
                var m = e[0].find(/HTTP[^\s]+\s+([0-9]+)\s/);
                if (m) {
                    r.code = m[1].string.toInt();
                } else {
                    var x = e[1];
                    if (x =~ /^[1-9][0-9]*$/) {
                        x = x.toInt();
                    }
                    r[e[0]] = x;
                }
                return r;
            }, {});
            r.body = b;
            r.code ??= r.Status.split(/\s+/)[0].toInt();
            return r;
        }

        private doHttpMethod(hder, body) {
            try {
                curl_.setOptionInt(Net.CURLOPT_HTTPAUTH, Net.CURLAUTH_BASIC|Net.CURLAUTH_DIGEST);
                do {
                    curl_.perform();
                    if (curl_.debugInfo.length() > 0) {
                        if (dbgCallback_.isFunction) {
                            dbgCallback_(curl_.debugInfo);
                        }
                        curl_.debugInfo = "";
                    }
                    if (curl_.header.length() > 0) {
                        if (hder.isFunction) {
                            hder(curl_.header);
                        }
                        hdr_.append(curl_.header);
                        curl_.header = "";
                    }
                    if (curl_.received.length() > 0) {
                        if (body.isFunction) {
                            body(curl_.received);
                        }
                        buf_.append(curl_.received);
                        curl_.received = "";
                    }
                    curl_.wait(1000);
                } while (curl_.isRunning);
            } finally {
                curl_.perfromEnd();
            }
        }

        public head(url, callback) {
            clear();
            curl_.setupHandler();
            curl_.setOptionInt(Net.CURLOPT_NOBODY, 1);
            curl_.setOptionInt(Net.CURLOPT_HEADER, 0);
            curl_.setOptionString(Net.CURLOPT_URL, url);
            curl_.setOptionSlist(Net.CURLOPT_HTTPHEADER);
            curl_.setOptionInt(Net.CURLOPT_POST, 0);
            doHttpMethod(callback, null);
            return makeResponse(hdr_.clear());
        }

        public get(url, callback) {
            clear();
            curl_.setupHandler();
            curl_.setOptionInt(Net.CURLOPT_NOBODY, 0);
            curl_.setOptionInt(Net.CURLOPT_HEADER, 0);
            curl_.setOptionString(Net.CURLOPT_URL, url);
            curl_.setOptionSlist(Net.CURLOPT_HTTPHEADER);
            curl_.setOptionInt(Net.CURLOPT_POST, 0);
            var body = callback.body;
            var hder = callback.header;
            if (!body && !hder) {
                body = callback;
            }
            doHttpMethod(hder, body);
            return makeResponse(hdr_.clear() + buf_.clear());
        }

        public post(url, callback) {
            clear();
            curl_.setupHandler();
            curl_.setOptionInt(Net.CURLOPT_NOBODY, 0);
            curl_.setOptionInt(Net.CURLOPT_HEADER, 0);
            curl_.setOptionString(Net.CURLOPT_URL, url);
            curl_.setOptionSlist(Net.CURLOPT_HTTPHEADER);
            curl_.setOptionInt(Net.CURLOPT_POST, 1);
            curl_.setOptionString(Net.CURLOPT_POSTFIELDS, postData_);
            var body = callback.body;
            var hder = callback.header;
            if (!body && !hder) {
                body = callback;
            }
            doHttpMethod(hder, body);
            return makeResponse(hdr_.clear() + buf_.clear());
        }

        public put(url, callback) {
            clear();
            curl_.setOptionString(Net.CURLOPT_CUSTOMREQUEST, "PUT");
            return post(url, callback);
        }

        public delete(url, callback) {
            clear();
            curl_.setupHandler();
            curl_.setOptionInt(Net.CURLOPT_NOBODY, 0);
            curl_.setOptionInt(Net.CURLOPT_HEADER, 0);
            curl_.setOptionString(Net.CURLOPT_URL, url);
            curl_.setOptionString(Net.CURLOPT_CUSTOMREQUEST, "DELETE");
            curl_.setOptionSlist(Net.CURLOPT_HTTPHEADER);
            curl_.setOptionInt(Net.CURLOPT_POST, 0);
            var body = callback.body;
            var hder = callback.header;
            if (!body && !hder) {
                body = callback;
            }
            doHttpMethod(hder, body);
            return makeResponse(hdr_.clear() + buf_.clear());
        }
    }

}