/*
 * Copyright (c) 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 <rmmcustomapi.h>
#include <psetcontainer.h>
#include <psetnetwork.h>
#include <gsmerror.h>
#include <PsetCSP.h>

#include "psetnetworkwrapper_p.h"
#include "logging.h"
#include "psetnetworkinfoconverter.h"

/*!
    \class PSetNetworkWrapperPrivate
    \brief Private implementation for network wrapper.
*/

/*!
  PSetNetworkWrapperPrivate::PSetNetworkWrapperPrivate
 */
PSetNetworkWrapperPrivate::PSetNetworkWrapperPrivate(
    PSetNetworkWrapper &owner,
    CPsetContainer &psetContainer)
    :
    m_owner(owner),
    m_psetNetwork(NULL),
    m_psetNetworkMode(NULL)
{
    DPRINT << ": IN ";
    
    QT_TRAP_THROWING(
        m_psetNetwork.reset(psetContainer.CreateNetworkObjectL(*this)));
    m_psetNetwork->SetNetworkModeObserver(*this);
    m_psetNetwork->SetNetSAObserver(*this);
    QT_TRAP_THROWING(
        m_psetNetworkMode.reset(psetContainer.CreateNetworkModeObjectL(*this)));
    QT_TRAP_THROWING(
        m_refreshHandler.reset(psetContainer.CreateRefreshHandlerL()));
    QT_TRAP_THROWING(m_refreshHandler->NotifyFileChangeL(
                *this,
                KCsp1Ef,
                EFileChangeNotification));
    
    QT_TRAP_THROWING(m_csp.reset(CPsetCustomerServiceProfile::NewL()));
    QT_TRAP_THROWING(m_csp->OpenCSProfileL());

    DPRINT << ": OUT ";
}

/*!
  PSetNetworkWrapperPrivate::~PSetNetworkWrapperPrivate
 */
PSetNetworkWrapperPrivate::~PSetNetworkWrapperPrivate()
{
    DPRINT << ": IN ";
    
    while (!m_networkInfoList.isEmpty()) {
        DPRINT << " delete : " << m_networkInfoList.first()->m_longName;
        delete m_networkInfoList.takeFirst();
    }
    m_networkInfoList.clear();
    
    DPRINT << ": OUT ";
}

/*!
    PSetNetworkWrapperPrivate::getAvailableNetworks.
*/
void PSetNetworkWrapperPrivate::getAvailableNetworks()
{
    DPRINT << ": IN ";
    
    QT_TRAP_THROWING(m_psetNetwork->GetAvailableNetworksL());
    
    DPRINT << ": OUT ";
}

/*!
    PSetNetworkWrapperPrivate::getNetworkSelectionMode
*/
PSetNetworkWrapper::ErrorCode 
    PSetNetworkWrapperPrivate::getNetworkSelectionMode(
    PSetNetworkWrapper::NetworkSelectionMode& mode) const
{
    DPRINT;
    
    MPsetNetworkSelect::TSelectMode selectMode = 
        MPsetNetworkSelect::ENetSelectModeAutomatic;
    int result = m_psetNetwork->GetNetworkSelectMode(selectMode);
    mode = NetworkInfoConverter::ConvertToQtType(selectMode);
    
    return ConvertToQtErrorCode(result);
}

/*!
    PSetNetworkWrapperPrivate::selectNetwork.
 */
void PSetNetworkWrapperPrivate::selectNetwork( 
    const PSetNetworkWrapper::NetworkInfo& info)
{
    DPRINT << ": IN ";
    
    QT_TRAP_THROWING(m_psetNetwork->SelectNetworkL(
        NetworkInfoConverter::ConvertToSymbianType(info)));
         
    DPRINT << ": OUT ";
}

/*!
    PSetNetworkWrapperPrivate::cancelRequest
*/
void PSetNetworkWrapperPrivate::cancelRequest()
{
    DPRINT;
    
    m_psetNetwork->CancelProcess();
}

/*!
    PSetNetworkWrapperPrivate::getNetworkAccessMode
*/
void PSetNetworkWrapperPrivate::getNetworkAccessMode() const
{
    DPRINT << ": IN ";
    
    QT_TRAP_THROWING(
        m_psetNetwork->GetCurrentNetworkModeSelectionL());
        
    DPRINT << ": OUT ";
}

