/*
* 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:
*
*/

#ifndef _LCF_SBU_COMMON_DEFINITIONS_H_
#define _LCF_SBU_COMMON_DEFINITIONS_H_

///////////////////////////////////////////////////////
//
// SBu Common Definitions
//
///////////////////////////////////////////////////////

/** 
    $File: LcfSBuCommonDefitions.h
    $Author: burnevsk $
    $Date: 2004/10/18 08:14:23 $
    $Revision: 1.6 $
*/

///////////////////////////////////////////////////////
//
// Constants
//
///////////////////////////////////////////////////////


#include <e32def.h>
#include <e32std.h>
#include <e32err.h>

#define DEF_LCFPSY1_MODULEID        0x03133002
#define DEF_LCFPSY2_MODULEID        0x03133004
#define DEF_LCFPSY3_MODULEID        0x03133006
#define DEF_LCFPSYSLOW4_MODULEID    0x03133008
#define DEF_LCFPSY6_MODULEID        0x0313300c

const TInt KLcfPsy1UidValue = DEF_LCFPSY1_MODULEID;
const TInt KLcfPsy3UidValue = DEF_LCFPSY3_MODULEID;
const TInt KLcfPsy6UidValue = DEF_LCFPSY6_MODULEID;

const TInt KSecondsToMicro = 1000*1000;

// Show service formt
_LIT(KShowServiceFormat, "Name: %S \nType: %d \n  Id: %S");

// time value formatting
_LIT(KTimeSpec, "%H:%T:%S:%C");

// default requestors
_LIT(KServiceName, "Lcf.Service");
_LIT(KServiceId, "Lcf.ServiceId");

_LIT(KContactName, "Lcf.Contact");
_LIT(KPhone, "+79217654321");

_LIT(KFieldNamePhone, "Phone");
_LIT(KFieldNameEmail, "Email");
_LIT(KFieldNameUrl, "Url");

///////////////////////////////////////////////////////
//
// Other text
//
///////////////////////////////////////////////////////

// Indicate not yet implemented
_LIT(KNotImplemented, "Not yet implemented");   

//_LIT(KBadRequestResult, "Wrong location request result (result=%d, expected=%d)");
//_LIT(KBadDiagNum, "Wrong number of events in Notifier (count=%d, expected=%d)");
//_LIT(KBadLcfResult, "Wrong notifier event result (result=%d, expected=%d)");

_LIT(KBadDiagVerifEventNum, "Wrong number of Verification events in Notifier");
_LIT(KBadDiagNotifEventNum, "Wrong number of Notification events in Notifier");

///////////////////////////////////////////////////////
//
// Here are macros for error logging 
// Those imply that are called from within of 
// CUtfwTestBase-derived class's function (they use iLog member)
//
///////////////////////////////////////////////////////

// LEAVES with _error_ if _condition_ is true
#define LEAVE(condition, error)             \
    if (condition) {                        \
        errStr.Format(_L("%s (line %d)"), _S(error), __LINE__);    \
        iLog->Log(errStr);			\
        User::Leave(KErrGeneral);           	\
    }

// if _error_ is descritor
#define LEAVE_DES(condition, error_des)     \
    if (condition) {                        \
        errStr.Format(_L("%S (line %d)"), &error_des, __LINE__);    \
        iLog->Log(errStr);					\
        User::Leave(KErrGeneral);            \
    }

// Must be included in the begging of function definition
// in order to use following ("ERROR") macros
// (The string buffer needs to be defined once, otherwise,
// in case when a lot of errors are checked, stack may be
// overflown, and copilation will fail)
#define DECLARE_ERROR_STR                   TBuf<160> errStr;
#define DECLARE_MESSAGE_STR                 TBuf<160> message;

#define DECLARE_ERROR_LOGGING               DECLARE_ERROR_STR   DECLARE_MESSAGE_STR

#define START_ERROR_LOGGING                 iErrorCounter = 0;

// Logs a message, which is defined as "..." constant
#define LOG(msg)                            \
    {                                       \
        errStr.Format(_L("%s (line %d)"), _S(msg), __LINE__);    \
        iLog->Log(errStr);                  \
    }
#define LOG_DES(msg_des)                    \
    {                                       \
        errStr.Format(_L("%S (line %d)"), &msg_des, __LINE__);    \
        iLog->Log(errStr);                  \
    }
    
#define LOG_FORMAT_1(_format, _param)       \
    message.Format(_format, _param);        \
    LOG_DES(message);
    
#define LOG_FORMAT_2(_format, _param1, _param2)       \
    message.Format(_format, _param, _param2);         \
    LOG_DES(message);

#define LOG_IIF(condition, msg1, msg2)      \
    if (condition) LOG(msg1) else LOG(msg2)

// Logs an error, which is defined as "..." constant
#define ERR(error)                          \
    {                                       \
        errStr.Format(_L("%s (line %d)"), _S(error), __LINE__);    \
        iLog->Log(errStr);             \
        iErrorCounter++;                    \
    }
#define ERR_DES(error)                      \
    {                                       \
        errStr.Format(_L("%S (line %d)"), &error, __LINE__);    \
        iLog->Log(errStr);             \
        iErrorCounter++;                    \
    }

// Logs an _error_ if _condition_ is true
#define ERROR(condition, error)             \
    if (condition) ERR(error)

// Logs an error, which defined as descriptor
#define ERROR_DES(condition, error_des)     \
    if (condition) ERR_DES(error_des)

