/*
 * .============.
 * // M A K E / \
 * // C++ DEV / \
 * // E A S Y / \/ \
 * ++ ----------. \/\ .
 * \\ \ \ /\ /
 * \\ \ \ /
 * \\ \ \ /
 * -============'
 *
 * Copyright (c) 2023 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 "rpc.h"

#include <tbox/base/log.h>
#include <tbox/base/json.hpp>
#include <tbox/base/wrapped_recorder.h>
#include <tbox/util/uuid.h>

#include "proto.h"

namespace tbox {
namespace jsonrpc {

Rpc::Rpc(event::Loop *loop, IdType id_type)
 : id_type_(id_type)
 , request_timeout_(loop)
 , respond_timeout_(loop)
{
 using namespace std::placeholders;
 request_timeout_.setCallback(std::bind(&Rpc::onRequestTimeout, this, _1));
 respond_timeout_.setCallback(std::bind(&Rpc::onRespondTimeout, this, _1));

}

Rpc::~Rpc()
{
 respond_timeout_.cleanup();
 request_timeout_.cleanup();
}

bool Rpc::initialize(Proto *proto, int timeout_sec)
{
 using namespace std::placeholders;

 request_timeout_.initialize(std::chrono::seconds(1), timeout_sec);
 respond_timeout_.initialize(std::chrono::seconds(1), timeout_sec);

 if (id_type_ == IdType::kInt) {
 proto->setRecvCallback(
 std::bind(&Rpc::onRecvRequestInt, this, _1, _2, _3),
 std::bind(&Rpc::onRecvRespondInt, this, _1, _2)
 );
 } else {
 str_id_gen_func_ = [] { return util::GenUUID(); };
 proto->setRecvCallback(
 std::bind(&Rpc::onRecvRequestStr, this, _1, _2, _3),
 std::bind(&Rpc::onRecvRespondStr, this, _1, _2)
 );
 }

 proto_ = proto;

 return true;
}

void Rpc::cleanup()
{
 respond_timeout_.cleanup();
 request_timeout_.cleanup();

 tobe_respond_.clear();
 request_callback_.clear();
 str_id_gen_func_ = nullptr;

 method_services_.clear();

 proto_->cleanup();
 proto_ = nullptr;
}

void Rpc::addService(const std::string &method, ServiceCallback &&cb)
{
 method_services_[method] = std::move(cb);
}

void Rpc::removeService(const std::string &method)
{
 method_services_.erase(method);
}

void Rpc::request(const std::string &method, const Json &js_params, RequestCallback &&cb)
{
 RECORD_SCOPE();

 int int_id = 0;

 if (cb) {
 int_id = allocIntId();
 request_callback_[int_id] = std::move(cb);
 request_timeout_.add(int_id);
 }

 if (id_type_ == IdType::kInt) {
 proto_->sendRequest(int_id, method, js_params);

 } else {
 std::string str_id;
 if (int_id != 0) {
 str_id = str_id_gen_func_();

 int_to_str_map_[int_id] = str_id;
 str_to_int_map_[str_id] = int_id;
 }
 proto_->sendRequest(str_id, method, js_params);
 }
}

void Rpc::request(const std::string &method, RequestCallback &&cb)
{
 request(method, Json(), std::move(cb));
}

void Rpc::notify(const std::string &method, const Json &js_params)
{
 request(method, js_params, nullptr);
}

void Rpc::notify(const std::string &method)
{
 request(method, Json(), nullptr);
}

void Rpc::respondResult(int int_id, const Json &js_result)
{
 RECORD_SCOPE();
 if (int_id == 0) {
 LogWarn("send int_id == 0 respond");
 return;
 }

 if (id_type_ == IdType::kInt) {
 proto_->sendResult(int_id, js_result);

 } else {
 auto iter = int_to_str_map_.find(int_id);
 if (iter != int_to_str_map_.end()) {
 std::string str_id = iter->second;
 proto_->sendResult(str_id, js_result);
 int_to_str_map_.erase(iter);
 str_to_int_map_.erase(str_id);
 }
 }

 tobe_respond_.erase(int_id);
}

void Rpc::respondError(int int_id, int errcode, const std::string &message)
{
 RECORD_SCOPE();
 if (int_id == 0) {
 LogWarn("send int_id == 0 respond");
 return;
 }

 if (id_type_ == IdType::kInt) {
 proto_->sendError(int_id, errcode, message);

 } else {
 auto iter = int_to_str_map_.find(int_id);
 if (iter != int_to_str_map_.end()) {
 std::string str_id = iter->second;
 proto_->sendError(str_id, errcode, message);
 int_to_str_map_.erase(iter);
 str_to_int_map_.erase(str_id);
 }
 }

 tobe_respond_.erase(int_id);
}

std::string Rpc::getStrId(int int_id) const
{
 if (id_type_ == IdType::kString) {
 auto iter = int_to_str_map_.find(int_id);
 if (iter != int_to_str_map_.end())
 return iter->second;
 }
 return std::string();
}

void Rpc::setStrIdGenFunc(StrIdGenFunc &&func)
{
 if (id_type_ == IdType::kString && func) {
 str_id_gen_func_ = std::move(func);
 }
}

void Rpc::clear()
{
 int_id_alloc_ = 0;
 request_callback_.clear();
 tobe_respond_.clear();
 request_timeout_.clear();
 respond_timeout_.clear();
 int_to_str_map_.clear();
 str_to_int_map_.clear();
}

void Rpc::onRecvRequestInt(int int_id, const std::string &method, const Json &js_params)
{
 RECORD_SCOPE();
 auto iter = method_services_.find(method);
 if (iter != method_services_.end() && iter->second) {
 Response response;
 if (int_id != 0) {
 tobe_respond_.insert(int_id);
 if (iter->second(int_id, js_params, response)) {
 if (response.error.code == 0) {
 respondResult(int_id, response.js_result);
 } else {
 auto &error = response.error;
 respondError(int_id, error.code, error.message);
 }
 } else {
 respond_timeout_.add(int_id);
 }
 } else {
 iter->second(int_id, js_params, response);
 }
 } else {
 if (int_id != 0)
 respondError(int_id, ErrorCode::kMethodNotFound, "method not found");
 }
}

void Rpc::onRecvRequestStr(const std::string &str_id, const std::string &method, const Json &js_params)
{
 int int_id = 0;

 if (!str_id.empty()) {
 int_id = allocIntId();
 int_to_str_map_[int_id] = str_id;
 str_to_int_map_[str_id] = int_id;
 }

 onRecvRequestInt(int_id, method, js_params);
}


void Rpc::onRecvRespondInt(int int_id, const Response &response)
{
 RECORD_SCOPE();
 auto iter = request_callback_.find(int_id);
 if (iter != request_callback_.end()) {
 if (iter->second)
 iter->second(response);
 request_callback_.erase(iter);
 }
}

void Rpc::onRecvRespondStr(const std::string &str_id, const Response &response)
{
 //! 收到string的回复,要先转换成int
 RECORD_SCOPE();
 auto iter = str_to_int_map_.find(str_id);
 if (iter != str_to_int_map_.end()) {
 int int_id = iter->second;
 onRecvRespondInt(int_id, response);

 //! 最后要将map中的记录删除
 str_to_int_map_.erase(iter);
 int_to_str_map_.erase(int_id);
 }
}

void Rpc::onRequestTimeout(int int_id)
{
 Response response;
 response.error.code = ErrorCode::kRequestTimeout;
 response.error.message = "request timeout";

 auto iter = request_callback_.find(int_id);
 if (iter != request_callback_.end()) {
 if (iter->second)
 iter->second(response);
 request_callback_.erase(iter);

 //! 如果是string类的,还要将map中的记录删除
 if (id_type_ == IdType::kString) {
 auto iter = int_to_str_map_.find(int_id);
 if (iter != int_to_str_map_.end()) {
 std::string str_id = iter->second;
 int_to_str_map_.erase(iter);
 str_to_int_map_.erase(str_id);
 }
 }
 }
}

void Rpc::onRespondTimeout(int int_id)
{
 auto iter = tobe_respond_.find(int_id);
 if (iter != tobe_respond_.end()) {
 tobe_respond_.erase(iter);

 if (id_type_ == IdType::kInt) {
 LogWarn("respond timeout, int_id:%d", int_id);

 } else {
 //! 如果是string类的,还要将map中的记录删除
 auto iter = int_to_str_map_.find(int_id);
 if (iter != int_to_str_map_.end()) {
 std::string str_id = iter->second;
 LogWarn("respond timeout, int_id:%d, str_id:%s", int_id, str_id.c_str());
 int_to_str_map_.erase(iter);
 str_to_int_map_.erase(str_id);
 }
 }
 }
}

int Rpc::allocIntId()
{
 ++int_id_alloc_;

 //! 防止整数溢出
 if (int_id_alloc_ <= 0)
 int_id_alloc_ = 1;

 return int_id_alloc_;

}

}
}