#include <graphene/peerplays_sidechain/common/ws_client.hpp>

#include <sstream>

#include <boost/asio.hpp>
#include <boost/asio/buffers_iterator.hpp>
#include <boost/asio/ssl.hpp>
#include <boost/beast.hpp>
#include <boost/beast/core.hpp>
#include <boost/beast/http.hpp>
#include <boost/beast/ssl.hpp>
#include <boost/beast/websocket.hpp>
#include <boost/property_tree/json_parser.hpp>
#include <boost/property_tree/ptree.hpp>
#include <boost/xpressive/xpressive.hpp>

#include <fc/log/logger.hpp>

namespace graphene { namespace peerplays_sidechain {

ws_client::ws_client(std::string _url, std::string _user, std::string _password, bool _debug_ws_calls) :
      url(_url),
      user(_user),
      password(_password),
      debug_ws_calls(_debug_ws_calls),
      request_id(0) {

   std::string reg_expr = "^((?P<Protocol>wss|ws):\\/\\/)?(?P<Host>[a-zA-Z0-9\\-\\.]+)(:(?P<Port>\\d{1,5}))?(?P<Target>\\/.+)?";
   boost::xpressive::sregex sr = boost::xpressive::sregex::compile(reg_expr);

   boost::xpressive::smatch sm;

   if (boost::xpressive::regex_search(url, sm, sr)) {
      protocol = sm["Protocol"];
      if (protocol.empty()) {
         protocol = "ws";
      }

      host = sm["Host"];
      if (host.empty()) {
         host + "localhost";
      }

      port = sm["Port"];
      if (port.empty()) {
         port = "80";
      }

      target = sm["Target"];
      if (target.empty()) {
         target = "/";
      }
   } else {
      elog("Invalid URL: ${url}", ("url", url));
   }
}

std::string ws_client::retrieve_array_value_from_reply(std::string reply_str, std::string array_path, uint32_t idx) {
   std::stringstream ss(reply_str);
   boost::property_tree::ptree json;
   boost::property_tree::read_json(ss, json);
   if (json.find("result") == json.not_found()) {
      return "";
   }

   auto json_result = json.get_child_optional("result");
   if (json_result) {
      boost::property_tree::ptree array_ptree = json_result.get();
      if (!array_path.empty()) {
         array_ptree = json_result.get().get_child(array_path);
      }
      uint32_t array_el_idx = -1;
      for (const auto &array_el : array_ptree) {
         array_el_idx = array_el_idx + 1;
         if (array_el_idx == idx) {
            std::stringstream ss_res;
            boost::property_tree::json_parser::write_json(ss_res, array_el.second);
            return ss_res.str();
         }
      }
   }

   return "";
}

std::string ws_client::retrieve_value_from_reply(std::string reply_str, std::string value_path) {
   std::stringstream ss(reply_str);
   boost::property_tree::ptree json;
   boost::property_tree::read_json(ss, json);
   if (json.find("result") == json.not_found()) {
      return "";
   }

   auto json_result = json.get_child_optional("result");
   if (json_result) {
      return json_result.get().get<std::string>(value_path);
   }

   return json.get<std::string>("result");
}

std::string ws_client::send_post_request(std::string method, std::string params, bool show_log) {
   std::stringstream body;

   request_id = request_id + 1;

   body << "{ \"jsonrpc\": \"2.0\", \"id\": " << request_id << ", \"method\": \"" << method << "\"";

   if (!params.empty()) {
      body << ", \"params\": " << params;
   }

   body << " }";

   const auto reply = send_post_request(body.str(), show_log);

   if (reply.body.empty()) {
      wlog("RPC call ${function} failed", ("function", __FUNCTION__));
      return "";
   }

   std::stringstream ss(std::string(reply.body.begin(), reply.body.end()));
   boost::property_tree::ptree json;
   boost::property_tree::read_json(ss, json);

   if (reply.status == 200) {
      return ss.str();
   }

   if (json.count("error") && !json.get_child("error").empty()) {
      wlog("RPC call ${function} with body ${body} failed with reply '${msg}'", ("function", __FUNCTION__)("body", body.str())("msg", ss.str()));
   }
   return "";
}

ws_reply ws_client::send_post_request(std::string body, bool show_log) {

   // The io_context is required for all I/O
   boost::beast::net::io_context ioc;

   // These objects perform our I/O
   boost::beast::net::ip::tcp::resolver resolver(ioc);
   boost::beast::websocket::stream<boost::asio::ip::tcp::socket> ws{ioc};

   // Look up the domain name
   auto const results = resolver.resolve(host, port);

   // Make the connection on the IP address we get from a lookup
   boost::beast::net::connect(ws.next_layer(), results.begin(), results.end());

   // Set a decorator to change the User-Agent of the handshake
   ws.set_option(boost::beast::websocket::stream_base::decorator(
         [](boost::beast::websocket::request_type &req) {
            //// Set up an HTTP GET request message
            //boost::beast::http::request<boost::beast::http::string_body> req{boost::beast::http::verb::post, target, 11};
            //req.set(boost::beast::http::field::host, host + ":" + port);
            //req.set(boost::beast::http::field::accept, "application/json");
            //req.set(boost::beast::http::field::content_type, "application/json");
            //req.set(boost::beast::http::field::content_encoding, "utf-8");
            //req.set(boost::beast::http::field::content_length, body.length());
            //req.body() = body;
         }));

   // Perform the websocket handshake
   ws.handshake(host, "/");

   // Send the message
   ws.write(boost::asio::buffer(body));

   // This buffer is used for reading and must be persisted
   boost::beast::flat_buffer buffer;

   // Read a message into our buffer
   ws.read(buffer);

   // Close the WebSocket connection
   ws.close(boost::beast::websocket::close_code::normal);

   //std::string rbody{boost::asio::buffers_begin(buffer),
   //                  boost::asio::buffers_end(reading)};

   ws_reply reply;
   reply.status = 200;
   //reply.body = rbody;

   //if (show_log) {
   //   ilog("### Request URL:    ${url}", ("url", url));
   //   ilog("### Request:        ${body}", ("body", body));
   //   ilog("### Response:       ${rbody}", ("rbody", rbody));
   //}

   return reply;
}

}} // namespace graphene::peerplays_sidechain