/*
 * =====================================================================================
 *
 *       Filename:  util.h
 *
 *    Description:  
 *
 *        Version:  1.0
 *        Created:  2021年03月30日 11时24分26秒
 *       Revision:  none
 *       Compiler:  gcc
 *
 *         Author:  Li Chao (), 
 *   Organization:  
 *
 * =====================================================================================
 */

#ifndef UTIL_W8A0OA5U
#define UTIL_W8A0OA5U

#include "bh_util.h"
#include "shm.h"
#include "topic_node.h"
#include <boost/noncopyable.hpp>
#include <boost/test/unit_test.hpp>
#include <boost/timer/timer.hpp>
#include <chrono>
#include <functional>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <thread>
#include <vector>

using namespace std::chrono_literals;
using namespace std::chrono;

template <class D>
inline void Sleep(D d, bool print = true)
{
	if (print) {
		printf("sleep for %ld ms\n", std::chrono::duration_cast<std::chrono::milliseconds>(d).count());
	}
	std::this_thread::sleep_for(d);
}

typedef std::function<void(void)> FuncVV;

class ScopeCall : private boost::noncopyable
{
	FuncVV f_;

public:
	ScopeCall(FuncVV f) :
	    f_(f) { f_(); }
	~ScopeCall() { f_(); }
};
class ThreadManager
{
	std::vector<std::thread> threads_;

public:
	~ThreadManager() { WaitAll(); }
	template <class T, class... P>
	void Launch(T &&t, P &&...p) { threads_.emplace_back(std::forward<decltype(t)>(t), std::forward<decltype(p)>(p)...); }
	void WaitAll()
	{
		for (auto &t : threads_) {
			if (t.joinable()) {
				t.join();
			}
		}
	}
};
class ProcessManager
{
	std::vector<pid_t> procs_;

public:
	~ProcessManager() { WaitAll(); }
	template <class T, class... P>
	void Launch(T t, P... p)
	{
		auto pid = fork();
		if (pid == 0) {
			// child
			t(p...);
			exit(0);
		} else if (pid != -1) { // Ok
			procs_.push_back(pid);
		}
	};
	void WaitAll()
	{
		for (auto &pid : procs_) {
			int status = 0;
			int options = WUNTRACED | WCONTINUED;
			waitpid(pid, &status, options);
		}
		procs_.clear();
	}
};

using namespace bhome_shm;
using namespace bhome_msg;

struct ShmRemover {
	std::string name_;
	ShmRemover(const std::string &name) :
	    name_(name) { SharedMemory::Remove(name_); }
	~ShmRemover() { SharedMemory::Remove(name_); }
};

class DemoNode : public TopicNode
{
	std::string id_;

public:
	DemoNode(const std::string &id, SharedMemory &shm) :
	    TopicNode(shm), id_(id) { Init(); }
	void Init()
	{
		ProcInfo proc;
		proc.set_proc_id(id_);
		MsgCommonReply reply_body;

		if (!Register(proc, reply_body, 1000)) {
			printf("node %s register failed\n", id_.c_str());
		}
	}
};

bhome_shm::SharedMemory &TestShm();

#endif // end of include guard: UTIL_W8A0OA5U