// 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:
//



#include    "SIPExState.h"
#include    "SIPExGameEngine.h"
#include    "SIPExSIPEngine.h"
#include    "SIPExGameObserver.h"

// -----------------------------------------------------------------------------
// TSIPExState::ChangeState
// Changes the active state through the context.
// -----------------------------------------------------------------------------
//
void TSIPExState::ChangeState( CSIPExEngine* aContext, TSIPExState* aNewState )
    {
    aContext->ChangeState( *aNewState );
    }

// -----------------------------------------------------------------------------
// TSIPExState::Info
// Traps the leaving functions. Ignores if leaves.
// -----------------------------------------------------------------------------
//
void TSIPExState::Info( CSIPExEngine* aContext, const TDesC& aText )
    {
    TRAPD( ignore, aContext->InfoL( aText ) );
    }

// -----------------------------------------------------------------------------
// TSIPExState::StatusInfo
// Traps the leaving functions. Ignores if leaves.
// -----------------------------------------------------------------------------
//
void TSIPExState::StatusInfo( CSIPExEngine* aContext, const TDesC& aText )
    {
    TRAPD( ignore, aContext->StatusInfoL( aText ) );
    }

// -----------------------------------------------------------------------------
// TSIPExState::CombineAndShowInfoL
// Combine desc and number value. E.g. aText="Hello", aNum=2, result="Hello 2".
// -----------------------------------------------------------------------------
//
void TSIPExState::CombineAndShowInfoL( 
    CSIPExEngine* aContext, 
    const TDesC& aText, 
    TInt aNum )
    {
    HBufC* buf = HBufC::NewLC( 64 );
    buf->Des().Append( aText );
    buf->Des().AppendNum( aNum );
    Info( aContext, *buf );
    CleanupStack::PopAndDestroy( buf );
    }

// -----------------------------------------------------------------------------
// TSIPExState::InviteReceived
// Default implementation for virtual function.
// -----------------------------------------------------------------------------
//
void TSIPExState::InviteReceived( CSIPExEngine* /*aContext*/, 
                const TDesC8& /*aFrom*/, const TUint32 /*aIapId*/ ) 
    { 
    }

// -----------------------------------------------------------------------------
// TSIPExState::InviteAcceptedByRemote
// Default implementation for virtual function.
// -----------------------------------------------------------------------------
//
void TSIPExState::InviteAcceptedByRemote( 
    CSIPExEngine* /*aContext*/, 
    const TInetAddr& /*aIPAddress*/, 
    const TUint32 /*aIapId*/ ) 
    { 
    }

// -----------------------------------------------------------------------------
// TSIPExState::InviteDeclinedByRemote
// Default implementation for virtual function.
// -----------------------------------------------------------------------------
//
void TSIPExState::InviteDeclinedByRemote( 
    CSIPExEngine* /*aContext*/, 
    const TInt /*aResponse*/ ) 
    { 
    }

// -----------------------------------------------------------------------------
// TSIPExState::InvitationCancelled
// Default implementation for virtual function.
// -----------------------------------------------------------------------------
//
void TSIPExState::InvitationCancelled( CSIPExEngine* /*aContext*/) 
    { 
    }

// -----------------------------------------------------------------------------
// TSIPExState::CancelFailed
// Default implementation for virtual function.
// -----------------------------------------------------------------------------
//
void TSIPExState::CancelFailed( CSIPExEngine* /*aContext*/ ) 
    { 
    }

// -----------------------------------------------------------------------------
// TSIPExState::ProfileEnabled
// Default implementation for virtual function.
// -----------------------------------------------------------------------------
//
void TSIPExState::ProfileEnabled( 
    CSIPExEngine* /*aContext*/, 
    TUint32 /*aSIPProfileId*/ ) 
    { 
    }

// -----------------------------------------------------------------------------
// TSIPExState::SocketState
// Default implementation for virtual function.
// -----------------------------------------------------------------------------
//
void TSIPExState::SocketState( CSIPExEngine* /*aContext*/, TInt /*aNewState*/ ) 
    { 
    }

// -----------------------------------------------------------------------------
// TSIPExState::SocketData
// Default implementation for virtual function.
// -----------------------------------------------------------------------------
//
void TSIPExState::SocketData( CSIPExEngine* /*aContext*/, TDesC8& /*aData*/ ) 
    { 
    }

// -----------------------------------------------------------------------------
// TSIPExState::EnableProfileL
// Default implementation for virtual function.
// -----------------------------------------------------------------------------
//
void TSIPExState::EnableProfileL( CSIPExEngine* /*aContext*/ ) 
    { 
    }

