// This Source Code is in the Public Domain per: http://unlicense.org
package org.litesoft.aokeyhole.objects.support;

import java.util.*;

import org.litesoft.aokeyhole.objects.*;
import org.litesoft.aokeyhole.persist.*;
import org.litesoft.aokeyhole.toolkit.*;

import static org.litesoft.aokeyhole.objects.support.AbstractBase.*;

public class PropertyManager
{
    public static final PropertyManager NONE = new PropertyManager( null, false, PropertyMetaData.EMPTY_ARRAY );

    private Changeable mChangeable;
    private Property[] mProperties;
    private Map<String, Property> mNameToProperty;

    public PropertyManager( Changeable pChangeable, boolean pEditable, PropertyMetaData[] pPropertyMetaDatas )
    {
        mChangeable = pChangeable;
        mNameToProperty = new HashMap<String, Property>( pPropertyMetaDatas.length );
        mProperties = new Property[pPropertyMetaDatas.length];
        for ( int i = 0; i < pPropertyMetaDatas.length; i++ )
        {
            Property property = new Property( pPropertyMetaDatas[i], pEditable );
            mProperties[i] = property;
            if ( mNameToProperty.put( property.getName(), property ) != null )
            {
                throw new IllegalStateException( "Duplicate Property: " + property.getName() );
            }
        }
    }

    public Property[] getProperties()
    {
        return mProperties;
    }

    public Property getProperty( String pName )
    {
        return mNameToProperty.get( pName );
    }

    public void unpersistProperty( String pName, String pValueAsString )
    {
        Property property = getProperty( pName );
        if ( property != null ) // Ignoring not founds - as we assume that the model has changed...
        {
            property.unpersistValue( property.getMetaData().validateAndNormalize( pValueAsString ) );
        }
    }

    /**
     * @return null or Error
     */
    public String updatePropertyValue( String pName, Object pValue )
    {
        Property property = getProperty( pName );
        if ( property == null )
        {
            return "No Property Named: " + pName;
        }
        Object newNormalizedValue;
        try
        {
            newNormalizedValue = property.getMetaData().validateAndNormalize( pValue );
        }
        catch ( ParseException e )
        {
            return e.getMessage();
        }
        if ( property.setValue( newNormalizedValue ) && (mChangeable != null) )
        {
            mChangeable.changed();
        }
        return null;
    }

    public void addTo( PropertyableBuilder pBuilder )
    {
        for ( Property property : mProperties )
        {
            property.addTo( pBuilder );
        }
    }

    public void setRehydrated()
    {
        for ( Property property : mProperties )
        {
            property.setRehydrated();
        }
    }

    /**
     * @return null or Error
     */
    public String validatePersistable()
    {
        String error = null;
        for ( int i = 0; (i < mProperties.length) && (error == null); i++ )
        {
            error = mProperties[i].validatePersistable();
        }
        return error;
    }

    public void setUpView( NameValuesComponent pNameValuesComponent )
    {
        for ( Property property : mProperties )
        {
            pNameValuesComponent.setValue( property.getName(), property.getValueAsString() );
        }
    }

    public void saveFromView( ChangeHandler pChanges, NameValuesComponent pNameValuesComponent )
    {
        for ( Property property : mProperties )
        {
            String zName = property.getName();
            if ( pNameValuesComponent.hasComponentFor( zName ) )
            {
                pChanges.add( checkPropertyChange( property, pNameValuesComponent.getValue( zName ) ) );
            }
        }
    }

    private ChangeFragment checkPropertyChange( Property pProperty, String pNewValue )
    {
        PropertyMetaData zPMD = pProperty.getMetaData();
        String zNewValue = zPMD.valueToString( zPMD.validateAndNormalize( pNewValue ) );
        String zCurValue = pProperty.getValueAsString();
        return !areEqual( zCurValue, zNewValue ) ? new ChangeProperty( pProperty, zNewValue ) : null;
    }

    public String get_String( String pName, String pDefault )
    {
        Property zProperty = getProperty( pName );
        if ( zProperty != null )
        {
            Object zValue = zProperty.getValue();
            if ( zValue != null )
            {
                String rv = zValue.toString();
                if ( rv.length() != 0 )
                {
                    return rv;
                }
            }
        }
        return pDefault;
    }

    public boolean get_boolean( String pName )
    {
        Property zProperty = getProperty( pName );
        if ( zProperty != null )
        {
            Object zValue = zProperty.getValue();
            if ( zValue instanceof Boolean )
            {
                return Boolean.TRUE.equals( zValue );
            }
            if ( zValue != null )
            {
                String rv = zValue.toString();
                if ( rv.length() != 0 )
                {
                    return Boolean.parseBoolean( rv );
                }
            }
        }
        return false;
    }

    public int get_int( String pName, int pDefault )
    {
        Property zProperty = getProperty( pName );
        if ( zProperty != null )
        {
            Object zValue = zProperty.getValue();
            if ( zValue instanceof Integer )
            {
                return ((Integer) zValue);
            }
            if ( zValue != null )
            {
                String rv = zValue.toString();
                if ( rv.length() != 0 )
                {
                    return Integer.parseInt( rv );
                }
            }
        }
        return pDefault;
    }

    public Integer get_Integer( String pName, Integer pDefault )
    {
        Property zProperty = getProperty( pName );
        if ( zProperty != null )
        {
            Object zValue = zProperty.getValue();
            if ( zValue instanceof Integer )
            {
                return ((Integer) zValue);
            }
            if ( zValue != null )
            {
                String rv = zValue.toString();
                if ( rv.length() != 0 )
                {
                    return Integer.parseInt( rv );
                }
            }
        }
        return pDefault;
    }

    public String[] get_StringArray( String pName )
    {
        Property zProperty = getProperty( pName );
        if ( zProperty != null )
        {
            Object zValue = zProperty.getValue();
            if ( zValue instanceof String[] )
            {
                return ((String[]) zValue);
            }
            if ( zValue != null )
            {
                throw new IllegalArgumentException( "Property '" + pName + "' not a String Array, value: " + zValue );
            }
        }
        return new String[0];
    }

    protected class ChangeProperty implements ChangeFragment
    {
        private Property mProperty;
        private String mNewValue;

        public ChangeProperty( Property pProperty, String pNewValue )
        {
            mProperty = pProperty;
            mNewValue = pNewValue;
        }

        @Override
        public void commitChange()
        {
            if ( mProperty.setValue( mNewValue ) )
            {
                mChangeable.changed();
            }
        }
    }
}