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

import org.litesoft.commonfoundation.typeutils.*;

import java.util.*;

import org.litesoft.core.util.*;
import org.litesoft.core.util.HintValidator.*;
import org.litesoft.core.util.Hintable.*;
import org.litesoft.logger.*;

public final class HintController
{
    public static final String PER_PROBLEM_PREFIX = "\n    ";
    public static Logger LOGGER = LoggerFactory.getLogger( HintController.class );

    public static final String HINT_PROPERTY_PREFIX = "Hint.";

    public static String noValidatorText( String pCategory, String pGroup, String pName )
    {
        return "No Validator for: Cat(" + pCategory + "), Group(" + pGroup + "), Name(" + pName + ")";
    }

    public static void noValidator( String pCategory, String pGroup, String pName )
    {
        if ( LOGGER.warn.isEnabled() )
        {
            LOGGER.warn.log( noValidatorText( pCategory, pGroup, pName ) );
        }
    }

    /**
     * @param pName  !null or empty
     * @param pValue !null or empty
     *
     * @return null is no problem, "" is no validator, !null & !"" is the problem
     */
    public synchronized static String validate( String pCategory, String pGroup, String pName, String pValue )
    {
        pName = Strings.assertNotNullNotEmpty( "Name", pName );
        pValue = Strings.assertNotNullNotEmpty( "Value", pValue );

        int zSwitchOn = ((pCategory == null) ? 0 : 2) + //
                        ((pGroup == null) ? 0 : 1);

        Set<HintValidator> zValidators = new HashSet<HintValidator>();

        appendValidators( zValidators, null, null, pName ); // Do wild cards

        switch ( zSwitchOn )
        {
            default:
            case 0: // Nether
                break;
            case 1: // Group Only
                appendValidators( zValidators, null, pGroup, pName );
                break;
            case 2: // Cat Only
                appendValidators( zValidators, pCategory, null, pName );
                break;
            case 3: // Both
                appendValidators( zValidators, pCategory, pGroup, pName );
                appendValidators( zValidators, pCategory, null, pName );
                appendValidators( zValidators, null, pGroup, pName );
                break;
        }

        List<String> zProblems = new ArrayList<String>();
        for ( HintValidator zValidator : zValidators )
        {
            String problem = zValidator.validate( pName, pValue );
            if ( problem == null )
            {
                return null;
            }
            zProblems.add( problem );
        }

        if ( zSwitchOn == 3 ) // Stop future complaining if Cat & Group exists
        {
            add( new NullHintValidator( pCategory, pGroup, pName ) );
        }

        if ( zProblems.isEmpty() )
        {
            return ""; // Indicate that no Validators were found!
        }
        StringBuilder problems = new StringBuilder();
        Collections.sort( zProblems );
        for ( String zProblem : zProblems )
        {
            problems.append( PER_PROBLEM_PREFIX ).append( zProblem );
        }
        return problems.toString();
    }

    private static void appendValidators( Set<HintValidator> pValidators, String pCategory, String pGroup,
                                          String pName )
    {
        ValidatorsForCatGroup zValidatorsForCatGroup = sValidators.get( new CategoryGroup( pCategory, //
                                                                                           pGroup ) );
        if ( zValidatorsForCatGroup != null )
        {
            ValidatorsProxyForName zProxyForName = zValidatorsForCatGroup.getProxy( pName );
            if ( zProxyForName != null )
            {
                zProxyForName.appendValidators( pValidators );
            }
        }
    }

    private static Map<CategoryGroup, ValidatorsForCatGroup> sValidators = //
            new HashMap<CategoryGroup, ValidatorsForCatGroup>();

    public synchronized static void add( HintValidator pValidator )
    {
        if ( pValidator != null )
        {
            CategoryGroup[] zCategoryGroups = pValidator.getRegisterForCategoryGroups();
            if ( zCategoryGroups != null )
            {
                for ( CategoryGroup cg : zCategoryGroups )
                {
                    ValidatorsForCatGroup zValidatorsForCatGroup = sValidators.get( cg );
                    if ( zValidatorsForCatGroup == null )
                    {
                        sValidators.put( cg, new ValidatorsForCatGroup( pValidator ) );
                    }
                    else
                    {
                        zValidatorsForCatGroup.add( pValidator );
                    }
                }
            }
        }
    }

