package org.litesoft.aokeyhole.objects;

import java.util.*;

import org.litesoft.aokeyhole.objects.factories.*;
import org.litesoft.aokeyhole.objects.support.*;
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 Object mSource;
    private ObjectFactory mObjectFactory;

    public SubSystemMetaData( boolean pEditable, IdentifierValidator pNameValidator, int pSortIndex, String pName, Object pSource, ObjectFactory pObjectFactory )
    {
        super( "SubSystem", Mode.Rehydrating, pEditable, pNameValidator, pName );

        mSortIndex = pSortIndex;
        mSource = pSource;
        mObjectFactory = pObjectFactory;
    }

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

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

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

    public Object getSource()
    {
        return mSource;
    }

    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
    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 void createObjectsFromLines( String[] pLines )
    {
        ToLinesObjectsParseStream ops = new ToLinesObjectsParseStream( pLines );

        if ( ops.readLine() )
        {
            validateFileVersion( ops );
            while ( ops.readLine() )
            {
                createObjectFrom( ops );
            }
        }
    }

    private void validateFileVersion( ToLinesObjectsParseStream pOPS )
    {
        pOPS.validateDepth( 0 );

        String zType = pOPS.getWhat();

        if ( !"vs".equals( zType ) )
        {
            throw pOPS.error( "First Line not a 'vs' (version) line" );
        }
        String[] zParts = pOPS.parseData( '|' );
        String zActual = zParts[0];
        String zExpected = getSystemMetaData().getVersion();
        if ( !zExpected.equals( zActual ) )
        {
            throw pOPS.error( "File version mismatch, got '" + zActual + "', but expected '" + zExpected + "'." );
        }
    }

    private String createVersionLine()
    {
        return "vs:" + getSystemMetaData().getVersion() + "|" + getSystemMetaData().getKeyHoleVersion();
    }

    private void createObjectFrom( ToLinesObjectsParseStream pOPS )
    {
        pOPS.validateDepth( 0 );

        String zType = pOPS.getWhat();

        ObjectSet[] zObjectSets = mObjectFactory.getObjectSets();

        for ( ObjectSet zSet : zObjectSets )
        {
            if ( zSet.getType().equals( zType ) )
            {
                String[] nameNparent = pOPS.parseData( 2, '|' );
                ObjectMetaData md = unpersistObjectMetaData( zSet, nameNparent[0], nameNparent[1] );
                md.populateFrom( pOPS );
                return;
            }
        }
        throw pOPS.error( "Unrecognized Object-type '" + zType + "', not" + mObjectFactory.getTypesForError() );
    }

    public String[] toLinesObjects()
    {
        LinkedList<String> list = new LinkedList<String>();
        list.add( createVersionLine() );
        addOwnings( list, 0, getSortedObjects() );
        return list.toArray( new String[list.size()] );
    }

    public void addLines( List<String> pCollector, int pIndent )
    {
        pCollector.add( "" );
        pCollector.add( "" );
        pCollector.add( "" );
        StringBuilder sb = startLine( pIndent++ ).append( '|' );
        if ( mSource != null )
        {
            sb.append( mSource.toString() );
        }
        pCollector.add( sb.toString() );
        addOwnings( pCollector, pIndent, getSortedObjects() );
    }

    protected class DeleteObject implements ChangeFragment
    {
        private ObjectMetaData mToDelete;

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

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