// This Source Code is in the Public Domain per: http://litesoft.org/License.txt
package org.litesoft.bo.change;

import org.litesoft.bo.AttributeIllegalArgumentException;
import org.litesoft.bo.BoAttribute;
import org.litesoft.core.typeutils.Objects;

import java.util.NoSuchElementException;

public abstract class AbstractChangeTrackingObject implements IChangeTrackingObject
{
    public static final int INITIAL_CHANGE_NUMBER = 0;

    private int mChangeNumber = INITIAL_CHANGE_NUMBER;

    private boolean mInitialized = false;
    private boolean mDeleteRequested = false;

    private transient Boolean mChangeAllowed; // null means that we are reconstituted after Serialization
    private boolean mNew;

    private OriginalValueChangeTracker mChangeTracker;

    /**
     * For Serialization
     */
    protected AbstractChangeTrackingObject()
    {
        mChangeAllowed = null;
    }

    protected AbstractChangeTrackingObject( boolean pChangeAllowed, boolean pNew )
    {
        mChangeAllowed = pNew || pChangeAllowed;
        mNew = pNew;
        mChangeTracker = OriginalValueChangeTrackerNull.INSTANCE;
    }

    public final void forceSetAttributeValue( String pAttributeName, Object pValue )
            throws NoSuchElementException, AttributeIllegalArgumentException
    {
        boolean zInitialized = mInitialized;
        mInitialized = false;
        Boolean zChangeAllowed = mChangeAllowed;
        mChangeAllowed = true;
        setAttributeValue( pAttributeName, pValue );
        mChangeAllowed = zChangeAllowed;
        mInitialized = zInitialized;
    }

    protected void LLunNew()
    {
        mNew = false;
    }

    public boolean isInitialized()
    {
        return mInitialized;
    }

    // IChangeTrackingObject...

    public void initialize()
    {
        mInitialized = true;
    }

    public boolean isChangeAllowed()
    {
        return Boolean.TRUE.equals( mChangeAllowed );
    }

    public final int getChangeNumber()
    {
        return mChangeNumber;
    }

    public final boolean isDirty()
    {
        return isDeleteRequested() || isNew() || isAnyAttributeChanged() || LLisDirty();
    }

    public final void requestDelete()
    {
        if ( !mInitialized )
        {
            throw new IllegalStateException( "During Object initialization, attempted to Delete: " + toString() );
        }
        if ( verifyMutability() )
        {
            mDeleteRequested = LLrequestDelete();
        }
    }

    public final boolean isDeleteRequested()
    {
        return mDeleteRequested;
    }

    public final boolean isNew()
    {
        return mNew;
    }

    public final boolean isAnyAttributeChanged()
    {
        return mChangeTracker.hasChanges();
    }

    /**
     * @return if Attribute exists && it has changed
     */
    public final boolean isAttributeChanged( String pAttributeName )
    {
        return mChangeTracker.isAttributeChanged( pAttributeName );
    }

    public final String[] getChangedAttributeNames()
    {
        return mChangeTracker.getChangedAttributeNames();
    }

    public final boolean isOriginalValueAvailableFor( String pAttributeName )
    {
        return mChangeTracker.isOriginalValueAvailableFor( pAttributeName );
    }

    public final Object getOriginalValueFor( String pAttributeName )
    {
        return mChangeTracker.getOriginalValueFor( pAttributeName );
    }

    // support...

    protected void populateFrom( AbstractChangeTrackingObject pThem )
    {
        boolean zAnyChanges = false;

        for ( BoAttribute zAttribute : getBoMetaData().getBoAttributes() )
        {
            zAnyChanges |= populateFromRegular( pThem, zAttribute );
        }
        if ( zAnyChanges )
        {
            incChangeNumber();
        }
    }

    protected boolean populateFromRegular( AbstractChangeTrackingObject pThem, BoAttribute pAttribute )
    {
        String zName = pAttribute.getName();
        Object zCurValue = this.getAttributeValue( zName );
        Object zNewValue = pThem.getAttributeValue( zName );
        if ( !Objects.areEqual(zCurValue, zNewValue) )
        {
            ChangeControlledBoAttribute zCCA = getChangeControlledBoAttribute( pAttribute );

            if ( zCCA == null )
            {
                this.setAttributeValue( zName, zNewValue ); // Assume changeable
                return true;
            }
            if ( zCCA.isSetable() && canMutate( zCCA ) )
            {
                this.setAttributeValue( zName, zNewValue );
                ChangeEntry zChangeEntry = pThem.mChangeTracker.getOriginalValueChangeEntryFor( zName );
                if ( zChangeEntry != null )
                {
                    recordChange( zName, zChangeEntry, zCurValue, zNewValue );
                }
                return true;
            }
        }
        return false;
    }