// -----------------------------------------------------------------------------
// TSIPExState::DisableProfileL
// Default implementation for virtual function.
// -----------------------------------------------------------------------------
//
void TSIPExState::DisableProfileL( CSIPExEngine* /*aContext*/ ) 
    { 
    }

// -----------------------------------------------------------------------------
// TSIPExState::CursorPressed
// Default implementation for virtual function.
// -----------------------------------------------------------------------------
//
void TSIPExState::CursorPressed( CSIPExEngine* /*aContext*/ ) 
    { 
    }

// -----------------------------------------------------------------------------
// TSIPExState::CursorRight
// Default implementation for virtual function.
// -----------------------------------------------------------------------------
//
void TSIPExState::CursorRight( CSIPExEngine* /*aContext*/ ) 
    { 
    }

// -----------------------------------------------------------------------------
// TSIPExState::CursorLeft
// Default implementation for virtual function.
// -----------------------------------------------------------------------------
//
void TSIPExState::CursorLeft(  CSIPExEngine* /*aContext*/ ) 
    { 
    }

// -----------------------------------------------------------------------------
// TSIPExState::MoveCursorL
// Default implementation for virtual function.
// -----------------------------------------------------------------------------
//
void TSIPExState::MoveCursorL( 
    CSIPExEngine* /*aContext*/, 
    const TInt /*aNewPosition*/ ) 
    { 
    }

// -----------------------------------------------------------------------------
// TSIPExState::SendInstantMsgL
// Default implementation for virtual function.
// -----------------------------------------------------------------------------
//
void TSIPExState::SendInstantMsgL( 
    CSIPExEngine* /*aContext*/, 
    const TDesC& /*aAddress*/, 
    const TDesC& /*aMsg*/ ) 
    { 
    }

// -----------------------------------------------------------------------------
// TSIPExState::EndGameL
// Default implementation for virtual function.
// -----------------------------------------------------------------------------
//
void TSIPExState::EndGameL( CSIPExEngine* /*aContext*/ ) 
    { 
    }

// -----------------------------------------------------------------------------
// TSIPExState::InviteL
// Default implementation for virtual function.
// -----------------------------------------------------------------------------
//
void TSIPExState::InviteL( CSIPExEngine* /*aContext*/, const TDesC& /*aAddress*/ )
    {
    }

// -----------------------------------------------------------------------------
// TSIPExState::DrawCursor
// Returns always EFalse.
// -----------------------------------------------------------------------------
//
TBool TSIPExState::DrawCursor()
    {
    return EFalse;
    }

// -----------------------------------------------------------------------------
// TSIPExState::DrawBoard
// Returns always ETrue.
// -----------------------------------------------------------------------------
//
TBool TSIPExState::DrawBoard() 
    { 
    return ETrue; 
    }

// -----------------------------------------------------------------------------
// TSIPExState::CalculatePos
// Calculates the position next free position in the cursor's column.
// -----------------------------------------------------------------------------
//
TInt TSIPExState::CalculatePos( CSIPExEngine* aContext )
    {
    TInt y( KErrNotFound );

	for ( TInt i = KBoxCountX - 1; i >= 0; i-- ) 
        {
		if ( aContext->BoardValue( aContext->Cursor(), i ) == -1 ) 
            {
			y = i;
			return y;
		    }
	    }

	return y;
    }

