package org.litesoft.bo.attributes;

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

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

public class AttributeMetaData implements Serializable
{
    public enum Type
    {
        Boolean( BoAttribute.AttributeType.Boolean ),
        Double( BoAttribute.AttributeType.Double ),
        Float( BoAttribute.AttributeType.Float ),
        Integer( BoAttribute.AttributeType.Integer ),
        Long( BoAttribute.AttributeType.Long ),
        Password( BoAttribute.AttributeType.String ),
        Primitive_boolean( BoAttribute.AttributeType.Boolean ),
        Primitive_int( BoAttribute.AttributeType.Integer ),
        SimpleDate( BoAttribute.AttributeType.SimpleDate ),
        SimpleFixedPointLong( BoAttribute.AttributeType.SimpleFixedPointLong ),
        SimpleFloatingPointLong( BoAttribute.AttributeType.SimpleFloatingPointLong ),
        SimpleMoney( BoAttribute.AttributeType.SimpleMoney ),
        SimpleTime( BoAttribute.AttributeType.SimpleTime ),
        SimpleTimestamp( BoAttribute.AttributeType.SimpleTimestamp ),
        String( BoAttribute.AttributeType.String ),
        Text( BoAttribute.AttributeType.String ),
        TextLines( BoAttribute.AttributeType.TextLines ),
        ValidOptions( BoAttribute.AttributeType.String ),
        ToBlob( BoAttribute.AttributeType.Long ),
        ToOne( BoAttribute.AttributeType.Long ),
        ToOneCommonPaired( BoAttribute.AttributeType.String ),
        ToOnePaired( null ),
        ToOneVariable( BoAttribute.AttributeType.String ),
        ToOneVirtual( null ),
        ToMany( null ),
        ToManyVariable( null ),
        ToManyVirtual( null );

        Type( BoAttribute.AttributeType pBoAttributeType )
        {
            mBoAttributeType = pBoAttributeType;
        }

        private BoAttribute.AttributeType mBoAttributeType;

        public BoAttribute.AttributeType getBoAttributeType()
        {
            return mBoAttributeType;
        }
    }

    /**
     * @deprecated - for Serialization
     */
    protected AttributeMetaData()
    {
    }

    private Type mType;
    private Mutability mMutability;
    private Properties mProperties;

    private AttributeMetaData( Type pType, Mutability pMutability, Properties pProperties )
    {
        UtilsCommon.assertNotNull( "Type", mType = pType );
        mMutability = (pMutability != null) ? pMutability : Mutability.RW;
        mProperties = pProperties;
    }

    public AttributeMetaData( Type pType, Mutability pMutability )
    {
        this( pType, pMutability, null );
    }

    public AttributeMetaData( Type pType )
    {
        this( pType, Mutability.RW );
    }

    public final Type getType()
    {
        return mType;
    }

    public final Mutability getMutability()
    {
        return mMutability;
    }

    final Properties getProperties()
    {
        return Properties.deNull( mProperties );
    }

    @Override
    public String toString()
    {
        return toString( mType, mMutability, mProperties );
    }

    private static String toString( Type pType, Mutability pMutability, Properties pProperties )
    {
        StringBuilder sb = new StringBuilder();
        sb.append( '_' ).append( pType ).append( '.' ).append( pMutability ).append( "()" );
        Properties zProperties = Properties.deNull( pProperties );
        if ( !zProperties.isEmpty() )
        {
            sb.append( ".with( " );
            zProperties.augment( sb );
            sb.append( " )" );
        }
        return sb.toString();
    }

    public AttributeMetaData RW()
    {
        return updateMutability( Mutability.RW );
    }

    public AttributeMetaData AddOnly()
    {
        return updateMutability( Mutability.AddOnly );
    }

    public AttributeMetaData RO()
    {
        return updateMutability( Mutability.RO );
    }

    public AttributeMetaData updateMutability( Mutability pMutability )
    {
        return mMutability.equals( pMutability ) ? this : getInstance( mType, pMutability, mProperties );
    }

    public AttributeMetaData with( PropertyOfAMD... pInstances )
    {
        Properties zProperties = mProperties;
        if ( pInstances != null )
        {
            for ( PropertyOfAMD zInstance : pInstances )
            {
                if ( zInstance != null )
                {
                    zProperties = Properties.deNull( zProperties ).add( zInstance );
                }
            }
        }
        return (zProperties == mProperties) ? this : getInstance( mType, mMutability, zProperties );
    }

    private static AttributeMetaData getInstance( Type pType, Mutability pMutability, Properties pProperties )
    {
        // todo: check Instance Map
        return new AttributeMetaData( pType, pMutability, pProperties );
    }

    static class Properties extends HashMap<String, PropertyOfAMD>
    {
        public static final Properties EMPTY = new Properties();

        public static Properties deNull( Properties pProperties )
        {
            return (pProperties != null) ? pProperties : EMPTY;
        }

        public Properties add( PropertyOfAMD pInstance )
        {
            return pInstance.equals( get( pInstance.getMapKey() ) ) ? this : getInstance( pInstance );
        }

        private Properties getInstance( PropertyOfAMD pInstance )
        {
            // todo: check Instance Map
            return new Properties( this, pInstance );
        }

        Properties()
        {
        }

        Properties( Properties pThem, PropertyOfAMD pInstance )
        {
            super( pThem );
            put( pInstance.getMapKey(), pInstance );
        }

        @Override
        public String toString()
        {
            return augment( new StringBuilder() ).toString();
        }

        public StringBuilder augment( StringBuilder pSB )
        {
            if ( !isEmpty() )
            {
                List<String> zKeys = new ArrayList<String>( keySet() );
                if ( zKeys.size() == 1 )
                {
                    append( pSB, zKeys, 0 );
                }
                else
                {
                    int zOverhead = pSB.length();
                    Collections.sort( zKeys );
                    append( pSB, zKeys, 0 );
                    for ( int i = 1; i < zKeys.size(); i++ )
                    {
                        addWrap( pSB, zOverhead );
                        append( pSB, zKeys, i );
                    }
                }
            }
            return pSB;
        }

        private void addWrap( StringBuilder pSB, int pOverhead )
        {
            pSB.append( ", //\n" );
            while ( pOverhead-- > 0 )
            {
                pSB.append( ' ' );
            }
        }

        private void append( StringBuilder pSB, List<String> pKeys, int pIndex )
        {
            pSB.append( get( pKeys.get( pIndex ) ).toString() );
        }
    }
}