package org.litesoft.bo.views;

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

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

public abstract class Filter implements Serializable
{
    public static enum Type
    {
        OR, AND, ALL, NONE, EQUALS, EXPRESSION
    }

    public static final Filter ALL = new _All();
    public static final Filter NONE = new _None();

    private transient Type mType;

    protected Filter( Type pType )
    {
        mType = pType;
    }

    public Type getType()
    {
        return mType;
    }

    abstract public boolean isSatisfiedBy( BoAccessor pType );

    public static Filter Or( Filter pLeft, Filter pRight )
    {
        if ( pLeft.getType() == Type.NONE )
        {
            return pRight;
        }
        if ( pRight.getType() == Type.NONE )
        {
            return pLeft;
        }
        if ( (pLeft.getType() == Type.ALL) || (pRight.getType() == Type.ALL) )
        {
            return ALL;
        }
        return new _Or( pLeft, pRight );
    }

    public static Filter And( Filter pLeft, Filter pRight )
    {
        if ( pLeft.getType() == Type.NONE || pRight.getType() == Type.NONE )
        {
            return NONE;
        }
        if ( pLeft.getType() == Type.ALL )
        {
            return pRight;
        }
        if ( pRight.getType() == Type.ALL )
        {
            return pLeft;
        }
        return new _And( pLeft, pRight );
    }

    protected static class _All extends Filter
    {
        _All()
        {
            super( Type.ALL );
        }

        public boolean isSatisfiedBy( BoAccessor pType )
        {
            return true;
        }
    }

    protected static class _None extends Filter
    {
        _None()
        {
            super( Type.NONE );
        }

        public boolean isSatisfiedBy( BoAccessor pType )
        {
            return false;
        }
    }

    protected static class _Or extends BinaryGroup
    {
        /**
         * for Serialization
         */
        _Or()
        {
            super( Type.OR );
        }

        _Or( Filter pLeft, Filter pRight )
        {
            this();
            mLeft = pLeft;
            mRight = pRight;
        }

        public boolean isSatisfiedBy( BoAccessor pType )
        {
            return getLeft().isSatisfiedBy( pType ) || getRight().isSatisfiedBy( pType );
        }
    }

    protected static class _And extends BinaryGroup
    {
        /**
         * for Serialization
         */
        public _And()
        {
            super( Type.AND );
        }

        _And( Filter pLeft, Filter pRight )
        {
            this();
            mLeft = pLeft;
            mRight = pRight;
        }

        public boolean isSatisfiedBy( BoAccessor pType )
        {
            return getLeft().isSatisfiedBy( pType ) && getRight().isSatisfiedBy( pType );
        }
    }

    protected static abstract class BinaryGroup extends Filter
    {
        protected Filter mLeft;
        protected Filter mRight;

        BinaryGroup( Type pType )
        {
            super( pType );
        }

        public Filter getLeft()
        {
            return mLeft;
        }

        public Filter getRight()
        {
            return mRight;
        }
    }

    private static abstract class NameValueFilterBase extends Filter
    {
        protected String mName;
        protected String mValue;

        NameValueFilterBase( Type pType )
        {
            super( pType );
        }

        public String getName()
        {
            return mName;
        }

        public boolean isSatisfiedBy( BoAccessor pType )
        {
            Object zValue;
            try
            {
                zValue = pType.getAttributeValue( getName() );
            }
            catch ( NoSuchElementException e )
            {
                return false;
            }
            return (zValue == null) ? (mValue == null) : isSatisfiedByValue( zValue );
        }

        abstract protected boolean isSatisfiedByValue( Object pValue );
    }

    /**
     * implied: case-sensitivity
     */
    public static class ValueEqualsFilter extends NameValueFilterBase
    {
        ValueEqualsFilter()
        {
            super( Type.EQUALS );
        }

        public ValueEqualsFilter( String pName, String pValue )
        {
            this();
            mName = pName;
            mValue = pValue;
        }

        public String getValue()
        {
            return mValue;
        }

        protected boolean isSatisfiedByValue( Object pValueNonNull )
        {
            return pValueNonNull.toString().equals( mValue );
        }
    }

    public static class StringExpressionFilter extends NameValueFilterBase
    {
        private boolean mCaseSensitive;
        private transient volatile StringMatcher mMatcher;

        StringExpressionFilter()
        {
            super( Type.EXPRESSION );
        }

        public StringExpressionFilter( String pName, String pExpression, boolean pCaseSensitive )
        {
            this();
            mName = pName;
            mValue = pExpression;
            mCaseSensitive = pCaseSensitive;
        }

        public String getExpression()
        {
            return mValue;
        }

        public boolean isCaseSensitive()
        {
            return mCaseSensitive;
        }

        protected boolean isSatisfiedByValue( Object pValueNonNull )
        {
            if ( mMatcher == null )
            {
                if ( null == mValue )
                {
                    mMatcher = StringMatcher.EMPTY;
                }
                else
                {
                    String[] zParts = UtilsCommon.parseChar( mValue, '*' );
                    if ( null == (mMatcher = StringMatcherFactory.createStartsWith( !mCaseSensitive, zParts )) )
                    {
                        mMatcher = StringMatcher.ALL;
                    }
                }
            }
            return mMatcher.matches( pValueNonNull.toString() );
        }
    }
}