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

import java.io.*;
import java.util.*;

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

/**
 * Note all SubSystems are created in unpersist mode
 */
public class SubSystemMetaData extends AbstractNamedOwningMetaData<SystemMetaData, SubSystemMetaData, ObjectMetaData> implements Comparable<SubSystemMetaData>
{
    private MetaDataOwnerManager<SubSystemMetaData, ObjectMetaData> mOwnerManager = new MetaDataOwnerManager<SubSystemMetaData, ObjectMetaData>( this );

    private int mSortIndex;
    private SubSystemPersister mPersister;
    private ObjectFactory mObjectFactory;

    public SubSystemMetaData( boolean pEditable, IdentifierValidator pNameValidator, int pSortIndex, SubSystemPersister pPersister, ObjectFactory pObjectFactory )
    {
        super( "SubSystem", Mode.Rehydrating, pEditable, pNameValidator, pPersister.getName() );

        mSortIndex = pSortIndex;
        mPersister = pPersister;
        mObjectFactory = pObjectFactory;
    }

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

    @Override
    public int compareTo( SubSystemMetaData them )
    {
        return this.mSortIndex - them.mSortIndex;
    }

    @Override
    protected String updateName( String pName )
    {
        return getMetaDataType() + " does NOT support Name Change";
    }

    @Override
    public boolean isUsedOwnedName( String pNewName )
    {
        return getSystemMetaData().isUsedObjectName( pNewName );
    }

    // If we can succeed at the System level, then need to manage our list of Objects
    @Override
    public void reKeyOwnedName( ObjectMetaData pMetaDataOwned, String pNewName )
    {
        getSystemMetaData().reKeyObject( pMetaDataOwned, pNewName );
        super.reKeyOwnedName( pMetaDataOwned, pNewName );
    }

    public String[] getSortedParentOptionNames( ObjectSet pObjectSet, String pExcludedName )
    {
        return getSystemMetaData().getSortedParentOptionNames( this, pObjectSet, pExcludedName );
    }

    public ObjectMetaData unpersistObjectMetaData( ObjectSet pObjectSet, String pName, String pParentName )
    {
        ObjectMetaData md = mObjectFactory.createObjectMetaData( Mode.Rehydrating, isEditable(), pObjectSet, pName );
        getOwnerManager().add( md );
        md.unpersistParentName( pParentName );
        return getSystemMetaData().unpersist( md );
    }

    public void remove( ObjectMetaData pObjectMetaData, ChangeHandler pChanges )
    {
        pChanges.add( new DeleteObject( pObjectMetaData ) );
        getSystemMetaData().remove( pObjectMetaData, pChanges );
    }

    private void remove( ObjectMetaData pObjectMetaData )
    {
        getOwnerManager().remove( pObjectMetaData );
    }

    public ObjectMetaData createObjectMetaData( ObjectSet pObjectSet )
    {
        verifyEditability();
        ObjectMetaData md = mObjectFactory.createObjectMetaData( Mode.New, isEditable(), pObjectSet, null );
        getOwnerManager().add( md );
        pObjectSet.justCreated( md );
        return md;
    }

    public ObjectMetaData getObject( String pName )
    {
        return getOwnerManager().getEntry( pName );
    }

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

    public SubSystemMetaData loadObjects()
            throws IOException
    {
        SubSystemReader zSubSystemReader = mPersister.getReader( getSystemMetaData().getVersion() );
        for ( ObjectReader zReader; null != (zReader = zSubSystemReader.nextObject()); )
        {
            createObjectFrom( zReader );
        }
        return this;
    }

    private void createObjectFrom( ObjectReader pReader )
    {
        String zType = pReader.getType();
        for ( ObjectSet zSet : mObjectFactory.getObjectSets() )
        {
            if ( zSet.getType().equals( zType ) )
            {
                unpersistObjectMetaData( zSet, pReader.getName(), pReader.getParent() ).populateFrom( pReader );
                return;
            }
        }
        throw pReader.unrecognizedType( "Unrecognized Object-type '" + zType + "', not" + mObjectFactory.getTypesForError() );
    }

    public SubSystemWriter toSubSystemWriter()
    {
        SubSystemBuilder zBuilder = mPersister.getBuilder( getSystemMetaData().getVersion(), getSystemMetaData().getKeyHoleVersion() );

        for ( ObjectMetaData zObject : getSortedObjects() )
        {
            zObject.addTo( zBuilder );
        }

        return zBuilder.done();
    }

    protected class DeleteObject implements ChangeFragment
    {
        private ObjectMetaData mToDelete;

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

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