/*

* Copyright (c) 2006 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:  This file defines the class that handles the storage

*                of triggers in database.

*

*/

#include <sysutil.h>

#include <etelmm.h>

#include <lbtstartuptrigger.h>

#include <lbttriggerconditionarea.h>

#include <lbtgeocircle.h>

#include <lbttriggerfilterbase.h>

#include <lbttriggerfilterbyarea.h>

#include <lbttriggerfilterbyattribute.h>

#include <lbttriggerfiltercomposite.h>

#include <lbtgeorect.h>

#include <lbtgeocell.h>

#include <lbtgeohybrid.h>

#include <s32file.h>

#include <bautils.h>

#include "lbtdbtriggersmanager.h"

#include "lbtdboperationao.h"

#include "lbtcontainerextendedtriggerinfo.h"

#include "lbtcontainertriggerfilter.h"

#include "lbtcontainerfilterbase.h"

#include "lbtcontainerareafilter.h"

#include "lbtcontainerattrfilter.h"

#include "lbtcontainercompfilter.h"

#include "lbttriggerstoreobserver.h"

#include "lbtcontainerutilities.h"

#include "lbtserverconsts.h"

#include "lbtlogger.h"

_LIT(KLbtDbName,"lbt.db"); // Name of the Database file for storing triggers.

_LIT(KTriggersTable,"Triggers"); // Name of the Table for Triggers

_LIT(KCircularTriggersTable, "CircularTriggers");

_LIT(KCellTriggersTable, "CellTriggers");

_LIT(KHybridTriggersTable, "HybridTriggers");

_LIT(KTriggersIndexId,"TriggerIdIndex"); // Index based on Trigger Id column

_LIT(KCircTriggersIndexId,"CircularTriggerIdIndex");

_LIT(KCellTriggersIndexId,"CellularTriggerIdIndex");

_LIT(KHybridTriggersIndexId,"HybridTriggerIdIndex");

// Names for the fields in the table

_LIT(KLbtDbFieldId, "id");

_LIT(KLbtDbFieldName, "name");

_LIT(KLbtDbFieldType, "type");

_LIT(KLbtDbFieldDirection, "direction");

_LIT(KLbtDbFieldOwnerSid, "owner");

_LIT(KLbtDbFieldManagerUiSid, "managerui");

_LIT(KLbtDbFieldRearmTime, "rearmtime");

_LIT(KLbtDbFieldStartupSid, "stprocess");

_LIT(KLbtDbFieldStartupPath, "stprocesspath");

_LIT(KLbtDbFieldStartupCommandLine, "stprocesscmdline");

_LIT(KLbtDbFieldState, "state");

_LIT(KLbtDbFieldIsTriggerFired, "IsFired");

_LIT(KLbtDbFieldDistanceToLastLocation,"distance");

_LIT(KLbtDbFieldValidity, "validity");

_LIT(KLbtDbFieldIsTriggerFireOnCreation, "IsTriggerFireOnCreation");

_LIT(KLbtDbTriggerAreaType, "triggerareatype");

// Name for the fields in circular trigger table

_LIT(KLbtCircTrigDbFieldId, "idcirculartrigger");

_LIT(KLbtDbFieldCenterLat, "latitude");

_LIT(KLbtDbFieldCenterLong, "longitude");

_LIT(KLbtDbFieldRadius, "radius");

_LIT(KLbtDbFieldHysteresis, "hysteresis");

_LIT(KLbtDbFieldAreaLeft, "westlong");

_LIT(KLbtDbFieldAreaRight, "eastlong");

_LIT(KLbtDbFieldAreaTop, "northlat");

_LIT(KLbtDbFieldAreaBottom, "southlat");

_LIT(KLbtDbFieldTriggerFiredLat, "FiredLat");

_LIT(KLbtDbFieldTriggerFiredLong, "FiredLong");

_LIT(KLbtDbFieldTriggerFiredAlt, "FiredAlt");

_LIT(KLbtDbFieldTriggerFiredHorizAcc, "FiredHorizAcc");

_LIT(KLbtDbFieldTriggerFiredVertAcc, "FiredVertAcc");

_LIT(KLbtDbFieldCellIdStream,"cellidstream");  // 9.2TB Column additions start

// Name for the fields in cellular trigger table

_LIT(KLbtCellTrigDbFieldId, "idcelltrigger");

_LIT(KLbtCellTrigDbCountryCode, "countrycode");

_LIT(KLbtCellTrigDbNetworkId, "networkid");

_LIT(KLbtCellTrigDbNetworkType, "networktype");

_LIT(KLbtCellTrigDbLAC, "locationcode");

_LIT(KLbtCellTrigDbCellId, "cellid");

// Name for fields in Hybrid trigger table

_LIT(KLbtHybridTrigDbFieldId, "idhybridtrigger");

