#ifndef __lbank_spot__api_hpp
#define __lbank_spot__api_hpp

#include <parsing/api.hpp>
#include <parsing/core.hpp>
#include <parsing/parsing.hpp>
#include <parsing/markets/lbank_spot/errors.hpp>
#include <stdexcept>
#include <cstdlib>
#include <vector>

namespace mira {

    class lbank_spot_api : public basic_api {
    protected:
        static constexpr e_order_status _e_order_status_from_str(std::string_view status) {
            if (status == "-1" || status == "3" || status == "4") {
                return e_order_status::CANCELED;
            }
            if (status == "0") {
                return e_order_status::NEW;
            }
            if (status == "1") {
                return e_order_status::PARTIALLY_FILLED;
            }
            if (status == "2") {
                return e_order_status::FILLED;
            }
            std::cerr << "mira::lbank_spot_api::e_status_from_str: unknown status: " << status << std::endl;
            abort();
        }

        static constexpr e_order_type _e_order_type_from_str(std::string_view type) {
            size_t pos = type.find("_"); // TODO: ok?
            if (pos == std::string::npos || type.substr(pos) == "maker") {
                return e_order_type::LIMIT;
            } else if (type.substr(pos) == "market") {
                return e_order_type::MARKET;
            } else {
                std::cerr << "lbank_spot_api::cancel_order_wrapper::response_filler: unknown order type: " << type << std::endl;
                abort();
            }
        }

        template <typename Output, typename Error, typename... Args>
        class basic_wrapper {
        public:
            virtual market_error to_market_error(Error e) = 0;

            FutureHandle<result_t<Output, market_error>> run(std::string_view&& raw_request) {
                std::function<result_t<Output, market_error>(std::string&&)> transformer = [this] (std::string&& response_str) {
                    field_t response = field_t::deserialize(response_str);
                    result_t<Output, market_error> market_res;
                    if (response.count("_LE")) {
                        market_error err;
                        std::cout << "LocalError: " + response.serialize() + "\n";
                        err.code = static_cast<e_market_error>(-response.at("_LE").i());
                        market_res.set_error(err);
                        return market_res;
                    }
                    result_t<Output, Error> res = process(std::move(response));
                    if (res) {
                        market_res.set_value(std::move(res.value()));
                    } else {
                        market_res.set_error(to_market_error(res.code()));
                    }
                    return market_res;
                };
                return execute(std::move(raw_request)).transform(std::move(transformer));
            }

            FutureHandle<result_t<Output, market_error>> operator()(Args... args) {
                return run(request_filler(std::forward<Args>(args)...));
            }

            virtual result_t<Output, Error> process(field_t&& response) = 0;
            virtual FutureHandle<std::string> execute(std::string_view request) = 0;
            virtual std::string request_filler(Args... args) = 0;
            virtual Output response_filler(field_t&& response) = 0;

        protected:
            lbank_spot_api* api_;
        };

        template <typename Output, typename... Args>
        class lbank_spot_wrapper : public basic_wrapper<Output, e_lbank_spot_error, Args...> {
        public:
            market_error to_market_error(e_lbank_spot_error error) override {
                return lbank_spot_to_market(error);
            }

            result_t<Output, e_lbank_spot_error> process(field_t&& response) override {
                result_t<Output, e_lbank_spot_error> res;
                e_http_error http_error_code = e_http_error_from_str(response.at("code").s());
                response = response.at("data");
                switch (http_error_code) {
                    case e_http_error::OK:
                        res.set_value(std::move(response_filler(std::move(response))));
                        break;
                    case e_http_error::BAD_REQUEST:
                        std::cerr << response.serialize() << '\n';
                        res.set_error(static_cast<e_lbank_spot_error>(response.at("code").i()));
                        break;
                    default:
                        // throw std::runtime_error("mira::lbank_spot_wrapper::operator(): unknown http error: " + std::to_string(static_cast<int>(http_error_code)));
                        std::cerr << "mira::lbank_spot_wrapper::operator(): unknown http error: " + std::to_string(static_cast<int>(http_error_code)) << std::endl;
                        abort();
                }
                return res;
            }

            virtual FutureHandle<std::string> execute(std::string_view request) override = 0;
            virtual std::string request_filler(Args... args) override = 0;
            virtual Output response_filler(field_t&& response) override = 0;
        };

        class new_order_wrapper : public lbank_spot_wrapper<order_t, const order_request_t&> {
        public:
            new_order_wrapper(lbank_spot_api* api) {
                api_ = api;
            }

            FutureHandle<std::string> execute(std::string_view request) override;
            std::string request_filler(const order_request_t& order) override;
            order_t response_filler(field_t&& response) override;

        } _new_order{this};

        class cancel_order_wrapper : public lbank_spot_wrapper<order_t, const ticker_t*, const order_identifier_t&> {
        public:
            cancel_order_wrapper(lbank_spot_api* api) {
                api_ = api;
            }

            FutureHandle<std::string> execute(std::string_view request) override;
            std::string request_filler(const ticker_t* symbol, const order_identifier_t& id) override;
            order_t response_filler(field_t&& response) override;
        private:
            const ticker_t* symbol_;
        } _cancel_order{this};

        class cancel_open_orders_wrapper : public lbank_spot_wrapper<std::vector<order_t>, const ticker_t*> {
        public:
            cancel_open_orders_wrapper(lbank_spot_api* api) {
                api_ = api;
            }

            FutureHandle<std::string> execute(std::string_view request) override;
            std::string request_filler(const ticker_t* symbol) override;
            std::vector<order_t> response_filler(field_t&& response) override;
        private:
            const ticker_t* symbol_;
        } _cancel_open_orders{this};

