/*
 * Copyright (c) 2010 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 "cmgdcommandhandler.h"
#include <mmtsy_names.h> 
#include <mmretrieve.h>
#include <exterror.h>

#include "atmisccmdpluginconsts.h"
#include "debug.h"

const TInt KDefaultListLength = 256;

CCMGDCommandHandler* CCMGDCommandHandler::NewL(MATMiscCmdPlugin* aCallback, TAtCommandParser& aATCmdParser, RMobilePhone& aPhone)
    {
    TRACE_FUNC_ENTRY
    CCMGDCommandHandler* self = new (ELeave) CCMGDCommandHandler(aCallback, aATCmdParser, aPhone);
    CleanupStack::PushL(self);
    self->ConstructL();
    CleanupStack::Pop(self);
    TRACE_FUNC_EXIT
    return self;
    }

CCMGDCommandHandler::CCMGDCommandHandler(MATMiscCmdPlugin* aCallback, TAtCommandParser& aATCmdParser, RMobilePhone& aPhone) :
    CATCmdAsyncBase(aCallback, aATCmdParser, aPhone)
    {
    TRACE_FUNC_ENTRY

    TRACE_FUNC_EXIT
    }

void CCMGDCommandHandler::ConstructL()
    {
    TRACE_FUNC_ENTRY
    
    iReply.CreateL(KDefaultCmdBufLength);
    
    User::LeaveIfError( iMobileSmsMessaging.Open(iPhone) );

    TInt err = iMobileSmsStore.Open(iMobileSmsMessaging, KETelIccSmsStore);
    if (err != KErrNone)
        {
        iHandlerState = ECMGDStateSimStoreNotSupported;
        }
    
    iRetrieveSmsList = CRetrieveMobilePhoneSmsList::NewL(iMobileSmsStore, RMobileSmsStore::KETelMobileGsmSmsEntryV1);
    
    TRACE_FUNC_EXIT
    }

CCMGDCommandHandler::~CCMGDCommandHandler()
    {
    TRACE_FUNC_ENTRY
    Cancel();
    delete iGsmSmsList;
    delete iRetrieveSmsList;
    iMobileSmsStore.Close();
    iMobileSmsMessaging.Close();
    iReply.Close();
    iDeleteList.Close();
    TRACE_FUNC_EXIT
    }

void CCMGDCommandHandler::HandleCommand(const TDesC8& /*aCmd*/, RBuf8& /*aReply*/, TBool /*aReplyNeeded*/)
    {
    TRACE_FUNC_ENTRY
    
    if (iHandlerState == ECMGDStateSimStoreNotSupported)
        {
        // Reply "ERROR" if SIM store is not supported
        iCallback->CreateReplyAndComplete(EReplyTypeError);
        TRACE_FUNC_EXIT
        return;
        }
    
    TInt ret = KErrNone;
    
    TAtCommandParser::TCommandHandlerType cmdHandlerType = iATCmdParser.CommandHandlerType();
    
    switch (cmdHandlerType)
        {
        case (TAtCommandParser::ECmdHandlerTypeTest):
            {
            iRetrieveSmsList->Start(iStatus);
            iHandlerState = ECMGDStateRetrieveAllIndices;
            SetActive();
            }
            break;
        case (TAtCommandParser::ECmdHandlerTypeSet):
            {
            ret = ParseParameters();
            if (ret == KErrNone)
                {
                Trace(_L("index = %d"), iIndex);
                Trace(_L("delflag = %d"), iDelFlag);
                ret = DoHandleCommand();
                }
            else
                {
                ret = KErrArgument;
                }
            break;
            }
        default:
            {
            ret = KErrNotSupported;
            break;
            }
        }
    if (ret == KErrGsmSMSInvalidMemoryIndex)
        {
        iCallback->CreateCMSReplyAndComplete(ret);
        }
    else if (ret != KErrNone)
        {
        iCallback->CreateReplyAndComplete(EReplyTypeError);
        }

    TRACE_FUNC_EXIT
    }