_LIT(KLbtHybridDataStream, "hybriddatastream"); // Added for 9.2 TB. Older fields not valid from 9.2 TB

// Constants for SQL Queries

_LIT(KWhere, " WHERE ");

_LIT(KLike, " = ");

_LIT(KLessThanEqualTo, " <= ");

_LIT(KGreaterThanEqualTo, " >= ");

_LIT(KAnd, " AND ");

// Enums for the coulumn ids in the common table

enum TCommonDbColNum

	{

	ELbtDbFieldId = 1,

    ELbtDbFieldName,

    ELbtDbFieldType,

    ELbtDbFieldDirection,

    ELbtDbFieldOwnerSid,

    ELbtDbFieldManagerUiSid,

    ELbtDbFieldRearmTime,

    ELbtDbFieldStartupSid, 

    ELbtDbFieldStartupPath, 

    ELbtDbFieldStartupCommandLine,

    ELbtDbFieldState,

    ELbtDbFieldIsTriggerFired,

    ELbtDbFieldDistanceToLastLocation,

    ELbtDbFieldValidity,

    ELbtDbFieldIsTriggerFireOnCreation,

    ELbtDbTriggerAreaType,

    };

// Enums for the column ids in the cicular trigger's db

enum TCircleTriggerDbColNum

	{

	ECircleDbFieldId  = 1,

    ECircleDbFieldCenterLat,

    ECircleDbFieldCenterLong,

    ECircleDbFieldRadius,

    ECircleDbFieldHysteresis,

    ECircleDbFieldAreaLeft,

    ECircleDbFieldAreaRight,

    ECircleDbFieldAreaTop,

    ECircleDbFieldAreaBottom,

    ECircleDbFieldTriggerFiredLat,

    ECircleDbFieldTriggerFiredLong,

    ECircleDbFieldTriggerFiredAlt,

    ECircleDbFieldTriggerFiredHorizAcc,

    ECircleDbFieldTriggerFiredVertAcc,

    };

// Enums for the column ids in the cellular trigger db

enum TCellTriggerDbColNum

	{

	ECellDbFieldId  = 1,

	ECellDbCountryCode,

	ECellDbNetworkId,

	ECellDbNetworkType,	

	ECellDbLocationAreaCode,

	ECellDbTriggerCellId,	

	};

// Enums added for 9.2 TB

enum THybridTriggersDbColNum

    {

    EHybridDbFieldId = 1,

    EHybridDataStream

    };	

// SQL Query related constants

const TInt KMaxSqlQueryLength = 256;

// If less than the below % of the db is used for legitimate data then compaction is needed

const TInt KDatabaseMinUsagePercentage = 60;

const TInt KDatabaseMaxWastageBytes = (50 * 1024); // More than 50 KB cannot be wasted

const TInt KStepCount(2); // Number of steps to be executed in one step for async operation

// Assumption that the worst case time needed for compaction is the amount in seconds defined 

// by KSecondsNeededForCompaction

const TTimeIntervalSeconds KSecondsNeededForCompaction(15);

_LIT(KSelect, "SELECT ");

_LIT(KFrom, " FROM ");

_LIT(KSelectAllFields, "* ");

_LIT(KDelete,"DELETE ");

#ifdef _DEBUG

    _LIT(KLbtCntDbPanic,"LBT: Db ");

    TInt KLbtCntDbSqlQueryError = -1;

#endif

// ======== MEMBER FUNCTIONS ========

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

// The Symbian 2 phase constructor

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

//

