#include <list>
#include <atomic>
#include <thread>
#include <functional>
#include <condition_variable>

namespace auth {
class task_queue final {
public:
	task_queue(const task_queue&) =delete;
	task_queue& operator = (const task_queue&) =delete;

	task_queue();
	task_queue(task_queue&& other);
	task_queue& operator = (task_queue&& other);
	~task_queue() noexcept ;

	void add(const std::function<void ()>& task);
	std::size_t size() const ;
private:
	std::atomic<bool> stop_{false};
	std::thread thread_;

	mutable std::mutex tasks_mutex_;
	std::list<std::function<void ()>> tasks_;

	std::condition_variable tasks_condition_;
};
} // auth namespace

// cpp file
#include "task_queue.h"
#include <iostream>

auth::task_queue::task_queue(task_queue&& other) : thread_(std::move(other.thread_)), tasks_(std::move(other.tasks_)) {}
auth::task_queue& auth::task_queue::operator = (task_queue&& other)
{
	tasks_ = std::move(other.tasks_);
	thread_ = std::move(other.thread_);
	return *this;
}

auth::task_queue::task_queue() : thread_([this](){
			while(!stop_) {
				std::unique_lock<std::mutex> lock(tasks_mutex_);
				tasks_condition_.wait(lock,[this](){ return 0<tasks_.size() || stop_; });

				std::list<std::function<void ()>> tasks;
				tasks.swap(tasks_);
				lock.unlock();

				for(auto task:tasks) task();
			}
		}) {}

auth::task_queue::~task_queue() noexcept
{
	stop_ = true ;
	std::unique_lock<std::mutex> lock(tasks_mutex_);
	tasks_condition_.notify_all();
	thread_.join();
//	thread_.detach();
}

void auth::task_queue::add(const std::function<void ()>& task)
{
	std::unique_lock<std::mutex> lock(tasks_mutex_);
	tasks_.push_back(task);
	lock.unlock();
	tasks_condition_.notify_one();
}

std::size_t auth::task_queue::size() const
{
	std::unique_lock<std::mutex> lock(tasks_mutex_);
	return tasks_.size();
}

#define BOOST_TEST_DYN_LINK
#define BOOST_TEST_MODULE thread queue test

#include <mutex>
#include <boost/test/unit_test.hpp>
#include <iostream>

#include "cpphttpx/cms/auth/task_queue.h"

BOOST_AUTO_TEST_SUITE( task_queue )
BOOST_AUTO_TEST_CASE( add_and_size )
{
	auth::task_queue task;
	BOOST_CHECK_NO_THROW( task.add([](){ std::this_thread::yield();std::this_thread::yield(); }) );
	BOOST_CHECK_NO_THROW( task.add([](){ std::this_thread::yield();std::this_thread::yield(); }) );
	BOOST_CHECK_NO_THROW( task.add([](){ std::this_thread::yield();std::this_thread::yield(); }) );
	BOOST_CHECK( 0<task.size() );
}
BOOST_AUTO_TEST_CASE( tasks )
{
	auth::task_queue task;
	std::timed_mutex checker;
	BOOST_REQUIRE( checker.try_lock_for(std::chrono::milliseconds(10)) );

	BOOST_CHECK_NO_THROW( task.add([&checker](){
			BOOST_REQUIRE( !checker.try_lock() );
			std::cout << "hello from thread tasks" << std::endl;
			checker.unlock();
			}) );

	BOOST_CHECK( checker.try_lock_for(std::chrono::seconds(1)) );
}
BOOST_AUTO_TEST_SUITE_END() // task_queue

#pragma once

/*************************************************************************
 * Copyright © 2016 Hudyaev Alexy <hudyaev.alexy@gmail.com>;
 * This file is part of cpphttpx-cms.
 * Distributed under the GNU Affero General Public License.
 * See accompanying file copying (at the root of this repository)
 * or <http://www.gnu.org/licenses/> for details
 *************************************************************************/


#include <list>
#include <atomic>
#include <thread>
#include <functional>
#include <condition_variable>

namespace auth {
class task_queue final {
public:
	task_queue(const task_queue&) =delete;
	task_queue& operator = (const task_queue&) =delete;

	task_queue();
	task_queue(task_queue&& other);
	task_queue& operator = (task_queue&& other) ;
	~task_queue() noexcept ;

	void add(const std::function<void ()>& task);
	std::size_t size() const ;
private:
	void worker() ;

	mutable std::mutex tasks_mutex_;
	std::list<std::function<void ()>> tasks_;

	std::condition_variable tasks_condition_;

	std::atomic<bool> stop_{false};
	std::thread thread_;
};
} // auth namespace

