package org.litesoft.core.util.externalization;

import java.util.*;

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

/**
 * Externalization Data to be used with an Externally Sourced String keyed
 * template system that supports substitutions within any specific template by
 * "named" values.
 */
public class E13nData
{

    /**
     * Substitution Value w/ a flag indicating if it is User Data, or another
     * Template Id Code to be used as a Sub-Template.
     */
    public static class SubstitutionValue
    {
        private final boolean userData;
        private final String value;

        public SubstitutionValue( boolean userData, String value )
        {
            this.userData = userData;
            this.value = value;
        }

        /**
         * Flag indicating if the "value" is User Data, or another Template Id
         * Code to be used as a Sub-Template.
         */
        public boolean isUserData()
        {
            return userData;
        }

        /**
         * User Data, or another Template Id Code to be used as a Sub-Template.
         */
        public String getValue()
        {
            return value;
        }

        @Override
        public String toString()
        {
            return userData ? value : "{" + value + "}";
        }
    }

    private final String templateIdCode;
    private Map<String, SubstitutionValue> templateSubstitutionNamedValues;

    /**
     * Convert the templateIdCode (parameter) into an acceptable string form for
     * the templateIdCode.
     *
     * @param templateIdCode Template Identifying Code
     */
    public E13nData( Object templateIdCode )
    {
        this.templateIdCode = Objects.assertNoEmptyToString( "templateIdCode", templateIdCode );
    }

    private synchronized E13nData addPair( boolean userData, String name, String value )
    {
        name = Strings.assertNotNullNotEmpty( "name", name );
        if ( templateSubstitutionNamedValues == null )
        {
            templateSubstitutionNamedValues = new HashMap<String, SubstitutionValue>();
        }
        templateSubstitutionNamedValues.put( name, new SubstitutionValue( userData, value ) );
        return this;
    }

    /**
     * Add a User Substitution Named Value.
     *
     * @param name     Not allowed to be empty
     * @param userData null converted to ""
     */
    public E13nData addSubstitutionNamedUserData( String name, String userData )
    {
        return addPair( true, name, Strings.deNull( userData ) );
    }

    /**
     * Add a User Substitution Named Value.
     *
     * @param name              Not allowed to be empty
     * @param subTemplateIdCode Not allowed to be empty
     */
    public E13nData addSubstitutionNamedSubTemplateIdCode( String name, String subTemplateIdCode )
    {
        return addPair( false, name, Strings.assertNotNullNotEmpty( "subTemplateIdCode", subTemplateIdCode ) );
    }

    /**
     * @return Not Empty TemplateIdCode
     */
    public String getTemplateIdCode()
    {
        return templateIdCode;
    }

    /**
     * @return Not null map of Template Substitution Named Values
     */
    public synchronized Map<String, SubstitutionValue> getTemplateSubstitutionNamedValues()
    {
        if ( templateSubstitutionNamedValues == null )
        {
            return Collections.emptyMap();
        }
        return new HashMap<String, SubstitutionValue>( templateSubstitutionNamedValues ); // defensive copy for Thread Safety
    }

    @Override
    public String toString()
    {
        return getTemplateIdCode() + getTemplateSubstitutionNamedValues();
    }
}