/*
 * @build: make examples
 * @server bin/httpd -s restart -d
 * @usage: bin/curl -v www.baidu.com
 * bin/curl -v 127.0.0.1:8080
 * bin/curl -v 127.0.0.1:8080/ping
 * bin/curl -v 127.0.0.1:8080/echo -d 'hello,world!'
 */

#include "HttpClient.h"
#include "hurl.h"

#ifdef _MSC_VER
#include "misc/win32_getopt.h"
#else
#include <getopt.h>
#endif

static bool verbose = false;
static const char* method = NULL;
static const char* url = "/";
static int http_version = 1;
static int grpc = 0;
static int send_count = 1;
static int retry_count = 0;
static int retry_delay = 3;
static int timeout = 0;

static int lopt = 0;
static const char* http_proxy = NULL;
static const char* https_proxy = NULL;
static const char* no_proxy = NULL;

static const char* options = "hVvX:H:r:d:F:n:";
static const struct option long_options[] = {
 {"help", no_argument, NULL, 'h'},
 {"verion", no_argument, NULL, 'V'},
 {"verbose", no_argument, NULL, 'v'},
 {"method", required_argument, NULL, 'X'},
 {"header", required_argument, NULL, 'H'},
 {"range", required_argument, NULL, 'r'},
 {"data", required_argument, NULL, 'd'},
 {"form", required_argument, NULL, 'F'},
 {"count", required_argument, NULL, 'n'},
 {"http2", no_argument, &http_version, 2},
 {"grpc", no_argument, &grpc, 1},
 \
 {"http-proxy", required_argument, &lopt, 1},
 {"https-proxy", required_argument, &lopt, 2},
 {"no-proxy", required_argument, &lopt, 3},
 {"retry", required_argument, &lopt, 4},
 {"delay", required_argument, &lopt, 5},
 {"timeout", required_argument, &lopt, 6},
 \
 {NULL, 0, NULL, 0}
};
static const char* help = R"(Options:
 -h|--help Print this message.
 -V|--version Print version.
 -v|--verbose Show verbose infomation.
 -X|--method Set http method.
 -H|--header Add http header, -H "Content-Type: application/json"
 -r|--range Add http header Range:bytes=0-1023
 -d|--data Set http body.
 -F|--form Set http form, -F "name=value" -F "file=@filename"
 -n|--count Send request count, used for test keep-alive
 --http2 Use http2
 --grpc Use grpc over http2
 --http-proxy Set http proxy
 --https-proxy Set https proxy
 --no-proxy Set no proxy
 --retry Set fail retry count
 --timeout Set timeout, unit(s)

Examples:
 curl -v GET httpbin.org/get
 curl -v POST httpbin.org/post user=admin pswd=123456
 curl -v PUT httpbin.org/put user=admin pswd=123456
 curl -v localhost:8080
 curl -v localhost:8080 -r 0-9
 curl -v localhost:8080/ping
 curl -v localhost:8080/query?page_no=1\&page_size=10
 curl -v localhost:8080/echo hello,world!
 curl -v localhost:8080/kv user=admin\&pswd=123456
 curl -v localhost:8080/json user=admin pswd=123456
 curl -v localhost:8080/form -F file=@filename
 curl -v localhost:8080/upload @filename
)";

static void print_usage() {
 fprintf(stderr, "Usage: curl [%s] [METHOD] url [header_field:header_value] [body_key=body_value]\n", options);
}
static void print_version() {
 fprintf(stderr, "curl version 1.0.0\n");
}
static void print_help() {
 print_usage();
 puts(help);
 print_version();
}

static bool is_upper_string(const char* str) {
 const char* p = str;
 while (*p >= 'A' && *p <= 'Z') ++p;
 return *p == '0円';
}

static int parse_data(char* arg, HttpRequest* req) {
 char* pos = NULL;
 // @filename
 if (arg[0] == '@') {
 req->File(arg + 1);
 return 0;
 }

 // k1=v1&k2=v2
 hv::KeyValue kvs = hv::splitKV(arg, '&', '=');
 if (kvs.size() >= 2) {
 if (req->ContentType() == CONTENT_TYPE_NONE) {
 req->content_type = X_WWW_FORM_URLENCODED;
 }
 for (auto& kv : kvs) {
 req->Set(kv.first.c_str(), kv.second);
 }
 return 0;
 }

 // k=v
 if ((pos = strchr(arg, '=')) != NULL) {
 *pos = '0円';
 if (pos[1] == '@') {
 // file=@filename
 req->content_type = MULTIPART_FORM_DATA;
 req->SetFormFile(optarg, pos + 2);
 } else {
 if (req->ContentType() == CONTENT_TYPE_NONE) {
 req->content_type = APPLICATION_JSON;
 }
 req->Set(arg, pos + 1);
 }
 return 0;
 }

 if (req->ContentType() == CONTENT_TYPE_NONE) {
 req->content_type = TEXT_PLAIN;
 }
 req->body = arg;
 return 0;
}

