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

import org.litesoft.aokeyhole.objects.support.*;
import org.litesoft.aokeyhole.persist.*;
import org.litesoft.aokeyhole.toolkit.*;
import org.litesoft.core.simpletypes.nonpublic.*;

public abstract class AttributeMetaData extends AbstractNamedMetaData<ObjectMetaData> implements MinimalAttributeMetaData,
                                                                                                 ViewSupportable,
                                                                                                 Comparable<AttributeMetaData>
{
    public static final String ID_NAME = "ID";

    private final AttributeSet mAttributeSet;
    private final boolean mVirtual;
    private final PropertyManager mPropertyManager;
    private String mNotes = null;

    protected AttributeMetaData( AttributeSet pAttributeSet, Mode pMode, boolean pEditable, boolean pVirtual, PropertyMetaData[] pPropertyMetaDatas,
                                 IdentifierValidator pNameValidator, String pName )
    {
        super( pAttributeSet.getType().toString(), pMode, pEditable, pNameValidator, pName );

        mAttributeSet = pAttributeSet;
        mVirtual = pVirtual;
        mPropertyManager = new PropertyManager( this, pEditable, pPropertyMetaDatas );
    }

    @Override
    public int compareTo( AttributeMetaData them )
    {
        int zDiff = this.getAttributeSet().getSortIndex() - them.getAttributeSet().getSortIndex();
        if ( zDiff != 0 )
        {
            return zDiff;
        }
        return CompareSupport.compare( this.getName(), them.getName() );
    }

    public AttributeSet getAttributeSet()
    {
        return mAttributeSet;
    }

    abstract public boolean isRelated();

    public boolean isVirtual()
    {
        return mVirtual;
    }

    @Override
    public Class getSimpleDataType()
    {
        return getAttributeSetType().getSimpleDataType();
    }

    @Override
    public AttributeType getAttributeSetType()
    {
        return getAttributeSet().getType();
    }

    public String getNotes()
    {
        return mNotes;
    }

    public void unpersistNotes( String pNotes )
    {
        mNotes = pNotes;
    }

    public void setNotes( String pNotes )
    {
        verifyEditability();
        if ( !areEqual( mNotes, pNotes ) )
        {
            mNotes = pNotes;
            changed();
        }
    }

    @SuppressWarnings("UnusedDeclaration")
    public Object getPropertyValue( String pName )
    {
        Property property = mPropertyManager.getProperty( pName );
        return (property == null) ? null : property.getValue();
    }

    public PropertyManager getPropertyManager()
    {
        return mPropertyManager;
    }

    @SuppressWarnings("UnusedDeclaration")
    public Property[] getProperties()
    {
        return mPropertyManager.getProperties();
    }

    @SuppressWarnings("UnusedDeclaration")
    public void unpersistProperty( String pName, String pValueAsString )
    {
        mPropertyManager.unpersistProperty( pName, pValueAsString );
    }

    /**
     * @return null or Error
     */
    @SuppressWarnings("UnusedDeclaration")
    public String setPropertyValue( String pName, Object pValue )
    {
        return mPropertyManager.updatePropertyValue( pName, pValue );
    }

    public void populateFrom( AttributeReader pReader )
    {
        for ( PropertyReader zReader; null != (zReader = pReader.nextProperty()); )
        {
            String zWhat = zReader.getWhat();
            String zData = zReader.getData();
            if ( ObjectNames.NOTES.equals( zWhat ) )
            {
                unpersistNotes( zData );
            }
            else
            {
                mPropertyManager.unpersistProperty( zWhat, zData );
            }
        }
    }

    @Override
    public void setRehydrated()
    {
        super.setRehydrated();
        mPropertyManager.setRehydrated();
    }

    /**
     * @return null or Error
     */
    @Override
    public String validatePersistable()
    {
        String error = super.validatePersistable();
        return (error != null) ? error : mPropertyManager.validatePersistable();
    }

    public void addTo( ObjectBuilder pBuilder )
    {
        AttributeBuilder zBuilder = pBuilder.createAttributeBuilder( getMetaDataType(), isVirtual(), getName(),
                                                                     SingleLineNotes.convertStringToLines( getNotes() ),
                                                                     getAdditionalValues() );
        mPropertyManager.addTo( zBuilder );
        zBuilder.done();
    }

    abstract protected String[] getAdditionalValues();

    @Override
    public void setUpView( NameValuesComponent pNameValuesComponent )
    {
        pNameValuesComponent.setValue( AttribNames.NAME, getName() );
        pNameValuesComponent.setValue( ObjectNames.NOTES, getNotes() );
        mPropertyManager.setUpView( pNameValuesComponent );
    }

    protected void saveFromViewCollectChanges( ChangeHandler pChanges, NameValuesComponent pNameValuesComponent )
    {
        pChanges.add( checkNameChange( pNameValuesComponent.getValue( AttribNames.NAME ) ) );
        pChanges.add( checkNotesChange( pNameValuesComponent.getValue( ObjectNames.NOTES ) ) );
        mPropertyManager.saveFromView( pChanges, pNameValuesComponent );
    }

    /**
     * @return null or Error
     */
    @Override
    public final String saveFromView( NameValuesComponent pNameValuesComponent )
    {
        ChangeHandler zChanges = new ChangeHandler();
        try
        {
            saveFromViewCollectChanges( zChanges, pNameValuesComponent );
        }
        catch ( RuntimeException e )
        {
            return e.getMessage();
        }

        zChanges.commitChanges();
        return null;
    }

    /**
     * @return null or Error
     */
    public final String deleteExisting()
    {
        ChangeHandler zChanges = new ChangeHandler();
        try
        {
            deleteExistingCollectChanges( zChanges );
        }
        catch ( RuntimeException e )
        {
            return e.getMessage();
        }

        zChanges.commitChanges();
        return null;
    }

    public void deleteExistingCollectChanges( ChangeHandler pChanges )
    {
        pChanges.add( new DeleteAttribute( this ) );
    }

    public ObjectMetaData getObjectMetaData()
    {
        return getOwner();
    }

    public void clearRelatedToIf( ObjectMetaData pObjectMetaData, ChangeHandler pChanges )
    {
    }

    protected abstract static class AbstractChangeFragment implements ChangeFragment
    {
        protected AttributeMetaData mCaller;

        protected AbstractChangeFragment( AttributeMetaData pCaller )
        {
            mCaller = pCaller;
        }
    }

    protected ChangeFragment checkNameChange( String pNewName )
    {
        String zError = getNameValidator().validateIdentifier( pNewName, "Attribute Name" );
        if ( zError != null )
        {
            throw new RuntimeException( zError );
        }
        String zCurName = getName();
        if ( !areEqual( zCurName, pNewName ) )
        {
            ObjectMetaData zOwner = getObjectMetaData();
            if ( zOwner.isUsedOwnedName( pNewName ) )
            {
                throw new RuntimeException( "Duplicate Name" );
            }
            return createChangeNameFragment( pNewName );
        }
        return null;
    }

    protected ChangeFragment createChangeNameFragment( String pNewName )
    {
        return new ChangeName( this, pNewName );
    }

    protected static class ChangeName extends AbstractChangeFragment
    {
        private String mNewName;

        public ChangeName( AttributeMetaData pCaller, String pNewName )
        {
            super( pCaller );
            mNewName = pNewName;
        }

        @Override
        public void commitChange()
        {
            mCaller.setName( mNewName );
        }
    }

    protected ChangeFragment checkNotesChange( String pNewNotes )
    {
        String zCurNotes = getNotes();
        return !areEqual( zCurNotes, pNewNotes ) ? createChangeNotesFragment( pNewNotes ) : null;
    }

    protected ChangeFragment createChangeNotesFragment( String pNewNotes )
    {
        return new ChangeNotes( this, pNewNotes );
    }

    protected static class ChangeNotes extends AbstractChangeFragment
    {
        private String mNewNotes;

        public ChangeNotes( AttributeMetaData pCaller, String pNewNotes )
        {
            super( pCaller );
            mNewNotes = pNewNotes;
        }

        @Override
        public void commitChange()
        {
            mCaller.setNotes( mNewNotes );
        }
    }

    protected static class DeleteAttribute extends AbstractChangeFragment
    {
        public DeleteAttribute( AttributeMetaData pCaller )
        {
            super( pCaller );
        }

        @Override
        public void commitChange()
        {
            mCaller.getObjectMetaData().remove( mCaller );
        }
    }
}