#ifndef _QTL_ASYNC_H_
#define _QTL_ASYNC_H_

#include <tuple>
#include <memory>
#include <chrono>
#include <functional>

namespace qtl
{

#ifdef _WIN32
	typedef SOCKET socket_type;
#else
	typedef int socket_type;
#endif 

namespace detail 
{

template<typename Values, typename RowHandler, typename FinishHandler>
struct async_fetch_helper : public std::enable_shared_from_this<async_fetch_helper<Values, RowHandler, FinishHandler>>
{
	async_fetch_helper(const Values& values, const RowHandler& row_handler, const FinishHandler& finish_handler)
		: m_values(values), m_row_handler(row_handler), m_finish_handler(finish_handler), m_auto_close_command(true)
	{
	}

	template<typename Command, typename Exception>
	void start(const std::shared_ptr<Command>& command)
	{
		auto self = this->shared_from_this();
		command->fetch(std::forward<Values>(m_values), [this, command]() {
			return qtl::detail::apply<RowHandler, Values>(std::forward<RowHandler>(m_row_handler), std::forward<Values>(m_values));
		}, [self, command](const Exception& e) {
			if (e || self->m_auto_close_command)
			{
				command->close([self, command, e](const Exception& new_e) {
					self->m_finish_handler(e ? e : new_e);
				});
			}
			else 
			{
				self->m_finish_handler(e);
			}
		});
	}
	
	void auto_close_command(bool auto_close)
	{
		m_auto_close_command = auto_close;
	}

private:
	Values m_values;
	RowHandler m_row_handler;
	FinishHandler m_finish_handler;
	bool m_auto_close_command;
};

template<typename Values, typename RowHandler, typename FinishHandler>
inline std::shared_ptr<async_fetch_helper<Values, RowHandler, FinishHandler>> make_fetch_helper(const Values& values, const RowHandler& row_handler, const FinishHandler& cpmplete_handler)
{
	return std::make_shared<async_fetch_helper<Values, RowHandler, FinishHandler>>(values, row_handler, cpmplete_handler);
}


template<typename Exception, typename Command, typename RowHandler, typename FinishHandler>
inline void async_fetch_command(const std::shared_ptr<Command>& command, FinishHandler&& finish_handler, RowHandler&& row_handler)
{
	auto values=make_values(row_handler);
	typedef decltype(values) values_type;
	auto helper = make_fetch_helper(std::forward<values_type>(values), std::forward<RowHandler>(row_handler), std::forward<FinishHandler>(finish_handler));
	helper->auto_close_command(false);
	helper->template start<Command, Exception>(command);
}

template<typename Exception, typename Command, typename RowHandler, typename FinishHandler, typename... OtherHandler>
inline void async_fetch_command(const std::shared_ptr<Command>& command, FinishHandler&& finish_handler, RowHandler&& row_handler, OtherHandler&&... other)
{
	async_fetch_command<Exception>(command, [command, finish_handler, other...](const Exception& e) mutable {
		if (e)
		{
			finish_handler(e);
		}
		else
		{
			command->next_result([=](const Exception& e) mutable {
				if (e)
					finish_handler(e);
				else
					async_fetch_command<Exception>(command, std::forward<FinishHandler>(finish_handler), std::forward<OtherHandler>(other)...);
			});
		}
	}, std::forward<RowHandler>(row_handler));
}

}

struct event
{
	enum io_flags
	{
		ef_read = 0x1,
		ef_write = 0x2,
		ef_exception = 0x4,
		ef_timeout =0x8,
		ev_all = ef_read | ef_write | ef_exception
	};

	virtual ~event() { }
	virtual void set_io_handler(int flags, long timeout, std::function<void(int)>&&) = 0;
	virtual void remove() = 0;
	virtual bool is_busying() = 0;
};

template<typename T, class Command>
class async_connection
{
public:
	template<typename EventLoop>
	bool bind(EventLoop& ev)
	{
		T* pThis = static_cast<T*>(this);
		if(m_event_handler) 
		{
			if(m_event_handler->is_busying())
				return false;
			unbind();
		}
		m_event_handler = ev.add(pThis);
		return m_event_handler!=nullptr;
	}

	qtl::event* event() const
	{
		return m_event_handler;
	}

