// appui.cpp
//
// Copyright (c) 2003 Symbian Ltd.  All rights reserved.
//

#include "appui.h"
#include "controller.h"
#include "view.h"
#include "battleships-uids.h"
#include "battleships.hrh"
#include "gsdp.h"

#include <eikenv.h>
#include <eikbutb.h>
#include <eiktbar.h>
#include <eikdialg.h>
#include <eikedwin.h>
#include <eikfnlab.h>
#include <eikchlst.h>

/*
	CGameInitiateDialog
*/

class CGameInitiateDialog : public CEikDialog
	{
public:
	CGameInitiateDialog(CGameController* aController);
private:
	// from CEikDialog
	void PreLayoutDynInitL(); // settings on dialog launch
	TBool OkToExitL(TInt aKeycode); // action when OK pressed
	void HandleControlStateChangeL(TInt aControlId); // listen to changing selections
	// show only necessary controls
	void ShowRelevantControls(); // called when needed
	TBool ProtocolRequiresAddress(TUid aProtocol); // called when needed
private:
	CGameController* iController;
	
	};

CGameInitiateDialog::CGameInitiateDialog(CGameController* aController)
	: iController(aController)
	{
	}

void CGameInitiateDialog::PreLayoutDynInitL()
	{
	//CEikEdwin* edwin;
	// protocol
	CEikChoiceList* choicelist = static_cast<CEikChoiceList*>(Control(EGameControlIdProtocol));
	
	TUid protocol = iController->GetGdpProtocol();
	if(protocol == KGdpLoopbackUid){
		iEikonEnv->InfoMsg(_L("Setting loopback"));
		choicelist->SetCurrentItem(0);}
	if(protocol == KGdpSmsUid){
		iEikonEnv->InfoMsg(_L("Setting SMS"));
		choicelist->SetCurrentItem(1);}
	if(protocol == KGdpBluetoothUid){
		iEikonEnv->InfoMsg(_L("Setting BT"));
		choicelist->SetCurrentItem(2);}
	

	// show relevant controls
	ShowRelevantControls();
	}

TBool CGameInitiateDialog::OkToExitL(TInt /* aKeycode */)
	{
	CEikChoiceList* choicelist1 = static_cast<CEikChoiceList*>(Control(EGameControlIdProtocol));
	CEikChoiceList* choicelist2 = static_cast<CEikChoiceList*>(Control(EGameControlIdStartMode));
	CEikChoiceList* choicelist3 = static_cast<CEikChoiceList*>(Control(EGameControlIdFirstMovePref));
	// get start mode
	TInt listen=choicelist2->CurrentItem();//ChoiceListCurrentItem(EGameControlIdStartMode); // 1=listen, 0=initiate
	// get protocol
	TInt protocol=choicelist1->CurrentItem();
	// other address
	CEikEdwin* edwin=static_cast<CEikEdwin*>(Control(EGameControlIdOtherAddress));
	HBufC* address=edwin->GetTextInHBufL();
	if (!address)
		address=_L("").AllocL();
	CleanupStack::PushL(address);
	// get first-move preferences
	CGameController::TFirstMovePref firstMovePref=(CGameController::TFirstMovePref)choicelist3->CurrentItem();
	//	(CGameController::TFirstMovePref) ChoiceListCurrentItem(EGameControlIdFirstMovePref);
	// set GDP protocol and first move preferences
	if(protocol == 0){iController->SetGdpProtocolL(KGdpLoopbackUid);}
	if(protocol == 1){iController->SetGdpProtocolL(KGdpBluetoothUid);}
	if(protocol == 2){iController->SetGdpProtocolL(KGdpSmsUid);}
	
	iController->SetFirstMovePref(firstMovePref);
	// initiate or listen
	if (listen)
		{
		iController->Listen();
		iEikonEnv->InfoMsg(R_GAME_LISTENING);
		}
	else
		{
		iController->InitiateL(*address);
		iEikonEnv->InfoMsg(R_GAME_INITIATING);
		}
	// return
	CleanupStack::PopAndDestroy(); // address
	return ETrue;
	}