    /**
     * @return !null and No Nulls
     */
    public static Hint[] getGlobalHints()
    {
        return getGlobalHintManager().getHints();
    }

    /**
     * Return the value associated with pName if any.
     *
     * @param pName !null or empty
     *
     * @return null or value associated with pName
     *
     * @throws IllegalArgumentException if pName was null or empty
     */
    public static String getGlobalHintValue( String pName )
            throws IllegalArgumentException
    {
        return getGlobalHintManager().getHintValue( pName );
    }

    /**
     * Add the Hint (if pValue is not null or empty) and return any previous Hint's Value with the same pName
     *
     * @param pName !null or empty
     *
     * @return null or previous Hint's Value with the same pName
     *
     * @throws IllegalArgumentException if pName was null or empty
     */
    public static String addGlobalHint( String pName, String pValue )
            throws IllegalArgumentException
    {
        if ( null == (pValue = Strings.noEmpty( pValue )) )
        {
            return null;
        }
        return sHintManager.backDoorAddHint( new Hint( pName, pValue ) );
    }

    public static HintManager getGlobalHintManager()
    {
        return sHintManager;
    }

    private static GlobalHintManager sHintManager = new GlobalHintManager();

    public static class GlobalHintManager extends HintManager
    {
        public HintManager aboutToAdd()
        {
            return NULL.aboutToAdd().addAll( this );
        }

        public String addHint( Hint pHint )
        {
            throw new IllegalStateException( "Attempt to add a Hint to the Global HintManager" );
        }

        String backDoorAddHint( Hint pHint )
        {
            return super.addHint( pHint );
        }
    }

    private static class ValidatorsForCatGroup
    {
        private Map<String, ValidatorsProxyForName> mValidatorProxiesByName = //
                new HashMap<String, ValidatorsProxyForName>();

        public ValidatorsForCatGroup( HintValidator pInitialValidator )
        {
            add( pInitialValidator );
        }

        public ValidatorsProxyForName getProxy( String pName )
        {
            return mValidatorProxiesByName.get( pName );
        }

        public void add( HintValidator pValidator )
        {
            String[] names = pValidator.getRegisterForHintNames();
            if ( names != null )
            {
                for ( String name : names )
                {
                    ValidatorsProxyForName zProxyForName = mValidatorProxiesByName.get( name );
                    if ( zProxyForName == null )
                    {
                        mValidatorProxiesByName.put( name, new ValidatorsProxyForName( pValidator ) );
                    }
                    else
                    {
                        zProxyForName.add( pValidator );
                    }
                }
            }
        }

        public String toString()
        {
            return "ValidatorsForCatGroup: " + mValidatorProxiesByName;
        }
    }

    private static class ValidatorsProxyForName
    {
        private List<HintValidator> mValidators = new ArrayList<HintValidator>();

        public ValidatorsProxyForName( HintValidator pInitialValidator )
        {
            mValidators.add( pInitialValidator );
        }

        public void add( HintValidator pValidator )
        {
            mValidators.add( pValidator );
        }

        public void appendValidators( Set<HintValidator> pValidators )
        {
            pValidators.addAll( mValidators );
        }

        public String toString()
        {
            return "ValidatorsProxyForName: " + mValidators;
        }
    }

    private static class NullHintValidator implements HintValidator
    {
        private CategoryGroup mCG;
        private String mName;

        public NullHintValidator( String pCategory, String pGroup, String pName )
        {
            mCG = new CategoryGroup( pCategory, pGroup );
            mName = pName;
        }

        public CategoryGroup[] getRegisterForCategoryGroups()
        {
            return new CategoryGroup[]{mCG};
        }

        public String[] getRegisterForHintNames()
        {
            return new String[]{mName};
        }

        public String validate( String pName, String pValue )
        {
            return null;
        }

        public String toString()
        {
            return "NullHintValidator( " + mCG + ", '" + mName + "' )";
        }
    }
}