package com.sourceforge.jpatterns.core.configuration.model;

 import com.sourceforge.jpatterns.core.JPConstants;

 import com.sourceforge.jpatterns.core.configuration.PropertiesBasedFactory;

 import com.sourceforge.jpatterns.core.configuration.PropertiesProvider;

 import com.sourceforge.jpatterns.core.configuration.exceptions.JPConfigException;

 import com.sourceforge.jpatterns.core.configuration.exceptions.JPInitializationException;

 import com.sourceforge.jpatterns.schema.CastorConfigType;

 import com.sourceforge.jpatterns.schema.CastorFactoryType;

 import com.sourceforge.jpatterns.schema.CastorGroupType;

 import com.sourceforge.jpatterns.schema.CastorGroupTypeItem;

 import com.sourceforge.jpatterns.schema.CastorNameScopePriorityType;

 import com.sourceforge.jpatterns.schema.CastorSectionType;

 import com.sourceforge.jpatterns.schema.Item;

 import com.sourceforge.jpatterns.schema.JPatternsConfig;

 import com.sourceforge.jpatterns.utils.CastorUtils;

 import com.zmicer.utils.InputArgumentUtils;

 import com.zmicer.utils.ObjectStateUtils;

 import org.apache.commons.lang.StringUtils;

 import org.apache.log4j.Logger;

 import java.util.ArrayList;

 import java.util.List;

 import java.util.Map;

 /**

  * Default, "native" implementation of the appropriate interface.

  *

  * $Author:: zmicer             $<br/>

  * $Rev:: 67                    $<br/> * $Date:: 2007-08-28 21:37:07 #$<br/>

  * $Date:: 2007-08-28 21:37:07 #$<br/>

  */

 public class JPatternsConfigBeansBuilderImpl implements IJPatternsConfigBeansBuilder

 {

     /**

      * Logger instance.

      */

     final public static Logger LOG = Logger.getLogger(JPatternsConfigBeansBuilderImpl.class);

     /**

      * value for the com.sourceforge.jpatterns.core.configuration.PropertiesProvider.JPProperties.XML_CONFIG_OVERRIDING_DEPTH property

      */

     private static String OverridingDepth;

     /**

      * value for the

      * com.sourceforge.jpatterns.core.configuration.PropertiesProvider.JPProperties.XML_CONFIG_CUSTOM_OVERRIDES_NOT_DEPENDING_ON_PRIORITY

      */

     private static boolean OverrideNotDependingOnPriority;

     /**

      * Initialization block.

      */

     {

         PropertiesProvider propertiesProvider =

             PropertiesProvider.getInstance(PropertiesBasedFactory.getInstance().getPropertiesManager(), false);

         final String depth = propertiesProvider.getStringProperty(

             com.sourceforge.jpatterns.core.configuration.PropertiesProvider.JPProperties.XML_CONFIG_OVERRIDING_DEPTH);

         setOverridingDepth((null == depth) ? PropertiesProvider.OverridingDepths.OVERRIDING_LEVEL_SECTION.toString() : depth);

         final Boolean property = propertiesProvider.getBooleanProperty(com.sourceforge.jpatterns.core.configuration.

             PropertiesProvider.JPProperties.XML_CONFIG_CUSTOM_OVERRIDES_NOT_DEPENDING_ON_PRIORITY);

         setOverrideNotDependingOnPriority((null != property) && property);

     }

     /**

      * @see IJPatternsConfigBeansBuilder#build(com.sourceforge.jpatterns.schema.JPatternsConfig)

      * <br/>

      * <pre>

      * The algorithm is used here as follows:

      * <strong>Sections filling</strong>:

      * 1. the List of "section based" objects is formed<br/>

      *      - in the case the section has not explicit scope - the default one from the root castor object or the

      *      {@link com.sourceforge.jpatterns.core.JPConstants.DEFAULT_SCOPE_NAME} is set.

      * 2. all the "section based" objects are put to the map

      *      - in the case {@link com.sourceforge.jpatterns.core.configuration.PropertiesProvider.JPProperties.XML_CONFIG_OVERRIDING_DEPTH}

      * property equals to

      * <code>com.sourceforge.jpatterns.core.configuration.PropertiesProvider.OverridingDepths.OVERRIDING_LEVEL_ITEM</code> then in the case

      * of two identical sections (scopes, section name and priority), they would be merged to the one by joining the appropriate business

      * items. If there are identical business items (scopes, name and priority) - the

      * <code>com.sourceforge.jpatterns.core.configuration.exceptions.JPInitializationException</code> exception would appear

      *      - in the case {@link com.sourceforge.jpatterns.core.configuration.PropertiesProvider.JPProperties.XML_CONFIG_OVERRIDING_DEPTH}

      * property equals to

      * <code>com.sourceforge.jpatterns.core.configuration.PropertiesProvider.OverridingDepths.OVERRIDING_LEVEL_SECTION</code> then in the

      * case of two identical sections (scopes, section name and priority)

      * <code>com.sourceforge.jpatterns.core.configuration.exceptions.JPConfigException</code> exception would appear

      *      - in the case of the identical pathes but different priorities they would be taken into consideration (in this case

      * com.sourceforge.jpatterns.core.configuration.PropertiesProvider.JPProperties.XML_CONFIG_CUSTOM_OVERRIDES_NOT_DEPENDING_ON_PRIORITY

      * would be considered too).

      * <p/>

      *      <strong>Business items filling</strong>:

      *      todo [zmicer]: <<t.b.d.>>

      * <p/>

      * note [zmicer]: please be noticed the Section with the certain scope is allowed to store the business items with different scopes

      * </pre>

      */

     public JPatternsConfigBean build(final JPatternsConfig config)

     {

         // 00: check the input params on the validness.

         InputArgumentUtils.checkObjects(config);

         JPatternsConfigBean result = new JPatternsConfigBean();

         // 01: set additional info

         result.setDefaultScope(config.getDefaultScope());

         result.setCastorConfig(config);

         // 02: fill with sections/items

         CastorUtils.validateAndNormalizeScopesPriorities(config);

         fill(result, CastorUtils.extractCastorSectionTypeObjects(config));

         return result;

     }

     /**

      * @see IJPatternsConfigBeansBuilder#build(com.sourceforge.jpatterns.schema.JPatternsConfig)

      */

     public JPatternsConfigsBean build(final List<JPatternsConfigBaseBean> beans)

     {

         InputArgumentUtils.checkObjects(beans);

         final JPatternsConfigsBean result = new JPatternsConfigsBean();

         final List<CastorSectionType> sections = new ArrayList<CastorSectionType>();

         for (JPatternsConfigBaseBean bean : beans)

         {

             ObjectStateUtils.strongCheck(bean);

             sections.addAll(bean.getListOfSectionItems());

         }

         fill(result, sections);

         return result;

     }

     /**

      * Please review the Java Docs to the method {@link fill}

      * todo [zmicer]: adjust Java Doc

      * todo [zmicer]: think if this method could be moved to interface of the builder too

      *

      * @param initialBaseBean the initial bean to fill.

      *                        Can not be null (otherwise <code>IllegalArgumentException</code> would appear).

      * @param sections        the List of the CastorSectionType objects. They should be normalized in the sense of scopes and priorities(for

      *                        details study

      *                        {@link com.sourceforge.jpatterns.utils.CastorUtils#validateAndNormalizeScopesPriorities(JPatternsConfig)}).

      *                        Can not be null (otherwise <code>IllegalArgumentException</code> would appear).

      */

     protected void fill(final JPatternsConfigBaseBean initialBaseBean, final List<CastorSectionType> sections)

     {

         InputArgumentUtils.checkObjects(initialBaseBean, sections);

         ObjectStateUtils.strongCheck(initialBaseBean);

         // 01: working with the sections.

         for (final CastorSectionType section : sections)

         {

             if (null == section.getScope() && null == section.getName())

             {

                 throw new JPConfigException("The scope and name of CastorSectionType can not be null.");

             }

             final CastorSectionType alreadySection = initialBaseBean.getSection(section.getScope(), section.getName());

             // A. section with the same path is not existed yet or the pathes are different - just put it

             if (null == alreadySection ||

                 (!section.getScope().equals(alreadySection.getScope()) || !section.getName().equals(alreadySection.getName())))

             {

                 initialBaseBean.setSection(section.getScope(), section);

             }

             else

             {

                 initialBaseBean.setSection(section.getScope(),

                     (CastorSectionType) choiceOrMergeCastorNameScopePriorityTypes(section, alreadySection));

             }

         }

         // 02: working with the business items

         // A. iterate through all the sections we have at this moment

         Map<String, Map<String, CastorSectionType>> sectionItems = initialBaseBean.getSectionItems();

         for (String sectionScope : sectionItems.keySet())

         {

             final Map<String, CastorSectionType> sectionsMap = sectionItems.get(sectionScope);

             for (String sectionName : sectionsMap.keySet())

             {

                 final CastorSectionType section = sectionsMap.get(sectionName);

                 final List<CastorNameScopePriorityType> items = CastorUtils.extractCastorNameScopePriorityTypeObjects(section);

                 for (CastorNameScopePriorityType item : items)

                 {

                     if (null == item.getScope() && null == section.getName())

                     {

                         throw new JPConfigException("The scope and name of Item can not be null.");

                     }

                     if (StringUtils.isBlank(section.getScope()))

                     {

                         throw new JPInitializationException("Section should have scope set.");

                     }

                     final CastorNameScopePriorityType alreadyItem =

                         initialBaseBean.getBusinessItem(section.getScope(), sectionName, item.getScope(), item.getName());

                     // A. item with the same path is not existed yet

                     if (null == alreadyItem)

                     {

                         initialBaseBean.setBusinessItem(section.getScope(), sectionName, item);

                     }

                     else

                     {

                         initialBaseBean.setBusinessItem(section.getScope(), sectionName,

                             choiceOrMergeCastorNameScopePriorityTypes(item, alreadyItem));

                     }

                 }

             }

         }

     }

     /**

      * Choice one of the given CastorNameScopePriorityType castor objects or perform the merging if it is necessary. Please review the

      * comments to the main <code>fill</code> method to understand how it works (depending on the mentioned properties etc.)

      * <br/>

      * These objects should have the equal pathes to be passed here (scope, name) - otherwise the IllegalArgumentException appear

      *

      * @param castor1 the first object, Can not be null (otherwise <code>IllegalArgumentException</code> would appear).

      * @param castor2 the second object, Can not be null (otherwise <code>IllegalArgumentException</code> would appear).

      *

      * @return the object is more prioritized here

      */

     protected CastorNameScopePriorityType choiceOrMergeCastorNameScopePriorityTypes(final CastorNameScopePriorityType castor1,

         final CastorNameScopePriorityType castor2)

     {

         InputArgumentUtils.checkObjects(castor1, castor2);

         InputArgumentUtils.checkStrings(true, castor1.getScope(), castor1.getName(), castor1.getPriority());

         InputArgumentUtils.checkStrings(true, castor2.getScope(), castor2.getName(), castor2.getPriority());

         if (!castor1.getScope().equals(castor2.getScope()) || !castor1.getName().equals(castor2.getName()))

         {

             throw new IllegalArgumentException("The provided object should have the identical pathes to be checked / compared.");

         }

         if (!castor1.getClass().equals(castor2.getClass()))

         {

             throw new IllegalArgumentException("The classes of the provided objects should be identical.");

         }

         // 00: priorities are equals

         if (castor1.getPriority().equals(castor2.getPriority()))

         {

             // in the case of business items - just exception.

             if (!(castor1 instanceof CastorSectionType))

             {

                 throw new JPConfigException("The elements with identical pathes can not be merged - scope [" +

                     castor1.getScope() + "], name [" + castor1.getName() + "], priority [" + castor1.getPriority() + "]; class name " +

                     "is [" + castor1.getClass().getName() + "]");

             }

             // we need to apply overriding depth feature to here

             else

             {

                 // 00:b exception should be thrown - two identical pathes (including priotities)

                 if (OverridingDepth.equals(

                     com.sourceforge.jpatterns.core.configuration.PropertiesProvider.OverridingDepths.OVERRIDING_LEVEL_SECTION.toString()))

                 {

                     throw new JPConfigException("The elements with identical pathes can not be merged - scope [" +

                         castor1.getScope() + "], name [" + castor1.getName() + "], priority [" + castor1.getPriority() + "]; class " +

                         "name is [" + castor1.getClass().getName() + "]");

                 }

                 // 00:c no exception - we should merge the two items into the one (we won't check the items here - it would be done when

                 // the items would be put to the specialized map)

                 else if (OverridingDepth.equals(

                     com.sourceforge.jpatterns.core.configuration.PropertiesProvider.OverridingDepths.OVERRIDING_LEVEL_ITEM.toString()))

                 {

                     final List<CastorNameScopePriorityType> items =

                         CastorUtils.extractCastorNameScopePriorityTypeObjects((CastorSectionType) castor2);

                     for (CastorNameScopePriorityType item : items)

                     {

                         // perform add functionality through the reflexion

                         // note [zmicer]: very risky block still it is better then reflexion. Seems to be these three base classes limit

                         // the scope of root section classes

                         if (castor1 instanceof CastorConfigType)

                         {

                             if (!(item instanceof Item))

                             {

                                 throw new JPConfigException("The CastorNameScopePriorityType item should be of Item type in the " +

                                     "case castor section object is of the type CastorConfigType");

                             }

                             ((CastorConfigType) castor1).addItem((Item) item);

                         }

                         else if (castor1 instanceof CastorFactoryType)

                         {

                             if (!(item instanceof Item))

                             {

                                 throw new JPConfigException("The CastorNameScopePriorityType item should be of Item type in the " +

                                     "case castor section object is of the type CastorFactoryType");

                             }

                             ((CastorFactoryType) castor1).addItem((Item) item);

                         }

                         else if (castor1 instanceof CastorGroupType)

                         {

                             final CastorGroupTypeItem groupItem = CastorUtils.constructGroupItem(item);

                             ((CastorGroupType) castor1).addCastorGroupTypeItem(groupItem);

                         }

                     }

                     return castor1;

                 }

             }

         }

         else

         {

             int firstPriority = CastorUtils.getPriority(castor1);

             int secondPriority = CastorUtils.getPriority(castor2);

             boolean firstPrioritized = false;

             boolean secondPrioritized = false;

             if (castor1.getPriority().startsWith(JPConstants.PRIORITIZED_PRIOTITY_PREFIX))

             {

                 firstPrioritized = true;

             }

             if (castor2.getPriority().startsWith(JPConstants.PRIORITIZED_PRIOTITY_PREFIX))

             {

                 secondPrioritized = true;

             }

             // 00:d both prioritized or both not prioritized - just compare the priorities

             if (firstPrioritized && secondPrioritized || (!firstPrioritized && !secondPrioritized))

             {

                 return (firstPriority > secondPriority) ? castor1 : castor2;

             }

             // 00:e first prioritized - check the property too

             else if (firstPrioritized)

             {

                 if (OverrideNotDependingOnPriority)

                 {

                     return castor1;

                 }

                 else

                 {

                     return (firstPriority > secondPriority) ? castor1 : castor2;

                 }

             }

             // 00:f second prioritized - check the property too

             else

             {

                 if (OverrideNotDependingOnPriority)

                 {

                     return castor2;

                 }

                 else

                 {

                     return (firstPriority > secondPriority) ? castor1 : castor2;

                 }

             }

         }

         return null;

     }

     /**

      * Set the overriding depth. This method is necessary for the unit testing.

      *

      * @param depth the value we ned to set, Can not be null (otherwise <code>IllegalArgumentException</code> would appear).

      */

     protected static void setOverridingDepth(final String depth)

     {

         InputArgumentUtils.checkStrings(true, depth);

         OverridingDepth = depth;

     }

     /**

      * @return overriding depth

      */

     protected static String getOverridingDepth()

     {

         return OverridingDepth;

     }

     /**

      * Set the OverrideNotDependingOnPriority static field with the new value. This method is necessary for unit testing.

      *

      * @param value new boolean value

      */

     protected static void setOverrideNotDependingOnPriority(final boolean value)

     {

         OverrideNotDependingOnPriority = value;

     }

     /**

      * @return the value of OverrideNotDependingOnPriority

      */

     protected static boolean getOverrideNotDependingOnPriority()

     {

         return OverrideNotDependingOnPriority;

     }

 }