// Copyright (c) 2007-2010 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of "Eclipse Public License v1.0"

// which accompanies this distribution, and is available

// at the URL "http://www.eclipse.org/legal/epl-v10.html".

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

//

#include <e32base.h>

#include <e32std.h>

#include <e32cons.h>

#include <e32def.h>

#include <elements/cftransport.h>

#include <elements/nm_common.h>

#include <elements/nm_node.h>

#include <elements/nm_log.h>

#include <elements/nm_address.h>

#include <elements/nm_signatures.h>

#include <elements/nm_messages_base.h>

#include <elements/nm_interfaces.h>

#include <elements/mm_node.h>

#include <elements/mm_activities.h>

#include <MMExample1states.h>

class TMyWorkerThreadRegister; 

LOCAL_D CConsoleBase* console; 

_LIT8(KLoggingTag, "MMExample1");

_LIT(KJunctionPanicCat, "Junction");

const TInt KPanicUnknownMessage = 1;

/**

   This classes records information about a worker thread, which is useful

   when nodemessages is running across multiple threads. In this example,

   nodemessages is running in a single thread.

   Most users of node messages will never need to use this as they will be

   using node messages from within serverden which does all this setup for

   you.

 */

class TMyWorkerThreadRegister : public CommsFW::MWorkerThreadRegister

	{

public:

	CommsFW::TWorkerId SelfWorkerId() const

		{ return 1; }

	CommsFW::TWorkerId UpperBoundWorkerId() const

		{ return 1; }

	RAllocator& WorkerHeap(CommsFW::TWorkerId /*aWorkerId*/) const

		{

		return User::Allocator();

		}

	void PanicWorker(CommsFW::TWorkerId /*aWorkerId*/, const TDesC& aCategory, TInt aReason) const

		{

		User::Panic(aCategory, aReason);

		}

	};

_LIT(KNorth, "North");

_LIT(KSouth, "South");

_LIT(KEast, "East");

_LIT(KWest, "West");

LOCAL_C void MainL ()

	{

	/**

	   Setup the environment for passing messages.

	*/

	TMyWorkerThreadRegister workerregister;

	Messages::CGlobals* globals = &Messages::TlsGlobals::InstallGlobalsL();

	CommsFW::CCommsTransport* transport = CommsFW::CCommsTransport::NewL(workerregister, globals->VirtualCtor(), NULL);

	globals->SetTransportSender(&transport->GetSender());

	globals->SetTransportReceiver(&transport->GetReceiver());

	CleanupStack::PushL(transport);

	CClock* clock = new(ELeave)CClock();

	CleanupStack::PushL(clock);

	CController* controller = new(ELeave)CController();

	CleanupStack::PushL(controller);

	CTrafficLight* north = new(ELeave)CTrafficLight(console, KNorth());

	CleanupStack::PushL(north);

	north->AddClientL(clock->Id(), Messages::TClientType(EClock));

	clock->AddClientL(north->Id(), Messages::TClientType(ETrafficLight));

	north->AddClientL(controller->Id(), Messages::TClientType(EController));

	controller->AddClientL(north->Id(), Messages::TClientType(ETrafficLight, ENorth));

	CTrafficLight* south = new(ELeave)CTrafficLight(console, KSouth());

	CleanupStack::PushL(south);

	south->AddClientL(clock->Id(), Messages::TClientType(EClock));

	clock->AddClientL(south->Id(), Messages::TClientType(ETrafficLight));

	south->AddClientL(controller->Id(), Messages::TClientType(EController));

	controller->AddClientL(south->Id(), Messages::TClientType(ETrafficLight, ESouth));

	CTrafficLight* east = new(ELeave)CTrafficLight(console, KEast());

	CleanupStack::PushL(east);

	east->AddClientL(clock->Id(), Messages::TClientType(EClock));

	clock->AddClientL(east->Id(), Messages::TClientType(ETrafficLight));

	east->AddClientL(controller->Id(), Messages::TClientType(EController));

	controller->AddClientL(east->Id(), Messages::TClientType(ETrafficLight, EEast));

	CTrafficLight* west = new(ELeave)CTrafficLight(console, KWest());

	CleanupStack::PushL(west);

	west->AddClientL(clock->Id(), Messages::TClientType(EClock));

	clock->AddClientL(west->Id(), Messages::TClientType(ETrafficLight));

	west->AddClientL(controller->Id(), Messages::TClientType(EController));

	controller->AddClientL(west->Id(), Messages::TClientType(ETrafficLight, EWest));

	Messages::RNodeInterface::OpenPostMessageClose(controller->Id(), controller->Id(), TGo().CRef());

	CActiveScheduler::Start();

	CleanupStack::PopAndDestroy(7, transport);

	Messages::TlsGlobals::UnInstallGlobals();

	}

LOCAL_C void DoStartL ()

	{

	CActiveScheduler* scheduler = new (ELeave) CActiveScheduler();

	CleanupStack::PushL (scheduler);

	CActiveScheduler::Install (scheduler);

	MainL ();

	CleanupStack::PopAndDestroy (scheduler);

	}

GLDEF_C TInt E32Main()

	{

	__UHEAP_MARK;

	CTrapCleanup* cleanup = CTrapCleanup::New();

	TRAPD(createError, console = Console::NewL(_L("Mesh Machine Junction Example"), TSize(KConsFullScreen,KConsFullScreen)));

	if (createError)

		{

		return createError;

		}

	TRAPD(mainError, DoStartL());

	if (mainError)

		{

		console->Printf(_L(" failed, leave code = %d"), mainError);

		}

	console->Printf(_L(" [press any key]\n"));

	console->Getch();

	delete console;

	delete cleanup;

	__UHEAP_MARKEND;

	return KErrNone;

	}