/*
 *     .============.
 *    //  M A K E  / \
 *   //  C++ DEV  /   \
 *  //  E A S Y  /  \/ \
 * ++ ----------.  \/\  .
 *  \\     \     \ /\  /
 *   \\     \     \   /
 *    \\     \     \ /
 *     -============'
 *
 * Copyright (c) 2018 Hevake and contributors, all rights reserved.
 *
 * This file is part of cpp-tbox (https://github.com/cpp-main/cpp-tbox)
 * Use of this source code is governed by MIT license that can be found
 * in the LICENSE file in the root of the source tree. All contributing
 * project authors may be found in the CONTRIBUTORS.md file in the root
 * of the source tree.
 */
#include "url.h"
#include <sstream>
#include <tbox/util/string.h>

namespace tbox {
namespace http {

namespace {
//! 根据 RFC3986, https://www.rfc-editor.org/rfc/rfc3986
const std::string full_special_chars = R"( +&=<>"#,%{}|\^[]`;?:@$/.)";
const std::string path_special_chars = R"( +&=<>"#,%{}|\^[]`;?:@$)";
const char *char_to_hex = R"(0123456789ABCDEF)";

char HexCharToValue(char hex_char)
{
    if (('0' <= hex_char) && (hex_char <= '9'))
        return hex_char - '0';
    else if (('A' <= hex_char) && (hex_char <= 'F'))
        return hex_char - 'A' + 10;
    else if (('a' <= hex_char) && (hex_char <= 'f'))
        return hex_char - 'a' + 10;
    else
        throw std::runtime_error("should be A-Z a-z 0-9");
}
}

std::string UrlEncode(const std::string &local_str, bool path_mode)
{
    const auto& special_chars = path_mode ? path_special_chars : full_special_chars;

    std::string url_str;
    url_str.reserve(local_str.size() * 5 / 4); //! 预留1.25倍的空间

    for (char c : local_str) {
        //! 如果非ASCII或是特殊字符
        if (special_chars.find(c) != std::string::npos || !std::isprint(c)) {
            unsigned char uc = static_cast<unsigned char>(c);
            url_str.push_back('%');
            url_str.push_back(char_to_hex[uc >> 4]);
            url_str.push_back(char_to_hex[uc & 0xf]);
        } else
            url_str.push_back(c);
    }
    return url_str;
}

std::string UrlDecode(const std::string &url_str)
{
    std::string local_str;
    local_str.reserve(url_str.size());

    enum class State {
        kNone,
        kStart,
        kHalfHex,
    };

    char tmp = 0;
    State state = State::kNone;

    for (char c : url_str) {
        if (state == State::kNone) {
            if (c == '%') {
                state = State::kStart;
                tmp = 0;
            } else if (c == '+') {
                local_str.push_back(' ');
            } else if (c == '#') {
                break; //! 结束
            } else {
                local_str.push_back(c);
            }
        } else {
            if (state == State::kStart) {
                tmp = HexCharToValue(c) << 4;
                state = State::kHalfHex;
            } else if (state == State::kHalfHex) {
                tmp |= HexCharToValue(c);
                state = State::kNone;
                local_str.push_back(tmp);
            }
        }
    }

    if (state != State::kNone)
        throw std::runtime_error("url imcomplete");

    return local_str;
}

/**
 * URL格式：<scheme>://<user>:<password>@<host>:<port>/<path>;<params>?<query>#<frag>
 */

std::string UrlHostToString(const Url::Host &host)
{
    std::ostringstream oss;

    if (!host.user.empty()) {
        oss << host.user;
        if (!host.password.empty())
            oss << ':' << host.password;
        oss << '@';
    }

    oss << host.host;
    if (host.port != 0)
        oss << ':' << host.port;

    return oss.str();
}

std::string UrlPathToString(const Url::Path &path)
{
    std::ostringstream oss;

    oss << UrlEncode(path.path, true);

    for (const auto &item : path.params)
        oss << ';' << UrlEncode(item.first) << '=' << UrlEncode(item.second);

    if (!path.query.empty()) {
        oss << '?';
        bool not_first = false;
        for (const auto &item : path.query) {
            if (not_first)
                oss << '&';
            not_first = true;
            oss << UrlEncode(item.first) << '=' << UrlEncode(item.second);
        }
    }

    if (!path.frag.empty())
        oss << '#' << path.frag;

    return oss.str();
}

std::string UrlToString(const Url &url)
{
    std::ostringstream oss;

    if (!url.scheme.empty())
        oss << url.scheme << "://";

    oss << UrlHostToString(url.host);
    oss << UrlPathToString(url.path);

    return oss.str();
}

bool StringToUrl(const std::string &str, Url &url)
{
    auto pos = str.find("://");
    if (pos != std::string::npos) {
        url.scheme = str.substr(0, pos);
        pos += 3;
    } else {
        pos = 0;
    }

    std::string host_str;
    std::string path_str;

    //! 将剩下的 url 拆分成两部分 host + path，分别进行解析
    auto path_start_pos = str.find_first_of('/', pos);
    if (path_start_pos != std::string::npos) {
        host_str = str.substr(pos, path_start_pos - pos);
        path_str = str.substr(path_start_pos);
    } else {
        host_str = str.substr(pos);
        path_str = "/";
    }

    return StringToUrlHost(host_str, url.host) &&
           StringToUrlPath(path_str, url.path);
}

bool StringToUrlHost(const std::string &str, Url::Host &host)
{
    //! 解析：<user>:<password>@<host>:<port>

    //! 先找@。如果找到了，就分成 user:password 与 host:port 两部分
    //! 如果没有找到，则说明只有 host:port
    auto at_pos = str.find_first_of('@');
    auto host_start_pose = 0;
    try {
        if (at_pos != std::string::npos) {
            auto colon_pos = str.find_first_of(':');
            if (colon_pos == std::string::npos || colon_pos > at_pos) {
                //! 说明没有 password
                host.user = UrlDecode(str.substr(0, at_pos));
                host.password.clear();
            } else {
                host.user = UrlDecode(str.substr(0, colon_pos));
                host.password = UrlDecode(str.substr(colon_pos + 1, at_pos - colon_pos - 1));
            }
            host_start_pose = at_pos + 1;
        }

        auto colon_pos = str.find_first_of(':', host_start_pose);
        if (colon_pos == std::string::npos) {
            //! 说明没有 password
            host.host = UrlDecode(str.substr(host_start_pose));
            host.port = 0;
        } else {
            host.host = UrlDecode(str.substr(host_start_pose, colon_pos - host_start_pose));
            host.port = std::stoi(str.substr(colon_pos + 1));
        }
    } catch (const std::exception &) {
        return false;
    }

    return true;
}

bool StringToUrlPath(const std::string &str, Url::Path &path)
{
    //! /<path>;<params>?<query>#<frag>

    if (str.empty() || str[0] != '/')
        return false;

    auto semi_pos = str.find_first_of(';');
    auto query_pos = str.find_first_of('?');
    auto pound_pos = str.find_first_of('#');

    auto path_end_pos = std::string::npos;
    if (semi_pos != std::string::npos)
        path_end_pos = semi_pos;
    else if (query_pos != std::string::npos)
        path_end_pos = query_pos;
    else if (pound_pos != std::string::npos)
        path_end_pos = pound_pos;

    try {
        path.path = UrlDecode(str.substr(0, path_end_pos));

        if (semi_pos != std::string::npos) {
            //! 说明有 params
            auto params_end_pos = std::string::npos;
            if (query_pos != std::string::npos)
                params_end_pos = query_pos;
            else if (pound_pos != std::string::npos)
                params_end_pos = pound_pos;

            auto params_str = str.substr(semi_pos + 1, params_end_pos - semi_pos - 1);
            std::vector<std::string> params_vec;
            util::string::Split(params_str, ";", params_vec);
            for (const auto &param_str : params_vec) {
                std::vector<std::string> kv;
                util::string::Split(param_str, "=", kv);
                if (kv.size() != 2 || kv[0].empty())
                    return false;
                path.params[UrlDecode(kv[0])] = UrlDecode(kv[1]);
            }
        }

        if (query_pos != std::string::npos) {
            //! 说明有 query
            auto querys_end_pos = std::string::npos;
            if (pound_pos != std::string::npos)
                querys_end_pos = pound_pos;

            auto querys_str = str.substr(query_pos + 1, querys_end_pos - query_pos - 1);
            std::vector<std::string> querys_vec;
            util::string::Split(querys_str, "&", querys_vec);
            for (const auto &query_str : querys_vec) {
                std::vector<std::string> kv;
                util::string::Split(query_str, "=", kv);
                if (kv.size() != 2 || kv[0].empty())
                    return false;
                path.query[UrlDecode(kv[0])] = UrlDecode(kv[1]);
            }
        }

        if (pound_pos != std::string::npos) {
            //! 说明有 frag
            path.frag = UrlDecode(str.substr(pound_pos + 1));
        }

    } catch (const std::exception &) {
        return false;
    }

    return true;
}

}
}