/*
* Copyright (c) 2009-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:  Qt wrapper class implementation for CIRReportGenerator
*
*/

#include "irsessionlogger.h" // CIRReportGenerator

#include "irqstatisticsreporter.h"
#include "irqnetworkcontroller.h"
#include "irqreportsender.h"

//Network Indicator
_LIT(KGPRS,"gprs");
_LIT(KWCDMA,"wcdma");
_LIT(KWLAN,"wlan");
_LIT(KCDMA2000,"cdma2000");
_LIT(KEDGE,"edge");

//Music Shop Type
_LIT(KFind,"find");
_LIT(KLaunch,"launch");

// ---------------------------------------------------------------------------
// IRQStatisticsReporter::openInstance()
// Static function to get a singleton instance of IRQStatisticsReporter
// ---------------------------------------------------------------------------
//
EXPORT_C IRQStatisticsReporter* IRQStatisticsReporter::openInstance(IRQIsdsClient *aIsdsClient)
{
    // Get singleton instance
    IRQStatisticsReporter* reportGenerator =
                           reinterpret_cast<IRQStatisticsReporter*>(Dll::Tls());

    if (NULL == reportGenerator)
    {
        TRAPD(error, reportGenerator = createInstanceL(aIsdsClient));
        if (KErrNone != error)
        {
            delete reportGenerator;
            reportGenerator = NULL;
            Dll::SetTls(NULL);
        }
    }
    else
    {
        reportGenerator->iSingletonInstances++;
    }

    return reportGenerator;
}

// ---------------------------------------------------------------------------
// IRQStatisticsReporter::closeInstance()
// Close a singleton instance of IRQStatisticsReporter
// ---------------------------------------------------------------------------
//
EXPORT_C void IRQStatisticsReporter::closeInstance()
{
    iSingletonInstances--;

    if (0 == iSingletonInstances)
    {
        Dll::SetTls(NULL);
        delete this;
    }
}

// ---------------------------------------------------------------------------
// IRQStatisticsReporter::IRQStatisticsReporter()
// Creates IRQStatisticsReporter instance
// ---------------------------------------------------------------------------
//
IRQStatisticsReporter* IRQStatisticsReporter::createInstanceL(IRQIsdsClient *aIsdsClient)
{
    IRQStatisticsReporter* reportGenerator = new (ELeave) IRQStatisticsReporter();
    reportGenerator->constructL(aIsdsClient);
    User::LeaveIfError(Dll::SetTls(reportGenerator));
    reportGenerator->iSingletonInstances = 1;

    return reportGenerator;
}

// ---------------------------------------------------------------------------
// IRQStatisticsReporter::IRQStatisticsReporter()
// Constructor.
// ---------------------------------------------------------------------------
//
IRQStatisticsReporter::IRQStatisticsReporter():iBody(NULL),
                                               iSender(NULL),
                                               iNetworkController(NULL),
                                               iCurrentNetwork(0),
                                               iHomeOperator(0),
                                               iSingletonInstances(0)
{

}

// ---------------------------------------------------------------------------
// IRQStatisticsReporter::constructL()
// Two-Phase Constructor.
// ---------------------------------------------------------------------------
//
void IRQStatisticsReporter::constructL(IRQIsdsClient *aIsdsClient)
{
    iBody = CIRReportGenerator::OpenL();

    iNetworkController = IRQNetworkController::openInstance();

    iSender = new IRQReportSender(aIsdsClient);

    if(iBody && iSender)
    {
        iBody->SetDbStatusObserser(iSender);
    }

    connect(iSender, SIGNAL(reportSent()), this, SLOT(reportSent()));
}

// ---------------------------------------------------------------------------
// IRQStatisticsReporter::~IRQStatisticsReporter()
// Destructor.
// ---------------------------------------------------------------------------
//
IRQStatisticsReporter::~IRQStatisticsReporter()
{
    if(iBody)
    {
        iBody->SetDbStatusObserser(NULL);
        iBody->Close();
    }

    if(iNetworkController)
    {
        iNetworkController->closeInstance();
    }

    delete iSender;
    iSender = NULL;
}

// ---------------------------------------------------------------------------
// IRQStatisticsReporter::sessionStarted()
// starts a new session
// ---------------------------------------------------------------------------
//
EXPORT_C bool IRQStatisticsReporter::sessionStarted(const int aChanneldId, const IRQConnectedFrom aConnectedFrom)
{
    if(iBody)
    {
    	updateConnectedFrom(aConnectedFrom);
        iBody->UpdateChannelID(aChanneldId);
        updateConnectionType();

        TRAPD(error,iBody->SessionStartedL());
        if(error)
        {
            return false;
        }
        else
        {
            return true;
        }
    }
    return false;
}

