//
//  TimedNotificationQueueTest.cpp
//
//  Created by Setsu on 6/8/2010.
//  Copyright 2010 RoundSquare Inc. All rights reserved.
//
// Permission is hereby granted, free of charge, to any person or organization
// obtaining a copy of the software and accompanying documentation covered by
// this license (the "Software") to use, reproduce, display, distribute,
// execute, and transmit the Software, and to prepare derivative works of the
// Software, and to permit third-parties to whom the Software is furnished to
// do so, all subject to the following:
// 
// The copyright notices in the Software and this entire statement, including
// the above license grant, this restriction and the following disclaimer,
// must be included in all copies of the Software, in whole or in part, and
// all derivative works of the Software, unless such copies or derivative
// works are solely in the form of machine-executable object code generated by
// a source language processor.
// 
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
// SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
// FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
// ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
// DEALINGS IN THE SOFTWARE.
//

//----------------------------------------
//	include
//----------------------------------------
#include <Poco/Logger.h>
#include <Poco/PatternFormatter.h>
#include <Poco/FormattingChannel.h>
#include <Poco/ConsoleChannel.h>
#include <Poco/Format.h>
#include <Poco/Notification.h>
#include <Poco/TimedNotificationQueue.h>
#include <Poco/AtomicCounter.h>
#include <Poco/DateTime.h>
#include <Poco/Timespan.h>
#include <Poco/ThreadPool.h>
#include <Poco/Thread.h>
#include <Poco/Runnable.h>
#include <Poco/AutoPtr.h>
#include <Poco/Random.h>
#include <Poco/DateTimeFormatter.h>
#include <Poco/Timezone.h>

#include <string>

#include "ScopedLogMessage.h"

//----------------------------------------
//	const
//----------------------------------------
const int kNumEnqueueByChild = 3;
const long kSleepTime = 200;
const long kScheduleMaxTime = 500;

//----------------------------------------
//	ChildNotification
//----------------------------------------
class ChildNotification : public Poco::Notification
{
public:
	ChildNotification(int data, const std::string& name, const Poco::DateTime& datetime):
		m_data(data)
	,	m_name(name)
	,	m_datetime(datetime)
	{
		m_datetime.makeLocal(Poco::Timezone::tzd());
	}

	int data() const
	{
		return m_data;
	}

	std::string name() const
	{
		return m_name;
	}

	std::string datetime() const
	{
		return Poco::DateTimeFormatter::format(m_datetime.timestamp(), "%H:%M:%S.%i");
	}

private:
	int					m_data;
	const std::string	m_name;
	Poco::DateTime		m_datetime;
};

//----------------------------------------
//	Child
//----------------------------------------
class Child : public Poco::Runnable
{
public:
	typedef Poco::AutoPtr<ChildNotification> ChildNotificationPtr;

	Child(const std::string& name, Poco::TimedNotificationQueue& queue, ScopedLogMessage& msg):
		m_name(name)
	,	m_queue(queue)
	,	m_msg(msg)
	{
		m_msg.Message(Poco::format("  %s created", m_name));
	}

	~Child()
	{
		m_msg.Message(Poco::format("  %s deleted", m_name));
	}

	void run()
	{
		for(int i=0; i<kNumEnqueueByChild; ++i)
		{
			int counter = ++m_counter;
			Poco::DateTime datetime;
			datetime += Poco::Timespan(m_rnd.next(kScheduleMaxTime)*1000);
			m_queue.enqueueNotification(new ChildNotification(counter, m_name, datetime), datetime.timestamp());
			datetime.makeLocal(Poco::Timezone::tzd());
			m_msg.Message(Poco::format("   enqueueNotification #%d from %s (%s)"
										, counter
										, m_name
										, Poco::DateTimeFormatter::format(datetime.timestamp(), "%H:%M:%S.%i")));
		}
	}

	static int NumEnqueued(void)
	{
		return m_counter;
	}

private:
	std::string						m_name;
	Poco::TimedNotificationQueue&	m_queue;
	ScopedLogMessage&				m_msg;
	static Poco::AtomicCounter		m_counter;
	static Poco::Random				m_rnd;
};

Poco::AtomicCounter Child::m_counter(0);
Poco::Random Child::m_rnd;

//----------------------------------------
//	PrepareConsoleLogger
//----------------------------------------
void PrepareConsoleLogger(const std::string& name, int level=Poco::Message::PRIO_INFORMATION)
{
	Poco::FormattingChannel* pFCConsole = new Poco::FormattingChannel(new Poco::PatternFormatter("%t"));
	pFCConsole->setChannel(new Poco::ConsoleChannel);
	pFCConsole->open();

	Poco::Logger::create(name, pFCConsole, level);
}

//----------------------------------------
//	main
//----------------------------------------
int main(int /*argc*/, char** /*argv*/)
{
	PrepareConsoleLogger(Poco::Logger::ROOT, Poco::Message::PRIO_INFORMATION);

	ScopedLogMessage msg("TimedNotificationQueueTest ", "start", "end");

	Poco::TimedNotificationQueue queue;

	Child child1("Child 1", queue, msg);
	Child child2("Child 2", queue, msg);
	Child child3("Child 3", queue, msg);

	Poco::ThreadPool::defaultPool().start(child1);
	Poco::ThreadPool::defaultPool().start(child2);
	Poco::ThreadPool::defaultPool().start(child3);

	int numDequeued = 0;
	while(numDequeued < Child::NumEnqueued())
	{
		Poco::Notification::Ptr pNf(queue.waitDequeueNotification());
		if(pNf)
		{
			Child::ChildNotificationPtr pChildNf = pNf.cast<ChildNotification>();
			if(pChildNf)
			{
				msg.Message(Poco::format("    got child notification #%d from %s (%s)"
											, pChildNf->data()
											, pChildNf->name()
											, pChildNf->datetime()));
				++numDequeued;
				Poco::Thread::sleep(kSleepTime);
			}
		}
		else break;
	}

	return 0;
}