        class get_open_orders_wrapper : public lbank_spot_wrapper<std::vector<order_t>, const ticker_t*> {
        public:
            get_open_orders_wrapper(lbank_spot_api* api) {
                api_ = api;
            }

            FutureHandle<std::string> execute(std::string_view request) override;
            std::string request_filler(const ticker_t* symbol) override;
            std::vector<order_t> response_filler(field_t&& response) override;
        } _get_open_orders{this};

        class get_exchange_info_wrapper : public lbank_spot_wrapper<std::vector<ticker_t>, std::optional<std::string>> {
        public:
            get_exchange_info_wrapper(lbank_spot_api* api) {
                api_ = api;
            }

            FutureHandle<std::string> execute(std::string_view request) override;
            std::string request_filler(std::optional<std::string> symbol) override;
            std::vector<ticker_t> response_filler(field_t&& response) override;

        } _get_exchange_info{this};

        class get_depth_wrapper : public lbank_spot_wrapper<depth_t, const ticker_t*, std::optional<size_t>> {
        public:
            get_depth_wrapper(lbank_spot_api* api) {
                api_ = api;
            }

            FutureHandle<std::string> execute(std::string_view request) override;
            std::string request_filler(const ticker_t* symbol, std::optional<size_t> limit) override;
            depth_t response_filler(field_t&& response) override;

        private:
            const ticker_t* symbol_;
        } _get_depth{this};

        class get_account_wrapper : public lbank_spot_wrapper<account_t> {
        public:
            get_account_wrapper(lbank_spot_api* api) {
                api_ = api;
            }

            FutureHandle<std::string> execute(std::string_view request) override;
            std::string request_filler() override;
            account_t response_filler(field_t&& response) override;

        } _get_account{this};

        struct listen_key_manager {
        public:
            listen_key_manager(lbank_spot_api* api) : api_(api) {}

            struct new_listen_key_wrapper : public lbank_spot_wrapper<std::string> {

                listen_key_manager* manager_;

                new_listen_key_wrapper(listen_key_manager* api) {
                    api_ = api->api_;
                }

                FutureHandle<std::string> execute(std::string_view request) override;
                std::string request_filler() override;
                std::string response_filler(field_t&& response) override;

            } _new_listen_key{this};

            struct keep_alive_listen_key_wrapper : public lbank_spot_wrapper<std::string> {

                listen_key_manager* manager_;

                keep_alive_listen_key_wrapper(listen_key_manager* api) {
                    api_ = api->api_;
                }

                FutureHandle<std::string> execute(std::string_view request) override;
                std::string request_filler() override;
                std::string response_filler(field_t&& response) override;

            } _keep_alive_listen_key{this};

        private:
            lbank_spot_api* api_;
            std::string current_listen_key_;

            friend class keep_alive_listen_key_wrapper;
            friend class new_listen_key_wrapper;

        } _listen_key_manager{this};

        result_t<std::vector<ws_event>, e_stream_error> _feed_process(const char* feed) override;

        ws_trade_event _trade_filler(field_t&& feed);

        ws_diff_depth_event _diff_depth_filler(field_t&& feed);

        ws_part_depth_event _part_depth_filler(field_t&& feed);

        ws_book_event _book_filler(field_t&& feed);

        ws_account_balance_event _account_balance_filler(field_t&& feed);

        ws_account_trade_event _account_trade_filler(field_t&& feed);

        ws_account_order_event _account_order_filler(field_t&& feed);

        webcore::headers_t gen_headers(char* buf, const field_t& signed_query);

        field_t form_signed_query(field_t query);

        void _run_ws() override;

        std::string listen_key_;
        void *ws_client_;
        void *ws_mutex_;
        webcore core_;
        webcore::str_callback* ws_callback_;

        std::string api_ = "", secret_ = "";

        // унести в utils
        const char* letters_[62] = {
            "0", "1", "2", "3", "4", "5", "6", "7", "8", "9",
            "a", "b", "c", "d", "e", "f", "g", "h", "i", "j",
            "k", "l", "m", "n", "o", "p", "q", "r", "s", "t",
            "u", "v", "w", "x", "y", "z",
            "A", "B", "C", "D", "E", "F", "G", "H", "I", "J",
            "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T",
            "U", "V", "W", "X", "Y", "Z",
        };

        constexpr static const char* header_names_[4] = {"accept-language", "timestamp", "signature_method", "echostr"};

    public:
        static constexpr std::string_view HOST_URL = "https://www.lbkex.net";

        lbank_spot_api(const account_name_t& name);

        lbank_spot_api(const account_name_t& name, const std::unordered_map<std::string, std::string>& args);

        FutureHandle<result_t<order_t, market_error>> new_order(const order_request_t& order) override;

        FutureHandle<result_t<order_t, market_error>> cancel_order(const cancel_request_t& request) override;

        FutureHandle<result_t<std::vector<order_t>, market_error>> cancel_open_orders(const ticker_t* symbol, std::optional<e_order_group> order_group) override;

        FutureHandle<result_t<std::vector<order_t>, market_error>> get_open_orders(const ticker_t* symbol) override;

        FutureHandle<result_t<std::vector<ticker_t>, market_error>> get_exchange_info(std::optional<std::string> symbol = {}) override;

        FutureHandle<result_t<depth_t, market_error>> get_depth(const ticker_t* symbol, std::optional<size_t> limit = {}) override;

        FutureHandle<result_t<account_t, market_error>> get_account() override;

        void ws_blocking_call(std::function<void()> call) override {
            core_.ws_blocking_call(call, ws_mutex_);
        }

        ~lbank_spot_api() {}

    };

}

#endif