/*!
    PSetNetworkWrapperPrivate::setNetworkAccessMode
*/
void PSetNetworkWrapperPrivate::setNetworkAccessMode(
    PSetNetworkWrapper::NetworkAccessMode mode)
{
    DPRINT << ": IN ";
    
    RMmCustomAPI::TNetworkModeCaps modeCaps = 
        RMmCustomAPI::KCapsNetworkModeDual;
    switch (mode) {
        case PSetNetworkWrapper::AccessModeDual:
            modeCaps = RMmCustomAPI::KCapsNetworkModeDual;
            break;
        case PSetNetworkWrapper::AccessModeUmts:
            modeCaps = RMmCustomAPI::KCapsNetworkModeUmts;
            break;
        case PSetNetworkWrapper::AccessModeGsm:
            modeCaps = RMmCustomAPI::KCapsNetworkModeGsm;
            break;
        default:
            Q_ASSERT_X(false, "switch default", "unknown enumerator");
    }
    
    QT_TRAP_THROWING(m_psetNetwork->SetNetworkModeSelectionL(
        reinterpret_cast<TUint32&>(modeCaps)));
        
    DPRINT << ": OUT ";
}

/*!
     From MPsetNetworkInfoObserver.
     \see MPsetNetworkInfoObserver.
*/
void PSetNetworkWrapperPrivate::HandleNetworkInfoReceivedL( 
    const CNetworkInfoArray* aInfoArray, 
    const TInt aResult)
{
    DPRINT << ": IN ";
    
    Q_UNUSED(aResult);
    __ASSERT_DEBUG(NULL != aInfoArray, User::Leave(KErrArgument));
    
    // delete qlist
    while (!m_networkInfoList.isEmpty()) {
        DPRINT << " delete : " << m_networkInfoList.first()->m_longName;
        delete m_networkInfoList.takeFirst();
    }
    m_networkInfoList.clear();
    
    const int itemsCount = aInfoArray->Count();

    //then insert found networks
    for(int i = 0; i < itemsCount; i++)
        {
        PSetNetworkWrapper::NetworkInfo *info = 
            new (ELeave) PSetNetworkWrapper::NetworkInfo;
        
        info->m_id.m_countryCode = QString::fromUtf16(
            aInfoArray->At(i).iId.iCountryCode.Ptr(), 
            aInfoArray->At(i).iId.iCountryCode.Length());
        info->m_id.m_networkCode =  QString::fromUtf16(
            aInfoArray->At(i).iId.iNetworkCode.Ptr(), 
            aInfoArray->At(i).iId.iNetworkCode.Length());
        info->m_status = 
            static_cast<PSetNetworkWrapper::NetworkStatus>(
                aInfoArray->At(i).iStatus);
        info->m_mode = 
            static_cast<PSetNetworkWrapper::NetworkSelectionMode>(
                aInfoArray->At(i).iMode);
        info->m_access = 
            static_cast<PSetNetworkWrapper::NetworkAccessType>(
                aInfoArray->At(i).iAccess);
        info->m_shortName = 
            QString::fromUtf16(
                aInfoArray->At(i).iShortName.Ptr(), 
                aInfoArray->At(i).iShortName.Length());
        info->m_longName = 
            QString::fromUtf16(
                aInfoArray->At(i).iLongName.Ptr(), 
                aInfoArray->At(i).iLongName.Length());
        
        m_networkInfoList.append(info);
        }
    
    QT_TRYCATCH_LEAVING(
        emit m_owner.availableNetworksGot(m_networkInfoList);
    )
    
    DPRINT << ": OUT ";
}

/*!
     From MPsetNetworkInfoObserver.
     \see MPsetNetworkInfoObserver.
*/
void PSetNetworkWrapperPrivate::HandleCurrentNetworkInfoL( 
    const MPsetNetworkSelect::TCurrentNetworkInfo& aCurrentInfo, 
    const TInt aResult)
{
    DPRINT;
    
    Q_UNUSED(aCurrentInfo);
    Q_UNUSED(aResult);
}

/*!
     From MPsetNetworkInfoObserver.
     \see MPsetNetworkInfoObserver.
*/
void PSetNetworkWrapperPrivate::HandleNetworkChangedL( 
    const MPsetNetworkSelect::TNetworkInfo& aCurrentInfo,
    const MPsetNetworkSelect::TCurrentNetworkStatus aStatus, 
    const TInt aResult)
{
    DPRINT;
    
    Q_UNUSED(aCurrentInfo);
    Q_UNUSED(aStatus);
    Q_UNUSED(aResult);
}