void CGameInitiateDialog::HandleControlStateChangeL(TInt aControlId)
	{
	if (aControlId==EGameControlIdProtocol ||
		aControlId==EGameControlIdStartMode){
		ShowRelevantControls();}
	}

/// Does this protocol require an address for the 'other end'?
TBool CGameInitiateDialog::ProtocolRequiresAddress(TUid aProtocol)
	{
	if(aProtocol==KGdpSmsUid ||
		aProtocol==KGdpBluetoothUid){
		return ETrue;}
	return EFalse;
	}

void CGameInitiateDialog::ShowRelevantControls()
	{
	// get start mode
	CEikChoiceList* choicelist1 = static_cast<CEikChoiceList*>(Control(EGameControlIdProtocol));
	CEikChoiceList* choicelist2 = static_cast<CEikChoiceList*>(Control(EGameControlIdStartMode));
	
	TInt listen=choicelist2->CurrentItem(); // 1=listen, 0=initiate
	// get protocol
	TInt zprotocol= choicelist1->CurrentItem();

	TUid protocolID = KGdpLoopbackUid;
	
	if(zprotocol == 1){protocolID = KGdpSmsUid;}
	if(zprotocol == 2){protocolID = KGdpBluetoothUid;}

	// show other address if mode=initiate, and protocol is networked
	TBool otherAddressNeeded = !listen && ProtocolRequiresAddress(protocolID);		

	CEikEdwin* edwin=static_cast<CEikEdwin*>(Control(EGameControlIdOtherAddress));
	
	if (otherAddressNeeded){
		edwin->SetReadOnly(EFalse);
		edwin->SetDimmed(EFalse);
		edwin->DrawNow();}
	else{
		edwin->SetReadOnly(ETrue);
		edwin->SetDimmed(ETrue);
		edwin->DrawNow();}
	}

/*
	CGameRestartDialog
*/

class CGameRestartDialog : public CEikDialog
	{
public:
	CGameRestartDialog(CGameController* aController);
private:
	// from CEikDialog
	void PreLayoutDynInitL(); // settings on dialog launch
	TBool OkToExitL(TInt aKeycode); // action when OK pressed
private:
	CGameController* iController;
	};

CGameRestartDialog::CGameRestartDialog(CGameController* aController)
	: iController(aController)
	{
	}

void CGameRestartDialog::PreLayoutDynInitL()
	{
	// first-move preferences
	}

TBool CGameRestartDialog::OkToExitL(TInt /* aKeycode */)
	{
	// get first-move preferences
	//CGameController::TFirstMovePref firstMovePref=
	//	(CGameController::TFirstMovePref) ChoiceListCurrentItem(EGameControlIdFirstMovePref);
	CEikChoiceList* choicelist = static_cast<CEikChoiceList*>(Control(EGameControlIdFirstMovePref));
	CGameController::TFirstMovePref firstMovePref=(CGameController::TFirstMovePref)choicelist->CurrentItem();
	// set first move preferences, which will restart if needed
	iController->SetFirstMovePref(firstMovePref);
	// message and return
	iEikonEnv->InfoMsg(R_GAME_RESTARTING);
	return ETrue;
	}
/*
	CGameSettingsDialog
*/

class CGameSettingsDialog : public CEikDialog
	{
public:
	CGameSettingsDialog(CGameController* aController);
private:
	// from CEikDialog
	void PreLayoutDynInitL(); // settings on dialog launch
private:
	CGameController* iController;
	};

CGameSettingsDialog::CGameSettingsDialog(CGameController* aController)
	: iController(aController)
	{
	}

