#include <boost/asio/deadline_timer.hpp>
#include <boost/asio/io_service.hpp>
#include <boost/asio/ip/tcp.hpp>
#include <boost/asio/read_until.hpp>
#include <boost/asio/streambuf.hpp>
#include <boost/asio/write.hpp>
#include <boost/bind.hpp>
#include <iostream>

using boost::asio::deadline_timer;
using boost::asio::ip::tcp;


class client
{
public:
	// 在建構函式的初始化列表中 初始化所有變數
	client(boost::asio::io_service& io_service)
		: stopped_(false),
		socket_(io_service),
		deadline_(io_service),
		heartbeat_timer_(io_service)
	{
	}

	// 對外公開並使用的唯一介面
	// 
	void start(tcp::resolver::iterator endpoint_iter)
	{
		// 連線server
		start_connect(endpoint_iter);

		// 設定連線超時間，並指定回撥函式
		deadline_.async_wait(boost::bind(&client::check_deadline, this));
	}

private:
	void stop()
	{
		stopped_ = true;
		boost::system::error_code ignored_ec;
		socket_.close(ignored_ec);// 關閉socket
		deadline_.cancel();// 取消定時器
		heartbeat_timer_.cancel();
	}

	void start_connect(tcp::resolver::iterator endpoint_iter)
	{
		if (endpoint_iter != tcp::resolver::iterator())
		{
			std::cout << "Trying " << endpoint_iter->endpoint() << "...\n";

			// 設定定時器超時時間
			deadline_.expires_from_now(boost::posix_time::seconds(60));

			// 設定連線成功回撥函式
			socket_.async_connect(endpoint_iter->endpoint(),
				boost::bind(&client::handle_connect,
				this, _1, endpoint_iter));
		}
		else
		{
			stop();
		}
	}

	void handle_connect(const boost::system::error_code& ec,
		tcp::resolver::iterator endpoint_iter)
	{
		if (stopped_)
			return;

		if (!socket_.is_open())
		{
			std::cout << "Connect timed out\n";

			start_connect(++endpoint_iter);
		}
		else if (ec)
		{// 其他方面的錯誤 如伺服器沒有開啟
			std::cout << "Connect error: " << ec.message() << "\n";

			socket_.close();

			start_connect(++endpoint_iter);
		}
		else
		{// 連線成功
			std::cout << "Connected to " << endpoint_iter->endpoint() << "\n";

			start_read();

			start_write();// 開始心跳
		}
	}

	void start_read()
	{
		// 設定recv 超時時間，此處會觸發 check_deadline 但不是真正的超時
		deadline_.expires_from_now(boost::posix_time::seconds(30));

		// 非同步接收以"\n"為結束符/  意為從網路快取中讀取一行
		boost::asio::async_read_until(socket_, input_buffer_, '\n',
			boost::bind(&client::handle_read, this, _1));
	}

	void handle_read(const boost::system::error_code& ec)
	{
		if (stopped_)
			return;

		if (!ec)
		{
			std::string line;
			std::istream is(&input_buffer_);
			std::getline(is, line);// 從流中獲取一行內容  捨去回車

			if (!line.empty())// 如果line.empty == true 是表示是一個心跳包，心跳包只發送一個回車\n
			{
				std::cout << "Received: " << line << "\n";
			}

			// 開始新一次讀取
			start_read();
		}
		else
		{// 讀取發生錯誤/ 遠端已關閉socket
			std::cout << "Error on receive: " << ec.message() << "\n";

			stop();
		}
	}


	//////////////////////////////////////////////////////////////////////////
	// 定時器完成心跳
	void start_write()
	{
		if (stopped_)
			return;

		// Start an asynchronous operation to send a heartbeat message.
		boost::asio::async_write(socket_, boost::asio::buffer("\n", 1),
			boost::bind(&client::handle_write, this, _1));
	}

	void handle_write(const boost::system::error_code& ec)
	{
		if (stopped_)
			return;

		if (!ec)
		{
			// 設定超時時間
			heartbeat_timer_.expires_from_now(boost::posix_time::seconds(10));
			
			// 開始非同步等待，並設定超時回撥函式
			heartbeat_timer_.async_wait(boost::bind(&client::start_write, this));
		}
		else
		{
			std::cout << "Error on heartbeat: " << ec.message() << "\n";

			stop();
		}
	}
	//////////////////////////////////////////////////////////////////////////

	void check_deadline()
	{
		if (stopped_)// check 是存已標識並等待程式退出
			return;

		if (deadline_.expires_at() <= deadline_timer::traits_type::now())
		{// 真正的等待超時

			socket_.close();// 關閉對應的socket 包括連線超時/recv超時

			deadline_.expires_at(boost::posix_time::pos_infin);// 定時器 設定為永不超時/不可用狀態
		}

		// 如果不是真正的超時，定是其操作已成功/使用者重新設定了定時器
		// 重新啟動定時器
		deadline_.async_wait(boost::bind(&client::check_deadline, this));
	}

private:
	bool stopped_;								// 標識程式是否停止執行
	tcp::socket socket_;						// 
	boost::asio::streambuf input_buffer_;		// recv buf
	deadline_timer deadline_;					// 連線/recv 超時 定時器
	deadline_timer heartbeat_timer_;			// 心跳超時 計時器
};

int main(int argc, char* argv[])
{
	try
	{

		boost::asio::io_service io_service;
		tcp::resolver r(io_service);
		client c(io_service);

		c.start(r.resolve(tcp::resolver::query("127.0.0.1", "8889")));

		io_service.run();
	}
	catch (std::exception& e)
	{
		std::cerr << "Exception: " << e.what() << "\n";
	}

	return 0;
}