// ---------------------------------------------------------------------------
// IRQStatisticsReporter::markSessionStart()
// marks the start of a session
// ---------------------------------------------------------------------------
//
EXPORT_C void IRQStatisticsReporter::markSessionStart()
{
    if(iBody)
    {
        iBody->MarkSessionStart();
    }
}

// ---------------------------------------------------------------------------
// IRQStatisticsReporter::suspendSession()
// function handle session suspend
// ---------------------------------------------------------------------------
//
EXPORT_C void IRQStatisticsReporter::suspendSession()
{
    if(iBody)
    {
        iBody->HandleStopEvents(EFalse);
    }
}

// ---------------------------------------------------------------------------
// IRQStatisticsReporter::restartSession()
// function handle session restart
// ---------------------------------------------------------------------------
//
EXPORT_C void IRQStatisticsReporter::restartSession()
{
    if(iBody)
    {
        iBody->HandleStopEvents(ETrue);
    }
}

// ---------------------------------------------------------------------------
// IRQStatisticsReporter::sessionEnded()
// ends the session
// ---------------------------------------------------------------------------
//
EXPORT_C void IRQStatisticsReporter::sessionEnded(const IRQTerminatedType aTerminatedBy)
{
    if(iBody)
    {
        updateTerminatedBy(aTerminatedBy);
        TRAP_IGNORE(iBody->SessionEndL(EFalse));
    }
}

// ---------------------------------------------------------------------------
// IRQStatisticsReporter::logServerResult()
// logs server connection result
// ---------------------------------------------------------------------------
//
EXPORT_C void IRQStatisticsReporter::logServerResult(const QString& aUrl, const IRQError aServerResult)
{
    if(iBody)
    {
        TPtrC url(reinterpret_cast<const TUint16*>(aUrl.utf16()));
        switch(aServerResult)
        {
            case EIRQErrorNone:
                iBody->LogServerResult(url,EIRConnected);
                break;
            case EIRQPlayerErrorServerFull:
                iBody->LogServerResult(url,EIRFull);
                break;
            case EIRQPlayerErrorTimeOut:
                iBody->LogServerResult(url,EIRConnTimeOut);
                break;
            case EIRQPlayerErrorConnectingFailed:
                iBody->LogServerResult(url,EIRConnFailed);
                break;
            default:
                break;
        }
    }
}

// ---------------------------------------------------------------------------
// IRQStatisticsReporter::logNmsEvents()
// logs nmsEvents to Xml file
// ---------------------------------------------------------------------------
//
EXPORT_C void IRQStatisticsReporter::logNmsEvent(const IRQNmsType aNmsType, const int aChanneldId)
{
    TRAP_IGNORE(doLogNmsEventL(aNmsType,aChanneldId));
}

// ---------------------------------------------------------------------------
// IRQStatisticsReporter::doLogNmsEventsL()
// logs nmsEvents to Xml file
// ---------------------------------------------------------------------------
//
void IRQStatisticsReporter::doLogNmsEventL(const IRQNmsType aNmsType, const int aChanneldId)
{
    if(iBody)
    {
    	updateNmsType(aNmsType);
        iBody->UpdateNmsChannelID(aChanneldId);
        iBody->NmsLogStartedL();
        iBody->WriteNmsLogtoXmlL();
    }
}

// ---------------------------------------------------------------------------
// IRQStatisticsReporter::logSongRecogEvent()
// logs songRecog event to Xml file 
// ---------------------------------------------------------------------------
//
EXPORT_C void IRQStatisticsReporter::logSongRecogEvent()
{
    if(iBody)
    {
        iBody->LogSongRecog();
    }
}

// ---------------------------------------------------------------------------
// IRQStatisticsReporter::updateCurrentNetwork()
// updates the current network
// ---------------------------------------------------------------------------
//
EXPORT_C void IRQStatisticsReporter::updateCurrentNetwork(const QString &aCurrentNwkMCC, const QString &aCurrentNwkMNC)
{
    QString nwkCode = aCurrentNwkMCC + aCurrentNwkMNC;
    iCurrentNetwork = nwkCode.toInt();
    iBody->UpdateCurrentNetwork(iCurrentNetwork);
    iBody->UpdateCurrentBrowseNetwork(iCurrentNetwork);
    iBody->UpdateNmsCurrentNetwork(iCurrentNetwork);    
}

