package org.litesoft.aokeyhole.objects;

import java.util.*;

import org.litesoft.aokeyhole.objects.factories.*;
import org.litesoft.aokeyhole.objects.support.*;

/**
 * Note all Systems are created in unpersist mode
 */
public class SystemMetaData extends AbstractDataMetaData implements PropertyMetaDataDefinitionAccessor,
                                                                    MetaDataOwner<SystemMetaData, SubSystemMetaData>
{
    private MetaDataOwnerManager<SystemMetaData, SubSystemMetaData> mOwnerManager = new MetaDataOwnerManager<SystemMetaData, SubSystemMetaData>( this );

    private String mKeyHoleVersion;
    private SubSystemFactory mSubSystemFactory;
    private SubSystemMetaData mPrimeSubSystemMetaData = null;
    private Map<String, ObjectMetaData> mObjects = new HashMap<String, ObjectMetaData>();

    public SystemMetaData( boolean pEditable, String pKeyHoleVersion, SubSystemFactory pSubSystemFactory )
    {
        super( "System", Mode.Rehydrating, pEditable );

        mKeyHoleVersion = pKeyHoleVersion;
        mSubSystemFactory = pSubSystemFactory;
    }

    public String getKeyHoleVersion()
    {
        return mKeyHoleVersion;
    }

    public String getVersion()
    {
        return mSubSystemFactory.getPropertyMetaDataDefinitionAccessor().getVersion();
    }

    public ObjectSet[] getObjectSets()
    {
        return mSubSystemFactory.getPropertyMetaDataDefinitionAccessor().getObjectSets();
    }

    public AttributeSet[] getAttributeSets()
    {
        return mSubSystemFactory.getPropertyMetaDataDefinitionAccessor().getAttributeSets();
    }

    public boolean shouldShowParent( SubSystemMetaData pSubSystemMetaData, ObjectSet pObjectSet )
    {
        return mSubSystemFactory.getPropertyMetaDataDefinitionAccessor().shouldShowParent( pSubSystemMetaData, pObjectSet );
    }

    public MetaDataOwnerManager<SystemMetaData, SubSystemMetaData> getOwnerManager()
    {
        return mOwnerManager;
    }

    public SystemMetaData getSystemMetaData()
    {
        return this;
    }

    public boolean isUsedOwnedName( String pNewName )
    {
        return getOwnerManager().isUsedOwnedName( pNewName );
    }

    public void reKeyOwnedName( SubSystemMetaData pMetaDataOwned, String pNewName )
    {
        getOwnerManager().reKey( pMetaDataOwned, pNewName );
    }

    @Override
    public void clearChangeIndicators()
    {
        mOwnerManager.clearChangeIndicators();
        super.clearChangeIndicators();
    }

    /**
     * Only the first one will be editable
     *
     * @param pName   Non-Null Name of the SubSystem
     * @param pSource Used by the Persistence engine to resave from the original Source of the SubSystem
     *
     * @return Never null.
     */
    public SubSystemMetaData unpersistSubSystemMetaData( int pSortIndex, String pName, Object pSource )
    {
        SubSystemMetaData md = mSubSystemFactory.createSubSystemMetaData( pSortIndex, pName, pSource, isEditable() && (0 == mOwnerManager.getOwnedCount()) );
        mOwnerManager.add( md );
        if ( mPrimeSubSystemMetaData == null )
        {
            mPrimeSubSystemMetaData = md;
        }
        return md;
    }

    public ObjectMetaData getObject( String pName )
    {
        return mObjects.get( pName );
    }

    public boolean objectListHasChanged()
    {
        return (mSortedObjects == null);
    }

    private void objectListChanged()
    {
        mSortedObjects = null;
    }

    private ObjectMetaData[] mSortedObjects = null;

    public ObjectMetaData[] getSortedObjectMetaDatas()
    {
        if ( mSortedObjects == null )
        {
            ObjectMetaData[] zObjects = mObjects.values().toArray( new ObjectMetaData[mObjects.size()] );
            Arrays.sort( zObjects );
            mSortedObjects = zObjects;
        }
        return mSortedObjects;
    }

    public String[] getSortedParentOptionNames( SubSystemMetaData pSubSystemMetaData, ObjectSet pObjectSet, String pExcludedName )
    {
        return mSubSystemFactory.getPropertyMetaDataDefinitionAccessor().getSortedParentOptionNames( pSubSystemMetaData, pObjectSet, pExcludedName );
    }

    public void reKeyObject( ObjectMetaData pObjectMetaData, String pNewName )
    {
        String zOldName = pObjectMetaData.getName();

        if ( zOldName != null )
        {
            Object curO = mObjects.remove( zOldName );
            if ( curO != pObjectMetaData )
            {
                throw new IllegalStateException( "reKeyObject Failed from: " + zOldName );
            }
        }
        Object newO = mObjects.put( pNewName, pObjectMetaData );
        if ( newO != null )
        {
            throw new IllegalStateException( "reKeyObject Failed to: " + pNewName );
        }
        objectListChanged();
        changed();
    }

    public void remove( ObjectMetaData pObjectMetaData, ChangeHandler pChanges )
    {
        for ( ObjectMetaData zObject : mObjects.values() )
        {
            if ( zObject != pObjectMetaData )
            {
                zObject.clearAllAttributeRelatedToIf( pObjectMetaData, pChanges );
            }
        }
        pChanges.add( new DeleteObject( pObjectMetaData ) );
    }

    private void remove( ObjectMetaData pObjectMetaData )
    {
        String zOldName = pObjectMetaData.getName();

        if ( zOldName != null )
        {
            Object curO = mObjects.remove( zOldName );
            if ( curO != pObjectMetaData )
            {
                throw new IllegalStateException( "remove Failed from: " + zOldName );
            }
            objectListChanged();
            changed();
        }
    }

    public ObjectMetaData unpersist( ObjectMetaData pObjectMetaData )
    {
        String zName = pObjectMetaData.getName();

        if ( zName == null )
        {
            throw new IllegalStateException( "unpersist Object w/ No name" );
        }
        Object prev = mObjects.put( zName, pObjectMetaData );
        if ( prev != null )
        {
            throw new IllegalStateException( "Duplicate Object Name: " + zName );
        }
        objectListChanged();
        return pObjectMetaData;
    }

    public boolean isUsedObjectName( String pNewName )
    {
        return mObjects.containsKey( pNewName );
    }

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

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

    @Override
    public void addLines( List<String> pCollector, int pIndent )
    {
        pCollector.add( startLine( pIndent++ ).toString() );

        List<SubSystemMetaData> zSubSystems = new ArrayList<SubSystemMetaData>( getOwnerManager().getEntries() );
        Collections.sort( zSubSystems );
        for ( SubSystemMetaData zSubSystem : zSubSystems )
        {
            zSubSystem.addLines( pCollector, pIndent );
        }
    }

    protected class DeleteObject implements ChangeFragment
    {
        private ObjectMetaData mToDelete;

        public DeleteObject( ObjectMetaData pToDelete )
        {
            mToDelete = pToDelete;
        }

        public void commitChange()
        {
            remove( mToDelete );
        }
    }
}