/*

* Copyright (c) 2002-2005 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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 FILES

#include "BavpNPObject.h"

#include "BavpLogger.h"

#include <badesca.h>

#include <stdlib.h>

#include <string.h>

#include <npscript.h>

#include  "BavpPlugin.h"

#include  "BavpController.h"

#include  "BavpControllerVideo.h"

#include  "BavpControllerAudio.h"

const int NUM_METHOD_IDENTIFIERS = 5;

const int ID_PLAY = 0;

const int ID_STOP = 1;

const int ID_PAUSE = 2;

const int ID_FASTFORWARD = 3;

const int ID_REWIND = 4;

static NPIdentifier bavpMethodIdentifiers[NUM_METHOD_IDENTIFIERS];

static const NPUTF8 *bavpIdentifierNames[NUM_METHOD_IDENTIFIERS] = {

    "play",

    "stop",

    "pause",

    "fastforward",

    "rewind",

};

const int NUM_PROPERTY_IDENTIFIERS = 10;

const int ID_VOLUME = 0;

const int ID_POSITION = 1;

const int ID_DURATION = 2;

const int ID_STATE_CHANGED_CALLBACK = 3;

const int ID_STATE = 4;

const int ID_ISVIDEOCLIP = 5;

const int ID_ISSEEKABLE = 6;

const int ID_CLIPNAME = 7;

const int ID_FULLSCREENMODE = 8;

const int ID_MIMETYPE = 9;

static NPIdentifier bavpPropertyIdentifiers[NUM_PROPERTY_IDENTIFIERS];

static const NPUTF8 *bavpPropertyIdentifierNames[NUM_PROPERTY_IDENTIFIERS] = {

    "volume",

    "position",

    "duration",

    "statechangedcallback",

    "state",

    "isvideoclip",

    "isseekable",

    "clipname",

    "fullscreenmode",

    "mimetype",

};

static bool _initializedIdentifiers = false;    

static void initializeIdentifiers()

{

    if (!_initializedIdentifiers) {

        _initializedIdentifiers = true;

        NPN_GetStringIdentifiers (bavpPropertyIdentifierNames, NUM_PROPERTY_IDENTIFIERS, bavpPropertyIdentifiers);

        NPN_GetStringIdentifiers (bavpIdentifierNames, NUM_METHOD_IDENTIFIERS, bavpMethodIdentifiers);

    }

};

_LIT8(KNone,"None");

_LIT8(KBuffering,"Buffering");

_LIT8(KPlaying,"Playing");

_LIT8(KPlayComplete,"Playcomplete");

_LIT8(KStopped,"Stopped");

_LIT8(KPaused,"Paused");

_LIT8(KBadContent,"Badcontent");

_LIT8(KFastForwarding,"Fastforwarding");

_LIT8(KFFComplete,"Fastforward complete");

_LIT8(KRewinding,"Rewinding");

_LIT8(KRewindComplete,"Rewinding complete");

_LIT8(KInvalidState,"Invalid State");

static const TPtrC8 getState(int state)

{

    TPtrC8 ret;

    switch (state)

    {

        case EBavpNone:

            ret.Set(KNone);

            break;

        case EBavpBuffering:

            ret.Set(KBuffering);

            break;

        case EBavpPlaying:

            ret.Set(KPlaying);

            break;

        case EBavpPlayComplete:

            ret.Set(KPlayComplete);

            break;

        case EBavpStopped:

            ret.Set(KStopped);

            break;

        case EBavpPaused:

            ret.Set(KPaused);

            break;

        case EBavpBadContent:

            ret.Set(KBadContent);

            break;

        case EBavpFastForwarding:

            ret.Set(KFastForwarding);

            break;

        case EBavpFastForwardComplete:

            ret.Set(KFFComplete);

            break;

        case EBavpRewinding:

            ret.Set(KRewinding);

            break;

        case EBavpRewindComplete:

            ret.Set(KRewindComplete);

            break;

        default:

            ret.Set(KInvalidState);

            break;

    }

    return ret;

}

static void reportVolumeResults(int vol,CBavpController *ctlr)

{

    Log(ETrue,_L("SetProperty: Volume"));

    TInt setvol = ctlr->GetPlayerVolume();

    Log(ETrue,_L("Requested volume: "), vol);

    Log(ETrue,_L("Volume set to: "),setvol);

    if ( setvol == vol || setvol == KCRVolumeMax || setvol == KCRVolume0 )

    {

        Log(ETrue,_L("Result: Passed"));

    }

    else

    {

        Log(ETrue,_L("Result: Failed"));

    }

}

static void reportPositionResultsL(int pos, CBavpController *ctlr)

{

    Log(ETrue,_L("SetProperty: Position"));

    if ( !(ctlr->IsClipSeekable()) && !(ctlr->IsClipLocalMedia()) )

    {

        Log(ETrue,_L("Cannot set position for non-seekable and non-local media content"));

        return;

    }

    TTimeIntervalMicroSeconds ms = ctlr->getPositionL();

    TTimeIntervalMicroSeconds durationms = ctlr->Duration();

    int setpos = (int)ms.Int64();

    int duration = (int)durationms.Int64();

    Log(ETrue,_L("Requested position: "), pos);

    Log(ETrue,_L("Position set to: "),setpos);

    if ( setpos == pos || setpos == duration || setpos == 0)

    {	

        Log(ETrue,_L("Result: Passed"));

    }

    else

    {

        Log(ETrue,_L("Result: Failed"));

    }	

}

static void reportPlayResultsL(int initState, CBavpController *ctlr)

{

    if ( ctlr->IsClipVideo())

    {

        TPtrC8 expectedState = getState(EBavpPlaying);

        TPtrC8 expectedState2 = getState(EBavpBuffering);

        TPtrC8 actualState = getState(ctlr->State());

        if ( initState == EBavpStopped ||

             initState == EBavpPlayComplete ||

             initState == EBavpRewindComplete ||

             initState == EBavpFastForwardComplete ||

             initState == EBavpBadContent)

        {

            TTimeIntervalMicroSeconds ms = ctlr->getPositionL();

            int actualpos = (int)ms.Int64();

            Log(ETrue,_L("Expected Position: "), 0);

            Log(ETrue,_L("Actual Position: "),actualpos);

            if ( actualpos != 0)

            {

                Log(ETrue,_L("Result: Position test failed"));

            }

            else

            {

                Log(ETrue,_L("Result:Position test passed"));

            }

        }

        if ( ctlr->IsClipOnDemand() && initState == EBavpStopped )

        {

            Log(ETrue,_L8("Expected State: "), expectedState2);

            Log(ETrue,_L8("Actual State: "), actualState);

        }

        else

        {

            Log(ETrue,_L8("Expected State: "), expectedState);

            Log(ETrue,_L8("Actual State: "), actualState);	

        }

        if ( actualState.Compare(expectedState) != 0 && actualState.Compare(expectedState2) != 0)

        {

            Log(ETrue,_L("Result: State test failed"));

        }

        else

        {

            Log(ETrue,_L("Result: State test passed"));

        }

    }

    else

    {

        TPtrC8 expectedState = getState(EBavpPlaying);

        TPtrC8 actualState = getState(ctlr->State());

        Log(ETrue,_L8("Expected State: "), expectedState);

        Log(ETrue,_L8("Actual State: "), actualState);

        if ( expectedState.Compare(actualState) != 0)

        {

            Log(ETrue,_L("Result: Failed"));

        }

        else

        {

            Log(ETrue,_L("Result: Passed"));

        }

    }

}

static void reportStopResultsL(CBavpController *ctlr)

{

    TPtrC8 expectedState = getState(EBavpStopped);

    TPtrC8 actualState = getState(ctlr->State());

    TTimeIntervalMicroSeconds ms = ctlr->getPositionL();

    int position = (int)ms.Int64();

    Log(ETrue,_L8("Expected State: "), expectedState);

    Log(ETrue,_L8("Actual State: "), actualState);

    Log(ETrue,_L("Current Position: "), position);

    if ( (position != 0) || (expectedState.Compare(actualState) != 0) )

    {

        Log(ETrue,_L("Result: Failed"));

    }

    else

    {

        Log(ETrue,_L("Result: Passed"));

    }

}

static void reportRewindResults(CBavpController *ctlr)

{

    if ( ctlr->IsClipVideo() )

    {

        if ( !(ctlr->IsClipSeekable()) && !(ctlr->IsClipLocalMedia()) )

        {

            Log(ETrue,_L("Result: Rewind is not applicable to non-seekable and non-local media content"));

        }

        else

        {

            TPtrC8 expectedState = getState(EBavpRewinding);

            TPtrC8 expectedState2 = getState(EBavpRewindComplete);

            TPtrC8 actualState = getState(ctlr->State());

            Log(ETrue,_L8("Expected State: "), expectedState);

            Log(ETrue,_L8("Actual State: "), actualState);

            if ( (expectedState.Compare(actualState) != 0) && (expectedState2.Compare(actualState) != 0) )

            {

                Log(ETrue,_L("Result: Failed"));

            }

            else

            {

                Log(ETrue,_L("Result: Passed"));

            }

        }

    }

    else

    {

        Log(ETrue,_L("Result: Rewind is not applicable to Audio"));

    }

}

static void reportFFResults(CBavpController *ctlr)

{

    if ( ctlr->IsClipVideo() )

    {

        if ( !(ctlr->IsClipSeekable()) && !(ctlr->IsClipLocalMedia()) )

        {

            Log(ETrue,_L("Result: Fastforward is not applicable to non-seekable and non-local media content"));

        }

        else

        {

            TPtrC8 expectedState = getState(EBavpFastForwarding);

            TPtrC8 expectedState2 = getState(EBavpFastForwardComplete);

            TPtrC8 actualState = getState(ctlr->State());

            Log(ETrue,_L8("Expected State: "), expectedState);

            Log(ETrue,_L8("Actual State: "), actualState);

            if ( (expectedState.Compare(actualState) != 0) && (expectedState2.Compare(actualState) != 0) )

            {

                Log(ETrue,_L("Result: Failed"));

            }

            else

            {

                Log(ETrue,_L("Result: Passed"));

            }

        }

    }

    else

    {

        Log(ETrue,_L("Result: Fastforward is not applicable to Audio"));

    }

}

static void reportPauseResultsL(CBavpController *ctlr)

{

    TBool seekablevideo = (ctlr->IsClipSeekable() && ctlr->IsClipVideo());

    TBool seekableaudio = (ctlr->IsClipSeekable() && !ctlr->IsClipVideo() 

            && (ctlr->State() == EBavpPaused || ctlr->State() == EBavpPlaying));

    if ( seekablevideo || seekableaudio )

    {

        TPtrC8 expectedState = getState(EBavpPaused);

        TPtrC8 actualState = getState(ctlr->State());

        Log(ETrue,_L8("Expected State: "), expectedState);

        Log(ETrue,_L8("Actual State: "), actualState);

        if ( (expectedState.Compare(actualState) != 0) )

        {

            Log(ETrue,_L("Result: Failed"));

        }

        else

        {

            Log(ETrue,_L("Result: Passed"));

        }

    }

    else

    {

        reportStopResultsL(ctlr);

    }

}

static void BavpDesToNpvariant(TPtrC& string, NPVariant*& variant)

{

    char* newString = NULL;

    if (string.Length()) {

        newString = new char[string.Length()];

    }

    if (newString) {

        TPtr8 newStringPtr((unsigned char*)newString, 0, string.Length());

        newStringPtr.Copy(string);

        STRINGN_TO_NPVARIANT(newString, string.Length(), *variant);

    }

}

static void BavpDesToNpvariant(TPtrC8& string, NPVariant*& variant)

{

    char* newString = NULL;

    if (string.Length()) {

        newString = new char[string.Length()];

    }

    if (newString) {

        Mem::Copy(newString, string.Ptr(), string.Length());

        STRINGN_TO_NPVARIANT(newString, string.Length(), *variant);

    }

}

NPObject *BavpAllocate ()

{

    BavpNPObject *newInstance = (BavpNPObject *)User::AllocZ (sizeof(BavpNPObject));   

    return (NPObject *)newInstance;

}

void BavpInvalidate ()

{

    // Make sure we've released any remainging references to JavaScript

    // objects.

}

void BavpDeallocate (BavpNPObject *obj) 

{

    if (obj->stateChangedCallback)

        NPN_ReleaseObject((struct NPObject*)obj->stateChangedCallback);  

    User::Free ((void *)obj);

}    

bool BavpHasMethod(BavpNPObject */*obj*/, NPIdentifier name)

