package org.litesoft.mementobeansupport;

import java.util.*;

import org.litesoft.charstreams.*;
import org.litesoft.codec.*;
import org.litesoft.core.annotations.*;
import org.litesoft.core.simpletypes.nonpublic.*;
import org.litesoft.core.typeutils.*;
import org.litesoft.core.util.*;

public abstract class AbstractAttributeProxy<T, V extends AbstractAttributeProxy<T, V>> implements Cloneable,
                                                                                                   ToStringBuilder,
                                                                                                   Mementoable<V>
{
    private final boolean mLegacyMemoAttribute;
    private final String mName;
    private final TypedTerminatingCodec<T> mCodec;
    private boolean mRepeating = false;
    private Object mValue; // Note: If this is a LegacyMemoAttribute then this will always be null!

    protected AbstractAttributeProxy( String pName, TypedTerminatingCodec<T> pCodec )
    {
        mLegacyMemoAttribute = (null == pName);
        if ( !mLegacyMemoAttribute && !Strings.isAsciiIdentifier( pName ) )
        {
            throw new IllegalArgumentException( "Not an Identifier: '" + pName + "'" );
        }
        mName = pName;
        mCodec = pCodec;
    }

    protected AbstractAttributeProxy( AbstractAttributeProxy<T, V> pOrig )
    {
        this( pOrig.mName, pOrig.mCodec );
        this.mRepeating = pOrig.mRepeating;
        this.mValue = pOrig.mValue;
    }

    public boolean isEmpty()
    {
        return (mValue == null);
    }

    public final V repeating()
    {
        if ( isRepeating() )
        {
            return castV( this );
        }
        V zClone = copy();
        castBase( zClone ).mRepeating = true;
        return zClone;
    }

    public final boolean isRepeating()
    {
        return mRepeating;
    }

    public final T get()
    {
        if ( isRepeating() )
        {
            throw new IllegalStateException( "Attempt to access repeating attribute in a non-repeating way" );
        }
        return castT( mValue );
    }

    public final V set( T pValue )
    {
        if ( mLegacyMemoAttribute )
        {
            pValue = null;
        }
        else
        {
            pValue = normalize( pValue );
        }
        T zCurValue = get();
        if ( EqualSupport.equal( zCurValue, pValue ) )
        {
            return castV( this );
        }
        V zClone = copy();
        castBase( zClone ).mValue = pValue;
        return zClone;
    }

    public final List<T> getRepeating()
    {
        if ( !isRepeating() )
        {
            throw new IllegalStateException( "Attempt to access non-repeating attribute in a repeating way" );
        }
        return castListT( mValue );
    }

    public final V setRepeating( List<T> pValue )
    {
        if ( mLegacyMemoAttribute )
        {
            pValue = null;
        }
        else
        {
            pValue = normalize( pValue );
        }
        List<T> zCurValue = getRepeating();
        if ( EqualSupport.equal( zCurValue, pValue ) )
        {
            return castV( this );
        }
        V zClone = copy();
        castBase( zClone ).mValue = makeImmutable( pValue );
        return zClone;
    }

    @Override
    public final String toString()
    {
        return mLegacyMemoAttribute ? null : toStringBuilder( new StringBuilder(), 0 ).toString();
    }

    @Override
    public final StringBuilder toStringBuilder( StringBuilder pSB, int pDepth )
    {
        if ( !mLegacyMemoAttribute )
        {
            pSB.append( mName );
            if ( isRepeating() )
            {
                repeatingToStringBuilder( pSB, pDepth, getRepeating() );
            }
            else
            {
                singleToStringBuilder( pSB.append( ':' ), pDepth, get() );
            }
        }
        return pSB;
    }

    @Override
    public final int hashCode()
    {
        return EqualSupport.calcHashCode( mValue );
    }

    @Override
    public final boolean equals( Object obj )
    {
        return (this == obj) || //
               ((obj != null) && (this.getClass() == obj.getClass()) && EqualSupport.equal( this.mValue, ((AbstractAttributeProxy)obj).mValue ));
    }

    @Override
    public void toMemento( @NotNull CharSink pCharSink )
    {
        if ( !isRepeating() )
        {
            mCodec.encode( pCharSink, get() );
            return;
        }
        List<T> zRepeating = getRepeating();
        if ( zRepeating == null )
        {
            IntegerTypedTerminatingCodec.NON_NEGATIVE.encode( pCharSink, null );
            return;
        }
        IntegerTypedTerminatingCodec.NON_NEGATIVE.encode( pCharSink, zRepeating.size() );
        for ( T zValue : zRepeating )
        {
            mCodec.encode( pCharSink, zValue );
        }
    }

    @Override
    public V fromMemento( @NotNull CharSource pToMemoValue )
    {
        if ( !isRepeating() )
        {
            return set( mCodec.decode( pToMemoValue ) );
        }
        Integer zSize = IntegerTypedTerminatingCodec.NON_NEGATIVE.decode( pToMemoValue );
        List<T> zRepeating = null;
        if ( zSize != null )
        {
            int zCount = zSize;
            for ( zRepeating = new ArrayList<T>( zCount ); zCount > 0; zCount-- )
            {
                zRepeating.add( mCodec.decode( pToMemoValue ) );
            }
        }
        return setRepeating( zRepeating );
    }

    private List<T> makeImmutable( List<T> pValue )
    {
        if ( pValue == null )
        {
            return null;
        }
        return Collections.unmodifiableList( pValue );
    }

    private void repeatingToStringBuilder( StringBuilder pSB, int pDepth, List<T> pRepeating )
    {
        if ( pRepeating == null )
        {
            singleToStringBuilder( pSB.append( ':' ), pDepth, null );
            return;
        }
        pSB.append( " (" ).append( pRepeating.size() ).append( ')' );
        if ( !pRepeating.isEmpty() )
        {
            String zIndex = Strings.spaces( ++pDepth * 4 );
            pSB.append( ':' );
            for ( int i = 0; i < pRepeating.size(); i++ )
            {
                singleToStringBuilder( pSB.append( '\n' ).append( zIndex ).append( i ).append( " -" ), pDepth, pRepeating.get( i ) );
            }
        }
    }

    private void singleToStringBuilder( StringBuilder pSB, int pDepth, T pValue )
    {
        pSB.append( ' ' );
        if ( pValue == null )
        {
            pSB.append( pValue ); // null
        }
        else if ( pValue instanceof ToStringBuilder )
        {
            ((ToStringBuilder) pValue).toStringBuilder( pSB, pDepth );
        }
        else
        {
            appendNonNullValueToString( pSB, pDepth, pValue );
        }
    }

    protected final List<T> normalizeEachEntry( List<T> pValues )
    {
        if ( (pValues != null) && !pValues.isEmpty() )
        {
            List<T> zValues = new ArrayList<T>( pValues.size() );
            for ( T zValue : pValues )
            {
                zValues.add( normalize( zValue ) );
            }
            while ( zValues.get( zValues.size() - 1 ) == null )
            {
                zValues.remove( zValues.size() - 1 );
            }
            if ( !zValues.isEmpty() )
            {
                return zValues;
            }
        }
        return null;
    }

    protected List<T> normalize( List<T> pValues )
    {
        return pValues;
    }

    protected T normalize( T pValue )
    {
        return pValue;
    }

    @SuppressWarnings("UnusedParameters")
    protected void appendNonNullValueToString( StringBuilder pSB, int pDepth, T pValue )
    {
        pSB.append( pValue );
    }

    abstract protected V copy();

    protected final AbstractAttributeProxy castBase( V pV )
    {
        return (AbstractAttributeProxy) pV;
    }

    @SuppressWarnings({"unchecked"})
    protected final V castV( Object o )
    {
        return (V) o;
    }

    @SuppressWarnings({"unchecked"})
    protected final T castT( Object o )
    {
        return (T) o;
    }

    @SuppressWarnings({"unchecked"})
    protected final List<T> castListT( Object o )
    {
        return (List<T>) o;
    }
}