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

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

import java.util.*;

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();
            }
        }
    }
}