	bool unbind()
	{
		if(m_event_handler)
		{
			if(m_event_handler->is_busying())
				return false;
			m_event_handler->remove();
			m_event_handler=nullptr;
		}
		return true;
	}

	/*
		ResultHandler defines as:
			void handler(const exception_type& e, uint64_t affected=0);
		Copies will be made of the handler as required.
		If an error occurred, value of affected is undefined.
		Note: parameter affected must has default value.
	*/
	template<typename Params, typename ResultHandler>
	void execute(ResultHandler handler, const char* query_text, size_t text_length, const Params& params)
	{
		T* pThis = static_cast<T*>(this);
		pThis->open_command(query_text, text_length, [handler, params](const typename T::exception_type& e, std::shared_ptr<Command>& command) mutable {
			if(e)
			{
				command->close([command, e, handler](const typename T::exception_type& ae) mutable {
					handler(e ? e : ae, 0);
				});
				return;
			}
			command->execute(params, [command, handler](const typename T::exception_type& e, uint64_t affected) mutable {
				command->close([command, handler, e, affected](const typename T::exception_type& ae) mutable {
					handler(e ? e : ae, affected);
				});
			});
		});
	}
	template<typename Params, typename ResultHandler>
	void execute(ResultHandler handler, const char* query_text, const Params& params)
	{
		return execute(std::forward<ResultHandler>(handler), query_text, strlen(query_text), params);
	}
	template<typename Params, typename ResultHandler>
	void execute(ResultHandler handler, const std::string& query_text, const Params& params)
	{
		return execute(std::forward<ResultHandler>(handler), query_text.data(), query_text.length(), params);
	}

	template<typename... Params, typename ResultHandler>
	void execute_direct(ResultHandler handler, const char* query_text, size_t text_length, const Params&... params)
	{
		execute(std::forward<ResultHandler>(handler), query_text, text_length, std::forward_as_tuple(params...));
	}
	template<typename... Params, typename ResultHandler>
	void execute_direct(ResultHandler handler, const char* query_text, const Params&... params)
	{
		execute(std::forward<ResultHandler>(handler), query_text, std::forward_as_tuple(params...));
	}
	template<typename... Params, typename ResultHandler>
	void execute_direct(ResultHandler handler, const std::string& query_text, const Params&... params)
	{
		execute(std::forward<ResultHandler>(handler), query_text, query_text, std::forward_as_tuple(params...));
	}

	/*
		ResultHandler defines as:
			void handler(const exception_type& e, uint64_t insert_id=0);
		Copies will be made of the handler as required.
		If an error occurred, value of insert_id is undefined.
		If the command is not insert statement, value of insert_id is zero.
		Note: parameter insert_id must has default value.
	*/
	template<typename Params, typename ResultHandler>
	void insert(ResultHandler handler, const char* query_text, size_t text_length, const Params& params)
	{
		T* pThis = static_cast<T*>(this);
		pThis->open_command(query_text, text_length, [handler, params](const typename T::exception_type& e, std::shared_ptr<Command>& command) {
			if(e)
			{
				command->close([command, e, handler](const typename T::exception_type& ae) mutable {
					handler(e ? e : ae, 0);
				});
			}
			else
			{
				command->execute(params, [command, handler](const typename T::exception_type& e, uint64_t affected) {
					auto insert_id = 0;
					if(!e && affected>0)
						insert_id  = command->insert_id();
					command->close([command, handler, e, insert_id](const typename T::exception_type& ae) mutable {
						handler(e ? e : ae, insert_id);
					});
				});
			}
		});
	}

	template<typename Params, typename ResultHandler>
	void insert(ResultHandler&& handler, const char* query_text, const Params& params)
	{
		insert(std::forward<ResultHandler>(handler), query_text, strlen(query_text), params);
	}

	template<typename Params, typename ResultHandler>
	void insert(ResultHandler&& handler, const std::string& query_text, const Params& params)
	{
		insert(std::forward<ResultHandler>(handler), query_text.data(), query_text.length(), params);
	}

	template<typename... Params, typename ResultHandler>
	void insert_direct(ResultHandler&& handler, const char* query_text, size_t text_length, const Params&... params)
	{
		insert(std::forward<ResultHandler>(handler), query_text, text_length, std::forward_as_tuple(params...));
	}