// ---------------------------------------------------------------------------
// IRQStatisticsReporter::updateHomeOperator()
// updates the home network
// ---------------------------------------------------------------------------
//
EXPORT_C void IRQStatisticsReporter::updateHomeOperator(const QString &aHomeNetworkMCC, const QString &aHomeNetworkMNC)
{
    QString nwkCode = aHomeNetworkMCC + aHomeNetworkMNC;
    iHomeOperator = nwkCode.toInt();
    iBody->UpdateHomeOperator(iHomeOperator);
    iBody->UpdateNmsHomeOperator(iHomeOperator);    
}

// ---------------------------------------------------------------------------
// IRQStatisticsReporter::reportSent()
// should be called after report is sent to isds server
// ---------------------------------------------------------------------------
//
void IRQStatisticsReporter::reportSent()
{
    if(iBody)
    {
        iBody->ReportSent();
    }
}

// ---------------------------------------------------------------------------
// IRQStatisticsReporter::updateTerminatedBy()
// updates the termination status
// ---------------------------------------------------------------------------
//
void IRQStatisticsReporter::updateTerminatedBy(const IRQTerminatedType aTerminatedBy)
{
    if(iBody)
    {
        switch(aTerminatedBy)
        {
            case EIRQUserTerminated:
                iBody->UpdateTerminatedBy(EUserTerminated);
                break;
            case EIRQNoConnectionToServer:
                iBody->UpdateTerminatedBy(ENoConnectionToServer);
                break;
            case EIRQNoConnectionToNetwork:
                iBody->UpdateTerminatedBy(ENoConnectionToNetwork);
                break;
            default:
                // do NOT cover all cases
                iBody->UpdateTerminatedBy(EUserTerminated);
                break;
        }
    }
}

// ---------------------------------------------------------------------------
// IRQStatisticsReporter::updateConnectedFrom()
// updateds connected information
// ---------------------------------------------------------------------------
//
void IRQStatisticsReporter::updateConnectedFrom(const IRQConnectedFrom aConnectedFrom)
{
    if(iBody)
    {
        switch(aConnectedFrom)
        {
            case EIRQIsds:
                iBody->UpdateConnectedFrom(EIRIsds);
                break;
            case EIRQPresetAdhoc:
                iBody->UpdateConnectedFrom(EIRPresetAdhoc);
                break;
            case EIRQPresetIsds:
                iBody->UpdateConnectedFrom(EIRPresetIsds);
                break;
            case EIRQHistoryAdhoc:
                iBody->UpdateConnectedFrom(EIRHistoryAdhoc);
                break;
            case EIRQHistoryIsds:
                iBody->UpdateConnectedFrom(EIRHistoryIsds);
                break;
            case EIRQAdhocManual:
                iBody->UpdateConnectedFrom(EIRAdhocManual);
                break;
            case EIRQAdhocExternal:
                iBody->UpdateConnectedFrom(EIRAdhocExternal);
                break;                                
            default:
                break;
        }
    }
}

// ---------------------------------------------------------------------------
// IRQStatisticsReporter::updateConnectionType()
// updates the connection type
// ---------------------------------------------------------------------------
//
void IRQStatisticsReporter::updateConnectionType()
{
    if(iBody && iNetworkController)
    {
        IRQConnectionType connectionType = iNetworkController->identifyConnectionType();
        switch(connectionType)
        {
            case EIRQGprs:
                iBody->UpdateConnectionType(KGPRS);
                break;
            case EIRQWcdma:
                iBody->UpdateConnectionType(KWCDMA);
                break;
            case EIRQCdma2000:
                iBody->UpdateConnectionType(KCDMA2000);
                break;                
            case EIRQWiFi:
                iBody->UpdateConnectionType(KWLAN);
                break;
            case EIRQEdge:
                iBody->UpdateConnectionType(KEDGE);
                break;
            default:
                // do NOT cover all cases
                iBody->UpdateConnectionType(KNullDesC);
                break;
        }
    }
}

// ---------------------------------------------------------------------------
// IRQStatisticsReporter::updateNmsType()
// updates the nokia music shop access type
// ---------------------------------------------------------------------------
//
void IRQStatisticsReporter::updateNmsType(const IRQNmsType aNmsType)
{
    if(iBody)
    {
        switch(aNmsType)
        {
            case EIRQFind:
                iBody->UpdateNmsType(KFind);
                break;
            case EIRQLaunch:
                iBody->UpdateNmsType(KLaunch);
                break;
            default:
                break;
        }
    }
}