#ifndef _QTL_ASIO_H_
#define _QTL_ASIO_H_

#include "qtl_async.hpp"
#include <asio/version.hpp>
#define ASIO_STANDALONE
#if defined(_MSC_VER) && _WIN32_WINNT<0x0600
#define ASIO_ENABLE_CANCELIO 1 
#endif
#if ASIO_VERSION < 101200
#include <asio/io_service.hpp>
#else
#include <asio/io_context.hpp>
#endif // ASIO_VERSION
#include <asio/strand.hpp>
#include <asio/ip/tcp.hpp>
#include <asio/async_result.hpp>
#include <asio/steady_timer.hpp>

#if ASIO_VERSION < 100000
#error The asio version required by QTL is at least 10.0 
#endif

namespace qtl
{

namespace NS_ASIO = ::asio;

namespace asio
{

class service
{
public:
#if ASIO_VERSION < 101200
	typedef NS_ASIO::io_service service_type;
#else
	typedef NS_ASIO::io_context service_type;
#endif // ASIO_VERSION

	service() NOEXCEPT { }
	explicit service(int concurrency_hint) : _service(concurrency_hint) { }

	void reset()
	{
		_service.reset();
	}

	void run()
	{
		_service.run();
	}

	void stop()
	{
		_service.stop();
	}

	service_type& context() NOEXCEPT { return _service; }

private:

	class event_item : public qtl::event
	{
	public:
		event_item(service& service, qtl::socket_type fd)
			: _service(service), _strand(service.context()), _socket(service.context(), NS_ASIO::ip::tcp::v4(), fd), _timer(service.context()), _busying(false)
		{
		}

		NS_ASIO::ip::tcp::socket& next_layer() { return _socket; }