	template<typename... Params, typename ResultHandler>
	void insert_direct(ResultHandler&& handler, const char* query_text, const Params&... params)
	{
		insert(std::forward<ResultHandler>(handler), query_text, strlen(query_text), std::forward_as_tuple(params...));
	}

	template<typename... Params, typename ResultHandler>
	void insert_direct(ResultHandler&& handler, const std::string& query_text, const Params&... params)
	{
		insert(std::forward<ResultHandler>(handler), query_text.data(), query_text.length(), std::forward_as_tuple(params...));
	}

	/*
		RowHandler defines as:
			void row_handler(const Values& values);
		FinishHandler defines as:
			void finish_handler(const exception_type& e);
		If a row is fetched, the row handler is called.
		If an error occurred or the operation is completed, the result handler is called.
	*/
	template<typename Params, typename Values, typename RowHandler, typename FinishHandler>
	void query_explicit(const char* query_text, size_t text_length, const Params& params, Values&& values, RowHandler&& row_handler, FinishHandler&& finish_handler)
	{
		T* pThis = static_cast<T*>(this);
		pThis->open_command(query_text, text_length, [values, row_handler, finish_handler, params](const typename T::exception_type& e, const std::shared_ptr<Command>& command) mutable {
			if(e)
			{
				finish_handler(e);
			}
			else
			{
				command->execute(params, [command, values, row_handler, finish_handler](const typename T::exception_type& e, uint64_t affected) mutable {
					auto helper=detail::make_fetch_helper(values, row_handler, finish_handler);
					helper->template start<Command, typename T::exception_type>(command);
				});
			}
		});
	}

	template<typename Params, typename Values, typename RowHandler, typename FinishHandler>
	void query_explicit(const char* query_text, const Params& params, Values&& values, RowHandler&& row_handler, FinishHandler&& finish_handler)
	{
		query_explicit(query_text, strlen(query_text), params, std::forward<Values>(values), std::forward<RowHandler>(row_handler), std::forward<FinishHandler>(finish_handler));
	}
	template<typename Params, typename Values, typename RowHandler, typename FinishHandler>
	void query_explicit(const std::string& query_text, const Params& params, Values&& values, RowHandler&& row_handler, FinishHandler&& finish_handler)
	{
		query_explicit(query_text.data(), query_text.size(), params, std::forward<Values>(values), std::forward<RowHandler>(row_handler), std::forward<FinishHandler>(finish_handler));
	}
	template<typename Values, typename RowHandler, typename FinishHandler>
	void query_explicit(const char* query_text, size_t text_length, Values&& values, RowHandler&& row_handler, FinishHandler&& finish_handler)
	{
		query_explicit(query_text, text_length, std::make_tuple(), std::forward<Values>(values), std::forward<RowHandler>(row_handler), std::forward<FinishHandler>(finish_handler));
	}
	template<typename Values, typename RowHandler, typename FinishHandler>
	void query_explicit(const char* query_text, Values&& values, RowHandler&& row_handler, FinishHandler&& finish_handler)
	{
		query_explicit(query_text, strlen(query_text), std::make_tuple(), std::forward<Values>(values), std::forward<RowHandler>(row_handler), std::forward<FinishHandler>(finish_handler));
	}
	template<typename Values, typename RowHandler, typename FinishHandler>
	void query_explicit(const std::string& query_text, Values&& values, RowHandler&& row_handler, FinishHandler&& finish_handler)
	{
		query_explicit(query_text, std::make_tuple(), std::forward<Values>(values), std::forward<RowHandler>(row_handler), std::forward<FinishHandler>(finish_handler));
	}