void CGameSettingsDialog::PreLayoutDynInitL()
	{
	//CEikEdwin* edwin;
	// protocol
	CEikChoiceList* choicelist1 = static_cast<CEikChoiceList*>(Control(EGameControlIdState));
	CEikChoiceList* choicelist2 = static_cast<CEikChoiceList*>(Control(EGameControlIdProtocol));

	choicelist1->SetCurrentItem(iController->GetStateID());

	TUid protocol = iController->GetGdpProtocol();
	if(protocol == KGdpLoopbackUid)
			choicelist2->SetCurrentItem(0);
	if(protocol == KGdpBluetoothUid)
			choicelist2->SetCurrentItem(1);
	if(protocol == KGdpSmsUid)
			choicelist2->SetCurrentItem(2);
	
	// other address
	TBuf8<KMaxGsdpAddress> address8;
	iController->Gsdp().GetOtherAddress(address8);

	TBuf<KMaxGsdpAddress> address16;
	address16.Copy(address8);

	CEikEdwin* edwin;
	edwin=static_cast<CEikEdwin*>(Control(EGameControlIdOtherAddress));
    edwin->SetTextL(&address16);
	edwin->SetReadOnly(ETrue);
	edwin->SetDimmed(ETrue);
	edwin->DrawNow();
	}

/*
	CGameAppUi
*/

void CGameAppUi::ConstructL()
    {
    BaseConstructL();
	// construct app view
	iController=(static_cast<CGameDocument*>(Document())->iController);
	// sound effects
	iSoundEffects=new(ELeave) CSoundEffects;
	iSoundEffects->ConstructL();

	// view data object
	iFleetViewData = new (ELeave) CFleetViewData(*iSoundEffects,
		*iController, ClientRect());
	iFleetViewData->ConstructL();

	// construct opposition fleet view
    iOppFleetView=COppFleetView::NewL(*iFleetViewData,
    	iController->Engine().iOppFleet);//, ETrue);
	// construct P1 own fleet view
    iMyFleetView=CMyFleetView::NewL(*iFleetViewData,
    	iController->Engine().iMyFleet);//, ETrue);
	iActiveView = iOppFleetView;
	SetDefaultViewL(*iOppFleetView);
//	AddToStackL(iActiveView);
    }

CGameAppUi::~CGameAppUi()
	{
	delete iOppFleetView;
	delete iMyFleetView;

//	RemoveFromStack(iHiderView);

	delete iFleetViewData;	
	delete iSoundEffects;
	}

void CGameAppUi::HandleCommandL(TInt aCommand)
	{
	switch (aCommand)
		{
	case EEikCmdExit:
		SaveL();
		Exit();
		break;
	case EGameCmdMyFleet:
			ActivateViewL(TVwsViewId(KUidBattleShips,KP1MyViewUID));
		break;	
	case EGameCmdOppFleet:
			ActivateViewL(TVwsViewId(KUidBattleShips,KP1OppViewUID));
		break;
	case EGameCmdStart:
		CmdStartL();
		break;
	case EGameCmdResend:
		CmdResend();
		break;
	case EGameCmdAbandon:
		CmdAbandonL();
		break;
	case EEikCmdZoomIn:
		CmdZoomInL();
		break;
	case EEikCmdZoomOut:
		CmdZoomOutL();
		break;
	case EGameCmdTerminate:
		CmdTerminateL();
		break;
	case EGameCmdDisplaySettings:
		CmdDisplaySettingsL();
		break;
		}
	}
	
void CGameAppUi::DynInitMenuPaneL(TInt aResourceId, CEikMenuPane* aMenuPane)
	{
	//return;
	if (aResourceId != R_GAME_VIEW_MENU) return;
	// toggle menu item dimming on view displayed
	TBool view = (iActiveView == iMyFleetView); 
	aMenuPane->SetItemDimmed(EGameCmdMyFleet,view);
	view = (iActiveView == iOppFleetView); 
	aMenuPane->SetItemDimmed(EGameCmdOppFleet,view);
		

	if (iActiveView == NULL)
		{
		aMenuPane->SetItemDimmed(EEikCmdZoomOut,ETrue);
		aMenuPane->SetItemDimmed(EEikCmdZoomIn,ETrue);
		}
	}