// -----------------------------------------------------------------------------
// TSIPExState::IsWin
// Checks that if the specified move is the win move.
// -----------------------------------------------------------------------------
//
TInt TSIPExState::IsWin( CSIPExEngine* aContext, const TInt aX, const TInt aY )
    {
	TInt ret = -1;

	TInt player = aContext->BoardValue( aX, aY );
	TInt line1 = 1;
	TInt line2 = 1;
	TInt line3 = 1;
	TInt line4 = 1;

	TInt i = 0;
	TInt j = 0;

	for (i = aX + 1; i < 8; i ++) 
        {
		if ( aContext->BoardValue( i, aY ) == player )
			line1 ++;
		else
			break;
	    }

	for (i = aX - 1; i >= 0; i --) 
        {
		if ( aContext->BoardValue( i, aY ) == player )
			line1 ++;
		else
			break;
	    }

	if (line1 >= 4)
		return player;

	for (i = aY + 1; i < 8; i ++) 
        {
		if ( aContext->BoardValue( aX, i ) == player )
			line2 ++;
		else
			break;
	    }

	for (i = aY - 1; i >= 0; i --)
        {
		if ( aContext->BoardValue( aX, i ) == player )
			line2 ++;
		else
			break;
	    }

	if (line2 >= 4)
		return player;


	j = aY;
	for (i = aX + 1; i < 8; i ++) 
        {
		j = j + 1;
		if (j > 7)
			break;

		if ( aContext->BoardValue( i, j ) == player )
			line3 ++;
		else
			break;
	    }

	j = aY;
	for (i = aX - 1; i >= 0; i --) 
        {
		j = j - 1;
		if (j < 0)
			break;

		if ( aContext->BoardValue( i, j ) == player )
			line3 ++;
		else
			break;
	    }

	if (line3 >= 4)
		return player;

	j = aY;
	for (i = aX + 1; i < 8; i ++) 
        {
		j = j - 1;
		if (j < 0)
			break;

		if ( aContext->BoardValue( i, j ) == player )
			line4 ++;
		else
			break;
	    }

	j = aY;
	for (i = aX - 1; i >= 0; i --) 
        {
		j = j + 1;
		if (j > 7)
			break;

		if ( aContext->BoardValue( i, j ) == player )
			line4 ++;
		else
			break;
	    }

	if (line4 >= 4)
		return player;

	return ret;
    }

// -----------------------------------------------------------------------------
// TSIPExState::SessionEnded
// The remote peer has ended the session. 
// The state is changed to Idle and UI is notified.
// -----------------------------------------------------------------------------
//
void TSIPExState::SessionEnded( CSIPExEngine* aContext )
    {
    ChangeState( aContext, aContext->iStateRegistered );
    Info( aContext, KSessionEnded() );
    StatusInfo( aContext, KGameOver() );
    TRAPD( ignore, aContext->SocketEngineL()->Stop() );
    aContext->DestroySocketEngine();
    }

// -----------------------------------------------------------------------------
// TSIPExState::ConnectionLost
// The connection has lost. 
// The state is changed to Idle and UI is notified.
// -----------------------------------------------------------------------------
//
void TSIPExState::ConnectionLost( CSIPExEngine* aContext )
    {
    ChangeState( aContext, aContext->iStateIdle );
    Info( aContext, KConnectionLost() );
    StatusInfo( aContext, KGameOver() );
    }

// -----------------------------------------------------------------------------
// TSIPExState::ProfileError
// The error in profile operation
// The state is changed to Idle and UI is notified.
// -----------------------------------------------------------------------------
//
void TSIPExState::ProfileError( CSIPExEngine* aContext, TInt aError )
    {
    ChangeState( aContext, aContext->iStateIdle );
    TRAPD( ignore, CombineAndShowInfoL( aContext, KProfileError(), aError ) );
    StatusInfo( aContext, KGameOver() );
    }

// -----------------------------------------------------------------------------
// TSIPExState::IMReceived
// The error in profile operation
// The state is changed to Idle and UI is notified.
// -----------------------------------------------------------------------------
//
void TSIPExState::IMReceived( 
    CSIPExEngine* aContext, 
    const TDesC8& aFrom, 
    const TDesC8& aMessage )
    {
    TRAPD( ignore, aContext->GameObserver().IMReceivedL( aFrom, aMessage ) );
    }

// -----------------------------------------------------------------------------
// TSIPExState::EngineError
// The error in SIP Engine
// The state is changed to Idle and UI is notified.
// -----------------------------------------------------------------------------
//
void TSIPExState::EngineError( CSIPExEngine* aContext, TInt aError )
    {
    ChangeState( aContext, aContext->iStateIdle );
    TRAPD( ignore, CombineAndShowInfoL( aContext, KErrorInSIPEngine(), aError ) );
    StatusInfo( aContext, KGameOver() );
    }

// -----------------------------------------------------------------------------
// TSIPExState::InviteReceivedByRemote
// Callback from SIP engine observer.
// The UI is notified.
// -----------------------------------------------------------------------------
//
void TSIPExState::InviteReceivedByRemote( CSIPExEngine* aContext, 
                                          const TInt aResponse )
    {
    TRAPD( ignore, CombineAndShowInfoL( aContext, KProvResponse(), aResponse ) );
    }

// -----------------------------------------------------------------------------
// TSIPExState::InviteAcceptedByUs
// Callback from SIP engine observer.
// The UI is notified.
// -----------------------------------------------------------------------------
//
void TSIPExState::InviteAcceptedByUs( CSIPExEngine* aContext ) 
    { 
    Info( aContext, KAckReceived() ); 
    }

// End of file