// This Source Code is in the Public Domain per: http://unlicense.org
package org.litesoft.bo.views;

import java.io.*;

import org.litesoft.bo.*;
import org.litesoft.commonfoundation.typeutils.*;
import org.litesoft.core.simpletypes.*;

public class BoAccessorFilters implements Serializable
{
    private static final long serialVersionUID = 1L;

    private /* final */ SSMap mAlwaysFilters; // non-null
    private /* final */ SSMap mUniqueFilters; // non-null
    private /* final */ SSMap mRegularFilters; // non-null

    private BoAccessorFilters( SSMap pAlwaysFilters, SSMap pUniqueFilters, SSMap pRegularFilters )
    {
        mAlwaysFilters = pAlwaysFilters;
        mUniqueFilters = pUniqueFilters;
        mRegularFilters = pRegularFilters;
    }

    public BoAccessorFilters()
    {
        this( new SSMap(), new SSMap(), new SSMap() );
    }

    public BoAccessorFilters copy()
    {
        return new BoAccessorFilters( new SSMap( mAlwaysFilters ), new SSMap( mUniqueFilters ), new SSMap( mRegularFilters ) );
    }

    public SSMap getFilters()
    {
        return mUniqueFilters.isEmpty() ? mergeAlways( mRegularFilters ) : mergeAlways( mUniqueFilters );
    }

    public boolean isUniqueEmpty()
    {
        return mUniqueFilters.isEmpty();
    }

    public boolean isEmpty()
    {
        return mAlwaysFilters.isEmpty() && mUniqueFilters.isEmpty() && mRegularFilters.isEmpty();
    }

    public int activeFilters()
    {
        return mAlwaysFilters.size() + mUniqueFilters.size() + mRegularFilters.size();
    }

    public void clear()
    {
        mAlwaysFilters.clear();
        mUniqueFilters.clear();
        mRegularFilters.clear();
    }

    /**
     * @param pFilterType    !null
     * @param pAttributeName !null
     * @param pValue         (empty strings, "" or just spaces; treated as null) null == remove, !null == add/replace
     *
     * @return true if anything changed
     */
    public boolean setFilter( BoAccessorFilterType pFilterType, String pAttributeName, String pValue )
    {
        SSMap zFilter;
        switch ( pFilterType )
        {
            default:
            case Always:
                zFilter = mAlwaysFilters;
                break;
            case Unique:
                zFilter = mUniqueFilters;
                break;
            case Regular:
                zFilter = mRegularFilters;
                break;
        }
        if ( null == (pValue = Strings.noEmpty( pValue )) )
        {
            return (null != zFilter.remove( pAttributeName ));
        }
        return !Objects.areNonArraysEqual( pValue, zFilter.put( pAttributeName, pValue ) );
    }

    @Override
    public String toString()
    {
        return "[always=" + mAlwaysFilters + ",unique=" + mUniqueFilters + ",regular=" + mRegularFilters + ']';
    }

    private SSMap mergeAlways( SSMap pFilters )
    {
        if ( pFilters.isEmpty() )
        {
            return mAlwaysFilters;
        }
        if ( mAlwaysFilters.isEmpty() )
        {
            return pFilters;
        }
        return pFilters.copyAddAll( mAlwaysFilters );
    }
}