{

    int i;

    for (i = 0; i < NUM_METHOD_IDENTIFIERS; i++) {

        if (name == bavpMethodIdentifiers[i]){

            return true;

        }

    }

    return false;

}

bool BavpInvokeL(BavpNPObject *obj, NPIdentifier name, const NPVariant */* args */, uint32_t /* argCount */, NPVariant *result)

{

    if (!obj->plugin) {

        NULL_TO_NPVARIANT(*result);

        return true;    

    }    

    CBavpController *ctlr = obj->plugin->Controller();

    if (!ctlr)

    {

        NULL_TO_NPVARIANT(*result);

        return true; 

    }

    int initState = ctlr->State();

    Log( ETrue, _L("\n"));

    Log( ETrue, _L8("Initial state:"), getState(initState));

    if (name == bavpMethodIdentifiers[ID_PLAY]) 

    {

        Log( ETrue, _L("Method Invoked: Play"));

        if ( ctlr->State() != EBavpPlaying )

        {

            ctlr->PlayL();

        }

        VOID_TO_NPVARIANT(*result);

        reportPlayResultsL(initState,ctlr);

    }

    else if (name == bavpMethodIdentifiers[ID_STOP]) 

    {

        Log( ETrue, _L("Method Invoked: Stop"));

        if ( ctlr->State() != EBavpStopped )

        {

            ctlr->Stop();

        }

        VOID_TO_NPVARIANT(*result);

        reportStopResultsL(ctlr);

    }

    else if (name == bavpMethodIdentifiers[ID_PAUSE]) 

    {

        Log( ETrue, _L("Method Invoked: Pause"));

        if ( ctlr->State() != EBavpPaused )

        {

            ctlr->PauseL();

        }

        VOID_TO_NPVARIANT(*result);

        reportPauseResultsL(ctlr);

    }  

    else if (name == bavpMethodIdentifiers[ID_FASTFORWARD]) 

    {

        Log( ETrue, _L("Method Invoked: FastForward"));

        if ( ctlr->State() == EBavpRewinding )

        {

            ctlr->PauseL();

        }

        if ( ctlr->State() != EBavpFastForwarding )

        {

            ctlr->FastForwardL();

        }

        VOID_TO_NPVARIANT(*result);

        reportFFResults(ctlr);

    }  

    else if (name == bavpMethodIdentifiers[ID_REWIND]) 

    {

        Log( ETrue, _L("Method Invoked: Rewind"));

        if ( ctlr->State() == EBavpFastForwarding )

        {

            ctlr->PauseL();

        }

        if ( ctlr->State() != EBavpRewinding )

        {

            ctlr->RewindL();

        }

        VOID_TO_NPVARIANT(*result);

        reportRewindResults(ctlr);

    }