void CGameAppUi::CmdAbandonL()
	{
	// user-friendly check
	if (!iController->IsMyTurn())
		iEikonEnv->LeaveWithInfoMsg(R_GAME_NOT_YOUR_TURN);
	// confirm with the user
	if (!iEikonEnv->QueryWinL(R_GAME_QUERY_ABANDON)){
		return;}
	// do it
	iController->Abandon();
	}

void CGameAppUi::CmdStartL()
	{
	if (iController->IsBlank())
		{
		CEikDialog* dialog=new(ELeave) CGameInitiateDialog(iController);
		dialog->ExecuteLD(R_GAME_INITIATE_DIALOG);
		}
	else if (iController->IsFinished() || iController->IsRestarting())
		{
		CEikDialog* dialog=new(ELeave) CGameRestartDialog(iController);
		dialog->ExecuteLD(R_GAME_RESTART_DIALOG);
		}
	else
		iEikonEnv->InfoMsg(R_GAME_ALREADY_STARTED);

	}

void CGameAppUi::CmdResend()
	{
	// user-friendly check
	if (!iController->Rgcp()->IsInitiating() && !iController->Rgcp()->IsWaiting())
		{
		iEikonEnv->LeaveWithInfoMsg(R_GAME_NOTHING_TO_RESEND);
		}
	iController->Resend();
	}

void CGameAppUi::CmdTerminateL()
	{
	if (iController->IsBlank())
		return;
	if (!iEikonEnv->QueryWinL(R_GAME_QUERY_TERMINATE))
		return;
	iController->Reset();
	}

void CGameAppUi::CmdDisplaySettingsL()
	{
	CEikDialog* dialog=new(ELeave) CGameSettingsDialog(iController);
	dialog->ExecuteLD(R_GAME_SETTINGS_DIALOG);
	}

void CGameAppUi::CmdZoomInL()
	{
	iController->ZoomInL();
	}

void CGameAppUi::CmdZoomOutL()
	{
	iController->ZoomOutL();
	}
	


void CGameAppUi::HandleModelChangeL()
	{
	// change pointers to new objects
	iController=(static_cast<CGameDocument*>(Document())->iController);
	iController->SetAppView(iActiveView);
	}
	
/*
	CGameDocument
*/

CGameDocument::CGameDocument(CEikApplication& aApp)
		: CEikDocument(aApp)
	{
	}

void CGameDocument::ConstructL()
	{
	iController=CGameController::NewL();
	}

CGameDocument::~CGameDocument()
	{
	delete iController;
	}

CEikAppUi* CGameDocument::CreateAppUiL()
	{
    return new(ELeave) CGameAppUi;
	}

void CGameDocument::NewDocumentL()
	{
	iController->Reset();
	}

void CGameDocument::RestoreL(const CStreamStore& aStore,const CStreamDictionary& aStreamDict)
	{
	//return;
	// new controller initialized from store
	TStreamId id=aStreamDict.At(KUidBattleShips);
	//CGameController* controller=CGameController::NewL(aStore, id);

	iController->RestoreL(aStore, id);
	//delete iController;
	//iController=controller;
	}

void CGameDocument::StoreL(CStreamStore& aStore,CStreamDictionary& aStreamDict) const
	{
	//return;
	TStreamId id=iController->StoreL(aStore);
	aStreamDict.AssignL(KUidBattleShips,id);
	}

/*
	CGameApplication
*/

TUid CGameApplication::AppDllUid() const
	{
	return KUidBattleShips;
	}

CApaDocument* CGameApplication::CreateDocumentL()
	{
	CGameDocument* doc=new(ELeave) CGameDocument(*this);
	CleanupStack::PushL(doc);
	doc->ConstructL();
	CleanupStack::Pop();
	return doc;
	}

// DLL interface stuff

EXPORT_C CApaApplication* NewApplication()
	{
	return new CGameApplication;
	}

GLDEF_C TInt E32Dll(TDllReason)
	{
	return KErrNone;
	}