/*
* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, version 2.1 of the License.
* 
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this program.  If not, 
* see "http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html/".
*
* Description:
*
*/

#include "cpublishandsubscribehandler.h"
#include <e32property.h>

#include "xqsettingskey.h"

CPublishAndSubscribeHandler* CPublishAndSubscribeHandler::NewL(TUid aUid)
{
    CPublishAndSubscribeHandler* self = new (ELeave) CPublishAndSubscribeHandler(aUid); 
    CleanupStack::PushL(self);
    self->ConstructL();
    CleanupStack::Pop(self);
    return self;
}

void CPublishAndSubscribeHandler::ConstructL()
{
}

CPublishAndSubscribeHandler::CPublishAndSubscribeHandler(TUid aUid)
    : m_uid(aUid)
{
}

CPublishAndSubscribeHandler::~CPublishAndSubscribeHandler()
{
}

void CPublishAndSubscribeHandler::setObserver(MSettingsHandlerObserver* observer)
{
    m_observer = observer;
}

TInt CPublishAndSubscribeHandler::getValue(unsigned long key, TInt& value)
{
    return RProperty::Get(m_uid, key, value);
}

TInt CPublishAndSubscribeHandler::getValue(unsigned long /*key*/, TReal& /*value*/)
{
    return KErrArgument;
}

void CPublishAndSubscribeHandler::getValueL(unsigned long key, RBuf8& value)
{
    TInt err = RProperty::Get(m_uid, key, value);
    if (err == KErrOverflow)
    {
        value.ReAllocL(RProperty::KMaxPropertySize);
        err = RProperty::Get(m_uid, key, value);
        if (err == KErrOverflow)
        {
            value.ReAllocL(RProperty::KMaxLargePropertySize);
            err = RProperty::Get(m_uid, key, value);
        }
    }
    User::LeaveIfError(err);
}

void CPublishAndSubscribeHandler::getValueL(unsigned long key, RBuf16& value)
{
    TInt err = RProperty::Get(m_uid, key, value);
    if (err == KErrOverflow)
    {
        value.ReAllocL(RProperty::KMaxPropertySize);
        err = RProperty::Get(m_uid, key, value);
        if (err == KErrOverflow)
        {
            value.ReAllocL(RProperty::KMaxLargePropertySize);
            err = RProperty::Get(m_uid, key, value);
        }
    }
    User::LeaveIfError(err);
}

TInt CPublishAndSubscribeHandler::setValue(unsigned long key, const TInt& value)
{
    return RProperty::Set(m_uid, key, value);
}

TInt CPublishAndSubscribeHandler::setValue(unsigned long /*key*/, const TReal& /*value*/)
{
    return KErrArgument;
}

TInt CPublishAndSubscribeHandler::setValue(unsigned long key, const TDesC8& value)
{
    return RProperty::Set(m_uid, key, value);
}

TInt CPublishAndSubscribeHandler::setValue(unsigned long key, const TDesC16& value)
{
    return RProperty::Set(m_uid, key, value);
}

TInt CPublishAndSubscribeHandler::defineProperty(unsigned long key, XQSettingsManager::Type type)
{
    switch (type)
    {
        case XQSettingsManager::TypeInt:
        {
            return RProperty::Define(m_uid, key, RProperty::EInt);
        }
        case XQSettingsManager::TypeString:
        {
            return RProperty::Define(m_uid, key, RProperty::EText);
        }
        case XQSettingsManager::TypeByteArray:
        {
            return RProperty::Define(m_uid, key, RProperty::EByteArray);
        }
        case XQSettingsManager::TypeDouble:
        default:
        {
            return KErrArgument;
        }
    }
}

TInt CPublishAndSubscribeHandler::defineProperty(unsigned long key, XQSettingsManager::Type type,
    const XQPublishAndSubscribeSecurityPolicy& readPolicy, const XQPublishAndSubscribeSecurityPolicy& writePolicy)
{
    switch (type)
    {
        case XQSettingsManager::TypeInt:
        {
            return RProperty::Define(m_uid, key, RProperty::EInt, symbianPolicy(readPolicy), symbianPolicy(writePolicy));
        }
        case XQSettingsManager::TypeString:
        {
            return RProperty::Define(m_uid, key, RProperty::EText, symbianPolicy(readPolicy), symbianPolicy(writePolicy));
        }
        case XQSettingsManager::TypeByteArray:
        {
            return RProperty::Define(m_uid, key, RProperty::EByteArray, symbianPolicy(readPolicy), symbianPolicy(writePolicy));
        }
        case XQSettingsManager::TypeDouble:
        default:
        {
            return KErrArgument;
        }
    }
}