	public: // qtl::event
		virtual void set_io_handler(int flags, long timeout, std::function<void(int)>&& handler) override
		{
			if (flags&qtl::event::ef_read)
			{
#if ASIO_VERSION < 101200
				_socket.async_read_some(NS_ASIO::null_buffers(), _strand.wrap([this, handler](const NS_ASIO::error_code& ec, size_t bytes_transferred) {
#else
				_socket.async_wait(NS_ASIO::socket_base::wait_read, _strand.wrap([this, handler](const NS_ASIO::error_code& ec) {
#endif // ASIO_VERSION
					if (!ec)
						handler(qtl::event::ef_read);
					else if (ec == NS_ASIO::error::make_error_code(NS_ASIO::error::operation_aborted))
						handler(qtl::event::ef_timeout);
					else
						handler(qtl::event::ef_exception);
					_busying = false;
					_timer.cancel();
				}));
				_busying = true;
			}
			if (flags&qtl::event::ef_write)
			{
#if ASIO_VERSION < 101200
				_socket.async_write_some(NS_ASIO::null_buffers(), _strand.wrap([this, handler](const NS_ASIO::error_code& ec, size_t bytes_transferred) {
#else
				_socket.async_wait(NS_ASIO::socket_base::wait_write, _strand.wrap([this, handler](const NS_ASIO::error_code& ec) {
#endif //ASIO_VERSION
					if (!ec)
						handler(qtl::event::ef_write);
					else if (ec == NS_ASIO::error::make_error_code(NS_ASIO::error::operation_aborted))
						handler(qtl::event::ef_timeout);
					else
						handler(qtl::event::ef_exception);
					_timer.cancel();
					_busying = false;
				}));
				_busying = true;
			}
			if (timeout > 0)
			{
#if ASIO_VERSION < 101200
				_timer.expires_from_now(std::chrono::seconds(timeout));
#else
				_timer.expires_after(NS_ASIO::chrono::seconds(timeout));
#endif // ASIO_VERSION
				_timer.async_wait(_strand.wrap([this, handler](NS_ASIO::error_code ec) {
					if (!ec)
					{
						_socket.cancel(ec);
					}
				}));
			}
		}

		virtual void remove() override
		{
			if (_busying) return;
#if ASIO_VERSION >= 101200 && (!defined(_WIN32) || _WIN32_WINNT >= 0x0603 )
			_socket.release();
#endif //Windows 8.1
			_service.remove(this);
		}
		virtual bool is_busying() override
		{
			return _busying;
		}

	private:
		service& _service;
		service_type::strand _strand;
		NS_ASIO::ip::tcp::socket _socket;
		NS_ASIO::steady_timer _timer;
		bool _busying;
	};

public:

	template<typename Connection>
	event_item* add(Connection* connection)
	{
		event_item* item = new event_item(*this, connection->socket());
		std::lock_guard<std::mutex> lock(_mutex);
		_events.push_back(std::unique_ptr<event_item>(item));
		return item;
	}

private:
	service_type _service;
	std::mutex _mutex;
	std::vector<std::unique_ptr<event_item>> _events;

	void remove(event_item* item)
	{
		std::lock_guard<std::mutex> lock(_mutex);
		auto it = std::find_if(_events.begin(), _events.end(), [item](std::unique_ptr<event_item>& v) {
			return item==v.get();
		});
		if (it != _events.end()) _events.erase(it);
	}
};

#if ASIO_VERSION < 101200

template <typename Handler, typename Signature>
using async_init_type  = NS_ASIO::detail::async_result_init<Handler, Signature>;

template <typename Handler, typename Signature>
inline typename NS_ASIO::handler_type<Handler, Signature>::type 
get_async_handler(async_init_type<Handler, Signature>& init)
{
	return init.handler;
}

#else

template <typename Handler, typename Signature>
using async_init_type = NS_ASIO::async_completion<Handler, Signature>;

template <typename Handler, typename Signature>
inline typename async_init_type<Handler, Signature>::completion_handler_type 
get_async_handler(async_init_type<Handler, Signature>& init)
{
	return init.completion_handler;
}

#endif // ASIO_VERSION

template<typename Connection, typename OpenHandler, typename... Args>
inline ASIO_INITFN_RESULT_TYPE(OpenHandler, void(typename Connection::exception_type)) 
async_open(service& service, Connection& db, OpenHandler&& handler, Args&&... args)
{
#if ASIO_VERSION < 101200
	async_init_type<OpenHandler,
		void(typename Connection::exception_type)> init(std::forward<OpenHandler>(handler));
#else
	async_init_type<OpenHandler,
		void(typename Connection::exception_type)> init(handler);
#endif

	db.open(service, get_async_handler(init), std::forward<Args>(args)...);
	return init.result.get();
}

template<typename Connection, typename CloseHandler, typename... Args>
inline ASIO_INITFN_RESULT_TYPE(CloseHandler, void()) 
async_close(Connection& db, CloseHandler&& handler, Args&&... args)
{
#if ASIO_VERSION < 101200
	async_init_type<CloseHandler,
		void()> init(std::forward<CloseHandler>(std::forward<CloseHandler>(handler)));
#else
	async_init_type<CloseHandler,
		void()> init(std::forward<CloseHandler>(handler));
#endif

	db.close(get_async_handler(init), std::forward<Args>(args)...);
	return init.result.get();
}

template<typename Connection, typename ExecuteHandler, typename... Args>
inline ASIO_INITFN_RESULT_TYPE(ExecuteHandler, void(typename Connection::exception_type, uint64_t))  
async_execute(Connection& db, ExecuteHandler&& handler, Args&&... args)
{
#if ASIO_VERSION < 101200
	async_init_type<ExecuteHandler,
		void(typename Connection::exception_type, uint64_t)> init(std::forward<ExecuteHandler>(handler));
#else
	async_init_type<ExecuteHandler,
		void(typename Connection::exception_type, uint64_t)> init(handler);
#endif

	db.execute(get_async_handler(init), std::forward<Args>(args)...);
	return init.result.get();
}

template<typename Connection, typename ExecuteHandler, typename... Args>
inline ASIO_INITFN_RESULT_TYPE(ExecuteHandler, void(typename Connection::exception_type, uint64_t))  
async_execute_direct(Connection& db, ExecuteHandler&& handler, Args&&... args)
{
#if ASIO_VERSION < 101200
	async_init_type<ExecuteHandler,
		void(typename Connection::exception_type, uint64_t)> init(std::forward<ExecuteHandler>(handler));
#else
	async_init_type<ExecuteHandler,
		void(typename Connection::exception_type, uint64_t)> init(handler);
#endif

	db.execute_direct(get_async_handler(init), std::forward<Args>(args)...);
	return init.result.get();
}

template<typename Connection, typename ExecuteHandler, typename... Args>
inline ASIO_INITFN_RESULT_TYPE(ExecuteHandler, void(typename Connection::exception_type, uint64_t)) 
 async_insert(Connection& db, ExecuteHandler&& handler, Args&&... args)
{
#if ASIO_VERSION < 101200
	async_init_type<ExecuteHandler,
		void(typename Connection::exception_type, uint64_t)> init(std::forward<ExecuteHandler>(handler));
#else
	async_init_type<ExecuteHandler,
		void(typename Connection::exception_type, uint64_t)> init(handler);
#endif

	db.insert(get_async_handler(init), std::forward<Args>(args)...);
	return init.result.get();
}

template<typename Connection, typename ExecuteHandler, typename... Args>
inline ASIO_INITFN_RESULT_TYPE(ExecuteHandler, void(typename Connection::exception_type, uint64_t)) 
 async_insert_direct(Connection& db, ExecuteHandler&& handler, Args&&... args)
{
#if ASIO_VERSION < 101200
	async_init_type<ExecuteHandler,
		void(typename Connection::exception_type, uint64_t)> init(std::forward<ExecuteHandler>(handler));
#else
	async_init_type<ExecuteHandler,
		void(typename Connection::exception_type, uint64_t)> init(handler);
#endif

	db.insert_direct(get_async_handler(init), std::forward<Args>(args)...);
	return init.result.get();
}

template<typename Connection, typename FinishHandler, typename... Args>
inline ASIO_INITFN_RESULT_TYPE(FinishHandler, void(typename Connection::exception_type)) 
 async_query(Connection& db, FinishHandler&& handler, Args&&... args)
{
#if ASIO_VERSION < 101200
	async_init_type<FinishHandler,
		void(typename Connection::exception_type)> init(std::forward<FinishHandler>(handler));
#else
	async_init_type<FinishHandler,
		void(typename Connection::exception_type)> init(handler);
#endif

	db.query(std::forward<Args>(args)..., get_async_handler(init));
	return init.result.get();
}

template<typename Connection, typename FinishHandler, typename... Args>
inline ASIO_INITFN_RESULT_TYPE(FinishHandler, void(typename Connection::exception_type)) 
async_query_explicit(Connection& db, FinishHandler&& handler, Args&&... args)
{
#if ASIO_VERSION < 101200
	async_init_type<FinishHandler,
		void(typename Connection::exception_type)> init(std::forward<FinishHandler>(handler));
#else
	async_init_type<FinishHandler,
		void(typename Connection::exception_type)> init(handler);
#endif

	db.query_explicit(std::forward<Args>(args)..., get_async_handler(init));
	return init.result.get();
}

template<typename Connection, typename A1, typename A2, typename FinishHandler, typename... RowHandlers>
inline ASIO_INITFN_RESULT_TYPE(FinishHandler, void(typename Connection::exception_type))
async_query_multi_with_params(Connection& db, A1&& a1, A2&& a2, FinishHandler&& handler, RowHandlers&&... row_handlers)
{
#if ASIO_VERSION < 101200
	async_init_type<FinishHandler,
		void(typename Connection::exception_type)> init(std::forward<FinishHandler>(handler));
#else
	async_init_type<FinishHandler,
		void(typename Connection::exception_type)> init(handler);
#endif

	db.query_multi_with_params(std::forward<A1>(a1), std::forward<A2>(a2), get_async_handler(init), std::forward<RowHandlers>(row_handlers)...);
	return init.result.get();
}

template<typename Connection, typename A1, typename FinishHandler, typename... RowHandlers>
inline ASIO_INITFN_RESULT_TYPE(FinishHandler, void(typename Connection::exception_type))
async_query_multi_with_params(Connection& db, A1&& a1, FinishHandler&& handler, RowHandlers&&... row_handlers)
{
#if ASIO_VERSION < 101200
	async_init_type<FinishHandler,
		void(typename Connection::exception_type)> init(std::forward<FinishHandler>(handler));
#else
	async_init_type<FinishHandler,
		void(typename Connection::exception_type)> init(handler);
#endif

	db.query_multi_with_params(std::forward<A1>(a1), get_async_handler(init), std::forward<RowHandlers>(row_handlers)...);
	return init.result.get();
}

template<typename Connection, typename A1, typename A2, typename FinishHandler, typename... RowHandlers>
inline ASIO_INITFN_RESULT_TYPE(FinishHandler, void(typename Connection::exception_type))
async_query_multi(Connection& db, A1&& a1, A2&& a2, FinishHandler&& handler, RowHandlers&&... row_handlers)
{
#if ASIO_VERSION < 101200
	async_init_type<FinishHandler,
		void(typename Connection::exception_type)> init(std::forward<FinishHandler>(handler));
#else
	async_init_type<FinishHandler,
		void(typename Connection::exception_type)> init(handler);
#endif

	db.query_multi(std::forward<A1>(a1), std::forward<A2>(a2), get_async_handler(init), std::forward<RowHandlers>(row_handlers)...);
	return init.result.get();
}

template<typename Connection, typename A1, typename FinishHandler, typename... RowHandlers>
inline ASIO_INITFN_RESULT_TYPE(FinishHandler, void(typename Connection::exception_type))
async_query_multi(Connection& db, A1&& a1, FinishHandler&& handler, RowHandlers&&... row_handlers)
{
#if ASIO_VERSION < 101200
	async_init_type<FinishHandler,
		void(typename Connection::exception_type)> init(std::forward<FinishHandler>(handler));
#else
	async_init_type<FinishHandler,
		void(typename Connection::exception_type)> init(handler);
#endif

	db.query_multi(std::forward<A1>(a1), get_async_handler(init), std::forward<RowHandlers>(row_handlers)...);
	return init.result.get();
}

}

}

#endif //_QTL_ASIO_H_