/*!
     From MPsetNetworkInfoObserver.
     \see MPsetNetworkInfoObserver.
*/
void PSetNetworkWrapperPrivate::HandleNetworkChangedL( 
    const MPsetNetworkSelect::TNetworkInfo& aCurrentInfo,
    const RMobilePhone::TMobilePhoneRegistrationStatus& aStatus, 
    const TInt aResult)
{
    DPRINT << ": IN ";
    
    Q_UNUSED(aResult);
    
    PSetNetworkWrapper::NetworkInfo info;      
    info.m_id.m_countryCode =  QString::fromUtf16(
        aCurrentInfo.iId.iCountryCode.Ptr(), 
        aCurrentInfo.iId.iCountryCode.Length());
    info.m_id.m_networkCode =  QString::fromUtf16(
        aCurrentInfo.iId.iNetworkCode.Ptr(), 
        aCurrentInfo.iId.iNetworkCode.Length());
    info.m_status = 
        static_cast<PSetNetworkWrapper::NetworkStatus>(
            aCurrentInfo.iStatus);
    info.m_mode = 
        static_cast<PSetNetworkWrapper::NetworkSelectionMode>(
            aCurrentInfo.iMode);
    info.m_access = 
        static_cast<PSetNetworkWrapper::NetworkAccessType>(
            aCurrentInfo.iAccess);
    info.m_shortName = 
        QString::fromUtf16(
            aCurrentInfo.iShortName.Ptr(), 
            aCurrentInfo.iShortName.Length());
    info.m_longName = 
        QString::fromUtf16(
            aCurrentInfo.iLongName.Ptr(), 
            aCurrentInfo.iLongName.Length());
    
    PSetNetworkWrapper::RegistrationStatus status;
    switch (aStatus){
        case RMobilePhone::ERegisteredOnHomeNetwork:
            status = PSetNetworkWrapper::RegisteredOnHomeNetwork;
            break;
        case RMobilePhone::ERegisteredRoaming:
            status = PSetNetworkWrapper::RegisteredRoaming;
            break;
        }
   
    QT_TRYCATCH_LEAVING(
        emit m_owner.networkChanged(info, status);
    )
    
    DPRINT << ": OUT ";
}

/*!
     From MPsetNetworkInfoObserver.
     \see MPsetNetworkInfoObserver.
*/
void PSetNetworkWrapperPrivate::HandleSearchingNetworksL( 
    MPsetNetworkInfoObserver::TServiceRequest aRequest)
{
    DPRINT << ": IN ";
    
    PSetNetworkWrapper::RequestType type =
        static_cast<PSetNetworkWrapper::RequestType>(aRequest);
    QT_TRYCATCH_LEAVING(
        emit m_owner.searchingNetworks(type);
    )
    
    DPRINT << ": OUT ";
}

/*!
     From MPsetNetworkInfoObserver.
     \see MPsetNetworkInfoObserver.
*/
void PSetNetworkWrapperPrivate::HandleRequestingSelectedNetworkL( 
    TBool aOngoing)
{
    DPRINT << ": IN ";
    
    QT_TRYCATCH_LEAVING(
        emit m_owner.requestingSelectedNetwork(
            static_cast<bool>(aOngoing));
    )
    
    DPRINT << ": OUT ";
}

/*!
     From MPsetNetworkInfoObserver.
     \see MPsetNetworkInfoObserver.
*/
void PSetNetworkWrapperPrivate::HandleCallActivatedL()
{
    DPRINT;
}

/*!
     From MPsetNetworkInfoObserver.
     \see MPsetNetworkInfoObserver.
*/
void PSetNetworkWrapperPrivate::HandleNetworkErrorL( 
    const MPsetNetworkInfoObserver::TServiceRequest aRequest,
    const TInt aError)
{
    DPRINT << ": IN ";
    
    PSetNetworkWrapper::ErrorCode error;
    switch(aError) {
        case KErrGsmNetCauseCallActive:
            error = PSetNetworkWrapper::ErrCauseCallActive;
            break;
        case KErrGsm0707NoNetworkService:
            error = PSetNetworkWrapper::ErrNoNetworkService;
            break;
        case KErrGsmOfflineOpNotAllowed:
            error = PSetNetworkWrapper::ErrOfflineOpNotAllowed;
            break;
        default:
            error = PSetNetworkWrapper::ErrNoNetworkAccess;
            break;
    }

    QT_TRYCATCH_LEAVING(
        emit m_owner.networkReqestFailed(
            error, static_cast<PSetNetworkWrapper::RequestType>(aRequest));
    )
}

