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

import org.litesoft.bo.*;
import org.litesoft.core.typeutils.Objects;

import java.util.*;

public class AttributeMetaData
{
    public enum Type
    {
        Boolean( BoAttribute.AttributeType.Boolean ),
        CalendarY( BoAttribute.AttributeType.CalendarY ),
        CalendarYM( BoAttribute.AttributeType.CalendarYM ),
        CalendarYMD( BoAttribute.AttributeType.CalendarYMD ),
        Double( BoAttribute.AttributeType.Double ),
        Float( BoAttribute.AttributeType.Float ),
        Integer( BoAttribute.AttributeType.Integer ),
        Long( BoAttribute.AttributeType.Long ),
        OpenValidOptions( BoAttribute.AttributeType.String ),
        Password( BoAttribute.AttributeType.String ),
        Primitive_boolean( BoAttribute.AttributeType.Primitive_boolean ),
        Primitive_int( BoAttribute.AttributeType.Primitive_boolean ),
        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;
        }

        public boolean isImplicitlyRequired()
        {
            return getBoAttributeType().isPrimitive();
        }

        public Object normalize( Object pValue, boolean pRequired )
        {
            return getBoAttributeType().normalize( pValue, pRequired );
        }
    }

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

    private AttributeMetaData( Type pType, Mutability pMutability, Properties pProperties )
    {
        Objects.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() );
        }
    }
}