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

import org.litesoft.util.*;

import java.util.*;

public abstract class AbstractDataMetaData extends AbstractMetaData implements Changeable {
    private Mode mMode;
    private boolean mEditable;
    private int mChangeCounter = 0;
    private int mLastChangeCounter = 0;
    private CopyOnWriteUniqueIdentityListManager<ChangeCallback> mChangeCallbacks = new CopyOnWriteUniqueIdentityListManager<ChangeCallback>();

    public AbstractDataMetaData( String pMetaDataType, Mode pMode, boolean pEditable ) {
        super( pMetaDataType );

        mMode = pMode;
        mEditable = pEditable;
    }

    @Override
    public List<ChangeCallback> getChangeCallbacks() {
        return mChangeCallbacks.getAll();
    }

    @Override
    public void removeAllChangeCallbacks() {
        mChangeCallbacks.removeAll();
    }

    @Override
    public boolean add( ChangeCallback pChangeCallback ) {
        return mChangeCallbacks.add( pChangeCallback );
    }

    @Override
    public boolean remove( ChangeCallback pChangeCallback ) {
        return mChangeCallbacks.remove( pChangeCallback );
    }

    protected void LLchanged() {
        // System.out.println( getClass().getSimpleName() + ".LLchanged" );
        mChangeCounter++;
        notifyCallbacks();
    }

    @Override
    public void clearChangeIndicators() {
        if ( isChanged() ) {
            // System.out.println( getClass().getSimpleName() + ".clearChangeIndicators" );
            mChangeCounter = mLastChangeCounter = 0;
            notifyCallbacks();
        }
    }

    @Override
    public boolean isChanged() {
        return (mChangeCounter != 0);
    }

    @Override
    public boolean chkChanged() {
        if ( mChangeCounter == mLastChangeCounter ) {
            return false;
        }
        mLastChangeCounter = mChangeCounter;
        return true;
    }

    @Override
    public void changed() {
        if ( !Mode.Rehydrating.equals( getMode() ) ) {
            LLchanged();
        }
    }

    private void notifyCallbacks() {
        List<ChangeCallback> zCallbacks = mChangeCallbacks.getAll();
        for ( ChangeCallback zCallback : zCallbacks ) {
            zCallback.changeStateUpdated( this );
        }
    }

    public void setNewSaved() {
        mMode = Mode.Ready;
    }

    public void setRehydrated() {
        mMode = Mode.Ready;
    }

    public Mode getMode() {
        return mMode;
    }

    public boolean isEditable() {
        return mEditable;
    }

    protected void verifyEditability() {
        checkBadMode( Mode.Rehydrating.equals( getMode() ) );
        if ( !isEditable() ) {
            throw new IllegalStateException( getMetaDataType() + " is NOT Editable" );
        }
    }

    /**
     * @return null or Error
     */
    public String validatePersistable() {
        return null;
    }

    protected void chkUnhappyCase( String pNullOrError ) {
        if ( pNullOrError != null ) {
            throw new IllegalStateException( pNullOrError );
        }
    }

    protected void checkBadMode( boolean pBadMode ) {
        if ( pBadMode ) {
            throw new IllegalStateException( getMetaDataType() + " is still in " + getMode() + " Mode" );
        }
    }
}