TSecurityPolicy CPublishAndSubscribeHandler::symbianPolicy(const XQPublishAndSubscribeSecurityPolicy& policy)
{
    //Use constructor for EAlwaysFail or EAlwaysPass
    switch (policy.secPolicyType())
    {
        case XQPublishAndSubscribeSecurityPolicy::SecPolicyAlwaysFail:
        {
            return TSecurityPolicy(TSecurityPolicy::EAlwaysFail);
        }
        case XQPublishAndSubscribeSecurityPolicy::SecPolicyAlwaysPass:
        {
            return TSecurityPolicy(TSecurityPolicy::EAlwaysPass);
        }
        default:
        {
            break;
        }
    }
    
    TCapability capability1 = ECapability_None;
    TCapability capability2 = ECapability_None;
    TCapability capability3 = ECapability_None;
    TCapability capability4 = ECapability_None;
    TCapability capability5 = ECapability_None;
    TCapability capability6 = ECapability_None;
    TCapability capability7 = ECapability_None;
    
    const QList<XQPublishAndSubscribeSecurityPolicy::Capability>& capabilities = policy.capabilities();
    
    if (capabilities.count() > 0) capability1 = symbianCapability(capabilities[0]);
    if (capabilities.count() > 1) capability2 = symbianCapability(capabilities[1]);
    if (capabilities.count() > 2) capability3 = symbianCapability(capabilities[2]);
    if (capabilities.count() > 3) capability4 = symbianCapability(capabilities[3]);
    if (capabilities.count() > 4) capability5 = symbianCapability(capabilities[4]);
    if (capabilities.count() > 5) capability6 = symbianCapability(capabilities[5]);
    if (capabilities.count() > 6) capability7 = symbianCapability(capabilities[6]);
    
    long int secureId = policy.secureId().uid();
    if (secureId != -1)
    {
        //Use constructor for TSecureId + max 3 capabilities
        return TSecurityPolicy(TSecureId(secureId), capability1, capability2, capability3);
    }
    
    long int vendorId = policy.vendorId().uid();
    if (vendorId != -1)
    {
        //Use constructor for TVendorId + max 3 capabilities
        return TSecurityPolicy(TVendorId(vendorId), capability1, capability2, capability3);
    }
    
    if (capabilities.count() < 4)
    {
        //Use constructor for max 3 capabilities
        return TSecurityPolicy(capability1, capability2, capability3);
    }
    else
    {
        //Use constructor for max 7 capabilities
        return TSecurityPolicy(capability1, capability2, capability3, capability4, capability5, capability6, capability7);
    }
}

TCapability CPublishAndSubscribeHandler::symbianCapability(const XQPublishAndSubscribeSecurityPolicy::Capability& capability)
{
    switch (capability)
    {
        case XQPublishAndSubscribeSecurityPolicy::CapabilityTCB:                return ECapabilityTCB;
        case XQPublishAndSubscribeSecurityPolicy::CapabilityCommDD:             return ECapabilityCommDD;
        case XQPublishAndSubscribeSecurityPolicy::CapabilityPowerMgmt:          return ECapabilityPowerMgmt;
        case XQPublishAndSubscribeSecurityPolicy::CapabilityMultimediaDD:       return ECapabilityMultimediaDD;
        case XQPublishAndSubscribeSecurityPolicy::CapabilityReadDeviceData:     return ECapabilityReadDeviceData;
        case XQPublishAndSubscribeSecurityPolicy::CapabilityWriteDeviceData:    return ECapabilityWriteDeviceData;
        case XQPublishAndSubscribeSecurityPolicy::CapabilityDRM:                return ECapabilityDRM;
        case XQPublishAndSubscribeSecurityPolicy::CapabilityTrustedUI:          return ECapabilityTrustedUI;
        case XQPublishAndSubscribeSecurityPolicy::CapabilityProtServ:           return ECapabilityProtServ;
        case XQPublishAndSubscribeSecurityPolicy::CapabilityDiskAdmin:          return ECapabilityDiskAdmin;
        case XQPublishAndSubscribeSecurityPolicy::CapabilityNetworkControl:     return ECapabilityNetworkControl;
        case XQPublishAndSubscribeSecurityPolicy::CapabilityAllFiles:           return ECapabilityAllFiles;
        case XQPublishAndSubscribeSecurityPolicy::CapabilitySwEvent:            return ECapabilitySwEvent;
        case XQPublishAndSubscribeSecurityPolicy::CapabilityNetworkServices:    return ECapabilityNetworkServices;
        case XQPublishAndSubscribeSecurityPolicy::CapabilityLocalServices:      return ECapabilityLocalServices;
        case XQPublishAndSubscribeSecurityPolicy::CapabilityReadUserData:       return ECapabilityReadUserData;
        case XQPublishAndSubscribeSecurityPolicy::CapabilityWriteUserData:      return ECapabilityWriteUserData;
        case XQPublishAndSubscribeSecurityPolicy::CapabilityLocation:           return ECapabilityLocation;
        case XQPublishAndSubscribeSecurityPolicy::CapabilitySurroundingsDD:     return ECapabilitySurroundingsDD;
        case XQPublishAndSubscribeSecurityPolicy::CapabilityUserEnvironment:    return ECapabilityUserEnvironment;
        default:
        {
            break;
        }
    }
    return TCapability();
}

TInt CPublishAndSubscribeHandler::deleteProperty(unsigned long key)
{
    return RProperty::Delete(m_uid, key);
}

bool CPublishAndSubscribeHandler::handleStartMonitoring(const XQSettingsKey& key, XQSettingsManager::Type type, MSettingsHandlerObserver& observer, TInt& error)
{
    if (m_monitors.contains(key.key()))
    {
        error = KErrAlreadyExists;
        return false;
    }
    CPubSubMonitor* newMonitor = new CPubSubMonitor(key, type, observer);
    if (newMonitor)
    {
        m_monitors[key.key()] = newMonitor;
        error = newMonitor->StartMonitoring();
        return error == KErrNone;
    }
    error = KErrNoMemory;
    return false;
}

bool CPublishAndSubscribeHandler::handleStopMonitoring(const XQSettingsKey& key, TInt& error)
{
    if (!m_monitors.contains(key.key()))
    {
        error = KErrNotFound;
        return false;
    }
    const long int itemKey = key.key();
    CPubSubMonitor* monitor = m_monitors[itemKey];
    m_monitors.remove(itemKey);
    delete monitor;
    
    return error == KErrNone;
}