/*!
     From MPsetNetworkInfoObserver.
     \see MPsetNetworkInfoObserver.
*/
void PSetNetworkWrapperPrivate::HandleNetworkSystemModeEventsL( 
    const MPsetNetworkModeObserver::TServiceRequest aRequest,
    const TUint32 aNetworkModeCaps)
{
    DPRINT;
    
    switch (aRequest) {
        case MPsetNetworkModeObserver::EServiceRequestNone:
            // TODO: what to do with this kind of event
            break;
        case MPsetNetworkModeObserver::EServiceRequestSetSelectedNetworkMode:
            // TODO: implement this
            break;
        case MPsetNetworkModeObserver::EServiceRequestGetCurrentNetworkMode: {
            PSetNetworkWrapper::NetworkAccessMode mode =
                PSetNetworkWrapper::AccessModeDual;
            if (aNetworkModeCaps & RMmCustomAPI::KCapsNetworkModeDual) {
                mode = PSetNetworkWrapper::AccessModeDual;
            } else if 
                (aNetworkModeCaps & RMmCustomAPI::KCapsNetworkModeUmts) {
                    mode = PSetNetworkWrapper::AccessModeUmts;
            } else if 
                (aNetworkModeCaps & RMmCustomAPI::KCapsNetworkModeGsm) {
                    mode = PSetNetworkWrapper::AccessModeGsm;
            } else {
                Q_ASSERT(false);
            }
            QT_TRYCATCH_LEAVING(
                emit m_owner.networkAccessModeGot(static_cast<int>(mode));
            )

        }
            break;
        default:
            Q_ASSERT_X(false, "switch default", "unknown enumerator");
    }
}

/*!
     From MPsetNetworkInfoObserver.
     \see MPsetNetworkInfoObserver.
*/
void PSetNetworkWrapperPrivate::HandleNetworkErrorL(
    const MPsetNetworkModeObserver::TServiceRequest aRequest,
    const TInt aError)
{
    DPRINT;
    
    Q_UNUSED(aRequest);
    Q_UNUSED(aError);
}

/*!
     PSetNetworkWrapperPrivate::ConvertToQtErrorCode
*/
PSetNetworkWrapper::ErrorCode PSetNetworkWrapperPrivate::ConvertToQtErrorCode(
    TInt symbianErrorCode) const
{
    // TODO: do proper conversion for error codes
    if (KErrNone == symbianErrorCode) {
        return PSetNetworkWrapper::ErrNoError;
    } else {
        return PSetNetworkWrapper::ErrGeneral;
    }    
}

/*!
     PSetNetworkWrapperPrivate::isManualNetworkSelectionSupported
*/
bool PSetNetworkWrapperPrivate::isManualNetworkSelectionSupported() const
{
    DPRINT << ": IN ";
    
    TBool settingSupported(EFalse);
    TInt retVal = m_csp->IsNetworkSelectionSupported(settingSupported);
 
    if ( retVal != KErrNone )
         {
        //if a CSP error occurs, by default service is available
        settingSupported = ETrue;
        }

    DPRINT << ": OUT ";
    return settingSupported;
}

/*!
     PSetNetworkWrapperPrivate::AllowRefresh
*/
TBool PSetNetworkWrapperPrivate::AllowRefresh(
                const TSatRefreshType aType,
                const TSatElementaryFiles aFiles )
{
    DPRINT << "aType: " << aType;
    DPRINT << "aFiles: " << aFiles;
    
    return ETrue;
}

/*!
     PSetNetworkWrapperPrivate::Refresh
*/
void PSetNetworkWrapperPrivate::Refresh(
                const TSatRefreshType aType,
                const TSatElementaryFiles aFiles )
{
    DPRINT << "aType: " << aType;
    DPRINT << "aFiles: " << aFiles;
    
    if ((aType != EFileChangeNotification) ||
        ((aType == EFileChangeNotification) &&
        (aFiles == KCsp1Ef))) {
        TBool networkSelectionSupported;
        if (KErrNone == m_csp->IsNetworkSelectionSupported(networkSelectionSupported)) {
            DPRINT << "networkSelectionSupported " << networkSelectionSupported;
            emit m_owner.chageVisbilityOfManualNetworkSelection(networkSelectionSupported);
        }
    }
    
    DPRINT << ": OUT";
}