/*
* Copyright (c) 2006-2007 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:   ?Description
*
*/



#include "uiacceltk/HuiScheduler.h"  // Class definition
#include "uiacceltk/HuiEnv.h"
#include "uiacceltk/HuiCommand.h"
#include "uiacceltk/HuiEvent.h"
#include "uiacceltk/HuiStatic.h"
#include "uiacceltk/HuiUtil.h"

#include "uiacceltk/HuiPanic.h"


CHuiScheduler::CHuiScheduler(CHuiEnv& aEnv)
        : iEnv(aEnv)
    {
    }

CHuiScheduler::~CHuiScheduler()
    {
    for(TInt i = iPendingCommands.Count() - 1; i >= 0; --i)
        {
        RemovePendingCommand(i);
        }
    iPendingCommands.Close();
    }
    
    
void CHuiScheduler::RemovePendingCommand(TInt aIndex)
    {
    delete iPendingCommands[aIndex].iCommand;
    iPendingCommands[aIndex].iCommand = NULL;
    iPendingCommands.Remove(aIndex);
    }


void CHuiScheduler::AdvanceTime(TReal32 /*aElapsedTime*/)
    {
    TTime now = CHuiStatic::Time();

    // Check the pending commands. They are iterated in chronological order
    // so that commands with the same execution time will be executed in
    // the same order as they were posted.    

    /** @todo  Could be done more efficiently. Priority queue? */
    
    for(TInt i = 0; i < iPendingCommands.Count(); ++i)
        {
        if(iPendingCommands[i].iExecutionTime <= now)
            {
            // The execution of the command may modify the list of pending
            // commands. Take the command out of the pending array first.
            const THuiCommand* command = iPendingCommands[i].iCommand;
            iPendingCommands.Remove(i);

            // Must trap because the command is not on the cleanup stack.
            TRAPD(err, command->ExecuteL(iEnv));
            if(err != KErrNone)
                {
                HUI_DEBUG1(_L("CHuiScheduler::AdvanceTime() - Leave %i during command execution."), err);
                }

            delete command; 
            command = NULL;

            // Check through the list of pending again, in case there
            // were alterations.
            i = -1;
            }
        }
    }


void CHuiScheduler::PostCommandL(const THuiCommand& aCommand,
                                 TInt aTransitionTime)
    {
    if(aTransitionTime > 0)
        {
        // Make a copy of the command.
        const THuiCommand* data = (const THuiCommand*) new (ELeave) TUint8[aCommand.Size()];
        CleanupStack::PushL((TAny*)data);
        Mem::Copy((TAny*)data, (TAny*)&aCommand, aCommand.Size());
        
        // Won't be executed yet.
        TDelayedCommand delayed(data);
        delayed.iExecutionTime = CHuiStatic::Time() +
            TTimeIntervalMicroSeconds32(1000 * aTransitionTime);
        User::LeaveIfError( iPendingCommands.Append(delayed) ); 
        CleanupStack::Pop((TAny*)data);
        }
    else
        {
        // Execute immediately.
        aCommand.ExecuteL(iEnv);
        }
    }


void CHuiScheduler::CancelCommands(const TAny* aObject)
    {
    for(TInt i = iPendingCommands.Count() - 1; i >= 0; --i)
        {
        const THuiObjectCommand* objectCommand = iPendingCommands[i].iCommand->ObjectCommand();
        if(objectCommand && objectCommand->Object() == aObject)
            {
            // Cancel this one.
            RemovePendingCommand(i);
            }
        }
    }


void CHuiScheduler::CancelCommands(const TAny* aObject, THuiOp aCommandOperation)
    {
    for(TInt i = iPendingCommands.Count() - 1; i >= 0; --i)
        {
        const THuiObjectCommand* objectCommand = iPendingCommands[i].iCommand->ObjectCommand();
        if(objectCommand && 
           objectCommand->Object() == aObject &&
           objectCommand->Operation() == aCommandOperation)
            {
            // Cancel this one.
            RemovePendingCommand(i);
            }
        }
    }
    
    
void CHuiScheduler::CancelCommands(const TAny* aObject,
                                   THuiCommandType aCommandType,
                                   TInt aParam)
    {
    for(TInt i = iPendingCommands.Count() - 1; i >= 0; --i)
        {
        const THuiObjectCommand* objectCommand = iPendingCommands[i].iCommand->ObjectCommand();

        if(objectCommand && 
           objectCommand->Object() == aObject &&
           objectCommand->Type() == aCommandType)
            {
            if(objectCommand->Type() == EHuiCommandTypeCustomEvent)
                {
                const THuiCustomEventCommand* cec = 
                    static_cast<const THuiCustomEventCommand*>( objectCommand );
                    
                if(cec->Param() != aParam)
                    {
                    // Not this one, wrong parameter.
                    continue;
                    }
                }
            // Cancel this one.
            RemovePendingCommand(i);
            }
        }
    }


TInt CHuiScheduler::TimeUntilCommand(const TAny* aObject,
                                     THuiCommandType aCommandType)
    {
    TTime now = CHuiStatic::Time();
    TInt earliest = -1;

    for(TInt i = 0; i < iPendingCommands.Count(); ++i)
        {
        const THuiObjectCommand* objectCommand = iPendingCommands[i].iCommand->ObjectCommand();
        if(objectCommand &&
           objectCommand->Object() == aObject &&
           objectCommand->Type() == aCommandType)
            {
            TInt remaining =
#ifndef EKA2
                iPendingCommands[i].iExecutionTime.MicroSecondsFrom(now).Int64().GetTInt() / 1000;
#else
                I64LOW(iPendingCommands[i].iExecutionTime.MicroSecondsFrom(now).Int64()) / 1000;
#endif

            if(remaining < 0)
                {
                /** @todo  Should never happen? */
                remaining = 0;
                }
            if(earliest < 0 || remaining < earliest)
                {
                earliest = remaining;
                }
            }
        }

    return earliest;
    }


TInt CHuiScheduler::PendingCount() const
    {
    return iPendingCommands.Count();
    }