static int parse_cmdline(int argc, char* argv[], HttpRequest* req) {
 int opt;
 int opt_idx;
 char* pos = NULL;
 while ((opt = getopt_long(argc, argv, options, long_options, &opt_idx)) != EOF) {
 switch(opt) {
 case 'h': print_help(); exit(0);
 case 'V': print_version(); exit(0);
 case 'v': verbose = true; break;
 case 'X': method = optarg; break;
 case 'H':
 // -H "Content-Type: application/json"
 pos = strchr(optarg, ':');
 if (pos) {
 *pos = '0円';
 req->headers[optarg] = hv::trim(pos + 1);
 *pos = ':';
 }
 break;
 case 'r':
 req->headers["Range"] = std::string("bytes=").append(optarg);
 break;
 case 'd':
 parse_data(optarg, req);
 break;
 case 'F':
 pos = strchr(optarg, '=');
 if (pos) {
 req->content_type = MULTIPART_FORM_DATA;
 *pos = '0円';
 if (pos[1] == '@') {
 // -F file=@filename
 req->SetFormFile(optarg, pos + 2);
 } else {
 // -F name=value
 req->SetFormData(optarg, pos + 1);
 }
 *pos = '=';
 }
 break;
 case 'n': send_count = atoi(optarg); break;
 case 0 :
 {
 switch (lopt) {
 case 1: http_proxy = optarg; break;
 case 2: https_proxy = optarg; break;
 case 3: no_proxy = optarg; break;
 case 4: retry_count = atoi(optarg);break;
 case 5: retry_delay = atoi(optarg);break;
 case 6: timeout = atoi(optarg);break;
 default: break;
 }
 }
 default: break;
 }
 }

 if (optind == argc) {
 fprintf(stderr, "Missing url\n");
 print_usage();
 exit(-1);
 }

 if (is_upper_string(argv[optind])) {
 method = argv[optind++];
 }
 url = argv[optind++];

 for (int d = optind; d < argc; ++d) {
 char* arg = argv[d];
 if ((pos = strchr(arg, ':')) != NULL) {
 *pos = '0円';
 req->headers[arg] = pos + 1;
 } else {
 parse_data(arg, req);
 }
 }

 // --grpc
 if (grpc) {
 http_version = 2;
 req->content_type = APPLICATION_GRPC;
 }
 // --http2
 if (http_version == 2) {
 req->http_major = 2;
 req->http_minor = 0;
 }
 // --timeout
 if (timeout > 0) {
 req->timeout = timeout;
 }

 return 0;
}

int main(int argc, char* argv[]) {
 if (argc < 2) {
 print_usage();
 return 0;
 }

 int ret = 0;
 HttpRequest req;
 parse_cmdline(argc, argv, &req);
 if (method) {
 req.method = http_method_enum(method);
 } else {
 req.DumpBody();
 if (req.body.empty()) {
 req.method = HTTP_GET;
 } else {
 req.method = HTTP_POST;
 }
 }
 req.url = hv::escapeURL(url);
 req.http_cb = [](HttpMessage* res, http_parser_state state, const char* data, size_t size) {
 if (state == HP_HEADERS_COMPLETE) {
 if (verbose) {
 fprintf(stderr, "%s", res->Dump(true, false).c_str());
 }
 } else if (state == HP_BODY) {
 if (data && size) {
 printf("%.*s", (int)size, data);
 // This program no need to save data to body.
 // res->body.append(data, size);
 }
 }
 };

 hv::HttpClient cli;
 // http_proxy
 if (http_proxy) {
 hv::StringList ss = hv::split(http_proxy, ':');
 const char* host = ss[0].c_str();
 int port = ss.size() == 2 ? hv::from_string<int>(ss[1]) : DEFAULT_HTTP_PORT;
 fprintf(stderr, "* http_proxy=%s:%d\n", host, port);
 cli.setHttpProxy(host, port);
 }
 // https_proxy
 if (https_proxy) {
 hv::StringList ss = hv::split(https_proxy, ':');
 const char* host = ss[0].c_str();
 int port = ss.size() == 2 ? hv::from_string<int>(ss[1]) : DEFAULT_HTTPS_PORT;
 fprintf(stderr, "* https_proxy=%s:%d\n", host, port);
 cli.setHttpsProxy(host, port);
 }
 // no_proxy
 if (no_proxy) {
 hv::StringList ss = hv::split(no_proxy, ',');
 fprintf(stderr, "* no_proxy=");
 for (const auto& s : ss) {
 fprintf(stderr, "%s,", s.c_str());
 cli.addNoProxy(s.c_str());
 }
 fprintf(stderr, "\n");
 }

send:
 if (verbose) {
 fprintf(stderr, "%s\n", req.Dump(true, true).c_str());
 }
 HttpResponse res;
 ret = cli.send(&req, &res);
 if (ret != 0) {
 fprintf(stderr, "* Failed:%s:%d\n", http_client_strerror(ret), ret);
 if (retry_count > 0) {
 fprintf(stderr, "\nretry again later...%d\n", retry_count);
 --retry_count;
 hv_sleep(retry_delay);
 goto send;
 }
 }
 if (--send_count > 0) {
 fprintf(stderr, "\nsend again later...%d\n", send_count);
 hv_sleep(retry_delay);
 goto send;
 }
 return ret;
}