/*
* 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 "irqsystemeventhandler.h"
#include "irqsystemeventhandler_p.h"
#include "irdiskspaceobserver.h"
#include "iralarmobserver.h"
#include "irpropertyobserver.h"
#include "irqlogger.h"

#ifdef USER_DEFINED_DISKSPACE 
#include <QFile>
#include <QTextStream>
#include <QStringList> 
#endif

#define DEFAULT_DISKSPACE_LOW_LEVEL   (3*1024*1024)

IRQSystemEventHandlerPrivate::IRQSystemEventHandlerPrivate(IRQSystemEventHandler *aSystemEventHandler) : q_ptr(aSystemEventHandler),
                              mAlarmOn(false),mDefaultLevel(DEFAULT_DISKSPACE_LOW_LEVEL),mAlarmObserver(NULL), mDiskSpaceObserver(NULL),
                              mPropertyObserver(NULL),mErrorCode(0)
{ 
}

IRQSystemEventHandlerPrivate::~IRQSystemEventHandlerPrivate()
{
    cancel();
    delete mDiskSpaceObserver;
    delete mAlarmObserver;   
    delete mPropertyObserver;
}

bool IRQSystemEventHandlerPrivate::init()
{ 
#ifdef USER_DEFINED_DISKSPACE
    getDiskSpaceCriticalLevel(mDefaultLevel);
#endif  
    
    TRAPD(err, initializeL());      
    if( KErrNone == err )
    {
        return true;
    }
    else
    {
        mAlarmObserver = NULL;
        mDiskSpaceObserver = NULL;
        mPropertyObserver = NULL;        
    }
    
    
    return false;
}

qint64 IRQSystemEventHandlerPrivate::diskCriticalLevel() const
{
    if(NULL != mDiskSpaceObserver)
    {
        return (qint64)(mDiskSpaceObserver->CriticalLevel());
    }
    else
    {
        return -1;
    }
}


void IRQSystemEventHandlerPrivate::initializeL()
{
    mAlarmObserver = CIRAlarmObserver::NewLC(this);    
    mDiskSpaceObserver = CIRDiskSpaceObserver::NewLC(this);
    mPropertyObserver = CIRPropertyObserver::NewL(this);   
    CleanupStack::Pop(mDiskSpaceObserver);
    CleanupStack::Pop(mAlarmObserver);    
}

void IRQSystemEventHandlerPrivate::cancel()
{
    if( mAlarmObserver )
    {
        mAlarmObserver->Cancel();
    }
    
    if( mDiskSpaceObserver )
    {
        mDiskSpaceObserver->Cancel();
    }
}

void IRQSystemEventHandlerPrivate::start()
{
    if( mAlarmObserver )
    {
        mAlarmObserver->Start();        
    }
    
    if( mDiskSpaceObserver )
    {
        mDiskSpaceObserver->Start((TInt64)mDefaultLevel);            
    }       
}


bool IRQSystemEventHandlerPrivate::isBelowCriticalLevel(const qint64 aCriticalLevel)
{
    if( 0 == aCriticalLevel )
    {
        return mDiskSpaceObserver->IsBelowCriticalLevel((TInt64)mDefaultLevel );
    }
    
    return mDiskSpaceObserver->IsBelowCriticalLevel((TInt64)aCriticalLevel );
}

bool IRQSystemEventHandlerPrivate::isCallActive() const
{
    return mPropertyObserver->IsCallActive();
}

int IRQSystemEventHandlerPrivate::getErrorCode() const
{
    return mErrorCode;
}

#ifdef USER_DEFINED_DISKSPACE
void IRQSystemEventHandlerPrivate::getDiskSpaceCriticalLevel(qint64 & aLevel)
{
    QFile file("C:\\data\\QTIRConfigure.txt");
    if(file.open(QIODevice::ReadOnly)) 
    {
        QTextStream stream( &file );
        QString line;
        QStringList parameter;
        while (!stream.atEnd())
        {
            line = stream.readLine();
            parameter = line.split("=");
            if (parameter.count() == 2)
            {
                if (parameter.first() == "diskSpaceCriticalLevel")
                {
                    QString level = parameter.last();
                    aLevel = level.toLongLong();
                    break;
                }
            }
        }
    }
    
    file.close();
}
#endif

void IRQSystemEventHandlerPrivate::alarmStarted()
{
    if( !mAlarmOn )
    {
        emit q_ptr->alarmStarted();
        mAlarmOn = true;
    }
}

void IRQSystemEventHandlerPrivate::alarmStopped()
{
    if( mAlarmOn )
    {
        emit q_ptr->alarmStopped();
        mAlarmOn = false;
    }
}

void IRQSystemEventHandlerPrivate::notifyLowDiskSpace(qint64 aCriticalLevel)
{
    emit q_ptr->diskSpaceLowNotification(aCriticalLevel);
}

void IRQSystemEventHandlerPrivate::callIsActivated()
{
    LOG_METHOD;
    emit q_ptr->callActivated();    
}

void IRQSystemEventHandlerPrivate::callIsDeactivated()
{
    LOG_METHOD;
    emit q_ptr->callDeactivated();    
}

void IRQSystemEventHandlerPrivate::errorCallback(int aError)
{
    mErrorCode = aError;
}

void IRQSystemEventHandlerPrivate::headsetIsConnected()
{
    LOG_METHOD;    
    emit q_ptr->headsetConnected();
}

void IRQSystemEventHandlerPrivate::headsetIsDisconnected()
{
    LOG_METHOD;
    emit q_ptr->headsetDisconnected();
}