	template<typename Params, typename RowHandler, typename FinishHandler>
	void query(const char* query_text, size_t text_length, const Params& params, RowHandler&& row_handler, FinishHandler&& finish_handler)
	{
		query_explicit(query_text, text_length, params, detail::make_values(row_handler), std::forward<RowHandler>(row_handler), std::forward<FinishHandler>(finish_handler));
	}
	template<typename Params, typename RowHandler, typename FinishHandler>
	void query(const char* query_text, const Params& params, RowHandler&& row_handler, FinishHandler&& finish_handler)
	{
		query_explicit(query_text, params, detail::make_values(row_handler), std::forward<RowHandler>(row_handler), std::forward<FinishHandler>(finish_handler));
	}
	template<typename Params, typename RowHandler, typename FinishHandler>
	void query(const std::string& query_text, const Params& params, RowHandler&& row_handler, FinishHandler&& finish_handler)
	{
		query_explicit(query_text, params, detail::make_values(row_handler), std::forward<RowHandler>(row_handler), std::forward<FinishHandler>(finish_handler));
	}
	template<typename RowHandler, typename FinishHandler>
	void query(const char* query_text, size_t text_length, RowHandler&& row_handler, FinishHandler&& finish_handler)
	{
		query_explicit(query_text, text_length, detail::make_values(row_handler), std::forward<RowHandler>(row_handler), std::forward<FinishHandler>(finish_handler));
	}
	template<typename RowHandler, typename FinishHandler>
	void query(const char* query_text, RowHandler&& row_handler, FinishHandler&& finish_handler)
	{
		query_explicit(query_text, detail::make_values(row_handler), std::forward<RowHandler>(row_handler), std::forward<FinishHandler>(finish_handler));
	}
	template<typename RowHandler, typename FinishHandler>
	void query(const std::string& query_text, RowHandler&& row_handler, FinishHandler&& finish_handler)
	{
		query_explicit(query_text, detail::make_values(row_handler), std::forward<RowHandler>(row_handler), std::forward<FinishHandler>(finish_handler));
	}

	template<typename Params, typename FinishHandler, typename... RowHandlers>
	void query_multi_with_params(const char* query_text, size_t text_length, const Params& params, FinishHandler&& finish_handler, RowHandlers&&... row_handlers)
	{
		T* pThis = static_cast<T*>(this);
		pThis->open_command(query_text, text_length, [params, finish_handler, row_handlers...](const typename T::exception_type& e, const std::shared_ptr<Command>& command) mutable {
			if (e)
			{
				finish_handler(e);
			}
			else
			{
				command->execute(params, [=](const typename T::exception_type& e, uint64_t affected) mutable {
					if (e)
						finish_handler(e);
					else
						qtl::detail::async_fetch_command<typename T::exception_type>(command, std::forward<FinishHandler>(finish_handler), std::forward<RowHandlers>(row_handlers)...);
				});
			}
		});
	}
	template<typename Params, typename FinishHandler, typename... RowHandlers>
	void query_multi_with_params(const char* query_text, const Params& params, FinishHandler&& finish_handler, RowHandlers&&... row_handlers)
	{
		query_multi_with_params(query_text, strlen(query_text), params, std::forward<FinishHandler>(finish_handler), std::forward<RowHandlers>(row_handlers)...);
	}
	template<typename Params, typename FinishHandler, typename... RowHandlers>
	void query_multi_with_params(const std::string& query_text, const Params& params, FinishHandler&& finish_handler, RowHandlers&&... row_handlers)
	{
		query_multi_with_params(query_text.data(), query_text.size(), params, std::forward<FinishHandler>(finish_handler), std::forward<RowHandlers>(row_handlers)...);
	}
	template<typename FinishHandler, typename... RowHandlers>
	void query_multi(const char* query_text, size_t text_length, FinishHandler&& finish_handler, RowHandlers&&... row_handlers)
	{
		query_multi_with_params<std::tuple<>, FinishHandler, RowHandlers...>(query_text, text_length, std::make_tuple(), std::forward<FinishHandler>(finish_handler), std::forward<RowHandlers>(row_handlers)...);
	}
	template<typename FinishHandler, typename... RowHandlers>
	void query_multi(const char* query_text, FinishHandler&& finish_handler, RowHandlers&&... row_handlers)
	{
		query_multi_with_params<std::tuple<>, FinishHandler, RowHandlers...>(query_text, strlen(query_text), std::make_tuple(), std::forward<FinishHandler>(finish_handler), std::forward<RowHandlers>(row_handlers)...);
	}
	template<typename FinishHandler, typename... RowHandlers>
	void query_multi(const std::string& query_text, FinishHandler&& finish_handler, RowHandlers&&... row_handlers)
	{
		query_multi_with_params<std::tuple<>, FinishHandler, RowHandlers...>(query_text.data(), query_text.size(), std::make_tuple(), std::forward<FinishHandler>(finish_handler), std::forward<RowHandlers>(row_handlers)...);
	}

protected:
	qtl::event* m_event_handler { nullptr };
};

}

#endif //_QTL_ASYNC_H_