package org.litesoft.mementobeansupport;

import java.util.*;

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

public abstract class AbstractMementoBean<CT extends AbstractMementoBean> implements Cloneable,
                                                                                     ToStringBuilder,
                                                                                     Mementoable<CT>
{
    private final AbstractAttributeProxy[] mAttributeProxies;

    protected AbstractMementoBean( AbstractAttributeProxy[] pAttributeProxies )
    {
        mAttributeProxies = pAttributeProxies;
    }

    protected AbstractMementoBean( AbstractMementoBean<CT> pOrig )
    {
        this.mAttributeProxies = new AbstractAttributeProxy[pOrig.mAttributeProxies.length];
        System.arraycopy( pOrig.mAttributeProxies, 0, this.mAttributeProxies, 0, pOrig.mAttributeProxies.length );
    }

    public final boolean isEmpty()
    {
        for ( AbstractAttributeProxy zProxy : mAttributeProxies )
        {
            if ( !zProxy.isEmpty() )
            {
                return false;
            }
        }
        return true;
    }

    protected <T> T getValueFor( int pIndex )
    {
        return cast( getProxy( pIndex ).get() );
    }

    protected <T> CT setValueFor( int pIndex, T pValue )
    {
        if ( EqualSupport.equal( getValueFor( pIndex ), pValue ) )
        {
            return cast( this );
        }
        CT zClone = copy();
        AbstractAttributeProxy<T, ?> zProxy = getProxy( pIndex );
        castBase( zClone ).mAttributeProxies[pIndex] = zProxy.set( pValue );
        return zClone;
    }

    protected <T> List<T> getRepeatingValueFor( int pIndex )
    {
        return cast( getProxy( pIndex ).getRepeating() );
    }

    protected CT clearRepeatingValueFor( int pIndex )
    {
        return setRepeatingValueFor( pIndex, (List<?>) null );
    }

    protected <T> CT addRepeatingValueFor( int pIndex, T pValue )
    {
        List<T> zCurList = getRepeatingValueFor( pIndex );
        List<T> zNewList = (zCurList == null) ? new ArrayList<T>() : new ArrayList<T>( zCurList );
        zNewList.add( pValue );
        return setRepeatingValueFor( pIndex, zNewList );
    }

    protected <T> CT setRepeatingValueFor( int pIndex, T... pValues )
    {
        List<T> zValues = (pValues == null) ? null : Arrays.asList( pValues );
        return setRepeatingValueFor( pIndex, zValues );
    }

    protected <T> CT setRepeatingValueFor( int pIndex, List<T> pValues )
    {
        if ( EqualSupport.equal( getRepeatingValueFor( pIndex ), pValues ) )
        {
            return cast( this );
        }
        CT zClone = copy();
        AbstractAttributeProxy<T, ?> zProxy = getProxy( pIndex );
        castBase( zClone ).mAttributeProxies[pIndex] = zProxy.setRepeating( pValues );
        return zClone;
    }

    private <T> AbstractAttributeProxy<T, ?> getProxy( int pIndex )
    {
        return cast( mAttributeProxies[pIndex] );
    }

    abstract protected CT copy();

    abstract protected CT defaultInstance();

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

    @Override
    public final boolean equals( Object obj )
    {
        return (this == obj) || ((obj instanceof AbstractMementoBean) && equals( (AbstractMementoBean) obj ));
    }

    public final boolean equals( AbstractMementoBean them )
    {
        if ( this != them )
        {
            if ( (them == null) || (this.getClass() != them.getClass()) )
            {
                return false;
            }
            for ( int i = 0; i < mAttributeProxies.length; i++ )
            {
                if ( !EqualSupport.equal( this.mAttributeProxies[i], them.mAttributeProxies[i] ) )
                {
                    return false;
                }
            }
        }
        return true;
    }

    @Override
    public int hashCode()
    {
        int hash = 0;
        for ( AbstractAttributeProxy zProxy : mAttributeProxies )
        {
            hash = EqualSupport.hashCodeEm( hash, EqualSupport.calcHashCode( zProxy ) );
        }
        return hash;
    }

    public String toMemento()
    {
        if ( isEmpty() )
        {
            return null;
        }
        CharSinkToString zCharSink = new CharSinkToString();
        toMemento( zCharSink );
        return zCharSink.toString();
    }

    public CT fromMemento( CharSequence pToMemoValue )
    {
        return fromMemento( new CharSourceFromSequence( pToMemoValue ) );
    }

    @Override
    public void toMemento( @NotNull CharSink pCharSink )
    {
        for ( AbstractAttributeProxy zProxy : mAttributeProxies )
        {
            zProxy.toMemento( pCharSink );
        }
    }

    @Override
    public CT fromMemento( @NotNull CharSource pToMemoValue )
    {
        return Cast.it( castBase( defaultInstance() ).defaultFromMemento( pToMemoValue ) );
    }

    private CT defaultFromMemento( @NotNull CharSource pToMemoValue )
    {
        CT zCopy = copy();
        AbstractMementoBean zClone = castBase( zCopy );
        for ( int i = 0; i < mAttributeProxies.length; i++ )
        {
            zClone.mAttributeProxies[i] = getProxy( i ).fromMemento( pToMemoValue );
        }
        return zCopy;
    }

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

    @Override
    public StringBuilder toStringBuilder( StringBuilder pSB, int pDepth )
    {
        pSB.append( Objects.justClassNameOf( this ) );
        String zIndex = Strings.spaces( ++pDepth * 4 );
        String zPrefix = ":";
        for ( AbstractAttributeProxy zProxy : mAttributeProxies )
        {
            String s = zProxy.toString();
            if ( s != null )
            {
                zProxy.toStringBuilder( pSB.append( zPrefix ).append( '\n' ).append( zIndex ), pDepth );
                zPrefix = "";
            }
        }
        return pSB;
    }

    protected final AbstractMementoBean castBase( CT pCT )
    {
        return (AbstractMementoBean) pCT;
    }
}