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

import org.litesoft.aokeyhole.objects.*;
import org.litesoft.aokeyhole.objects.support.*;
import org.litesoft.aokeyhole.swing.*;
import org.litesoft.aokeyhole.toolkit.*;

import javax.swing.*;

public abstract class NamedComponent extends LabeledComponent implements NameValueComponent, ValueChangedListener // todo: Indicate Errors?
{
    private static final ValueStringConverter NULL_VALIDATER = new NullValueStringConverter();
    private static final int VALUE_CHANGE_REJECTED = 0;
    private static final int VALUE_CHANGE_ACCEPTED = 1;
    private static final int VALUE_CHANGE_BUT_MUTATED = 2;

    private boolean mDataRequired;
    private boolean mPermDisabled = false;
    protected NameValueChangedByUserListener mNameValueChangedByUserListener = null;
    private ValueStringConverter mValidater = NULL_VALIDATER;
    private String mInitialValue = null; // 'External' (non-Native) Value
    protected Object mLastValue = null; // Component Native Value
    protected boolean mSystemUpdate = false;

    protected NamedComponent( NameValueComponentParams pParams )
    {
        super( pParams );

        mDataRequired = pParams.isDataRequired();
        setName( pParams.getName() );
        mPermDisabled = pParams.isPermDisabled();
        mNameValueChangedByUserListener = pParams.getNameValueChangedByUserListener();
        mValidater = (pParams.getValidater() != null) ? pParams.getValidater() : NULL_VALIDATER;
        mInitialValue = mValidater.valueToString( mValidater.validateAndNormalize( pParams.getInitialValue() ) );
    }

    @Override
    public LabeledComponent initialize()
    {
        super.initialize();

        if ( mPermDisabled )
        {
            LLsetComponentEnabled( false );
        }

        return this;
    }

    public String getInitialValue()
    {
        return mInitialValue;
    }

    public boolean isDataRequired()
    {
        return mDataRequired;
    }

    @Override
    public String getValue()
    {
        String rv = mValidater.valueToString( mValidater.validateAndNormalize( getComponentValue() ) );
        return (rv.length() != 0) ? rv : null;
    }

    @Override
    public void clearValue()
    {
        if ( !setValue( mInitialValue ) )
        {
            System.err.println( "NamedComponent(" + getName() + ").clearValue failed with: '" + mInitialValue + "'" );
        }
    }

    @Override
    public void initializeView()
    {
        // Nothing needed at the common level
    }

    @Override
    public boolean setValue( String pValue )
    {
        try
        {
            systemSetComponentValue( mValidater.validateAndNormalize( pValue ) );
        }
        catch ( ParseException e )
        {
            return false;
        }
        return true;
    }

    @Override
    public boolean setOptions( String[] pOptions )
    {
        return false;
    }

    @Override
    public void setComponentEnabled( boolean pEnable )
    {
        if ( !mPermDisabled )
        {
            LLsetComponentEnabled( pEnable );
        }
    }

    @Override
    public boolean isComponentEnabled()
    {
        return !mPermDisabled && LLisComponentEnabled();
    }

    abstract protected boolean LLisComponentEnabled();

    abstract protected void LLsetComponentEnabled( boolean pEnable );

    protected void systemSetComponentValue( Object pValue )
    {
        mSystemUpdate = true;
        try
        {
            setComponentValue( mLastValue = normalize( pValue ) );
        }
        finally
        {
            mSystemUpdate = false;
        }
    }

    protected Object normalize( Object pValue )
    {
        return pValue;
    }

    protected int determineValueChangeType( Object pCurCompValue, Object pMutatedCompValue )
    {
        if ( AbstractBase.areEqual( pMutatedCompValue, mLastValue ) )
        {
            return VALUE_CHANGE_REJECTED;
        }
        if ( AbstractBase.areEqual( pMutatedCompValue, pCurCompValue ) )
        {
            return VALUE_CHANGE_ACCEPTED;
        }
        return VALUE_CHANGE_BUT_MUTATED;
    }

    protected void notifyValueChangedByUser()
    {
        if ( mNameValueChangedByUserListener != null )
        {
            mNameValueChangedByUserListener.namedValueChangedByUser( getName() );
        }
    }

    @Override
    public void valueChanged()
    {
        if ( !mSystemUpdate )
        {
            Object curValue = getComponentValue();
            if ( !AbstractBase.areEqual( curValue, mLastValue ) )
            {
                Object mutatedValue = mutateChangeTo( mLastValue, curValue );
                Runnable r;
                switch ( determineValueChangeType( curValue, mutatedValue ) )
                {
                    default:
                    case VALUE_CHANGE_REJECTED:
                        r = new ValueChangeRejectedRunner();
                        break;
                    case VALUE_CHANGE_ACCEPTED:
                        mLastValue = curValue;
                        r = new ValueChangeAcceptedRunner();
                        break;
                    case VALUE_CHANGE_BUT_MUTATED:
                        r = new ValueChangeButMutatedRunner( mutatedValue );
                        break;
                }
                SwingUtilities.invokeLater( r );
            }
        }
    }

    protected Object mutateChangeTo( Object pLastValue, Object pCurValue )
    {
        return pCurValue;
    }

    abstract public Object getComponentValue();

    abstract public void setComponentValue( Object pValue );

    protected String toString( Object pValue )
    {
        return mValidater.valueToString( pValue );
    }

    private static class NullValueStringConverter implements ValueStringConverter
    {
        @Override
        public Object validateAndNormalize( Object pValue )
                throws ParseException
        {
            return pValue;
        }

        @Override
        public String valueToString( Object pValue )
        {
            return (pValue == null) ? null : pValue.toString();
        }
    }

    private class ValueChangeRejectedRunner implements Runnable
    {
        @Override
        public void run()
        {
            systemSetComponentValue( mLastValue );
        }
    }

    private class ValueChangeAcceptedRunner implements Runnable
    {
        @Override
        public void run()
        {
            notifyValueChangedByUser();
        }
    }

    private class ValueChangeButMutatedRunner implements Runnable
    {
        private Object mMutatedValue;

        public ValueChangeButMutatedRunner( Object pMutatedValue )
        {
            mMutatedValue = pMutatedValue;
        }

        @Override
        public void run()
        {
            systemSetComponentValue( mMutatedValue );
            notifyValueChangedByUser();
        }
    }
}