/*
 * .============.
 * // 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 "tcp_client.h"

#include <tbox/base/log.h>
#include <tbox/base/assert.h>
#include <tbox/base/defines.h>
#include <tbox/base/wrapped_recorder.h>

#include "tcp_connector.h"
#include "tcp_connection.h"
#include "tcp_factory.h"
#include "tcp_raw_factory.h"
#include "tls_factory_entry.h"

#undef MODULE_ID
#define MODULE_ID "tbox.tcp"

namespace tbox {
namespace network {

struct TcpClient::Data {
 event::Loop *wp_loop;
 State state = State::kNone;

 ConnectedCallback connected_cb;
 DisconnectedCallback disconnected_cb;
 ReceiveCallback received_cb;
 size_t received_threshold = 0;
 SendCompleteCallback send_complete_cb;
 ByteStream *wp_receiver = nullptr;
 bool reconnect_enabled = true;

 TcpFactory *sp_factory = nullptr;
 TcpConnector *sp_connector = nullptr;
 TcpConnection *sp_connection = nullptr;

 int cb_level = 0;
};

TcpClient::TcpClient(event::Loop *wp_loop)
 : d_(new Data)
{
 TBOX_ASSERT(d_ != nullptr);

 d_->wp_loop = wp_loop;
 d_->sp_factory = new TcpRawFactory;
 d_->sp_connector = d_->sp_factory->createConnector(wp_loop);
}

TcpClient::~TcpClient()
{
 TBOX_ASSERT(d_->cb_level == 0);

 cleanup();

 CHECK_DELETE_RESET_OBJ(d_->sp_connection);
 CHECK_DELETE_RESET_OBJ(d_->sp_connector);
 CHECK_DELETE_RESET_OBJ(d_->sp_factory);

 delete d_;
}

bool TcpClient::setTlsConfig(const TlsConfig &config)
{
 if (d_->state != State::kNone) {
 LogWarn("cannot set TLS config after initialization");
 return false;
 }

 if (!config.isValid()) {
 LogWarn("invalid TLS config");
 return false;
 }

 //! 替换 factory 和 connector
 TcpFactory *tls_factory = CreateTlsFactory(TlsRole::kClient, config);
 if (tls_factory == nullptr) {
 LogWarn("failed to create TLS factory, TLS module may not be linked");
 return false;
 }

 if (!tls_factory->initialize()) {
 LogWarn("failed init TLS factory, config may invalid");
 delete tls_factory;
 return false;
 }

 CHECK_DELETE_RESET_OBJ(d_->sp_connector);
 CHECK_DELETE_RESET_OBJ(d_->sp_factory);
 d_->sp_factory = tls_factory;
 d_->sp_connector = d_->sp_factory->createConnector(d_->wp_loop);

 return true;
}

bool TcpClient::initialize(const SockAddr &server_addr)
{
 if (d_->state != State::kNone) {
 LogWarn("not in none state, cleanup first.");
 return false;
 }

 using namespace std::placeholders;
 d_->sp_connector->initialize(server_addr);
 d_->sp_connector->setConnectedCallback(std::bind(&TcpClient::onTcpConnected, this, _1));

 d_->state = State::kInited;
 return true;
}

void TcpClient::setConnectedCallback(const ConnectedCallback &cb)
{
 d_->connected_cb = cb;
}

void TcpClient::setDisconnectedCallback(const DisconnectedCallback &cb)
{
 d_->disconnected_cb = cb;
}

void TcpClient::setAutoReconnect(bool enable)
{
 d_->reconnect_enabled = enable;
}

void TcpClient::setReconnectDelayCalcFunc(const ReconnectDelayCalc &func)
{
 d_->sp_connector->setReconnectDelayCalcFunc(func);
}

bool TcpClient::start()
{
 if (d_->state != State::kInited) {
 LogWarn("not in idle state, initialize or stop first");
 return false;
 }

 d_->state = State::kConnecting;
 return d_->sp_connector->start();
}

void TcpClient::stop()
{
 if (d_->state == State::kConnecting) {
 d_->state = State::kInited;
 d_->sp_connector->stop();

 } else if (d_->state == State::kConnected) {
 TcpConnection *tobe_delete = nullptr;
 std::swap(tobe_delete, d_->sp_connection);
 tobe_delete->disconnect();

 d_->wp_loop->runNext(
 [tobe_delete] { delete tobe_delete; },
 "TcpClient::stop, delete"
 );

 d_->state = State::kInited;
 }
}

bool TcpClient::shutdown(int howto)
{
 if (d_->state == State::kConnected)
 return d_->sp_connection->shutdown(howto);
 return false;
}

void TcpClient::cleanup()
{
 if (d_->state <= State::kNone)
 return;

 stop();

 d_->sp_connector->cleanup();

 d_->connected_cb = nullptr;
 d_->disconnected_cb = nullptr;
 d_->received_cb = nullptr;
 d_->received_threshold = 0;
 d_->send_complete_cb = nullptr;
 d_->wp_receiver = nullptr;
 d_->reconnect_enabled = true;

 d_->state = State::kNone;
}

TcpClient::State TcpClient::state() const
{
 return d_->state;
}

void TcpClient::setReceiveCallback(const ReceiveCallback &cb, size_t threshold)
{
 if (d_->sp_connection != nullptr)
 d_->sp_connection->setReceiveCallback(cb, threshold);

 d_->received_cb = cb;
 d_->received_threshold = threshold;
}

void TcpClient::setSendCompleteCallback(const SendCompleteCallback &cb)
{
 if (d_->sp_connection != nullptr)
 d_->sp_connection->setSendCompleteCallback(cb);

 d_->send_complete_cb = cb;
}

bool TcpClient::send(const void *data_ptr, size_t data_size)
{
 if (d_->sp_connection != nullptr)
 return d_->sp_connection->send(data_ptr, data_size);

 return false;
}

void TcpClient::bind(ByteStream *receiver)
{
 if (d_->sp_connection != nullptr)
 d_->sp_connection->bind(receiver);

 d_->wp_receiver = receiver;
}

void TcpClient::unbind()
{
 if (d_->sp_connection != nullptr)
 d_->sp_connection->unbind();

 d_->wp_receiver = nullptr;
}

Buffer* TcpClient::getReceiveBuffer()
{
 if (d_->sp_connection != nullptr)
 return d_->sp_connection->getReceiveBuffer();
 return nullptr;
}

void TcpClient::onTcpConnected(TcpConnection *new_conn)
{
 RECORD_SCOPE();
 new_conn->setDisconnectedCallback(std::bind(&TcpClient::onTcpDisconnected, this));
 new_conn->setReceiveCallback(d_->received_cb, d_->received_threshold);
 new_conn->setSendCompleteCallback(d_->send_complete_cb);
 if (d_->wp_receiver != nullptr)
 new_conn->bind(d_->wp_receiver);

 //! 可以直接释放,因为本函数一定是 d_->sp_connector 对象调用的
 CHECK_DELETE_RESET_OBJ(d_->sp_connection);
 d_->sp_connection = new_conn;

 d_->state = State::kConnected;

 if (d_->connected_cb) {
 RECORD_SCOPE();
 ++d_->cb_level;
 d_->connected_cb();
 --d_->cb_level;
 }
}

void TcpClient::onTcpDisconnected()
{
 RECORD_SCOPE();
 TcpConnection *tobe_delete = nullptr;
 std::swap(tobe_delete, d_->sp_connection);

 //! 这里要使用延后释放,因为本函数一定是 d_->sp_connection 对象自己调用的
 d_->wp_loop->runNext(
 [tobe_delete] { delete tobe_delete; },
 "TcpClient::onTcpDisconnected, delete"
 );

 d_->state = State::kInited;

 if (d_->reconnect_enabled)
 start();

 if (d_->disconnected_cb) {
 RECORD_SCOPE();
 ++d_->cb_level;
 d_->disconnected_cb();
 --d_->cb_level;
 }
}

}
}