void CCMGDCommandHandler::RunL()
    {
    TRACE_FUNC_ENTRY
    
    Trace(_L("Error = %d"), iStatus.Int());
    Trace(_L("State = %d"), iHandlerState);
    
    iReply.Zero();
    
    TInt err = iStatus.Int();
    if(err == KErrNone)
        {
        switch (iHandlerState)
            {
            case ECMGDStateRetrieveAllIndices:
                {
                GetMessageIndexListL();
                iDeleteList.Reset();
                break;
                }
            case ECMGDStateDeleteOneEntry:                
            case ECMGDStateDeleteAllEntries:
                {
                // do nothing
                break;
                }
            case ECMGDStateDeleteFilteredEntries:
                {
                FilterMessageListL();
                break;
                }
            default:
                {
                iHandlerState = ECMGDStateIdle;
                iCallback->CreateReplyAndComplete(EReplyTypeError);
                TRACE_FUNC_EXIT
                return;
                }
            }
        
        if (iDeleteList.Count() != 0)
            {
            // delete the first entry in the list
            iMobileSmsStore.Delete(iStatus, iDeleteList[0]);
            iDeleteList.Remove(0);
            iHandlerState = ECMGDStateDeleteOneEntry;
            SetActive();                    
            }
        else
            {
            // deleting finished
            iCallback->CreateReplyAndComplete(EReplyTypeOk, iReply);
            }
        }
    else if (err == KErrNotFound)
        {
        // no message found in SIM
        switch (iHandlerState)
            {
            case ECMGDStateRetrieveAllIndices:
                {
                iHandlerState = ECMGDStateIdle;
                iReply.Format(KCMGDSupportedCmdsList, &KNullDesC8);
                iCallback->CreateReplyAndComplete(EReplyTypeOk, iReply);
                break;
                }
            case ECMGDStateDeleteFilteredEntries:
                {
                iMobileSmsStore.DeleteAll(iStatus);
                iHandlerState = ECMGDStateDeleteAllEntries;
                SetActive();
                break;
                }
            default:
                iHandlerState = ECMGDStateIdle;
                iCallback->CreateCMSReplyAndComplete(err);
                break;
            }
        }
    else 
        {
        iHandlerState = ECMGDStateIdle;
        iCallback->CreateCMSReplyAndComplete(err);
        }

    TRACE_FUNC_EXIT
    }

TInt CCMGDCommandHandler::RunError(TInt aError)
    {
    TRACE_FUNC_ENTRY
    
    iCallback->CreateCMSReplyAndComplete(aError);
    
    TRACE_FUNC_EXIT
    return KErrNone;
    }

void CCMGDCommandHandler::DoCancel() 
    {
    TRACE_FUNC_ENTRY
    
    switch (iHandlerState)
        {
        case ECMGDStateRetrieveAllIndices:
        case ECMGDStateDeleteFilteredEntries:
            {
            iRetrieveSmsList->Cancel();
            break;
            }
        case ECMGDStateDeleteOneEntry:
            {
            iMobileSmsStore.CancelAsyncRequest(EMobilePhoneStoreDelete);
            break;
            }
        case ECMGDStateDeleteAllEntries:
            {
            iMobileSmsStore.CancelAsyncRequest(EMobilePhoneStoreDeleteAll);
            break;
            }
        }

    TRACE_FUNC_EXIT
    }

TInt CCMGDCommandHandler::ParseParameters()
    {
    TRACE_FUNC_ENTRY
    
    TInt ret = KErrNone;
    TInt index = 0;
    TInt delflag = 0; // default value
    TInt otherParams = 0;
    
    // get index 
    TInt retIndex = iATCmdParser.NextIntParam(index);
    // get delflag
    TInt retDelflag = iATCmdParser.NextIntParam(delflag);
    // get other params
    TInt retOther = iATCmdParser.NextIntParam(otherParams);
    // Syntax error happens if
    // a)there is no param2 or param2 error 
    // b)there is no param1 but param2==0
    // c)there are too many params
    TBool noParam = (retIndex!=KErrNone && retDelflag!=KErrNone || retDelflag==KErrGeneral );
    TBool noParam1 = (retIndex!=KErrNone && retDelflag==KErrNone && delflag==0);
    TBool tooManyParams = (retOther!=KErrNotFound);
    
    if (noParam || noParam1 || tooManyParams)
        {
        ret = KErrArgument;
        }
    else
        {
        iIndex = index;
        iDelFlag = delflag;
        }

    TRACE_FUNC_EXIT
    return ret;
    }

