// This Source Code is in the Public Domain per: http://unlicense.org
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();
    }
}