/*
* Copyright (c) 2007 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:   Property object for Alfred
*
*/



#include "alf/alfpropertyowner.h"


// ---------------------------------------------------------------------------
// Constructor
// ---------------------------------------------------------------------------
//     
EXPORT_C CAlfPropertyOwner::CAlfPropertyOwner()
    {
        
    }

// ---------------------------------------------------------------------------
// Destructor
// ---------------------------------------------------------------------------
//     
EXPORT_C CAlfPropertyOwner::~CAlfPropertyOwner()
    {
    PropertyClear();    
    }

// ---------------------------------------------------------------------------
// Remove property
// ---------------------------------------------------------------------------
//     
EXPORT_C TBool CAlfPropertyOwner::PropertyRemove(const TDesC8& aName)
    {
    TInt index;
    
    if (!Find(aName, &index))
        {
        return EFalse;            
        }
    
    delete iProperties[index];
    iProperties.Remove(index);
    iProperties.Compress();
    
    return ETrue;
    }
    
// ---------------------------------------------------------------------------
// Clear property
// ---------------------------------------------------------------------------
//         
EXPORT_C void CAlfPropertyOwner::PropertyClear()
    {
    iProperties.ResetAndDestroy();   
    }


// We have a different registration method for each property type.

// ---------------------------------------------------------------------------
// Set integer property
// ---------------------------------------------------------------------------
//     
EXPORT_C TBool CAlfPropertyOwner::PropertySetIntegerL(const TDesC8& aName, TInt aVal, TInt aMin, TInt aMax)
    {
    CAlfPropertyInteger* property;
    TAlfPropertyType type;
    TInt index;
    
    if (aName.Length() == 0)
        {
        // Cannot have zero-length name as an argument.
        return EFalse;
        }    

    if (Find(aName, &index, &type))
        {
        // Property exists already.
        if (type != EAlfPropertyTypeInteger)
            {
            // Wrong type. We have to exit without doing anything.
            return EFalse;
            }
        
        // Modify existing property.
        property = static_cast<CAlfPropertyInteger*>(iProperties[index]);                
        property->Set(TRangedValue(aVal, aMin, aMax));        
        }
    else
        {
        // Not found, so add new item to the property list.
        property = new (ELeave) CAlfPropertyInteger();
        CleanupStack::PushL(property);
        property->ConstructL(aName);         
        CleanupStack::Pop(property);
        
        property->Set(TRangedValue(aVal, aMin, aMax));        
        
        User::LeaveIfError(iProperties.Append(property));        
        }
    
    return ETrue;
    }

// ---------------------------------------------------------------------------
// Find integer property
// ---------------------------------------------------------------------------
//         
EXPORT_C TBool CAlfPropertyOwner::PropertyFindInteger(const TDesC8& aName, TInt* aValue) const
    {   
    TInt index;

    if (!FindOfType(aName, &index, EAlfPropertyTypeInteger))
        {
        return EFalse;            
        }
        
    if (aValue)
        {
        // Clamp the value.
        CAlfPropertyInteger* foundVal = static_cast<CAlfPropertyInteger*>(iProperties[index]);        
        
        *aValue = Min(foundVal->Data().iValue, foundVal->Data().iMax);
        *aValue = Max(*aValue, foundVal->Data().iMin);
        }
    
    return ETrue;
    }

// ---------------------------------------------------------------------------
// Find complete ranged value
// ---------------------------------------------------------------------------
//         
TBool CAlfPropertyOwner::PropertyFindInteger(const TDesC8& aName, TRangedValue& aValue) const
    {   
    TInt index;

    if (FindOfType(aName, &index, EAlfPropertyTypeInteger))
        {
        CAlfPropertyInteger* foundVal = static_cast<CAlfPropertyInteger*>(iProperties[index]);        
        
        aValue = foundVal->Data();
        return ETrue;
        }
    
    return EFalse;
    }

