package org.litesoft.aokeyhole.objects.support;

import java.util.*;

public class MetaDataOwnerManager<Owner extends MetaDataOwner,Owned extends AbstractNamedMetaData<Owner>>
{
    private Owner mOurOwner;
    private Map<String, Owned> mOwned = new HashMap<String, Owned>();
    private Owned mUnNamed = null;

    public MetaDataOwnerManager( Owner pOurOwner )
    {
        mOurOwner = pOurOwner;
    }

    public int getOwnedCount()
    {
        return mOwned.size();
    }

    public void add( Owned pToBeOwned )
    {
        // System.out.println( "" + this + ".add: " + pToBeOwned );
        String name = pToBeOwned.getName();
        if ( name == null )
        {
            mUnNamed = pToBeOwned;
        }
        else
        {
            Object prev = mOwned.put( name, pToBeOwned );
            if ( prev != null )
            {
                throw new IllegalStateException( "add w/ dup name: " + name );
            }
        }
        pToBeOwned.setOwner( mOurOwner );
    }

    public boolean remove( Owned pCurrentlyOwned )
    {
        // System.out.println( "" + this + ".remove: " + pCurrentlyOwned );
        String name = pCurrentlyOwned.getName();
        if ( name == null )
        {
            throw new IllegalStateException( "remove w/ No name" );
        }
        Object prev = mOwned.remove( name );
        if ( prev == null )
        {
            return false;
        }
        if ( prev != pCurrentlyOwned )
        {
            throw new IllegalStateException( "remove '" + pCurrentlyOwned + "', but removed dup: " + prev );
        }
        pCurrentlyOwned.setOwner( null );
        mOurOwner.changed();
        return true;
    }

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

    public void reKey( Owned pOwnedToBeReKeyed, String pNewName )
    {
        if ( mOurOwner != pOwnedToBeReKeyed.getOwner() )
        {
            throw new IllegalStateException( "reKey Failed not properly Owned" );
        }
        String pOldName = pOwnedToBeReKeyed.getName();

        if ( pOldName == null )
        {
            if ( pOwnedToBeReKeyed != mUnNamed )
            {
                throw new IllegalStateException( "reKey Failed from UnNamed" );
            }
        }
        else
        {
            Object curO = mOwned.remove( pOldName );
            if ( curO != pOwnedToBeReKeyed )
            {
                throw new IllegalStateException( "reKey Failed from: " + pOldName );
            }
        }
        Object newO = mOwned.put( pNewName, pOwnedToBeReKeyed );
        if ( newO != null )
        {
            throw new IllegalStateException( "reKey Failed to: " + pNewName );
        }
        mOurOwner.changed();
    }

    public Collection<Owned> getEntries()
    {
        return mOwned.values();
    }

    public Owned getEntry( String pName )
    {
        return (pName == null) ? mUnNamed : mOwned.get( pName );
    }

    public boolean available( String pName )
    {
        return !mOwned.containsKey( pName );
    }

    /**
     * @return null or Error
     */
    public String validatePersistable()
    {
        for ( Owned md : getEntries() )
        {
            String error = md.validatePersistable();
            if ( error != null )
            {
                return error;
            }
        }
        return null;
    }

    public void setRehydrated()
    {
        for ( Owned md : getEntries() )
        {
            md.setRehydrated();
        }
    }

    public void clearChangeIndicators()
    {
        for ( Owned md : getEntries() )
        {
            md.clearChangeIndicators();
        }
    }

    @Override
    public String toString()
    {
        return mOurOwner.toString();
    }
}