/*

* Copyright (c) 2004-2009 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:

*

*/

#ifndef __CSIPEXENGINE_H__

#define __CSIPEXENGINE_H__

// INCLUDES

#include    "SIPExGameConstants.h"

#include    "SIPExSocketEngineObserver.h"

#include    "SIPExSIPEngineObserver.h"

// Remove imports in unit test build

#ifdef CPPUNIT_TEST

#undef IMPORT_C

#define IMPORT_C

#endif

// DATA TYPES

// FORWARD DECLARATIONS

class MSIPExStateViewNotifier;

class TSIPExState;

class MSIPExGameObserver;

class CSIPExSIPEngine;

class CSIPExSocketEngine;

class TInetAddr;

// CLASS DECLARATIONS

/**

* The engine class for SIP Example application.

* the networking and SIP messaging.

*/

class CSIPExEngine 

:   public CBase, 

    public MSIPExSIPEngineObserver,

    public MSIPExSocketEngineObserver

    {

    public:

		/**

		* Create new instance of GameEngine.

		* @param aGameObserver Reference to observing class.

		* @returns Pointer to new CSIPExEngine instance.

		*/

        IMPORT_C static CSIPExEngine* NewL( MSIPExGameObserver& aGameObserver );

		/**

		* Create new instance of GameEngine.

        * The GameEngine pointer is left to the CleanupStack 

        * returned.

		* @param aGameObserver Reference to observing class.

		* @returns Pointer to new CSIPExEngine instance.

		*/

        IMPORT_C static CSIPExEngine* NewLC( MSIPExGameObserver& aGameObserver );

		/**

		* Destructor.

		*/

        IMPORT_C ~CSIPExEngine();

    public: // public data

		/**

		* Enumerations for the application role.

        * The inviting peer acts as a client and invited peer as a server.

		*/        

        enum TPeer 

            {

            EUnknown,

            EClient,

            EServer

            };

        /**

        * Game engine states for UI.

        */

        enum TEngineState

            {

            EIdle,

            EEnabled,

            EActivating,

            EActive

            };

    public: // New functions

        /**

        * The instant message is send to the remote user.

		* Redirects the call to the active State object.

        * @param aAddress The address of the recipient.

        * @param aMsg The message.

		*/

        IMPORT_C void SendInstantMsgL( const TDesC& aAddress, const TDesC& aMsg );

        /**

		* Player invites the remote peer to the game.

        * Redirectes the call to the active State object.

        * @param aAddress The address of the invited peer.

		*/

        IMPORT_C void InviteL( const TDesC& aAddress );

        /**

		* The SIP profile is enabled.

        * Redirectes the call to the active State object.

		*/

        IMPORT_C void EnableProfileL();

        /**

		* The SIP profile is disabled.

        * Redirectes the call to the active State object.

		*/

        IMPORT_C void DisableProfileL();

        /**

		* The user ends the game.

        * Redirectes the call to the active State object.

		*/

        IMPORT_C void EndGameL();

        /**

        * Resolves whether we should draw cursor or not.

        * @return Returns ETrue if the game is in state where we 

        * should draw cursor (if it is our turn). Otherwise

        * EFalse is returned.

        */

        IMPORT_C TBool DrawCursor();

        /**

        * Resolves whether we should draw board or not.

        * @return Returns ETrue if the game is in state where we 

        * should draw board (if profile is enabled). Otherwise

        * EFalse is returned.

        */

        IMPORT_C TBool DrawBoard();

        /**

        * Updates the game state. User has pressed left key.

        */

        IMPORT_C void CursorLeft();

        /**

        * Updates the game state. User has pressed right key.

        */

        IMPORT_C void CursorRight();

        /**

        * Updates the game state. User has pressed enter key.

        */

        IMPORT_C void CursorPressed();

        /**

        * Updatas the game state. User moves the cursor with pointer.

        * @param aNewCursorPosition A new cursor column position.

        */

        IMPORT_C void MoveCursorL( const TInt aNewCursorPosition );

        /**

        * Returns value in specified place in the board.

        * @param aX The place's x coordinate.

        * @param aY The place's y coordinate.

        * @return The value in specified place.

        */

        IMPORT_C TInt BoardValue( TInt aX, TInt aY );

        /**

        * Returns the cursor position.

        * @return The cursor's position

        */

        IMPORT_C TInt Cursor();

        /**

        * Sets the iNotifier.

        * @param aNotifier Reference to the view notifier.

        */

        IMPORT_C void SetViewNotifier( MSIPExStateViewNotifier& aNotifier );

    public: // From socket observer

        /**

		* Callback from socket observer.

        * Called when the state changes in the socket engine.

        * @param aNewState A new state of the socket engine.

        */

        void SocketState( TInt aNewState );

        /**

		* Callback from socket observer.

        * Called when the data is received from the socket.

        * @param aData The data received from the socket.

        */

        void SocketData( TDesC8& aData );

    private: // From SIP observer. See SIPExObserver.h

        void InviteReceived( const TDesC8& aFrom, const TUint32 aIapId );

        void InviteReceivedByRemote( const TInt aResponse );

        void InviteDeclinedByRemote( const TInt aResponse );

        void InviteAcceptedByRemote( const TInetAddr& aIPAddress, const TUint32 aIapId );

        void InviteAcceptedByUs();

        void InvitationCancelled();

        void EngineError( TInt aError );

        void CancelFailed();

        void SessionEnded();

        void ConnectionLost();

        void ProfileEnabled( TUint32 aSIPProfileId );

        void ProfileError( TInt aError );

        void IMReceived( const TDesC8& aFrom,

						 const TDesC8& aMessage );

        void WriteLog( const TDesC8& aLog );

    private: // New functions

        /**

        * Initilizes the game state.

        */

        void ResetGame();

        /**

        * Destroys the iSocketEngine.

        */

        void DestroySocketEngine();

        /**

        * Changes the active state.

        * @param aNewState A reference the to new active state.

        */

        void ChangeState( TSIPExState& aNewState );

        /**

        * Send the move to the remote peer.

        * @param aX The x coordinate of the move.

        * @param aY The y coordinate of the move.

        */

        void SendMessage( const TInt aX, const TInt aY );

        /**

        * Shows the text in the status info area. The call is

        * redirected to the view notifier.

        * @param aTxt The text shown in the status info area.

        */

        void StatusInfoL( const TDesC& aTxt );

        /**

        * Shows the text in the info area. The call is redirected 

        * to the view notifier.

        * @param aTxt The text shown in the info area.

        */

        void InfoL( const TDesC& aInfoTxt );

        /**

        * Calculates the next free place in cursor's column.

        * @return The next free position on the board.

        */

        TInt CalculatePos();

        /**

        * Checks if the move is win move.

        * @param aX The x coordinate of the move.

        * @param aY The y coordinate of the move.

        * @return 1 if you won, 

        *         2 if the remote player has won,

        *         -1 if not win move.

        */

        TInt IsWin( const TInt aX, const TInt aY );

        /**

        * Returns the count of moves in this game.

        * @return The count of moves.

        */

        TInt Moves();

        /**

        * Sets the specified value in to the specified place in

        * the board.

        * @param aX The x coordinate value.

        * @param aY The y coordinate value.

        * @param aValue The value to be set to the (x, y) position.

        */

        void SetBoard( const TInt aX, const TInt aY, const TInt aValue );

        /**

        * Increases the moves value by specified amount.

        * @param aAmount The amount of the increased moves.

        */

        void IncreaseMovesBy( const TInt aAmount );

        /**

        * Set cursor the specified position.

        * @param aNewValue The new position value for the cursor.

        */

        void SetCursor( const TInt aNewValue );

        /**

        * Returns the peer value.

        * @return The iPeer value.

        */

        TPeer Peer();

        /**

        * Sets the iPeer's value

        * @param aPeer A new value for the iPeer.

        */

        void SetPeer( TPeer aPeer );

        /**

        * Sets remote peer's move to the board.

        * @param aX The x coordinate value.

        * @param aY The y coordinate value.

        */

        void SetRemote( const TInt aX, const TInt aY );

        /**

		* The acceptance is asked from the user

        * Redirectes the call to the game observer.

        * @param aFrom The summoner's address

        * @return Whether we accept the invitation or not.

		*/

        TBool AcceptInvitationL( const TDesC8& aFrom );

        /**

        * Returns the SIP Engine pointer.

        * @return The pointer to the CSIPExSIPEngine. The ownership

        *         is NOT transferred.

        */

        CSIPExSIPEngine*    SIPEngine();

        /**

        * Returns the socket engine. If the socket engine (iSocketEngine) is 

        * NULL it will be created.

        * @return The pointer to the CSIPExSocketEngine. The ownership

        *         is NOT transferred.

        */        

        CSIPExSocketEngine* SocketEngineL();

        /**

        * Returns the game observer reference.

        * @return The reference to the MSIPExGameObserver.

        */        

        MSIPExGameObserver& GameObserver();

    private:

        /**

        * Constructor

        * @param aGameObserver The observer reference.

        */        

        CSIPExEngine( MSIPExGameObserver& aGameObserver );

        /**

        * 2nd phase constructor

        */        

        void ConstructL();

    private: // Member variables

        // Owned: States

        TSIPExState*    iStateIdle;

        TSIPExState*    iStateRegistering;

        TSIPExState*    iStateRegistered;

        TSIPExState*    iStateInviting;

        TSIPExState*    iStateConnecting;

        TSIPExState*    iStateLocal;

        TSIPExState*    iStateRemote;

        TSIPExState*    iStateAcceptingSIP;

        // Not owned: ui notifier

        MSIPExStateViewNotifier*     iNotifier;

        // Owned: The networking engine

        CSIPExSocketEngine*     iSocketEngine;

        // Owned: The SIP signaling engine.

        CSIPExSIPEngine*        iSIPEngine;

        // Observer for game events

        MSIPExGameObserver&     iGameObserver;

        // Game data

        TInt iMoves;

	    TInt iBoard[ KBoxCountX ][ KBoxCountY ];

	    TInt iCursor;

        TPeer iPeer;

        // Not owned: Reference to active state

        TSIPExState*    iActiveState;

       // State classes are friend classes because they need access 

        // to the engine.

        friend class TSIPExState;

        friend class TSIPExStateAcceptingSIP;

        friend class TSIPExStateConnecting;

        friend class TSIPExStateIdle;

        friend class TSIPExStateInviting;

        friend class TSIPExStateLocal;

        friend class TSIPExStateRegistered;

        friend class TSIPExStateRegistering;

        friend class TSIPExStateRemote;

        // In unit tests following friend class definitions are needed

        #ifdef CPPUNIT_TEST

        friend class CGameEngineTest;

        friend class CBaseStateTest;

        friend class CStateAcceptingSIPTest;

        #endif

    };

#endif // __CSIPEXENGINE_H__