#define ERROR_1(condition, msg_fmt_des, param1)  \
    message.Format(msg_fmt_des, param1);        \
    ERROR_DES(condition, message);

#define ERROR_2(condition, msg_fmt_des, param1, param2)  \
    message.Format(msg_fmt_des, param1, param2);        \
    ERROR_DES(condition, message);

#define ERROR_3(condition, msg_fmt_des, param1, param2, param3) \
    message.Format(msg_fmt_des, param1, param2, param3);        \
    ERROR_DES(condition, message);

#define IF_ERROR(error_code, msg)                               \
    { TInt32 _err = error_code;                                 \
    ERROR_2(_err != KErrNone, _L("%s (error=%d)"), _S(msg), _err); }

#define IF_ERROR_DES(error_code, msg_des)                       \
    { TInt32 _err = error_code;                                 \
    ERROR_2(_err != KErrNone, _L("%S (error=%d)"), &msg_des, _err); }

#define CHECK_EQUAL(_actual, _expected, _msg)                     \
    ERROR_3(_actual != _expected, _L("%s (actual=%d, expected=%d)"), _S(_msg), _actual, _expected);

#define CHECK_EQUAL_DES(_actual, _expected, _msg_des)           \
    ERROR_3(_actual != _expected, _L("%S (actual=%d, expected=%d)"), &_msg_des, _actual, _expected);

// Leaves if there were errors generated by ERROR macros
// (put it at the end of you test function)
#define LEAVE_IF_ERRORS()               \
    if (iErrorCounter > 0) {             \
        errStr.Format(_L("There were %d errors in the test, see previous messages!"), iErrorCounter);    \
        iLog->Log(errStr); \
          User::Leave(KErrGeneral);  \
    }

#define PAUSE_MS(_microseconds)                                 \
    User::After(TTimeIntervalMicroSeconds32(_microseconds));
#define PAUSE(_seconds)                                         \
    PAUSE_MS(_seconds * KSecondsToMicro)

class TWatch 
{
    public:
        TWatch() { RestartWatch(); };
        void RestartWatch() { iTime.UniversalTime(); iLastTick = iTime; };
        void Tick() { iLastTick.UniversalTime(); };
        TTimeIntervalMicroSeconds ElapsedTotal()
        {
            TTime now;
            now.UniversalTime();
            return now.MicroSecondsFrom(iTime);
        };
        TTimeIntervalMicroSeconds ElapsedFromTick()
        {
            TTime now;
            now.UniversalTime();
            return now.MicroSecondsFrom(iLastTick);
        };
        TTime Time() {return iTime; };
    private:
        TTime iTime;
        TTime iLastTick;
};

class TThreadUtility
{
    public:
        typedef void (*TThreadFunctionL)(TAny* aPtr);

        struct TOptions
        {
            TThreadFunctionL    ThreadFunctionL;
            TAny*               parameters; 
        };

        static TInt ThreadFunction(TAny* aPtr)
        {
            CTrapCleanup* cs = CTrapCleanup::New();
            if (cs == NULL)
            {
                return KErrNoMemory;
            }

            // new ActiveScheduler
            CActiveScheduler* scheduler = new(ELeave) CActiveScheduler;
            CActiveScheduler::Install(scheduler);

            TOptions* options = reinterpret_cast<TOptions*>(aPtr);
            TRAPD(err, (*options->ThreadFunctionL)(options->parameters));

            delete scheduler;
            delete cs;
            User::Exit(err);
            return err;
        };

        void CreateL(const TDesC& aThreadName, TOptions* aOptions)
        {
            iName.Set(aThreadName);
            User::LeaveIfError( iThread.Create(aThreadName,
                                TThreadUtility::ThreadFunction,
                                KDefaultStackSize,
                                KMinHeapSize,
                                10 * KMinHeapSize,
                                aOptions,
                                EOwnerProcess));
        };
        void CreateReuseHeapL(const TDesC& aThreadName, TOptions* aOptions)
        {
            iName.Set(aThreadName);
            User::LeaveIfError( iThread.Create(aThreadName,
                                TThreadUtility::ThreadFunction,
                                KDefaultStackSize,
                                &User::Heap(),
                                aOptions,
                                EOwnerProcess));
        };
        void Start()
        {
            iThread.Resume();
        };
        void Stop()
        {
            iThread.Suspend();
        };

        TInt Wait()
        {
            TRequestStatus threadStatus;
            if (iThread.ExitType() == EExitPending) // still executing
            {
                iThread.Logon(threadStatus);
                User::WaitForRequest(threadStatus);
            }
            return iThread.ExitReason();
        };

        const RThread Handle()
        {
            return iThread;
        };

        void Format(TDes& aMessage)
        {
            TExitCategoryName category = iThread.ExitCategory();
            _LIT(KThreadFormat, "Thread %S, Reason %d, ExitType %d, ExitName %S");
            aMessage.Format(KThreadFormat, 
                &iName, iThread.ExitReason(), iThread.ExitType(), &category);
        };

        // used if class destroyed
        void Close()
        {
            if (iThread.Handle())
            {
                if (iThread.ExitType() == EExitPending) // still executing
                {
                    iThread.Kill(KErrNone);
                }
                iThread.Close();
            }
        };

    protected:
        RThread iThread;
        TPtrC   iName;
};

#endif // _LCF_SBU_COMMON_DEFINITIONS_H_