package org.litesoft.bo.views;

import org.litesoft.bo.*;
import org.litesoft.bo.change.*;
import org.litesoft.core.util.*;

import java.io.*;
import java.util.*;

public abstract class ViewObject<VO extends IViewObject<VO>> extends AbstractChangeTrackingObject implements IViewObject<VO>,
                                                                                                         VoNames,
                                                                                                         Comparable<VO>,
                                                                                                         Serializable
{
    private static long sLastNewID = 0;

    private static synchronized long getNextNewID()
    {
        return ++sLastNewID;
    }

    private transient VoMetaData<VO> mVoMetaData;
    private TransactionSet mTransactionSet;
    private Long mNewID;
    private Long mRecordVersion;

    protected ViewObject( VoMetaData<VO> pVoMetaData )
    {
        mVoMetaData = pVoMetaData;
    }

    protected ViewObject( VoMetaData<VO> pVoMetaData, boolean pNew, TransactionSet pTransactionSet )
    {
        super( (pTransactionSet != null), pNew );
        UtilsCommon.assertNotNull( "VoMetaData", mVoMetaData = pVoMetaData );
        if ( null == (mTransactionSet = pTransactionSet) )
        {
            if ( pNew )
            {
                throw new IllegalStateException( "New ViewObjects MUST be in a TransactionSet" );
            }
        }
        mNewID = pNew ? getNextNewID() : null;
    }

    // BoAccessor...

    public final BoMetaData getBoMetaData()
    {
        return mVoMetaData;
    }

    @SuppressWarnings({"unchecked"})
    public final <T> T getAttributeValue( String pAttributeName )
            throws NoSuchElementException
    {
        return (T) LLgetAttributeValue( mVoMetaData.getVoAttribute( pAttributeName ) );
    }

    public final void setAttributeValue( String pAttributeName, Object pValue )
            throws NoSuchElementException, AttributeIllegalArgumentException
    {
        LLsetAttributeValue( mVoMetaData.getVoAttribute( pAttributeName ), pValue );
    }

    // IChangeTrackingObject...

    @Override
    public void initialize()
    {
        super.initialize();
        if ( mTransactionSet != null )
        {
            mTransactionSet.add( this );
        }
    }

    // IViewObject...

    public void committed( Object pID )
    {
        if ( isNew() )
        {
            if ( pID == null )
            {
                throw new IllegalStateException( "No ID for the Inserted 'Instance' for: " + toString() );
            }
            forceSetAttributeValue( "ID", pID );
            LLunNew();
        }
        mTransactionSet = null;
    }

    public void removeExistingFromTransactionSet()
    {
        if ( isNew() )
            throw new IllegalStateException( "May NOT Remove from the TransactionSet a New: " + toString() );

        if ( mTransactionSet != null )
        {
            mTransactionSet.remove( this );
            mTransactionSet = null;
        }
    }

    @Override
    protected void LLunNew()
    {
        mCachedObjectURL = null;
        mNewID = null;
        super.LLunNew();
    }

    public final Long getNewID()
    {
        return mNewID;
    }

    public final void setNewID( Long pNewID )
    {
        if ( verifyMutabilityOnChange( aNewID, pNewID ) )
        {
            mNewID = pNewID;
        }
    }

    public final Long getRecordVersion()
    {
        return mRecordVersion;
    }

    public final void setRecordVersion( Long pRecordVersion )
    {
        if ( isInitialized() )
        {
            throw new UnsupportedOperationException( "Attempt to change a RecordVersion post Initialization: " + toString() );
        }
        mRecordVersion = pRecordVersion;
    }

    public final VoMetaData getVoMetaData()
    {
        return mVoMetaData;
    }

    public final TransactionSet getTransactionSet()
    {
        return mTransactionSet;
    }

    public final String getObjectName()
    {
        return mVoMetaData.getObjectName();
    }

    private ObjectURL mCachedObjectURL = null;

    public final synchronized ObjectURL getObjectURL()
    {
        if ( mCachedObjectURL == null )
        {
            mCachedObjectURL = new ObjectURL( getObjectName(), mVoMetaData.createObjectUniqueKey( this ), getURLxtra() );
        }
        return mCachedObjectURL;
    }

    protected String getURLxtra()
    {
        return "";
    }

    public String getDisplayValue()
    {
        String format = UtilsCommon.noEmpty( mVoMetaData.getDisplayValueFormat() );
        if ( format == null )
        {
            return "Display Value: " + getObjectURL();
        }
        int from = 0;
        StringBuilder sb = new StringBuilder();
        for ( int at; -1 != (at = format.indexOf( "${", from )); from = at + 1 )
        {
            if ( at != from )
            {
                sb.append( format.substring( from, at ) );
            }
            int end = format.indexOf( '}', at + 2 );
            if ( end == -1 )
            {
                from = at;
                break;
            }
            String attr = format.substring( at + 2, end );
            at = end;
            try
            {
                Object value = getAttributeValue( attr );
                if ( value != null )
                {
                    sb.append( value );
                }
            }
            catch ( NoSuchElementException e )
            {
                sb.append( "${" ).append( attr ).append( '}' );
            }
        }
        return sb.append( format.substring( from ) ).toString();
    }

    /**
     * Copy this IViewObject into the provided Transaction Set.
     *
     * @param pTransactionSet if null may fail if 'this' is New
     *
     * @return copy of this
     */
    public final VO copyInto( TransactionSet pTransactionSet )
            throws UnsupportedOperationException
    {
        VO them = mVoMetaData.createViewObject( this.isNew(), pTransactionSet );

        them.setRecordVersion( this.getRecordVersion() );
        
        ((ViewObject) them).populateFrom( this );

        them.initialize();

        return them;
    }

    // Comparable...

    public int compareTo( VO them )
    {
        return this.getDisplayValue().compareTo( them.getDisplayValue() );
    }

    // Object...

    public final boolean equals( ViewObject pThem )
    {
        return (this == pThem) || ((pThem != null) && this.getObjectURL().equals( pThem.getObjectURL() ));
    }

    public final boolean equals( Object o )
    {
        return (this == o) || ((o instanceof ViewObject) && equals( (ViewObject) o ));
    }

    public final int hashCode()
    {
        return getObjectURL().hashCode();
    }

    public final String toString()
    {
        return getDisplayValue();
    }

    protected final boolean verifyMutabilityOnChange( String pAttributeName, Object pNewValue )
            throws UnsupportedOperationException
    {
        VoAttribute<VO> zAttribute = mVoMetaData.getVoAttribute( pAttributeName );
        return verifyMutabilityOnChange( zAttribute, LLgetAttributeValue( zAttribute ), pNewValue );
    }

    @SuppressWarnings({"unchecked"})
    private Object LLgetAttributeValue( VoAttribute<VO> pAttribute )
    {
        return pAttribute.getAttributeValue( (VO) this );
    }

    @SuppressWarnings({"unchecked"})
    private void LLsetAttributeValue( VoAttribute<VO> pAttribute, Object pValue )
    {
        pAttribute.setAttributeValue( (VO) this, pValue );
    }
}