/*******************************************************************************
 * Copyright © 2016 Hudyaev Alexy <hudyaev.alexy@gmail.com>;
 *
 * This file is part of cpphtpx-cms
 *
 * CPPHTTPX-CMS is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * CPPHTTPX-CMS is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with cpphttpx-cms (copying file in the root of this repository). If not,
 * see <http://www.gnu.org/licenses/>
 * *****************************************************************************/


#include "task_queue.h"
#include <cassert>

auth::task_queue::task_queue(task_queue&& other)
{
	operator = (static_cast<task_queue&&>(other)) ;
}

auth::task_queue& auth::task_queue::operator = (auth::task_queue&& other)
{
	assert( !other.stop_ );
	other.stop_=true;

	std::unique_lock<std::mutex> own_lock(tasks_mutex_);
	std::unique_lock<std::mutex> thr_lock(other.tasks_mutex_);
	tasks_ = std::move(other.tasks_);

	std::thread tmp(std::bind(&auth::task_queue::worker,this));
	thread_.swap(tmp);

	return *this;
}

auth::task_queue::task_queue()
{
	std::thread tmp(std::bind(&auth::task_queue::worker,this));
	thread_.swap(tmp);
}

auth::task_queue::~task_queue() noexcept
{
	stop_ = true ;

	{
		std::unique_lock<std::mutex> lock(tasks_mutex_);
		tasks_condition_.notify_one();
	}

	if(thread_.joinable()) thread_.join();
}

void auth::task_queue::add(const std::function<void ()>& task)
{
	std::unique_lock<std::mutex> lock(tasks_mutex_);
	tasks_.push_back(task);
	tasks_condition_.notify_one();
}

std::size_t auth::task_queue::size() const
{
	std::unique_lock<std::mutex> lock(tasks_mutex_);
	return tasks_.size();
}

void auth::task_queue::worker()
{
	while(!stop_) {
		std::list<std::function<void ()>> tasks;

		std::unique_lock<std::mutex> lock(tasks_mutex_);
		if(stop_) break;
		if(tasks_.size()==0) tasks_condition_.wait(lock,[this](){ return 0<tasks_.size() || stop_; });

		tasks.swap(tasks_);
		lock.unlock();

		for(auto task:tasks) task();
	}
}

#define BOOST_TEST_DYN_LINK
#define BOOST_TEST_MODULE thread queue test

#include <mutex>
#include <boost/test/unit_test.hpp>

#include "cpphttpx/cms/auth/task_queue.h"

void wait_fnc ()
{
	std::this_thread::yield();
	std::this_thread::yield();
}

BOOST_AUTO_TEST_SUITE( task_queue )
BOOST_AUTO_TEST_CASE( add_is_ok )
{
	auth::task_queue task;
	BOOST_CHECK_NO_THROW( task.add(wait_fnc) );
}
BOOST_AUTO_TEST_CASE( tasks )
{
	auth::task_queue task;
	std::timed_mutex checker;
	BOOST_REQUIRE( checker.try_lock_for(std::chrono::milliseconds(10)) );

	BOOST_CHECK_NO_THROW( task.add([&checker](){
			BOOST_REQUIRE( !checker.try_lock() );
			checker.unlock();
			}) );

	BOOST_CHECK( checker.try_lock_for(std::chrono::seconds(1)) );
}
BOOST_AUTO_TEST_CASE( move )
{
	std::timed_mutex checker;
	checker.lock();

	auth::task_queue task_first;

	BOOST_CHECK_NO_THROW( task_first.add([&checker](){wait_fnc();checker.unlock();}) );
	auth::task_queue task_second( std::move(task_first) );

	BOOST_CHECK( checker.try_lock_for(std::chrono::seconds(1)) );
}

BOOST_AUTO_TEST_SUITE_END() // task_queue

namespace details {
	template<typename T>
	struct fake_copyable {
		fake_copyable(T&& t) : target(std::forward<T>(t)) {}
		fake_copyable(fake_copyable&& )=default ;
		fake_copyable(const fake_copyable&) {throw std::logic_error("apptemt to copy a fake copyable object");}
		template<typename... Args>
		auto operator()(Args&&... a) { return target(std::forward<Args>(a)...); }

		T target ;
	};
}

// ....

	template< class Function, class ... Args >
	boost::fibers::future<
	    std::result_of_t< std::decay_t< Function >( std::decay_t< Args > ... ) >
	>
	async( Function && fn, Args && ... args) {
		using result_t = std::result_of_t< std::decay_t< Function >( std::decay_t< Args > ... )> ;
		using pt_t = boost::fibers::packaged_task< result_t( std::decay_t< Args > ... ) > ;

		pt_t pt{ /*std::allocator_arg, salloc, */std::forward< Function >( fn) };
		boost::fibers::future< result_t > f{ pt.get_future() };

		details::fake_copyable<pt_t> ca_pt(std::move(pt));
		tasks_.push_back(std::move(ca_pt));
		tasks_condition_.notify_one();

		return f;
	}