#ifndef TFE_HTTP_H
#define TFE_HTTP_H

#include <vector>
#include <memory>
#include <map>
#include <string>
#include <list>

#include "util.h"
#include "easylogging++.h"

class HttpConnection;
class HttpSession;
class HttpRequest;
class HttpResponse;

class Http
{
public:
    /* 回调函数调用 */
    using connection_cb_t = std::function<void(Http & ht, HttpConnection & ct)>;

    /* 回调函数设置 */
    void SetHttpConnectionNewCallback(connection_cb_t cb)
    { connection_new_cb_ = cb; }
    void SetHttpConnectionCloseCallback(connection_cb_t cb)
    { connection_close_cb_ = cb; }

    /* 回调函数调用 */
    void TriggerConnectionNew(HttpConnection & ct)
    { return connection_new_cb_(*this, ct); }
    void TriggerConnectionClose(HttpConnection & ct)
    { return connection_close_cb_(*this, ct); }

    static std::unique_ptr<Http> Factory(TfeConfigParser & cfg);

private:
    connection_cb_t connection_new_cb_;
    connection_cb_t connection_close_cb_;

    /* 压缩降级选项 */
    std::vector<std::string> accept_encoding_strip_list_;
};

class HttpHeaders
{
public:
    HttpHeaders() = default;
    virtual ~HttpHeaders() = default;

    using str_field_t = std::string;
    using str_value_t = std::string;

    virtual void Add(const str_field_t & str_field, const str_value_t & str_value) = 0;
    virtual void Set(const str_field_t & str_field, const str_value_t & str_value) = 0;
    virtual void Remove(const str_field_t & str_field) = 0;

    using for_each_cb_t = std::function<bool(const str_field_t &, const str_value_t &)>;

    virtual bool ForEachHeader(for_each_cb_t cb) const = 0;
    virtual bool ForEachValueOfHeader(const str_field_t & str_field, for_each_cb_t cb) const = 0;
};

class HttpRequest
{
public:
    HttpRequest() = default;
    virtual ~HttpRequest() = default;

    /* URL读取、设置接口 */
    virtual const std::string & Url() const = 0;
    virtual void Url(const std::string & url) = 0;

    virtual const std::string & Uri() const = 0;
    virtual void Uri(const std::string & url) = 0;

    /* HttpHeaders */
    virtual HttpHeaders & Headers() = 0;
    virtual const HttpHeaders & cHeaders() const = 0;

    /* Request Body */
    using body_content_t = std::vector<char>;
    using body_content_ptr_t = std::unique_ptr<body_content_t>;

    /* Body读取、设置接口 */
    virtual const body_content_t * Body() const = 0;
    virtual void Body(body_content_ptr_t body) = 0;

    /* Body的Stolen接口 */
    virtual body_content_ptr_t StolenBody() = 0;

    /* Bypass，标记本请求为直通
     * 当请求标记为直通时，转发数据，不再调用业务处理函数 */
    virtual bool Bypass() = 0;
    virtual void Bypass(bool is_bypass) = 0;

    /* ReadOnly，标记本请求为只读。
     * 当一个请求为只读请求时，业务不应修改它的内容，底层处理Readonly的请求时，应直接转发不缓存 */
    virtual bool ReadOnly() = 0;
    virtual void ReadOnly(bool is_readonly) = 0;

    /* Forward，标记本请求应被转发到对端
     * 当请求标记为不转发时，该请求被丢弃 */
    virtual bool Forward() = 0;
    virtual void Forward(bool is_forward) = 0;

    /* 完整标记，该请求是否已经完整可用 */
    enum section_t
    {
        kSectionHeader, kSectionBody, kSecionMessage
    };
    virtual bool Complete(section_t section) = 0;

    /* HTTP版本 */
    using version_t = std::tuple<short, short>;
    virtual version_t Version() = 0;

    /* 构建接口，根据结构化数据构建HTTP请求头部 */
    virtual void Construct() = 0;

    /* 调试接口 */
    virtual std::string DumpToString() = 0;
};

class HttpResponse
{
public:
    enum section_t
    {
        kSectionHeader,
        kSectionBody,
        kSectionMessage,
        kSectionMax
    };

    enum section_state_t
    {
        kStateBegin,
        kStateReading,
        kStateComplete,
        kStateStream,
        kStateCalled,
        kStateStolen
    };

public:
    HttpResponse() = default;
    virtual ~HttpResponse() = default;

    /* 响应码 */
    virtual int ResponseCode() = 0;
    virtual void ResponseCode(int cde) = 0;

    /* HttpHeaders */
    virtual HttpHeaders & Headers() = 0;
    virtual const HttpHeaders & cHeaders() const = 0;

    /* Request Body */
    using body_content_t = std::vector<char>;
    using body_content_ptr_t = std::unique_ptr<body_content_t>;