// ---------------------------------------------------------------------------
// Set string property
// ---------------------------------------------------------------------------
//     
EXPORT_C TBool CAlfPropertyOwner::PropertySetStringL(const TDesC8& aName, const TDesC& aValue)
    {
    CAlfPropertyString* property;
    TAlfPropertyType type;
    TInt index;
    
    if (aName.Length() == 0)
        {
        // Cannot have zero-length name as an argument.
        return EFalse;
        }    

    if (Find(aName, &index, &type))
        {
        // Property exists already.
        if (type != EAlfPropertyTypeString)
            {
            // Wrong type. We have to exit without doing anything.
            return EFalse;
            }
        
        // Modify existing property.
        property = static_cast<CAlfPropertyString*>(iProperties[index]);                
        property->SetL(aValue);        
        }
    else
        {
        // Not found, so add new item to the property list.
        property = new (ELeave) CAlfPropertyString();
        CleanupStack::PushL(property);
        property->ConstructL(aName);         
        CleanupStack::Pop(property);
        
        property->SetL(aValue);        
        
        User::LeaveIfError(iProperties.Append(property));        
        }
    
    return ETrue;
    }
    
    
// ---------------------------------------------------------------------------
// Find string property
// ---------------------------------------------------------------------------
//         
EXPORT_C TBool CAlfPropertyOwner::PropertyFindString(const TDesC8& aName, TDesC** aValue) const
    {   
    TInt index;

    if (!FindOfType(aName, &index, EAlfPropertyTypeString))
        {
        return EFalse;            
        }
    
    CAlfPropertyString* foundVal = static_cast<CAlfPropertyString*>(iProperties[index]);
    
    if (aValue)
        {
        *aValue = foundVal->Data();
        }
    
    return ETrue;
    }    
    
    
// Private methods

// ---------------------------------------------------------------------------
// Find property
// ---------------------------------------------------------------------------
//     
TBool CAlfPropertyOwner::Find(const TDesC8& aName, TInt* aIndex, TAlfPropertyType* aType) const
    {
    TIdentityRelation<CAlfProperty> matchName( CAlfProperty::Matches );
    
    if (iProperties.Count() == 0)
        {
        // Array is empty, nothing to find.
        return false;
        }
    
    // Create a temporary property with the name we want to find.
    CAlfProperty* toFind = new CAlfProperty();
    if ( !toFind )
        {
        return EFalse;
        }
        
    TRAPD( err, toFind->ConstructL(aName) );
    if ( err != KErrNone )
        {
        delete toFind;
        return EFalse;
        }

    TInt found = iProperties.Find(toFind, matchName);
    delete toFind;

    if (found == KErrNotFound)
        {
        return EFalse;
        }
       
    CAlfProperty* foundProperty = iProperties[found];       
       
    if (aIndex)
        {
        *aIndex = found;
        }
    
    if (aType)
        {
        *aType = foundProperty->Type();
        }
    
    return ETrue;        
    }

// ---------------------------------------------------------------------------
// Find property and check for the correct type
// ---------------------------------------------------------------------------
//     
TBool CAlfPropertyOwner::FindOfType(const TDesC8& aName, TInt* aIndex, TAlfPropertyType aRequiredType) const
    {
    TAlfPropertyType foundType;
    
    if (!Find(aName, aIndex, &foundType))
        {
        return EFalse;            
        }
        
    if (foundType != aRequiredType)
        {
        return EFalse;            
        }

    // Return, with find index stored in return parameter.
    return ETrue;      
    }

    
EXPORT_C TInt CAlfPropertyOwner::CopyProperty(const CAlfPropertyOwner& aOwner, const TDesC8& aPropertyName)
    {
    TInt index(0), result(KErrNone);
    TAlfPropertyType propertyType;
  
    if (aOwner.Find(aPropertyName, &index, &propertyType))
        {
        switch (propertyType)
            {
            case EAlfPropertyTypeInteger:
                {    
                TRangedValue value;
                aOwner.PropertyFindInteger(aPropertyName, value); // we know it exists
                TRAP(result, PropertySetIntegerL(aPropertyName, value.iValue, value.iMin, value.iMax))
                break;
                }
            case EAlfPropertyTypeString:
                {
                TDesC* string = 0;
                aOwner.PropertyFindString(aPropertyName, &string); // we know it exists
                TRAP(result, PropertySetStringL(aPropertyName, *string))
                break;
                }
            default:
                result = KErrNotSupported;
                break;
            }
        }
    else 
        {
        result = KErrNotFound;
        } 
        
    return result;
    }

EXPORT_C void CAlfPropertyOwner::PropertyOwnerExtension(const TUid& /*aExtensionUid*/, TAny** /*aExtensionParams*/)
    {
    
    }