CLbtDbTriggersManager* CLbtDbTriggersManager::NewL( ) 

    {

    CLbtDbTriggersManager* self = new(ELeave)CLbtDbTriggersManager( );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// Destructor

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

//

CLbtDbTriggersManager::~CLbtDbTriggersManager()

    {

    FUNC_ENTER("CLbtDbTriggersManager::~CLbtDbTriggersManager");

    // Close all open Handles    

    delete iDbOperation;

    delete iSqlQuery;

    iIdArray.Close();

    if(iIsDbOpened)

    	{

    	// Compact the data base before going down

    	iDb.Compact();

    	}    

    iDb.Close();

    iFs.Close();

    }

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

// Specify the types of triggers supported by the Db Trigger Store

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

//

TTriggerTypeMask CLbtDbTriggersManager::SupportedTriggerTypes()

    {

    return ( CLbtTriggerEntry::ETypeStartup );

    }

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

// Specify the types of triggers supported by the Db Trigger Store

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

//

void CLbtDbTriggersManager::CreateTriggerL( CLbtContainerTriggerEntry &aEntry,

    										TRequestStatus& aStatus )

    {

    FUNC_ENTER("CLbtDbTriggersManager::CreateTriggerL-I");

    // This is just a safe check. While compaction is ongoing the

    // request is queued in container AO

    if(iDbOperation->IsCompactionOngoing())

    	{

        TRequestStatus* status = &aStatus;

    	User::RequestComplete(status, KErrServerBusy);

    	return;

    	}

    // Save client data for create trigger

 	iCurrentOperation = EDbOpCreateTrigger;

    iEntry = &aEntry;

    iClientReqStatus = &aStatus;

    TInt size = 500;//ToDo: implement this GetSize( aEntry );

 	if ( SysUtil::FFSSpaceBelowCriticalLevelL( &iFs, size ) )

 	    {

 	    // Try Db Compaction in case we don't have enough disk space

        iDbOperation->CompactDb();

        iOperationState = EOpCompaction;

 	    }

 	else

 	    {

 	    iOperationState = EOpStateQuery;

 	    TInt error = AsyncPrepareViewOfCommonTable();

 	    if( error != KErrNone )

 	        {

 	        CompleteClientRequest( error );

 	        }

 	    }

    }

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

// CLbtDbTriggersManager::ResetCurrentStates

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

//

void CLbtDbTriggersManager::ResetCurrentStates()

    {

    iOperationState = EOpStateNone;

    iCurrentOperation = EDbOpNone;

    iEntry = NULL;

    iClientReqStatus = NULL;

    iFilter = NULL;

    delete iFilterBase;

    iFilterBase = NULL;

    iView.Close();

    }

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

// CLbtDbTriggersManager::HandleTriggerCreationEventL

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

//

void CLbtDbTriggersManager::HandleTriggerCreationEventL( )

    {

    FUNC_ENTER("CLbtDbTriggersManager::HandleTriggerCreationEventL");    

    switch(iOperationState)

        {

        case EOpStateQuery:

            {

            // Query is done. Now update the view

            TRAPD( err, CreateTriggerInViewL() );                        

            if( err == KErrNone )

                {

                CLbtTriggerEntry* trigger = iEntry->TriggerEntry();

                if((trigger->State() == CLbtTriggerEntry::EStateEnabled) &&

                   (iEntry->DynInfo()->iValidity == TLbtTriggerDynamicInfo::EValid))

                    {

                    iCountOfEnabledAndValidTrigger++;

                    }

                }

            CompleteClientRequest(err);

            CompactDbIfRequiredL();

            break;

            }

        case EOpCompaction:

            {

            TInt size = 500;//ToDo: implement this GetSize( aEntry );

            if ( !SysUtil::FFSSpaceBelowCriticalLevelL(&iFs, size) )

                {

                iOperationState = EOpStateQuery;

                TInt error = AsyncPrepareViewOfCommonTable();

                if( error != KErrNone )

                    {

                    CompleteClientRequest( KErrDiskFull );

                    }

                }

            else

                {

                CompleteClientRequest( KErrDiskFull );

                }

            break;

            }

        default:

            {

            CompleteClientRequest( KErrGeneral );

            break;

            }

        }

    }

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

// CLbtDbTriggersManager::HandleTriggerUpdationEventL

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

//

void CLbtDbTriggersManager::HandleTriggerUpdationEventL()

    {

    // Sanity checks to be done here

    __ASSERT_DEBUG(iView.CountL() < 2, User::Panic(KLbtCntDbPanic, KLbtCntDbSqlQueryError) );

    switch(iOperationState)

        {

        case EOpStateQuery:

            {

            // check if view is empty, return KErrNotFound

                {

                CompleteClientRequest( KErrNotFound );

                break;

                }       

            // Start iterating through all the triggers in view            

            iOperationState = EOpStateIterating;

            }

            // Omitting break is intentional

       case EOpStateIterating:

            {  

            TPtr sql = iSqlQuery->Des();

            iView.GetL();

            CLbtContainerTriggerEntry* triggerEntry = RetrieveTriggerEntryFromDbL( iView );    

            TBool securityCheck = LbtContainerUtilities::RunSecurityPolicy( triggerEntry, iClientSecurityPolicy );

            if( securityCheck )

                {

                // if security check has passed then the trigger will be updated

                AppendTriggerInfo( triggerEntry );

                }

            else

                {

                CompleteClientRequest( KErrAccessDenied );

                return;

                }

            delete triggerEntry;

            iView.FirstL();

            iView.UpdateL();

            // Check the trigger type and update the appropriate view

            CLbtGeoAreaBase::TGeoAreaType triggerAreaType = static_cast<CLbtGeoAreaBase::TGeoAreaType>(iView.ColInt8(ELbtDbTriggerAreaType));

            CLbtStartupTrigger* trigger = static_cast<CLbtStartupTrigger*>(iEntry->TriggerEntry());

            // Check if the condition itself has to be replaced

            if( iAttrMask & CLbtTriggerEntry::EAttributeCondition )

                {

                CLbtTriggerConditionArea* cond=static_cast <CLbtTriggerConditionArea*> (trigger->GetCondition());

                CLbtGeoAreaBase* areaBase = cond->TriggerArea();

                // The area condition has changed

                if( triggerAreaType != areaBase->Type() )

                    {

                    // Check if the trigger area type itself has been updated

                    RemoveTriggerConditionFromDb( iEntry->TriggerEntry()->Id(), triggerAreaType );

                    switch(areaBase->Type())

                        {

                        case CLbtGeoAreaBase::ECircle:

                            {

                            AddGeoCircleIntoDbL(trigger);

                            break;

                            }

                        case CLbtGeoAreaBase::ECellular:

                            {

                            AddGeoCellIntoDbL(trigger);

                            break;

                            }

                        case CLbtGeoAreaBase::EHybrid:

                            {

                            AddGeoHybridIntoDbL(trigger);

                            break;

                            }

                        default:

                            {

                            CompleteClientRequest( KErrArgument );

                            break;

                            }

                        }

                    // Write the area type

                    iView.SetColL(ELbtDbTriggerAreaType,static_cast<TInt8>(areaBase->Type()));

                    // Negate the Attribute condition so that it is not updated again

                    iAttrMask = iAttrMask & (~(CLbtTriggerEntry::EAttributeCondition));

                    // Update trigger area type

                    triggerAreaType = areaBase->Type();

                    }

                    CLbtTriggerConditionArea::TDirection currentTriggerDirection = 

                            static_cast<CLbtTriggerConditionArea::TDirection>(iView.ColInt8(ELbtDbFieldDirection));

                    if( currentTriggerDirection != cond->Direction() )

                        {

                        iView.SetColL( ELbtDbFieldDirection, static_cast<TInt8>((cond->Direction())) );

                        }

                    }    

            CLbtTriggerEntry::TLbtTriggerState currentState = 

                        static_cast<CLbtTriggerEntry::TLbtTriggerState>(iView.ColInt8(ELbtDbFieldState));

            if( (iEntry->TriggerEntry()->State() == CLbtTriggerEntry::EStateEnabled) && 

                (currentState == CLbtTriggerEntry::EStateDisabled) )

                 {

                 iCountOfEnabledAndValidTrigger++;

                 }

            else if( (iEntry->TriggerEntry()->State() == CLbtTriggerEntry::EStateDisabled) && 

                     (currentState == CLbtTriggerEntry::EStateEnabled) )

                 {

                 iCountOfEnabledAndValidTrigger--;

                 }

            CLbtExtendedTriggerInfo* extdInfo = iEntry->ExtendedTriggerInfo();

            TLbtTriggerDynamicInfo* trigDynInfo = iEntry->DynInfo();

            //Check the masks and update the specified attributes

            if(trigger != NULL)

                {

                if( iAttrMask & CLbtTriggerEntry::EAttributeId )

                    {

                    iView.SetColL( ELbtDbFieldId, static_cast<TInt64>(trigger->Id()) );

                    }

                if( iAttrMask & CLbtTriggerEntry::EAttributeName )

                    {

                    iView.SetColL( ELbtDbFieldName, trigger->Name() );

                    }

                if( iAttrMask & CLbtTriggerEntry::EAttributeState )

                    {

                    iView.SetColL( ELbtDbFieldState, trigger->State() );

                    }

                if( iAttrMask & CLbtTriggerEntry::EAttributeRearmTime )

                    {

                    iView.SetColL( ELbtDbFieldRearmTime, trigger->TimeToRearm() );

                    }        

                if( iAttrMask & CLbtTriggerEntry::EAttributeStartUpCommandLine )

                    {

                    iView.SetColL( ELbtDbFieldStartupCommandLine, trigger->CommandLine() );          

                    }

                if( iAttrMask & CLbtTriggerEntry::EAttributeCondition )

                    {

                    CLbtTriggerConditionArea* cond=static_cast <CLbtTriggerConditionArea*> (trigger->GetCondition());

                    switch( triggerAreaType )

                        {

                        case CLbtGeoAreaBase::ECircle:

                            {

                            //Since the trigger type is circular get the appropriate tuple from the circular trigger table

                            RDbView circView;

                            sql.Zero();

                            sql.Append( KSelect );

                            sql.Append( KSelectAllFields );

                            sql.Append( KFrom );

                            sql.Append( KCircularTriggersTable );

                            sql.Append( KWhere );

                            sql.Append( KLbtCircTrigDbFieldId );

                            sql.Append( KLike );

                            sql.AppendNum(iEntry->TriggerEntry()->Id());

                            TInt error = iDbOperation->ExecuteSyncQuery( circView, sql );

                            if(error != KErrNone)

                                {

                                circView.Close();