    /* Body读取、设置接口 */
    virtual const std::vector<const body_content_t *> Body() const = 0;
    virtual void Body(std::vector<body_content_ptr_t> body) = 0;
    virtual std::vector<body_content_ptr_t> StolenBody() = 0;

    /* ReadOnly，标记本请求为只读。
     * 当一个请求为只读请求时，业务不应修改它的内容，底层处理Readonly的请求时，应直接转发不缓存 */
    virtual bool ReadOnly() = 0;
    virtual void ReadOnly(bool is_readonly) = 0;

    /* Forward，标记本请求应被转发到对端
     * 当请求标记为不转发时，该请求被丢弃 */
    virtual bool Forward() = 0;
    virtual void Forward(bool is_forward) = 0;

    /* Bypass，标记本应答为直通
     * 当应答标记为直通时，转发数据，不再调用业务处理函数 */
    virtual bool Bypass() = 0;
    virtual void Bypass(bool is_bypass) = 0;

    virtual section_state_t SectionState(section_t section) = 0;
    /* 构建指令，根据Object构建对应的Memory */
    virtual void Construct() = 0;

    /* 调试接口 */
    virtual std::string DumpToString() = 0;
};

class HttpConnection
{
public:
    HttpConnection() = default;
    virtual ~HttpConnection() = default;

    using http_connection_cb_t = std::function<void(HttpSession &)>;

    /* 回调函数设置 */
    virtual void SetSessionNewCallback(http_connection_cb_t cb)
    { session_new_cb_ = cb; }
    virtual void SetSessionCloseCallback(http_connection_cb_t cb)
    { session_close_cb_ = cb; }

    /* 四元组信息获取 */
    virtual const struct sockaddr * SockAddrSource() const = 0;
    virtual const struct sockaddr * SockAddrDest() const = 0;

    virtual void Write(std::unique_ptr<HttpSession> http_session) = 0;
    virtual void Close() = 0;

protected:
    http_connection_cb_t session_new_cb_{nullptr};
    http_connection_cb_t session_close_cb_{nullptr};
};

class HttpSession
{
public:
    explicit HttpSession(HttpConnection & connection) : http_connection_(connection) {}
    virtual ~HttpSession() { __dump_session(); }

    using http_session_cb_t = std::function<void(HttpSession &)>;

    HttpRequest & request() const
    { return *request_; }

    void request(std::unique_ptr<HttpRequest> req)
    { request_ = std::move(req); }

    HttpResponse & response() const
    { return *response_; }

    void response(std::unique_ptr<HttpResponse> rsp)
    { response_ = std::move(rsp); }

    HttpConnection & connection() const
    { return http_connection_; }

    virtual void SetRequestHeadAerCallback(http_session_cb_t cb)
    { request_header_cb_ = cb; }
    virtual void SetRequestBodyCallback(http_session_cb_t cb)
    { request_body_cb_ = cb; }
    virtual void SetResponseHeaderCallback(http_session_cb_t cb)
    { response_header_cb_ = cb; }
    virtual void SetResponseBodyCallback(http_session_cb_t cb)
    { response_body_cb_ = cb; }

    virtual void CallRequestHeaderCallback()
    { __call_session_callback(request_header_cb_, tag_request_header_cb_); }
    virtual void CallRequestBodyCallback()
    { __call_session_callback(request_body_cb_, tag_request_body_cb_); }
    virtual void CallResponseHeaderCallback()
    { __call_session_callback(response_header_cb_, tag_response_header_cb_); }
    virtual void CallResponseBodyCallback()
    { __call_session_callback(response_body_cb_, tag_response_body_cb_); }

    enum CallbackTag
    {
        kCallbackTagIgnore,
        kCallbackTagNormal,
        kCallBackTagOnlyOnce,
        kCallbackTagRepeat
    };

    virtual void SetRequestHeaderTag(enum CallbackTag tag)
    { tag_request_header_cb_ = tag; }
    virtual void SetRequestBodyTag(enum CallbackTag tag)
    { tag_request_body_cb_ = tag; }
    virtual void SetResponseHeaderTag(enum CallbackTag tag)
    { tag_response_header_cb_ = tag; }
    virtual void SetResponseBodyTag(enum CallbackTag tag)
    { tag_response_body_cb_ = tag; }

    /* 丢弃这一Session，不转发 */
    virtual void Drop()
    {
        /* Disable all callbacks */
        SetRequestHeaderTag(kCallbackTagIgnore);
        SetRequestBodyTag(kCallbackTagIgnore);
        SetResponseHeaderTag(kCallbackTagIgnore);
        SetResponseBodyTag(kCallbackTagIgnore);

        /* Tag, please drop this session */
        need_to_drop_ = true;
    }

