package com.sourceforge.jpatterns.utils;

 import com.sourceforge.jpatterns.core.JPConstants;

 import com.sourceforge.jpatterns.core.JPException;

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

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

 import com.sourceforge.jpatterns.core.configuration.model.JPatternsConfigBaseBean;

 import com.sourceforge.jpatterns.schema.CastorGroupTypeItem;

 import com.sourceforge.jpatterns.schema.CastorNameScopePriorityType;

 import com.sourceforge.jpatterns.schema.CastorSectionType;

 import com.sourceforge.jpatterns.schema.Config;

 import com.sourceforge.jpatterns.schema.Factory;

 import com.sourceforge.jpatterns.schema.JPatternsConfig;

 import com.sourceforge.jpatterns.schema.JPatternsConfigItem;

 import com.zmicer.utils.InputArgumentUtils;

 import com.zmicer.utils.LoggingUtils;

 import com.zmicer.utils.ReflexionUtils;

 import com.zmicer.utils.StringUtils;

 import org.apache.log4j.Logger;

 import org.exolab.castor.xml.Unmarshaller;

 import java.io.File;

 import java.io.FileReader;

 import java.lang.reflect.Method;

 import java.util.ArrayList;

 import java.util.Arrays;

 import java.util.List;

 /**

  * This class contains the castor utils related to the JPatterns project (appropriate project specific model is used here).

  * <p/>

  * $Author:: zmicer             $<br/>

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

  */

 public class CastorUtils

 {

     /**

      * Logger instance.

      */

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

     /**

      * Base name of the class to be used.

      */

     final protected static String GROUP_ITEM_CLASS_NAME = CastorGroupTypeItem.class.getName();

     /**

      * Get <code>JPatternsConfig</code> using the provided file.

      *

      * @param file File using which we need to obtain <code>JPatternsConfig</code>

      *             Can not be null (otherwise <code>IllegalArgumentException</code> would appear), also should point to the existed file

      *             (otherwise <code>IllegalArgumentException</code> would appear).

      *

      * @return the castor object, <code>JPatternsConfig</code>. In the case of the failure it returns <code>null</null>

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

      */

     public static JPatternsConfig getJPatternsConfig(final File file)

     {

         InputArgumentUtils.checkObjects(file);

         if (!file.isFile())

         {

             throw new IllegalArgumentException("The provided object is not file.");

         }

         try

         {

             FileReader fileReader = new FileReader(file);

             Unmarshaller unmarshaller = new Unmarshaller(JPatternsConfig.class);

             Object object = unmarshaller.unmarshal(fileReader);

             if (null == object)

             {

                 final String message = "Can not instantiate the object using unmarshal operation.";

                 LOG.debug(message);

                 throw new IllegalStateException(message);

             }

             if (!(object instanceof JPatternsConfig))

             {

                 final String message = "The object instantiated using operation unmarshal should be the type JPatternsConfig.";

                 LOG.debug(message);

                 throw new IllegalStateException(message);

             }

             return (JPatternsConfig) object;

         }

         catch (Exception e)

         {

             LoggingUtils.logException(LOG, e, null, null);

             throw new JPInitializationException(e);

         }

     }

     /**

      * Stores and retrive all the objects of CastorSectionType (it means all the objects of this type and also child of this type).

      * This would be performed trough the reflexion. This method is necessary because it doesn could be used without any changes in

      * the case some new types - childs of CastorSectionType would be added - so we won't need to change the sources.

      *

      * @param config JPatternsConfig object to be parsed. Can not be null (otherwise <code>IllegalArgumentException</code> would appear).

      *

      * @return List of <code>CastorSectionType</code> objects, could be empty List returned in the case the provided config doesn't store

      *         the necessary objects

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

      */

     public static List<CastorSectionType> extractCastorSectionTypeObjects(final JPatternsConfig config)

     {

         InputArgumentUtils.checkObjects(config);

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

         final JPatternsConfigItem[] configItems = config.getJPatternsConfigItem();

         // no information

         if (configItems.length == 0)

         {

             return result;

         }

         final JPatternsConfigItem configItem = new JPatternsConfigItem();

         // 00: obtain the methods and find the methods the names of which start with "get" and return object of CastorSectionType

         final String methodPrefix = "get";

         final Method[] methods = configItem.getClass().getMethods();

         final List<Method> methodsWeNeed = new ArrayList<Method>();

         for (final Method method : methods)

         {

             final Class returnedType = method.getReturnType();

             //  && returnedType.isArray() - earlier this method checked if array is returned

             if (method.getName().contains(methodPrefix) && !method.getName().contains("getClass"))

             {

                 //final String arrayMembersClassName = ReflexionUtils.getClassNameOfArrayMembers(returnedType);

                 // commented still could be used later

                 try

                 {

                     final Object objectToCheck = returnedType.newInstance();

                     if (objectToCheck instanceof CastorSectionType)

                     {

                         methodsWeNeed.add(method);

                     }

                 }

                 catch (Exception e)

                 {

                     // just log and continue with finding the methods we need.

                     LoggingUtils.logException(LOG, e, null, null);

                 }

             }

         }

         // 01: iterate through the methods we have obtained, call them on the provided castor object, using the reflexion and accumulate

         // the results to the result storage. Check the results of the method are the thing we need.

         for (final JPatternsConfigItem item : configItems)

         {

             for (final Method method : methodsWeNeed)

             {

                 try

                 {

                     final Object object = method.invoke(item);

                     // if (object instanceof CastorSectionType[]) was earlier

                     if (object instanceof CastorSectionType)

                     {

                         result.add((CastorSectionType) object);

                     }

                 }

                 catch (Exception ex)

                 {

                     LoggingUtils.logException(LOG, ex, null, null);

                 }

             }

         }

         return result;

     }

     /**

      * Extract all the possible CastorNameScopePriorityType castor objects from the provided CastorSectionType. The sense of this method is

      * as follows: CastorSectionType is a base "sections" object and has lots of child with the business items which are the instances of

      * the class CastorNameScopePriorityType. In the case of CastorFactoryType, CastorConfigType it would be just method getItem returning

      * Item[] which are instances of CastorNameScopePriorityType too. But for the castorGroupType it is the method getCastorGroupTypeItem

      * returning CastorGroupTypeItem[] each of them is a choice - in this case we would call "getChoiceValue" method.

      *

      * @param sectionType the section type to be analyzed. Can not be null (otherwise <code>IllegalArgumentException</code> would appear).

      *

      * @return the List of the <code>CastorNameScopePriorityType</code> objects.

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

      */

     public static List<CastorNameScopePriorityType> extractCastorNameScopePriorityTypeObjects(final CastorSectionType sectionType)

     {

         InputArgumentUtils.checkObjects(sectionType);

         final String methodPrefix = "get";

         final String choiceValueMethod = "getChoiceValue";

         final String groupItemName = "";

         final Method[] methods = sectionType.getClass().getMethods();

         final List<Method> methodsWeNeed = new ArrayList<Method>();

         for (final Method method : methods)

         {

             final Class returnedType = method.getReturnType();

             if (method.getName().contains(methodPrefix) && returnedType.isArray())

             {

                 final String arrayMembersClassName = ReflexionUtils.getClassNameOfArrayMembers(returnedType);

                 try

                 {

                     // todo [zmicer]: not sure if we need the reflexion here - may be string contains method would be enough?

                     final Object objectToCheck = sectionType.getClass().getClassLoader().loadClass(arrayMembersClassName).newInstance();

                     if (objectToCheck instanceof CastorNameScopePriorityType || objectToCheck instanceof CastorGroupTypeItem)

                     {

                         methodsWeNeed.add(method);

                     }

                 }

                 catch (Exception e)

                 {

                     // just log and continue with finding the methods we need.

                     LoggingUtils.logException(LOG, e, null, null);

                 }

             }

         }

         // 01: iterate through the methods we have obtained, call them on the provided castor object, using the reflexion and accumulate

         // the results to the result storage. Check the results of the method are the thing we need.

         final List<CastorNameScopePriorityType> result = new ArrayList<CastorNameScopePriorityType>();

         for (final Method method : methodsWeNeed)

         {

             try

             {

                 final Object object = method.invoke(sectionType);

                 // if (object instanceof CastorSectionType[]) was earlier

                 if (null != object)

                 {

                     if (object instanceof CastorNameScopePriorityType[])

                     {

                         result.addAll(Arrays.asList((CastorNameScopePriorityType[]) object));

                     }

                     else if (object instanceof CastorGroupTypeItem[])

                     {

                         CastorGroupTypeItem[] groupItems = (CastorGroupTypeItem[]) object;

                         for (CastorGroupTypeItem groupItem : groupItems)

                         {

                             if (groupItem.getChoiceValue() instanceof CastorNameScopePriorityType)

                             {

                                 result.add((CastorNameScopePriorityType) groupItem.getChoiceValue());

                             }

                         }

                     }

                 }

             }

             catch (Exception ex)

             {

                 LoggingUtils.logException(LOG, ex, null, null);

             }

         }

         return result;

     }

     /**

      * Make the scopes of all the elements here normalized. Currently (possibly smth. could be changed) it means:

      * <br/>

      * 1. the scopes of the root/child elements can be different

      * 2. in the case "business" item is defined with scope and parent without - the defined scope would have power on the business item

      * 3. in the case the parent elements is defined with a scope, then all the childs of it would be of the appropriate scope

      * <br/>

      * The default scope is mentioned is either the default scope of the castor root config or

      * <code>com.sourceforge.jpatterns.core.JPConstants.DEFAULT_SCOPE_NAME</code>

      * <br/>

      * note1 [zmicer]: think over the adjustment of principles of normalization, as some new types could appear here, and this method would

      * be extended (new scope supported types different from the base type CastorSectionType would appear).

      * note2 [zmicer]: earlier at this method we retrict the case when parent and child have different scopes - for now it is allowed (it

      * was decided to allow the support of scopes of the business item elements inside the section - it is one more scope visibility area).

      *

      * @param config castor root config objects to be processed.

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

      *

      * @version 1.1

      */

     public static void validateAndNormalizeScopesPriorities(final JPatternsConfig config)

     {

         InputArgumentUtils.checkObjects(config);

         final boolean configHasDefaultScope = (null != config.getDefaultScope() && !"".equals(config.getDefaultScope()));

         // 00: default scope

         final String defaultScope = (configHasDefaultScope) ? config.getDefaultScope() :

             com.sourceforge.jpatterns.core.JPConstants.DEFAULT_SCOPE_NAME;

         if (!configHasDefaultScope)

         {

             config.setDefaultScope(defaultScope);

         }

         // 01: working with sections

         final List<CastorSectionType> castorSectionTypes = CastorUtils.extractCastorSectionTypeObjects(config);

         for (final CastorSectionType castorSectionType : castorSectionTypes)

         {

             if (null == castorSectionType.getScope() || "".equals(castorSectionType.getScope()))

             {

                 castorSectionType.setScope(defaultScope);

             }

             setValidatePriority(castorSectionType, false);

             // 02: working with items

             final List<CastorNameScopePriorityType> items = extractCastorNameScopePriorityTypeObjects(castorSectionType);

             for (final CastorNameScopePriorityType item : items)

             {

                 // 02:a - set the scope of the parent

                 if (null == item.getScope() || "".equals(item.getScope()))

                 {

                     item.setScope(castorSectionType.getScope());

                 }

                 setValidatePriority(item, false);

             }

         }

     }

     /**

      * All the items of the provided <code>JPatternsConfig</code> - sections, business items - are made prioritized. For this

      * <code>com.sourceforge.jpatterns.core.JPConstants.PRIORITIZED_PRIOTITY_PREFIX</code> would be added as the prefix to all the

      * priorities. Then later, during the prioritized merging this items would have priority over the identical, but without this prefix.

      * <br/>

      * This functionality is introduced to make the algorithm of simlple merging of JPatterns configuration files identical with the

      * merging with priority (when some configuration takes the priority).

      *

      * @param castorConfig the target JPatternsConfig root castor object objects of which should be modified (their priorities)

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

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

      */

     public static void makePrioritized(final JPatternsConfig castorConfig)

     {

         InputArgumentUtils.checkObjects(castorConfig);

         // 01: working with sections

         final List<CastorSectionType> castorSectionTypes = CastorUtils.extractCastorSectionTypeObjects(castorConfig);

         for (final CastorSectionType castorSectionType : castorSectionTypes)

         {

             setValidatePriority(castorSectionType, true);

             // 02: working with items

             final List<CastorNameScopePriorityType> items = extractCastorNameScopePriorityTypeObjects(castorSectionType);

             for (final CastorNameScopePriorityType item : items)

             {

                 setValidatePriority(item, true);

             }

         }

     }

     /**

      * Make prioritized the provided bean.

      *

      * @param bean the instance to be prioritized.

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

      */

     public static void makePrioritized(final JPatternsConfigBaseBean bean)

     {

         InputArgumentUtils.checkObjects(bean);

         // 01: working with sections

         final List<CastorSectionType> castorSectionTypes = bean.getListOfSectionItems();

         for (final CastorSectionType castorSectionType : castorSectionTypes)

         {

             setValidatePriority(castorSectionType, true);

             // 02: working with items

             final List<CastorNameScopePriorityType> items = extractCastorNameScopePriorityTypeObjects(castorSectionType);

             for (final CastorNameScopePriorityType item : items)

             {

                 setValidatePriority(item, true);

             }

         }

     }

     /**

      * Set new / validate (is any) the priority field of the given castor object.

      *

      * @param castor          CastorNameScopePriorityType instance. Can not be null (otherwise <code>IllegalArgumentException</code> would appear).

      * @param makePrioritized signs if we need to make the priority prioritized (using JPConstants.PRIORITIZED_PRIOTITY_PREFIX)

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

      */

     protected static void setValidatePriority(final CastorNameScopePriorityType castor, final boolean makePrioritized)

     {

         InputArgumentUtils.checkObjects(castor);

         if (null == castor.getPriority() || "".equals(castor.getPriority()))

         {

             castor.setPriority(String.valueOf(JPConstants.DEFAULT_PRIORITY));

         }

         // check if it is already prioritized.

         if (!castor.getPriority().contains(JPConstants.PRIORITIZED_PRIOTITY_PREFIX))

         {

             if (null == StringUtils.getInteger(castor.getPriority()))

             {

                 throw new JPConfigException("The following priority " + castor.getPriority() + " is incorrect.");

             }

             if (makePrioritized)

             {

                 castor.setPriority(JPConstants.PRIORITIZED_PRIOTITY_PREFIX + castor.getPriority());

             }

         }

     }

     /**

      * Get the int representation of the priority.

      *

      * @param castor castor object storing the priority to be used.

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

      *

      * @return the int representaotion

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

      */

     public static int getPriority(final CastorNameScopePriorityType castor)

     {

         InputArgumentUtils.checkObjects(castor);

         InputArgumentUtils.checkStrings(true, castor.getPriority());

         String workingStr = null;

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

         {

             workingStr = castor.getPriority().substring(JPConstants.PRIORITIZED_PRIOTITY_PREFIX.length());

         }

         else

         {

             workingStr = castor.getPriority();

         }

         final Integer integer = StringUtils.getInteger(workingStr);

         if (null == integer)

         {

             throw new IllegalArgumentException("Invalid priority is set to the castor [" + castor.getPriority() + "]");

         }

         return integer;

     }

     /**

      * Get the List of <code>Config</code> castor objects by the root JPatterns configuration object. It is necessary for the convinient

      * opering with the Config object.

      *

      * @param config the <code>JPatternsConfig</code> root castor config objects,

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

      *

      * @return the List of the Config castor object we need, the empty List is returned in the case there are not Config objects.

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

      */

     public static List<Config> getConfig(final JPatternsConfig config)

     {

         InputArgumentUtils.checkObjects(config);

         final List<Config> result = new ArrayList<Config>();

         for (JPatternsConfigItem configItem : config.getJPatternsConfigItem())

         {

             if (null != configItem.getConfig())

             {

                 result.add(configItem.getConfig());

             }

         }

         return result;

     }

     /**

      * Get the List of <code>Factory</code> castor objects by the root JPatterns configuration object. It is necessary for the convinient

      * opering with the Factory object.

      *

      * @param config the <code>JPatternsConfig</code> root castor config objects,

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

      *

      * @return the List of the Factory castor object we need, the empty List is returned in the case there are not Config objects.

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

      */

     public static List<Factory> getFactory(final JPatternsConfig config)

     {

         InputArgumentUtils.checkObjects(config);

         final List<Factory> result = new ArrayList<Factory>();

         for (JPatternsConfigItem configItem : config.getJPatternsConfigItem())

         {

             if (null != configItem.getFactory())

             {

                 result.add(configItem.getFactory());

             }

         }

         return result;

     }

     /**

      * Add the instance of <code>Config</code> type to the provided JPatternsConfig root config object

      *

      * @param config     JPatternsConfig, Can not be null (otherwise <code>IllegalArgumentException</code> would appear).

      * @param configItem Config castor object. Can not be null (otherwise <code>IllegalArgumentException</code> would appear).

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

      */

     public static void addConfig(final JPatternsConfig config, final Config configItem)

     {

         InputArgumentUtils.checkObjects(config, configItem);

         JPatternsConfigItem item = new JPatternsConfigItem();

         item.setConfig(configItem);

         config.addJPatternsConfigItem(item);

     }

     /**

      * Add the instance of <code>Config</code> type to the provided JPatternsConfig root config object

      *

      * @param config      JPatternsConfig, Can not be null (otherwise <code>IllegalArgumentException</code> would appear).

      * @param factoryItem Factory castor object. Can not be null (otherwise <code>IllegalArgumentException</code> would appear).

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

      */

     public static void addFactory(final JPatternsConfig config, final Factory factoryItem)

     {

         InputArgumentUtils.checkObjects(config, factoryItem);

         JPatternsConfigItem item = new JPatternsConfigItem();

         item.setFactory(factoryItem);

         config.addJPatternsConfigItem(item);

     }

     /**

      * Construct the CastorGroupTypeItem (choice object) using the provided Object.

      *

      * @param object CastorNameScopePriorityType instance, can not be null, CastorGroupTypeItem should have appropriate method

      *               set***, where *** - the base name of the provided object. Otherwise IllegalArgumentException would appeared

      *

      * @return the constructed CastorGroupTypeItem

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

      */

     public static CastorGroupTypeItem constructGroupItem(final CastorNameScopePriorityType object)

     {

         InputArgumentUtils.checkObjects(object);

         final String typeToBeAdded = ReflexionUtils.getBaseName(object.getClass());

         final Method[] methods = CastorGroupTypeItem.class.getMethods();

         for (final Method method : methods)

         {

             if (method.getName().equals("set" + typeToBeAdded))

             {

                 try

                 {

                     CastorGroupTypeItem groupItem = new CastorGroupTypeItem();

                     method.invoke(groupItem, object);

                     return groupItem;

                 }

                 catch (Exception ex)

                 {

                     LoggingUtils.logException(LOG, ex, "Can not instantiate CastorGroupTypeItem", null);

                     throw new JPException("Can not instantiate CastorGroupTypeItem", ex);

                 }

             }

         }

         return null;

     }

     /**

      * Get the String representation of the Item in the format we need (the full path would be provided).

      * note [zmicer]: be noticed the both name and scope values should be filled for these object passed here

      *

      * @param section the Section object for which we need to get the full representation in the format we need

      *                Could be null, in this case information about the section is displayed

      * @param item    Item castor object. Can not be null (otherwise <code>IllegalArgumentException</code> would appear).

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

      *

      * @return the String representation we could use later.

      */

     public static String toString(final CastorSectionType section, final CastorNameScopePriorityType item)

     {

         InputArgumentUtils.checkObjects(item);

         InputArgumentUtils.checkStrings(true, item.getScope(), item.getName());

         String result = "";

         if (null != section)

         {

             InputArgumentUtils.checkStrings(true, section.getScope(), section.getName());

             result += "Section: scope [" + section.getScope() + "], name [" + section.getName() + "];";

         }

         return result += "Item: scope [" + item.getScope() + "], name [" + item.getName() + "];";

     }

 }