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

import java.util.*;

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

public class ObjectMetaData extends AbstractNamedOwningMetaData<SubSystemMetaData, ObjectMetaData, AttributeMetaData> implements ViewSupportable,
                                                                                                                                 Comparable<ObjectMetaData>
{
    protected static final String CIRCULAR_ERROR = "Can NOT specify the current Object as it's own ";

    public static final ObjectMetaData[] EMPTY_ARRAY = new ObjectMetaData[0];

    private MetaDataOwnerManager<ObjectMetaData, AttributeMetaData> mOwnerManager = new MetaDataOwnerManager<ObjectMetaData, AttributeMetaData>( this );

    private ObjectSet mObjectSet;

    private AttributeFactory mAttributeFactory;
    private String mNotes = null;
    private PropertyManager mPropertyManager;

    private ObjectProxy mParent;
    private ObjectMetaData[] mGeneratedRelationsByParent = EMPTY_ARRAY;

    public ObjectMetaData( Mode pMode, boolean pEditable, ObjectSet pObjectSet, IdentifierValidator pNameValidator, String pName,
                           AttributeFactory pAttributeFactory )
    {
        super( pObjectSet.getType(), pMode, pEditable, pNameValidator, pName );

        mObjectSet = pObjectSet;
        mAttributeFactory = pAttributeFactory;
        mPropertyManager = new PropertyManager( this, isEditable(), pObjectSet.getPMDs() );

        mParent = new ObjectProxy( this, "Parent" );
    }

    @Override
    public MetaDataOwnerManager<ObjectMetaData, AttributeMetaData> getOwnerManager()
    {
        return mOwnerManager;
    }

    public String[] getPotentialRelateToObjectNamesFor( AttributeSet pAttributeSet, boolean pVirtual )
    {
        ObjectMetaData[] zSortedObjectMetaDatas = getSystemMetaData().getSortedObjectMetaDatas();
        List<String> rv = new ArrayList<String>( zSortedObjectMetaDatas.length );
        for ( ObjectMetaData zMD : zSortedObjectMetaDatas )
        {
            if ( pAttributeSet.isAcceptableAsRelatedTo( zMD, pVirtual ) )
            {
                rv.add( zMD.getName() );
            }
        }
        return rv.toArray( new String[rv.size()] );
    }

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

    @SuppressWarnings({"EqualsWhichDoesntCheckParameterClass"}) @Override
    public final boolean equals( Object obj )
    {
        return this == obj;
    }

    @Override
    public final int hashCode()
    {
        return System.identityHashCode( this );
    }

    @Override
    public String toString()
    {
        String zChanged = isChanged() ? " * " : "   ";
        return zChanged + getName() + zChanged;
    }

    @SuppressWarnings({"UnusedDeclaration"})
    public String toStringForError()
    {
        return getSubSystemMetaData().getName() + "." + getName();
    }

    public AttributeMetaData unpersistAttributeID( String pName )
    {
        return add( mAttributeFactory.createAttributeMetaDataID( getObjectSet(), Mode.Rehydrating, isEditable(), pName ) );
    }

    public AttributeMetaData unpersistAttributeValidOptions( AttributeType pType, String pName, String[] pOptions, boolean pVirtual )
    {
        return add( mAttributeFactory.createAttributeMetaDataValidOptions( getObjectSet(), Mode.Rehydrating, isEditable(), pType, pVirtual, pName, pOptions ) );
    }

    public AttributeMetaData unpersistAttributeSimple( AttributeType pType, String pName, boolean pVirtual )
    {
        return add( mAttributeFactory.createAttributeMetaDataSimple( getObjectSet(), Mode.Rehydrating, isEditable(), pType, pVirtual, pName ) );
    }

    public AttributeMetaData unpersistAttributeRelatedVirtual( AttributeType pType, String pName, String pRelatedToName )
    {
        AttributeMetaDataRelatedVirtual md =
                mAttributeFactory.createAttributeMetaDataRelatedVirtual( getObjectSet(), Mode.Rehydrating, isEditable(), pType, pName );
        add( md );
        md.unpersistRelatedTo( pRelatedToName );
        return md;
    }

    public AttributeMetaData unpersistAttributeRelatedPersisted( AttributeType pType, String pName, String pRelatedToName, String pBackAttrib )
    {
        AttributeMetaDataRelatedPersisted md =
                mAttributeFactory.createAttributeMetaDataRelatedPersisted( getObjectSet(), Mode.Rehydrating, isEditable(), pType, pName );
        add( md );
        md.unpersistRelatedTo( pRelatedToName );
        md.unpersistBackAttrib( pBackAttrib );
        return md;
    }

    public ObjectSet getObjectSet()
    {
        return mObjectSet;
    }

    public void createAttributeMetaDataID()
    {
        verifyEditability();

        add( mAttributeFactory.createAttributeMetaDataID( getObjectSet(), Mode.New, isEditable(), null ) );
    }

    public void createAttributeMetaDataCommonPairedToOne()
    {
        verifyEditability();

        add( mAttributeFactory.createAttributeMetaDataRelatedPersisted( getObjectSet(), Mode.New, isEditable(), A_CommonPairedToOne.TYPE, "Varies" ) );
    }

    public void createAttributeMetaDataPairedToOne()
    {
        verifyEditability();

        add( mAttributeFactory.createAttributeMetaDataRelatedPersisted( getObjectSet(), Mode.New, isEditable(), A_PairedToOne.TYPE, "PairTo" ) );
    }

    public void createAttributeMetaDataVariableBridgeToOneLeft()
    {
        verifyEditability();

        add( mAttributeFactory.createAttributeMetaDataRelatedPersisted( getObjectSet(), Mode.New, isEditable(), A_VariableBridgeToOneLeft.TYPE, "Left" ) );
    }

    public void createAttributeMetaDataBridgeToOneLeft()
    {
        verifyEditability();

        add( mAttributeFactory.createAttributeMetaDataRelatedPersisted( getObjectSet(), Mode.New, isEditable(), A_BridgeToOneLeft.TYPE, "Left" ) );
    }

    public void createAttributeMetaDataBridgeToOneRight()
    {
        verifyEditability();

        add( mAttributeFactory.createAttributeMetaDataRelatedPersisted( getObjectSet(), Mode.New, isEditable(), A_BridgeToOneRight.TYPE, "Right" ) );
    }

    public AttributeMetaData createAttributeMetaData( AttributeType pType, boolean pVirtual )
    {
        verifyEditability();

        if ( pType.getFAT().isRelated() )
        {
            return add( createRelatedAttributeMetaData( pType, pVirtual ) );
        }
        if ( pType instanceof AbstractValidOptionsAttributeTypeSimple )
        {
            return add( mAttributeFactory.createAttributeMetaDataValidOptions( getObjectSet(), Mode.New, isEditable(), pType, pVirtual, null ) );
        }
        // Simple
        return add( mAttributeFactory.createAttributeMetaDataSimple( getObjectSet(), Mode.New, isEditable(), pType, pVirtual, null ) );
    }

    private AttributeMetaData createRelatedAttributeMetaData( AttributeType pType, boolean pVirtual )
    {
        if ( pVirtual )
        {
            return mAttributeFactory.createAttributeMetaDataRelatedVirtual( getObjectSet(), Mode.New, isEditable(), pType, null );
        }
        return mAttributeFactory.createAttributeMetaDataRelatedPersisted( getObjectSet(), Mode.New, isEditable(), pType, null );
    }

    public void remove( AttributeMetaData pAMD )
    {
        getOwnerManager().remove( pAMD );
    }

    private AttributeMetaData add( AttributeMetaData pAMD )
    {
        getOwnerManager().add( pAMD );
        return pAMD;
    }

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

    public boolean shouldShowParent()
    {
        return getSystemMetaData().shouldShowParent( getSubSystemMetaData(), mObjectSet );
    }

    public String getParentLabel()
    {
        return mObjectSet.getParentLabel( getSubSystemMetaData().getName() );
    }

    public String getParentName()
    {
        return mParent.getObjectName();
    }

    public void unpersistParentName( String pParentName )
    {
        chkUnhappyCase( updateParentName( pParentName ) );
    }

    /**
     * @return null or Error
     */
    public String setParentName( String pParentName )
    {
        verifyEditability();
        return updateParentName( pParentName );
    }

    /**
     * @return null or Error
     */
    protected String updateParentName( String pParentName )
    {
        ObjectMetaData curParent = mParent.getObjectMetaData();
        try
        {
            if ( !mParent.setObjectName( pParentName, this, CIRCULAR_ERROR + getParentLabel() ) )
            {
                return null;
            }
        }
        catch ( IllegalArgumentException e )
        {
            return e.getMessage();
        }
        if ( curParent != null )
        {
            curParent.removeGeneratedRelation( this );
        }
        wireGeneratedRelation();
        changed();
        return null;
    }

    private void wireGeneratedRelation() // Parent or Paired
    {
        ObjectMetaData newParent = mParent.getObjectMetaData();
        if ( newParent != null )
        {
            newParent.addGeneratedRelation( this );
        }
    }

    @SuppressWarnings({"UnusedDeclaration"})
    public PropertyManager getPropertyManager()
    {
        return mPropertyManager;
    }

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

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

    @Override
    public void setRehydrated()
    {
        if ( getOwnerManager().available( AttributeMetaData.ID_NAME ) && mObjectSet.requireID() )
        {
            add( mAttributeFactory.createAttributeMetaDataID( getObjectSet(), Mode.Rehydrating, isEditable(), null ) );
        }
        mPropertyManager.setRehydrated();
        mParent.unpersistFini( getSystemMetaData(), getNameValidator(), this, CIRCULAR_ERROR + getParentLabel() );
        wireGeneratedRelation();
        super.setRehydrated();
    }

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

    public String[] getSortedChildNames()
    {
        if ( mGeneratedRelationsByParent.length == 0 )
        {
            return EMPTY_STRINGS;
        }
        String[] names = new String[mGeneratedRelationsByParent.length];
        for ( int i = 0; i < mGeneratedRelationsByParent.length; i++ )
        {
            names[i] = mGeneratedRelationsByParent[i].getName();
        }
        Arrays.sort( names );
        return names;
    }

    public void addGeneratedRelation( ObjectMetaData pGeneratedRelation ) // Parent or Paired
    {
        mGeneratedRelationsByParent = add( mGeneratedRelationsByParent, pGeneratedRelation );
    }

    public void removeGeneratedRelation( ObjectMetaData pGeneratedRelation )
    {
        mGeneratedRelationsByParent = remove( mGeneratedRelationsByParent, pGeneratedRelation );
    }

    public String[] getSortedRelatedPersistedAttributeNamesTo( boolean pToManys, ObjectMetaData pToObject )
    {
        ArrayList<String> names = new ArrayList<String>();
        for ( AttributeMetaData zAMD : getOwnerManager().getEntries() )
        {
            if ( zAMD.isRelated() && !zAMD.isVirtual() )
            {
                AttributeMetaDataRelatedPersisted rpmd = (AttributeMetaDataRelatedPersisted) zAMD;
                if ( (pToManys == rpmd.isToMany()) && (rpmd.isRelatedTo( pToObject ) || rpmd.isVariableToOne()) )
                {
                    names.add( zAMD.getName() );
                }
            }
        }
        Collections.sort( names );
        return names.toArray( new String[names.size()] );
    }

    public AttributeMetaData getAttribute( String pName )
    {
        return getOwnerManager().getEntry( pName );
    }

    public List<AttributeMetaData> getSortedAttributes()
    {
        List<AttributeMetaData> rv = new ArrayList<AttributeMetaData>( getOwnerManager().getEntries() );
        Collections.sort( rv );
        return rv;
    }

    protected ObjectMetaData[] add( ObjectMetaData[] pOrig, ObjectMetaData pNew )
    {
        int oldLength = pOrig.length;
        if ( oldLength == 0 )
        {
            return new ObjectMetaData[]{pNew};
        }
        ObjectMetaData[] joined = new ObjectMetaData[oldLength + 1];
        joined[0] = pNew;
        System.arraycopy( pOrig, 0, joined, 1, oldLength );
        return joined;
    }

    protected ObjectMetaData[] remove( ObjectMetaData[] pOrig, ObjectMetaData pToRemove )
    {
        for ( int i = 0; i < pOrig.length; i++ )
        {
            if ( pToRemove == pOrig[i] )
            {
                if ( i == 0 )
                {
                    return removeFirst( pOrig );
                }
                if ( i == (pOrig.length - 1) )
                {
                    return removeLast( pOrig );
                }
                return removeMiddle( pOrig, i );
            }
        }
        return pOrig;
    }

    private ObjectMetaData[] removeFirst( ObjectMetaData[] pOrig )
    {
        if ( pOrig.length == 1 )
        {
            return EMPTY_ARRAY;
        }
        int newLength = pOrig.length - 1;
        ObjectMetaData[] shrunk = new ObjectMetaData[newLength];
        System.arraycopy( pOrig, 1, shrunk, 0, newLength );
        return shrunk;
    }

    private ObjectMetaData[] removeLast( ObjectMetaData[] pOrig )
    {
        int newLength = pOrig.length - 1;
        ObjectMetaData[] shrunk = new ObjectMetaData[newLength];
        System.arraycopy( pOrig, 0, shrunk, 0, newLength );
        return shrunk;
    }

    private ObjectMetaData[] removeMiddle( ObjectMetaData[] pOrig, int pIndex )
    {
        int newLength = pOrig.length - 1;
        ObjectMetaData[] shrunk = new ObjectMetaData[newLength];
        System.arraycopy( pOrig, 0, shrunk, 0, pIndex );
        System.arraycopy( pOrig, pIndex + 1, shrunk, pIndex, newLength - pIndex );
        return shrunk;
    }

    public void addTo( SubSystemBuilder pBuilder )
    {
        ObjectBuilder zBuilder =
                pBuilder.createObjectBuilder( getMetaDataType(), getName(), getParentName(), SingleLineNotes.convertStringToLines( getNotes() ) );
        mPropertyManager.addTo( zBuilder );
        for ( AttributeMetaData zAttribute : getSortedAttributes() )
        {
            zAttribute.addTo( zBuilder );
        }
        zBuilder.done();
    }

    public void populateFrom( ObjectReader pReader )
    {
        unpersistNotes( SingleLineNotes.convertLinesToString( pReader.getNotes() ) );
        for ( PropertyReader zReader; null != (zReader = pReader.nextProperty()); )
        {
            String zWhat = zReader.getWhat();
            String zData = zReader.getData();
            mPropertyManager.unpersistProperty( zWhat, zData );
        }
        for ( AttributeReader zReader; null != (zReader = pReader.nextAttribute()); )
        {
            String zType = zReader.getType();

            boolean zVirtual = zReader.isVirtual();
            AttributeSet zSet = determineAttributeSet( zType, zVirtual );
            if ( zSet == null )
            {
                throw zReader.unrecognizedType(
                        "Unrecognized Attribute-type '" + (zVirtual ? "Virtual-" : "") + zType + "', not" + mAttributeFactory.getTypesForError() );
            }

            createAttributeMetaData( zSet, zVirtual, zReader ).populateFrom( zReader );
        }
    }

    private AttributeMetaData createAttributeMetaData( AttributeSet pSet, boolean pVirtual, AttributeReader pReader )
    {
        AttributeType zType = pSet.getType();
        FundamentalAttributeType zFAT = zType.getFAT();
        if ( zFAT.isRelated() )
        {
            String[] parts;
            if ( pVirtual )
            {
                parts = pReader.getAdditionalValues( 1 ); // assert there are not more than 1
                return unpersistAttributeRelatedVirtual( zType, pReader.getName(), parts[0] ); // RelatedToName
            }
            parts = pReader.getAdditionalValues( 2 ); // assert there are not more than 2
            return unpersistAttributeRelatedPersisted( zType, pReader.getName(), parts[0], parts[1] ); // RelatedToName, BackAttrib
        }
        if ( zType instanceof AbstractValidOptionsAttributeTypeSimple )
        {
            return unpersistAttributeValidOptions( zType, pReader.getName(), pReader.getAdditionalValues( null ), pVirtual );
        }
        pReader.getAdditionalValues( 0 ); // assert there are none!
        if ( zType instanceof A_ID )
        {
            return unpersistAttributeID( pReader.getName() );
        }
        return unpersistAttributeSimple( zType, pReader.getName(), pVirtual );
    }

    private AttributeSet determineAttributeSet( String pWhat, boolean pVirtual )
    {
        for ( AttributeSet zSet : mAttributeFactory.getAttributeSets() )
        {
            if ( pWhat.equals( zSet.getType().toString() ) )
            {
                if ( pVirtual )
                {
                    return (zSet.getVirtual() != null) ? zSet : null;
                }
                return (zSet.getPersisted() != null) ? zSet : null;
            }
        }
        return null;
    }

    public SubSystemMetaData getSubSystemMetaData()
    {
        return getOwner();
    }

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

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

    /**
     * @return null or Error
     */
    @Override
    public 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 String deleteExisting()
    {
        ChangeHandler zChanges = new ChangeHandler();
        try
        {
            deleteExisting( zChanges );
        }
        catch ( RuntimeException e )
        {
            return e.getMessage();
        }

        zChanges.commitChanges();
        return null;
    }

    private void deleteExisting( ChangeHandler pChanges )
    {
        Collection<AttributeMetaData> zChildren = getOwnerManager().getEntries();
        for ( AttributeMetaData zAMD : new ArrayList<AttributeMetaData>( zChildren ) )
        {
            zAMD.deleteExistingCollectChanges( pChanges );
        }
        getSubSystemMetaData().remove( this, pChanges );
    }

    public void clearAllAttributeRelatedToIf( ObjectMetaData pObjectMetaData, ChangeHandler pChanges )
    {
        Collection<AttributeMetaData> zChildren = getOwnerManager().getEntries();
        for ( AttributeMetaData zAMD : new ArrayList<AttributeMetaData>( zChildren ) )
        {
            zAMD.clearRelatedToIf( pObjectMetaData, pChanges );
        }
    }

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

        protected AbstractChangeFragment( ObjectMetaData 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 ) )
        {
            SubSystemMetaData zOwner = getSubSystemMetaData();
            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( ObjectMetaData 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( ObjectMetaData pCaller, String pNewNotes )
        {
            super( pCaller );
            mNewNotes = pNewNotes;
        }

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

    protected ChangeFragment checkParentChange( String pCurParent, String pNewParent )
    {
        return !areEqual( pCurParent, pNewParent ) ? new ChangeParent( pNewParent ) : null;
    }

    protected class ChangeParent implements ChangeFragment
    {
        private String mNewParent;

        public ChangeParent( String pNewParent )
        {
            mNewParent = pNewParent;
        }

        @Override
        public void commitChange()
        {
            setParentName( mNewParent );
        }
    }
}