/*

* 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 <e32std.h>

#include <qstring.h>

#include <qlist.h>

#include <qstringlist.h>

#include <f32file.h>

#include <xqconversions.h>

#include <utf.h>

#include <bautils.h>

#include <sysutil.h>

#include "piprofilerengineprivate.h"

#include <piprofiler/ProfilerSession.h>

#include "pluginattributes.h"

#include "generalattributes.h"

#include "piprofilerengine.h"

// literals for default general setting values

_LIT8(KTraceOutput, "file_system");

_LIT8(KTraceDebugOutput, "debug_output");

_LIT8(KProfilerDefaultDrive, "E:\\data");

_LIT8(KProfilerDefaultPrefix, "Profiler_#");

_LIT(KProfilerEngineExe, "PIProfilerEngine.exe");

const TInt KProfilerDefaultTimedSamplingPeriod = 60; // Sampling time in seconds  

// ---------------------------------------------------------------------------

PIProfilerEnginePrivate::PIProfilerEnginePrivate(PIProfilerEngine *aEngine) :

    iPublic(aEngine), iSamplerAttributes(0), iStatusChecker(0), iLeaveProfilingOnAfterClosing(

        EFalse)

{

}

// ---------------------------------------------------------------------------

PIProfilerEnginePrivate::~PIProfilerEnginePrivate()

{

    // remove profiler client

    RProfiler::RemoveClient();

    // Terminate engine in case it is running.

    if (iLeaveProfilingOnAfterClosing == EFalse) {

        terminateEngine();

    }

    // delete sampler attributes.

    if (iSamplerAttributes) {

        delete iSamplerAttributes;

        iSamplerAttributes = 0;

    }

    if (iStatusChecker) {

        iStatusChecker->Cancel();

        delete iStatusChecker;

        iStatusChecker = NULL;

    }

}

// ---------------------------------------------------------------------------

bool PIProfilerEnginePrivate::Init()

{

    TRAPD(error, this->LaunchEngineL());

    if (error != KErrNone) {

        return false;

    }

    // initialize attribute arrays

    TRAP(error, iSamplerAttributes = new (ELeave) CArrayFixFlat<TSamplerAttributes> (20)); // max sampler count is 20

    if (error != KErrNone) {

        return false;

    }

    // engine status checker

    TRAP(error, iStatusChecker = CProfilerEngineStatusChecker::NewL());

    if (error != KErrNone) {

        return false;

    }    

    iStatusChecker->SetObserver(this);

    TRAP(error, LoadGeneralSettingsL());

    if (error != KErrNone) {

        return false;

    }

    return true;

}

// ---------------------------------------------------------------------------

int PIProfilerEnginePrivate::LaunchEngineL()

{

    TRequestStatus stat = KRequestPending;

    RProcess proc;

    TInt err(KErrNone);

    // check if process exists

    err = FindProcessL(proc);

    // check if already exists and don't start a new eshell profiling

    if (err == KErrNotFound) {

        // try create new process

        err = proc.Create(KProfilerEngineExe, _L(""));

        // check if RProcess::Create() succeeded

        if (err == KErrNone) {

            // Trigger rendezvous on the supplied TRequestStatus object

            proc.Rendezvous(stat);

            // kick off the engine process

            proc.Resume();

            // wait for the constructor to complete 

            User::WaitForRequest(stat);

            // just lose the handle

            proc.Close();

        }

    }

    // Increase the client reference count in server:

    AttachClient();

}

// ---------------------------------------------------------------------------

void PIProfilerEnginePrivate::AttachClient()

{

    RProfiler::AttachClient();

}

// ---------------------------------------------------------------------------

int PIProfilerEnginePrivate::FindProcessL(RProcess& aProc)

{

    TProcessId engId;

    TFindProcess procName;

    procName.Find(_L("PIProfilerEngine.exe*"));

    TFullName aResult;

    TFullName aResult2;

    TInt err(KErrNone);

    // find the first appearance

    err = procName.Next(aResult);

    if (err != KErrNone) {

        // did not find any engine process

        return err;

    }

    else {

        err = aProc.Open(procName);

        if (err == KErrNone) {

            if (aProc.ExitCategory().Length() > 0) {

                aProc.Close();

                // process already exited => create a new one

                return KErrNotFound;

            }

            aProc.Close();

        }

    }

    // check now if a second appearance exists in process list, 

    // i.e. engine started from eshell => two engine processes appear in normal case

    procName.Next(aResult2);

    // check if aResult2 contained the second appearance of profiler engine

    if(aResult2.CompareF(aResult) > 0)

        {

        // other process found, i.e. right process to communicate with, in case started from eshell

        err = aProc.Open(procName);

        if(err == KErrNone)

            {

            if(aProc.ExitCategory().Length() > 0)

                {

                // process already exited => create a new one

                return KErrNotFound;

                }

            aProc.Close();

            }

        }

    return err;

}

// ---------------------------------------------------------------------------

void PIProfilerEnginePrivate::terminateEngine()

{

    // exit profiler engine 

    RProfiler::ExitProfiler();

}

// ---------------------------------------------------------------------------

void PIProfilerEnginePrivate::NotifyUIReady()

{

    // load initial plugins

    loadPlugins();

    // get the initial state

    int initialState = iStatusChecker->GetInitialState();

    if (initialState == ERunning) {

        HandleProfilerStatusChange(ERunning);

    }

}

// ---------------------------------------------------------------------------

void PIProfilerEnginePrivate::loadPlugins()

{

    // get samplers from Profiler Engine (client-server session) 

    // and add the to the samplers list for the first time

    LOGTEXT(_L("CProfilerGuiModel::LoadPlugins - get sampler plugins"));

    TInt err = RProfiler::GetSamplerAttributes(*iSamplerAttributes);

    // check if engine provided a list of samplers

    if (err != KErrNone) {

        // could not get samplers from engine

        LOGTEXT(_L("CProfilerGuiModel::LoadPlugins - failed to connect engine"));

    }

    else {

        LOGTEXT(_L("CProfilerGuiModel::LoadPlugins - adding new samplers into view"));

        addNewSamplers(*iSamplerAttributes);

    }LOGTEXT(_L("CProfilerGuiModel::LoadPlugins - exit"));

}

// ---------------------------------------------------------------------------

void PIProfilerEnginePrivate::addNewSamplers(CArrayFixFlat<TSamplerAttributes>& aAttributes)

{

    TSamplerAttributes item;

    TInt count(aAttributes.Count());

    // loop the attribute array and insert them into view list

    QList<PluginAttributes> samplerList;

    for (TInt i(0); i < count; i++) {

        // get a TSamplerAttributes from list at a time  

        item = aAttributes.At(i);

        PluginAttributes samplerAttributes;

        convertTSamplerAttributesToPluginAttributes(item, samplerAttributes);

        samplerList.append(samplerAttributes);

    }

    emit iPublic->pluginListUpdated(samplerList);

}

// ---------------------------------------------------------------------------

void PIProfilerEnginePrivate::convertTSamplerAttributesToPluginAttributes(

    TSamplerAttributes &tSamplerAttributes, PluginAttributes &samplerAttributes)

{

    samplerAttributes.mUid = tSamplerAttributes.iUid;

    samplerAttributes.mSampleRate = tSamplerAttributes.iSampleRate;

    samplerAttributes.mEnabled = tSamplerAttributes.iEnabled;

    samplerAttributes.mIsHidden = tSamplerAttributes.iIsHidden;

    samplerAttributes.mItemCount = tSamplerAttributes.iItemCount;

    TBuf16<8> temp8;

    temp8.Copy(tSamplerAttributes.iShortName);

    samplerAttributes.mShortName = QString((QChar*) temp8.Ptr(), temp8.Length());

    TBuf16<64> temp64;

    temp64.Copy(tSamplerAttributes.iName);

    samplerAttributes.mName = QString((QChar*) temp64.Ptr(), temp64.Length());

    TBuf16<256> temp256;

    temp256.Copy(tSamplerAttributes.iDescription);

    samplerAttributes.mDescription = QString((QChar*) temp256.Ptr(), temp256.Length());

    convertTSettingItemToSettingItem(tSamplerAttributes.iSettingItem1,

        samplerAttributes.mSettingItem1);

    convertTSettingItemToSettingItem(tSamplerAttributes.iSettingItem2,

        samplerAttributes.mSettingItem2);

    convertTSettingItemToSettingItem(tSamplerAttributes.iSettingItem3,

        samplerAttributes.mSettingItem3);

    convertTSettingItemToSettingItem(tSamplerAttributes.iSettingItem4,

        samplerAttributes.mSettingItem4);

    convertTSettingItemToSettingItem(tSamplerAttributes.iSettingItem5,

        samplerAttributes.mSettingItem5);

    convertTSettingItemToSettingItem(tSamplerAttributes.iSettingItem6,

        samplerAttributes.mSettingItem6);

}

// ---------------------------------------------------------------------------

bool PIProfilerEnginePrivate::SavePluginSettings(const PluginAttributes &samplerAttributes)

{

    for (int index = 0; index < iSamplerAttributes->Count(); index++) {

        if (samplerAttributes.mUid == this->iSamplerAttributes->At(index).iUid) {

            iSamplerAttributes->At(index).iEnabled = samplerAttributes.mEnabled;

            iSamplerAttributes->At(index).iSampleRate = samplerAttributes.mSampleRate;

            convertSettingItemToTSettingItem(this->iSamplerAttributes->At(index).iSettingItem1,

                samplerAttributes.mSettingItem1);

            convertSettingItemToTSettingItem(this->iSamplerAttributes->At(index).iSettingItem2,

                samplerAttributes.mSettingItem2);

            convertSettingItemToTSettingItem(this->iSamplerAttributes->At(index).iSettingItem3,

                samplerAttributes.mSettingItem3);

            convertSettingItemToTSettingItem(this->iSamplerAttributes->At(index).iSettingItem4,

                samplerAttributes.mSettingItem4);

            convertSettingItemToTSettingItem(this->iSamplerAttributes->At(index).iSettingItem5,

                samplerAttributes.mSettingItem5);

            convertSettingItemToTSettingItem(this->iSamplerAttributes->At(index).iSettingItem6,

                samplerAttributes.mSettingItem6);

            TSamplerAttributes attr = iSamplerAttributes->At(index);

            if (RProfiler::SetSamplerAttributes(this->iSamplerAttributes->At(index)) == KErrNone) {

                return true;

            }

            else {

                return false;

            }

        }

    }

    return false;

}

// ---------------------------------------------------------------------------

void PIProfilerEnginePrivate::StartAllSamplerItemsL(TProfilingMode aProfilingMode)

{

    TBuf<256> activeWriterDes;

    TBuf8<256> writer8;

    //iState = MProfilerStatusObserver::EInitializing;

    RProfiler::TProfilingMode profilingMode = aProfilingMode == EProfilingModeTimed

        ? RProfiler::EProfilingModeTimed : RProfiler::EProfilingModeNormal;

    // try to start profiling process through client-server interface

    if (RProfiler::StartSampling(profilingMode) == KErrNotFound) {

        // profiler stopped (e.g. from eshell) and must be restarted 

        LaunchEngineL();

        // try to launch sampling again

        RProfiler::StartSampling(profilingMode);

    }

}

// ---------------------------------------------------------------------------

// --------------------------------------------------------------------------------------------

void PIProfilerEnginePrivate::StopProfiling()

{

    // Stop profiling process through CS session

    RProfiler::StopSampling();

}

// --------------------------------------------------------------------------------------------

void PIProfilerEnginePrivate::HandleProfilerStatusChange(KProfilerStatus aStatus)

{

    if (aStatus == EIdle || aStatus == ERunning) {

        if (iGeneralAttributes.iTraceOutput == KTraceOutput) {

            TBuf<256> buf;

            // get profiler file name 

            TBool valu = RProfiler::GetFileName(buf);

            QString filename = QString((QChar*) buf.Ptr(), buf.Length());

            // Let ui know that status has changed

            if (aStatus == EIdle) {

                QString text = QString("Wrote trace data to: \n");

                text.append(filename);

                emit iPublic->profilingStatusChanged(PI_FINISHED_SUCCEFULLY, text,

                    PI_PROFILINGMODENORMAL, PI_FILE_OUTPUT);

            }

            else if (aStatus == ERunning) {

                QString text = QString("Writing trace data to: \n");

                text.append(filename);

                emit iPublic->profilingStatusChanged(PI_PROFILING, text, PI_PROFILINGMODENORMAL,

                    PI_FILE_OUTPUT);

            }

        }

        else {

            // Let ui know that status has changed

            if (aStatus == EIdle) {

                emit iPublic->profilingStatusChanged(PI_FINISHED_SUCCEFULLY, QString(

                    "Wrote trace data to debug output"), PI_PROFILINGMODENORMAL, PI_DEBUG_OUTPUT);

            }

            else if (aStatus == ERunning) {

                emit iPublic->profilingStatusChanged(PI_PROFILING, QString(

                    "Writing trace data to debug output"), PI_PROFILINGMODENORMAL, PI_DEBUG_OUTPUT);

            }

        }

    }

}

// ---------------------------------------------------------------------------

void PIProfilerEnginePrivate::HandleProfilerErrorL(TInt aError)

{

    {

        QString errorMsg = QString("Error: ");

        QString KNoMemory = QString("Cannot write to file, check settings");

        // message from pwr sampler

        if (aError < -1000) {

            errorMsg.append(QString("Stop other power measurement tools!"));

        }

        else if (aError == KErrAlreadyExists || aError == 11) {

            errorMsg.append(QString("Close old Profiler before start!"));

        }

        else if (aError == KErrNotReady) {

            errorMsg.append(QString("Memory card removed, failed to write!"));

        }

        else if (aError == KErrPathNotFound) {

            errorMsg.append(QString("Given trace data location does not exist"));

        }

        else {

            if (aError == KErrNoMemory || aError == KErrOverflow || aError == KErrDirFull || aError

                == KErrDiskFull || aError == KErrNotReady) {

                errorMsg.append(KNoMemory);

            }

            else {

                errorMsg.append(QString("code: "));

                errorMsg.append(aError);

            }

        }

        emit iPublic->profilingStatusChanged(PI_ERROR, errorMsg);

    }

}

// ---------------------------------------------------------------------------

bool PIProfilerEnginePrivate::StartProfiling()

{

    TRAPD(error, this->StartAllSamplerItemsL(PIProfilerEnginePrivate::EProfilingModeNormal));

    if (error == KErrNone) {

        return true;

    }

    return false;

}

// ---------------------------------------------------------------------------

bool PIProfilerEnginePrivate::StartTimedProfiling()

{

    TRAPD(error, this->StartAllSamplerItemsL(PIProfilerEnginePrivate::EProfilingModeTimed));

    if (error == KErrNone) {

        return true;

    }

    return false;

}

// ---------------------------------------------------------------------------

void PIProfilerEnginePrivate::convertTGeneralAttributesToGeneralAttributes(

    TGeneralAttributes &tSamplerAttributes, GeneralAttributes &samplerAttributes)

{

    samplerAttributes.mTimedSamplingPeriod = tSamplerAttributes.iTimedSamplingPeriod;

    int test = tSamplerAttributes.iSaveFileDrive.Length();

    TBuf16<KPrefixMaxLength> test2;

    test2.Copy(tSamplerAttributes.iSaveFileDrive);

    samplerAttributes.mSaveFileDrive = QString((QChar*) test2.Ptr(), test2.Length());

    test2.Copy(tSamplerAttributes.iTraceFilePrefix);

    samplerAttributes.mTraceFilePrefix = QString((QChar*) test2.Ptr(), test2.Length());

    test2.Copy(tSamplerAttributes.iTraceOutput);

    samplerAttributes.mTraceOutput = QString((QChar*) test2.Ptr(), test2.Length());

}

// ---------------------------------------------------------------------------

void PIProfilerEnginePrivate::convertGeneralAttributesToTGeneralAttributes(

    TGeneralAttributes &tSamplerAttributes, GeneralAttributes &samplerAttributes)

{

    tSamplerAttributes.iTimedSamplingPeriod = samplerAttributes.mTimedSamplingPeriod;

    tSamplerAttributes.iTraceOutput.Copy(TBuf<KPrefixMaxLength> (

        samplerAttributes.mTraceOutput.utf16()));

    tSamplerAttributes.iSaveFileDrive.Copy(TBuf<KPrefixMaxLength> (

        samplerAttributes.mSaveFileDrive.utf16()));

    tSamplerAttributes.iTraceFilePrefix.Copy(TBuf<KPrefixMaxLength> (

        samplerAttributes.mTraceFilePrefix.utf16()));

}

// ---------------------------------------------------------------------------

TInt PIProfilerEnginePrivate::LoadGeneralSettingsL()

{

    // local variable for getting saved settings from profiler engine

    TGeneralAttributes generalAttr;

    TInt err(KErrNone);

    // before loading saved settings (from settings file) set the default values 

    iGeneralAttributes.iTraceOutput.Copy(KTraceOutput);

    iGeneralAttributes.iTraceFilePrefix.Copy(KProfilerDefaultPrefix);

    iGeneralAttributes.iSaveFileDrive.Copy(KProfilerDefaultDrive);

    iGeneralAttributes.iTimedSamplingPeriod = KProfilerDefaultTimedSamplingPeriod;

    // request to 

    err = RProfiler::GetGeneralAttributes(generalAttr);

    // check that request succesfull

    if (err != KErrNone) {