TInt CCMGDCommandHandler::DoHandleCommand()
    {
    TRACE_FUNC_ENTRY
    
    TInt err = KErrNone;
    
    switch (iDelFlag)
        {
        case 0:
            // deletes the designated message with <index>.
            {
            if (iIndex == 0)
                {
                // The first position in SIM store is 1,
                // so zero is not in the supported range.
                err = KErrGsmSMSInvalidMemoryIndex;
                }
            else
                {
                iDeleteList.Reset();
                iMobileSmsStore.Delete(iStatus, iIndex);
                iHandlerState = ECMGDStateDeleteOneEntry;
                SetActive();
                }
            }
            break;
        case 1:
            // deletes all read message in first-choice memory and reserves unread message, 
            // sent message and unsent message.
            {
            iRetrieveSmsList->Start(iStatus);
            iHandlerState = ECMGDStateDeleteFilteredEntries;
            iFilterType = ECMGDFilterReadMessagesOnly;
            SetActive();
            }
            break;
        case 2:
            // deletes all read message and sent message in first-choice memory 
            // and reserves unread message and unsent message.
            {
            iRetrieveSmsList->Start(iStatus);
            iHandlerState = ECMGDStateDeleteFilteredEntries;
            iFilterType = ECMGDFilterReadAndSentMessages;
            SetActive();            
            }
            break;
        case 3:
            // deletes all read message, sent message and unsent message in first-choice memory 
            // and reserves unread message.
            {
            iRetrieveSmsList->Start(iStatus);
            iHandlerState = ECMGDStateDeleteFilteredEntries;
            iFilterType = ECMGDFilterReadSentAndUnsentMessages;
            SetActive();            
            }
            break;
        case 4:
            // deletes all messages in first-choice memory, including unread message.
            {
            iDeleteList.Reset();
            iMobileSmsStore.DeleteAll(iStatus);
            iHandlerState = ECMGDStateDeleteAllEntries;
            SetActive();
            }
            break;
            
        default:
            err = KErrNotSupported;
            break;
        }
    
    TRACE_FUNC_EXIT
    return err;
    }

void CCMGDCommandHandler::GetMessageIndexListL()
    {
    TRACE_FUNC_ENTRY
    
    iReply.Zero();
    delete iGsmSmsList;
    iGsmSmsList = NULL;
    
    RBuf8 list;
    list.CreateL(KDefaultListLength);
    CleanupClosePushL(list);

    iGsmSmsList = iRetrieveSmsList->RetrieveGsmListL();
    TInt entriesNum = iGsmSmsList->Enumerate();
    
    if (entriesNum > 0)
        {
        // Append 1st item
        RMobileSmsStore::TMobileGsmSmsEntryV1 entry;
        entry = iGsmSmsList->GetEntryL(0);
        list.AppendNum(entry.iIndex);
        
        for (TInt i=1; i<entriesNum; ++i)
            {
            entry = iGsmSmsList->GetEntryL(i);
            list.Append(',');
            list.AppendNum(entry.iIndex);
            }
        }
    iReply.Format(KCMGDSupportedCmdsList, &list);
    
    CleanupStack::PopAndDestroy(&list); //list
    
    TRACE_FUNC_EXIT
    }

/**
 * Filter message list with iFilterType
 * ECMGDFilterReadSentAndUnsentMessages: read, sent and unsent messages
 * ECMGDFilterReadAndSentMessages: read and sent messages
 * ECMGDFilterReadMessagesOnly: read messages
 */
void CCMGDCommandHandler::FilterMessageListL()
    {
    TRACE_FUNC_ENTRY
    
    delete iGsmSmsList;
    iGsmSmsList = NULL;
        
    iDeleteList.Reset();
    
    iGsmSmsList = iRetrieveSmsList->RetrieveGsmListL();
    TInt entriesNum = iGsmSmsList->Enumerate();
    
    for (TInt i=0; i<entriesNum; ++i)
        {
        RMobileSmsStore::TMobileGsmSmsEntryV1 entry = iGsmSmsList->GetEntryL(i);
        switch (iFilterType)
            {
            case ECMGDFilterReadSentAndUnsentMessages:
                {
                // add unsent message 
                if (entry.iMsgStatus == RMobileSmsStore::EStoredMessageUnsent)
                    {
                    iDeleteList.AppendL(entry.iIndex);
                    break;
                    }
                }
            case ECMGDFilterReadAndSentMessages:
                {
                // add sent message 
                if (entry.iMsgStatus == RMobileSmsStore::EStoredMessageSent)
                    {
                    iDeleteList.AppendL(entry.iIndex);
                    break;
                    }
                }
            case ECMGDFilterReadMessagesOnly:
                {
                // add read message 
                if (entry.iMsgStatus == RMobileSmsStore::EStoredMessageRead )
                    {
                    iDeleteList.AppendL(entry.iIndex);
                    break;
                    }
                }
            }
        }
    
    TRACE_FUNC_EXIT
    }