    /* 直通，不再处理这一Session中的任何内容 */
    virtual void Bypass()
    {
        /* Disable all callbacks */
        SetRequestHeaderTag(kCallbackTagIgnore);
        SetRequestBodyTag(kCallbackTagIgnore);
        SetResponseHeaderTag(kCallbackTagIgnore);
        SetResponseBodyTag(kCallbackTagIgnore);

        need_to_drop_ = false;
    }

    virtual bool NeedToDrop()
    {
        return need_to_drop_;
    }

    virtual bool NeedToBypass()
    {
        return (tag_request_header_cb_ == kCallbackTagIgnore &&
                tag_request_body_cb_ == kCallbackTagIgnore &&
                tag_response_header_cb_ == kCallbackTagIgnore &&
                tag_response_body_cb_ == kCallbackTagIgnore) && (!need_to_drop_);
    }

protected:
    HttpConnection & http_connection_;
    std::unique_ptr<HttpRequest> request_{nullptr};
    std::unique_ptr<HttpResponse> response_{nullptr};
    std::shared_ptr<void> context_{nullptr};

    /* Session Callbacks */
    http_session_cb_t request_header_cb_{nullptr};
    http_session_cb_t request_body_cb_{nullptr};
    http_session_cb_t response_header_cb_{nullptr};
    http_session_cb_t response_body_cb_{nullptr};

    /* Call tag */
    enum CallbackTag tag_request_header_cb_{kCallBackTagOnlyOnce};
    enum CallbackTag tag_request_body_cb_{kCallbackTagNormal};
    enum CallbackTag tag_response_header_cb_{kCallBackTagOnlyOnce};
    enum CallbackTag tag_response_body_cb_{kCallbackTagNormal};

    /* Drop tag */
    bool need_to_drop_{false};

private:
    void __call_session_callback(const http_session_cb_t & cb, enum CallbackTag & cb_tag)
    {
        while (cb_tag != kCallbackTagIgnore)
        {
            cb(*this);
            if (cb_tag == kCallbackTagNormal) break;
            if (cb_tag == kCallBackTagOnlyOnce) cb_tag = kCallbackTagIgnore;
            if (cb_tag == kCallbackTagRepeat) cb_tag = kCallBackTagOnlyOnce;
        }
    }

    void __dump_session()
    {
        auto str_src_addr = sockaddr_to_string(http_connection_.SockAddrSource());
        auto str_dst_addr = sockaddr_to_string(http_connection_.SockAddrDest());

        auto str_request = request_->DumpToString();
        auto str_response = response_->DumpToString();

        std::string status{};
        if (NeedToDrop()) status += "DROP";
        if (NeedToBypass()) status += "BYPASS";

        CLOG(DEBUG, "HttpSessionTrace") << str_src_addr << str_dst_addr
                                        << str_request << str_response << status;
    }
};

std::unique_ptr<HttpRequest> HttpRequestFactory(int primary_version, int second_version);
std::unique_ptr<HttpResponse> HttpResponseFactory(short major_version, short minor_version);

#include "pxyconn.h"

class Http1Connection : public HttpConnection
{
public:
    Http1Connection(struct bufferevent * bev_downstream, struct bufferevent * bev_upstream,
        const struct sockaddr_storage & source, const struct sockaddr_storage & dest)
        : bev_downstream_(bev_downstream), bev_upstream_(bev_upstream), sockaddr_source_(source), sockaddr_dest_(dest)
    {}

    ~Http1Connection() = default;

    void Close() override
    { need_to_close_ = true; };

    bool NeedToClose()
    { return need_to_close_; }

    int on_connection_read_request(pxy_conn_ctx_t * conn_ctx, pxy_conn_desc_t * conn_this,
        pxy_conn_desc_t * conn_other);
    int on_connection_read_response(pxy_conn_ctx_t * conn_ctx, pxy_conn_desc_t * conn_this,
        pxy_conn_desc_t * conn_other);
    int on_connection_close(pxy_conn_ctx_t * conn_ctx, struct bufferevent * bev);

    void Write(std::unique_ptr<HttpSession> http_session) override;

    const sockaddr * SockAddrSource() const override;
    const sockaddr * SockAddrDest() const override;

private:
    enum direction
    {
        kDirectionRequest,
        kDirectionResponse
    };

    using http_sessions_t = std::list<std::unique_ptr<HttpSession>>;
    http_sessions_t http_sessions_{};

    HttpSession * create_new_session();
    HttpSession * last_uncomplete_session(enum direction dir);

    void drop_last_session();
    void drop_first_session();
    bool need_to_close_{false};

    /* connection info */
    struct sockaddr_storage sockaddr_source_;
    struct sockaddr_storage sockaddr_dest_;

    /* upstream bev */
    struct bufferevent * bev_upstream_;
    struct bufferevent * bev_downstream_;
};

#endif //TFE_HTTP_H