    private ChangeControlledBoAttribute getChangeControlledBoAttribute( BoAttribute pAttribute )
    {
        return (pAttribute instanceof ChangeControlledBoAttribute) ? (ChangeControlledBoAttribute) pAttribute : null;
    }

    private boolean canMutate( ChangeControlledBoAttribute pAttribute )
    {
        if ( mInitialized )
        {
            switch ( pAttribute.getMutability() )
            {
                case RW:
                    return true;
                case AddOnly:
                    return isNew();
                case RO:
                    return LLallowMutabilityOnRO( pAttribute );
                default:
                    throw new UnsupportedOperationException( "Unknown Mutability (" + pAttribute.getMutability() + ") on change of Attribute (" + pAttribute.getName() + ") on: " + toString() );
            }
        }
        return true;
    }

    private void recordChange( ChangeControlledBoAttribute pChangeControlledBoAttribute, Object pOldValue, Object pNewValue )
    {
        ChangeEntry zChangeEntry = pChangeControlledBoAttribute.createChangeEntryFor( pOldValue );
        if ( zChangeEntry != null )
        {
            String zAttributeName = pChangeControlledBoAttribute.getName();

            recordChange( zAttributeName, zChangeEntry, pOldValue, pNewValue );
        }
    }

    private void recordChange( String pAttributeName, ChangeEntry pChangeEntry, Object pOldValue, Object pNewValue )
    {
        mChangeTracker = mChangeTracker.recordChange( pAttributeName, pChangeEntry, pOldValue, pNewValue );
    }

    protected final boolean verifyMutability()
            throws UnsupportedOperationException
    {
        if ( !mInitialized ) // We are in "Creation" mode
        {
            return false;
        }
        if ( mChangeAllowed == null )
        {
            throw new UnsupportedOperationException( "Attempt to change a re-constituted from Serialization immutable: " + toString() );
        }
        if ( Boolean.FALSE.equals( mChangeAllowed ) )
        {
            throw new UnsupportedOperationException( "Attempt to change a read-only: " + toString() );
        }
        LLverifyMutability();
        return true;
    }

    protected final ChangeControlledBoAttribute verifyMutability( BoAttribute pAttribute )
            throws UnsupportedOperationException
    {
        return verifyMutability() ? getChangeControlledBoAttribute( pAttribute ) : null;
    }

    public final boolean verifyMutabilityOnChange( BoAttribute pBoAttribute, Object pOldValue, Object pNewValue )
            throws UnsupportedOperationException
    {
        if ( Objects.areEqual( pOldValue, pNewValue ) )
        {
            return false;
        }
        if ( mInitialized )
        {
            ChangeControlledBoAttribute zChangeControlledBoAttribute = verifyMutability( pBoAttribute );

            if ( zChangeControlledBoAttribute == null )
            {
                incChangeNumber();
            }
            else
            {
                if ( !canMutate( zChangeControlledBoAttribute ) )
                {
                    throw new UnsupportedOperationException( "Attempt to change read-only attribute '" + pBoAttribute.getName() + "' on: " + toString() );
                }
                incChangeNumber();

                recordChange( zChangeControlledBoAttribute, pOldValue, pNewValue );
            }
        }
        return true;
    }

    protected final void incChangeNumber()
    {
        mChangeNumber++;
    }

    /**
     * Throw exception if you want to STOP changes!
     */
    protected void LLverifyMutability()
    {
    }

    /**
     * @return true to allow Object's RO attribute to be changed anyway.
     */
    @SuppressWarnings({"UnusedDeclaration"})
    protected boolean LLallowMutabilityOnRO( ChangeControlledBoAttribute pAttribute )
    {
        return false;
    }

    /**
     * @return true to report dirty beyond the tracked attributes, and New, and Delete Requested
     */
    protected boolean LLisDirty()
    {
        return false;
    }

    /**
     * @return true if allowed to actually Request Delete
     */
    protected boolean LLrequestDelete()
    {
        return true;
    }
}