/*
* 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 "cntsimutility.h"
#include <mmtsy_names.h>
#include <startupdomainpskeys.h>
#include <e32property.h>
#include <centralrepository.h>

// Number of keys used in central repository to keep latest import date
// from SIM card: 5 IMSI strings and 5 dates. 
const int KCenRepKeysNumber = 10; 
const int KIMSISize = 15;
const int KCenRepUid = 0x200315A8;

CntSimUtility::CntSimUtility(StoreType type, int& error, QObject *parent)
    : QObject(parent),
    m_etelStoreInfoPckg(m_etelStoreInfo),
    m_serviceTablePckg(m_serviceTable),
    m_asyncWorker(NULL),
    m_activeRequest(ENoActiveRequest),
    m_securitySettings(NULL)
{
#ifdef __WINS__
    error = KErrNotSupported;
    return;
#endif

    error = m_etelServer.Connect();
    if (error == KErrNone) {
        error = m_etelServer.LoadPhoneModule(KMmTsyModuleName);
    }
    if (error == KErrNone) {
        RTelServer::TPhoneInfo info;
        error = m_etelServer.GetPhoneInfo(0, info);
        if (error == KErrNone) {
            error = m_etelPhone.Open(m_etelServer, info.iName);
        }
    }
    if (error == KErrNone) {
        // open specified Etel store
        if (type == AdnStore) {
            error = m_etelStore.Open(m_etelPhone, KETelIccAdnPhoneBook);
        }
        else if (type == SdnStore) {
            error = m_etelStore.Open(m_etelPhone, KETelIccSdnPhoneBook);
        }
        else if (type == FdnStore) {
            error = m_etelStore.Open(m_etelPhone, KETelIccFdnPhoneBook);
        }
        else {
            error = KErrNotSupported;
        }
    }
    
    if (error == KErrNone) {
        error = m_customPhone.Open(m_etelPhone);
    }
    
    if (error == KErrNone) {
        TRAP(error, 
                m_asyncWorker = new (ELeave)AsyncWorker(this);
                TSecUi::InitializeLibL();
                m_securitySettings = CSecuritySettings::NewL();
            );
    }
}

CntSimUtility::~CntSimUtility()
{
    m_etelStore.Close();
    m_etelPhone.Close();
    m_etelServer.Close();

    delete m_asyncWorker;
    delete m_securitySettings;
    TSecUi::UnInitializeLib();
}

CntSimUtility::SimInfo CntSimUtility::getSimInfo(int& error)
{
    TRequestStatus requestStatus;
    m_etelStore.GetInfo(requestStatus, (TDes8&)m_etelStoreInfoPckg);
    User::WaitForRequest(requestStatus);
    error = requestStatus.Int();
    SimInfo results;
    
    if (error == KErrNone) {
        results.totalEntries = m_etelStoreInfo.iTotalEntries;
        results.usedEntries = m_etelStoreInfo.iUsedEntries;
        results.maxNumLength = m_etelStoreInfo.iMaxNumLength;
        results.maxTextLength = m_etelStoreInfo.iMaxTextLength;
        results.maxSecondNames = m_etelStoreInfo.iMaxSecondNames;
        results.maxTextLengthSecondName = m_etelStoreInfo.iMaxTextLengthSecondName;
        results.maxAdditionalNumbers = m_etelStoreInfo.iMaxAdditionalNumbers;
        results.maxNumLengthAdditionalNumber = m_etelStoreInfo.iMaxNumLengthAdditionalNumber;
        results.maxTextLengthAdditionalNumber = m_etelStoreInfo.iMaxTextLengthAdditionalNumber;
        results.maxGroupNames = m_etelStoreInfo.iMaxGroupNames;
        results.maxTextLengthGroupName = m_etelStoreInfo.iMaxTextLengthGroupName;
        results.maxEmailAddr = m_etelStoreInfo.iMaxEmailAddr;
        results.maxTextLengthEmailAddr = m_etelStoreInfo.iMaxTextLengthEmailAddr;
    }
    return results;
}

CntSimUtility::AvailableStores CntSimUtility::getAvailableStores(int& error)
{
    AvailableStores availableStores;
    if (!isSimInserted()) {
        error = KErrNone;
        return availableStores;
    }
    
    m_serviceTableType = RMobilePhone::ESIMServiceTable;
    unsigned long int iccCaps;
    TRequestStatus requestStatus;
    
    int result = m_etelPhone.GetIccAccessCaps(iccCaps);
    if (result == KErrNone && (iccCaps & RMobilePhone::KCapsUSimAccessSupported)) {
        m_serviceTableType = RMobilePhone::EUSIMServiceTable;
    }

    m_etelPhone.GetServiceTable(requestStatus, m_serviceTableType, m_serviceTablePckg);
    User::WaitForRequest(requestStatus);
    error = requestStatus.Int();
    
    if (error == KErrNone) {
        //parse service table to find what stores are supported
         ParseServiceTable(&availableStores);
    }
    return availableStores;
}

bool CntSimUtility::verifyPin2Code()
{
    bool verified = false;
    TRAP_IGNORE(verified = m_securitySettings->AskPin2L(););
    return verified;
}

bool CntSimUtility::isFdnActive()
{
    RMobilePhone::TMobilePhoneFdnStatus fdnStatus;
    (void)m_etelPhone.GetFdnStatus(fdnStatus);
    if (fdnStatus == RMobilePhone::EFdnActive ||
        fdnStatus == RMobilePhone::EFdnPermanentlyActive) {
        return true;
        }
    return false;
}

int CntSimUtility::setFdnStatus(bool activated)
{
    RMobilePhone::TMobilePhoneFdnSetting fdnStatus = RMobilePhone::EFdnSetOff;
    if (activated) {
        fdnStatus = RMobilePhone::EFdnSetOn;
    }
    TRequestStatus status;
    m_etelPhone.SetFdnSetting(status, fdnStatus);
    User::WaitForRequest(status);
    return status.Int();
}

QDateTime CntSimUtility::getLastImportTime(int& error)
{
    error = KErrNone;
    if (!isSimInserted()) {
        error = KErrAccessDenied;
        return QDateTime();
    }
    
    // get IMSI
    TBuf<KIMSISize> imsiBuf;
    TRequestStatus reqStatus;
    m_etelPhone.GetSubscriberId(reqStatus, imsiBuf);
    User::WaitForRequest(reqStatus);
    if (reqStatus.Int() != KErrNone) {
        error = reqStatus.Int();
        return QDateTime();
    }
    
    CRepository* cenrep = NULL;
    TRAPD(err, cenrep = CRepository::NewL(TUid::Uid(KCenRepUid)));
    if (err != KErrNone) {
        error = err;
        return QDateTime();
    }
    
    // find current IMSI in the stored values
    int lastImportDate = 0;
    for (int i = 1; i <= KCenRepKeysNumber; i+=2) {
        TBuf<KIMSISize> storedImsiBuf;
        if (cenrep->Get(i, storedImsiBuf) == KErrNone) {
            if (storedImsiBuf.Compare(imsiBuf) == 0) {
                if (cenrep->Get(i+1, lastImportDate) == KErrNone) {
                    break;
                }
            }
        }
    }
    delete cenrep;
    cenrep = NULL;
    
    if (lastImportDate == 0) {
        error = KErrNotFound;
        return QDateTime();
    }
    
    QDateTime retLastImportDate;
    retLastImportDate.setTime_t(lastImportDate);
    return retLastImportDate;
}

void CntSimUtility::setLastImportTime(int& error)
{
    error = KErrNone;
    if (!isSimInserted()) {
        error = KErrAccessDenied;
        return;
    }
    
    // get IMSI
    TBuf<KIMSISize> imsiBuf;
    TRequestStatus reqStatus;
    m_etelPhone.GetSubscriberId(reqStatus, imsiBuf);
    User::WaitForRequest(reqStatus);
    if (reqStatus.Int() != KErrNone) {
        error = reqStatus.Int();
        return;
    }
    
    CRepository* cenrep = NULL;
    TRAPD(err, cenrep = CRepository::NewL(TUid::Uid(KCenRepUid)));
    if (err != KErrNone) {
        error = err;
        return;
    }
     
    // find current IMSI in the stored values
    int lastImportDate = QDateTime::currentDateTime().toTime_t();
    bool importDateUpdated = false;
    for (int i = 1; i <= KCenRepKeysNumber; i+=2) {
        TBuf<KIMSISize> storedImsiBuf;
        if (cenrep->Get(i, storedImsiBuf) == KErrNone) {
            if (storedImsiBuf.Compare(imsiBuf) == 0) {
                //current IMSI already stored, update import date
                if (cenrep->Set(i+1, lastImportDate) != KErrNone) {
                    error = KErrAccessDenied;
                }
                importDateUpdated = true;
                break;
            }
        }
    }
    
    if (!importDateUpdated) {
        int oldestDate = 0;
        int key = 0;
        // contacts were not imported from this SIM before,
        // find oldest import date and replace it
        for (int j = 2; j <= KCenRepKeysNumber; j+=2) {
            int date;
            if (cenrep->Get(j, date) == KErrNone) {
                if (date >= oldestDate ) {
                    oldestDate = date;
                    key = j;
                }
            }
        }
    
        if (key == 0) {
            error = KErrAccessDenied;
        }
        else {
            if (cenrep->Set(key, lastImportDate) != KErrNone) {
                error = KErrAccessDenied;
            }
            if (cenrep->Set(key-1, imsiBuf) != KErrNone) {
                error = KErrAccessDenied;
            }
        }
    }
    
    delete cenrep;
    cenrep = NULL;
}

bool CntSimUtility::startGetSimInfo()
{
    if(m_asyncWorker->IsActive()) {
        return false;
    }
    
    m_etelStore.GetInfo(m_asyncWorker->iStatus, (TDes8&)m_etelStoreInfoPckg);
    m_asyncWorker->SetActive();
    m_activeRequest = EGetInfo;
    return true;
}

bool CntSimUtility::startGetAvailableStores()
{
    if(m_asyncWorker->IsActive()) {
        return false;
    }
    
    if (!isSimInserted()) {
        AvailableStores availableStores;
        emit availableStoresReady(availableStores, KErrNone);
        return true;
    }
    
    m_serviceTableType = RMobilePhone::ESIMServiceTable;
    unsigned long int iccCaps;
    TRequestStatus requestStatus;
    
    int result = m_etelPhone.GetIccAccessCaps(iccCaps);
    if (result == KErrNone && (iccCaps & RMobilePhone::KCapsUSimAccessSupported)) {
        m_serviceTableType = RMobilePhone::EUSIMServiceTable;
    }
    m_etelPhone.GetServiceTable(m_asyncWorker->iStatus, m_serviceTableType, m_serviceTablePckg);
    m_asyncWorker->SetActive();
    m_activeRequest = EGetAvailableStores;
    return true;
}

bool CntSimUtility::notifyAdnCacheStatus()
{
    if(m_asyncWorker->IsActive()) {
        return false;
    }
    CacheStatus cacheStatus;
    
    //check current cache status
    TRequestStatus requestStatus;
    RMmCustomAPI::TPndCacheStatus pndStatus;
    TName storeName;
    storeName.Copy(KETelIccAdnPhoneBook);
    m_customPhone.GetPndCacheStatus(requestStatus, pndStatus, storeName);
    User::WaitForRequest(requestStatus);
    if (requestStatus.Int() != KErrNone) {
        return false;
    }
    
    if (pndStatus == RMmCustomAPI::ECacheReady ||
        pndStatus == RMmCustomAPI::ECacheNotUsed) {
        cacheStatus = ECacheReady;
        emit adnCacheStatusReady(cacheStatus, KErrNone);
        return true;
        }
    else if (pndStatus == RMmCustomAPI::ECacheFailed) {
        cacheStatus = ECacheFailed;
        emit adnCacheStatusReady(cacheStatus, KErrNone);
        return true;    
        }
    else if (pndStatus == RMmCustomAPI::ECacheNotReady) {
        //wait for cache notification
        m_customPhone.NotifyPndCacheReady(m_asyncWorker->iStatus, m_etelStoreNameCached);
        m_asyncWorker->SetActive();
        m_activeRequest = EGetCacheStatus;
        return true;
    }
    else {
        return false;
    }
}

void CntSimUtility::RequestCompleted(int error)
{
    if (m_activeRequest == EGetInfo) {
        SimInfo results;
        if (error == KErrNone) {
            results.totalEntries = m_etelStoreInfo.iTotalEntries;
            results.usedEntries = m_etelStoreInfo.iUsedEntries;
            results.maxNumLength = m_etelStoreInfo.iMaxNumLength;
            results.maxTextLength = m_etelStoreInfo.iMaxTextLength;
            results.maxSecondNames = m_etelStoreInfo.iMaxSecondNames;
            results.maxTextLengthSecondName = m_etelStoreInfo.iMaxTextLengthSecondName;
            results.maxAdditionalNumbers = m_etelStoreInfo.iMaxAdditionalNumbers;
            results.maxNumLengthAdditionalNumber = m_etelStoreInfo.iMaxNumLengthAdditionalNumber;
            results.maxTextLengthAdditionalNumber = m_etelStoreInfo.iMaxTextLengthAdditionalNumber;
            results.maxGroupNames = m_etelStoreInfo.iMaxGroupNames;
            results.maxTextLengthGroupName = m_etelStoreInfo.iMaxTextLengthGroupName;
            results.maxEmailAddr = m_etelStoreInfo.iMaxEmailAddr;
            results.maxTextLengthEmailAddr = m_etelStoreInfo.iMaxTextLengthEmailAddr;
        }
        emit simInfoReady(results, error);
    }//EGetInfo
    else if (m_activeRequest == EGetAvailableStores) {
        AvailableStores availableStores;
        if (error == KErrNone) {
            //parse service table to find what stores are supported
            ParseServiceTable(&availableStores);
        }
        emit availableStoresReady(availableStores, error);
    }//EGetAvailableStores
    else if (m_activeRequest == EGetCacheStatus) {
        if ( m_etelStoreNameCached.Compare(KETelIccAdnPhoneBook) == 0) {
            //ADN cache is ready
            CacheStatus cacheStatus;
            if (error != KErrNone) {
                cacheStatus = ECacheFailed;
                emit adnCacheStatusReady(cacheStatus, error);
            }
            else {
                cacheStatus = ECacheReady;
                emit adnCacheStatusReady(cacheStatus, error);
            }
        }
        else {
            //another store is cached, continue listening for ADN cache
            notifyAdnCacheStatus();
        }
    }//EGetCacheStatus
    
    if (!m_asyncWorker->IsActive()) {
        m_activeRequest = ENoActiveRequest;
    }
}

void CntSimUtility::ParseServiceTable(AvailableStores* availableStores) const
{
    availableStores->SimPresent = true;
    if (m_serviceTableType == RMobilePhone::EUSIMServiceTable) {
        //ADN store is always present if SIM card is inserted
        availableStores->AdnStorePresent = true;
        
        if (m_serviceTable.iServices1To8 & RMobilePhone::KUstSDN ) {
            availableStores->SdnStorePresent = true;
        }
        else {
            availableStores->SdnStorePresent = false;
        }
        
        if (m_serviceTable.iServices1To8 & RMobilePhone::KUstFDN) {
            availableStores->FdnStorePresent = true;
        }
        else {
            availableStores->FdnStorePresent = false;
        }
        
        if (m_serviceTable.iServices17To24 & RMobilePhone::KUstMSISDN) {
            availableStores->OnStorePresent = true;
        }
        else {
            availableStores->OnStorePresent = false;
        }
    }
    else if (m_serviceTableType == RMobilePhone::ESIMServiceTable) {
        //ADN store is always present if SIM card is inserted
        availableStores->AdnStorePresent = true;
        
        if (m_serviceTable.iServices17To24 & RMobilePhone::KSstSDN) {
            availableStores->SdnStorePresent = true;
        }
        else {
            availableStores->SdnStorePresent = false;
        }
        
        if (m_serviceTable.iServices1To8 & RMobilePhone::KSstFDN) {
            availableStores->FdnStorePresent = true;
        }
        else {
            availableStores->FdnStorePresent = false;
        }
        
        if (m_serviceTable.iServices9To16 & RMobilePhone::KSstMSISDN) {
            availableStores->OnStorePresent = true;
        }
        else {
            availableStores->OnStorePresent = false;
        }
    }
}
    
bool CntSimUtility::isSimInserted() const
{
    bool result = false;
    
    RProperty property;   
    int simStatus = KErrNotFound;
    
    int ret = property.Get(KPSUidStartup, KPSSimStatus, simStatus);
    if (simStatus == ESimUsable && ret == KErrNone) {
        result = true;
        }
    
    property.Close();
    return result;
}