/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements. See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership. The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License. You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied. See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */

package org.apache.axis2.databinding.utils;


import java.beans.BeanInfo;
import java.beans.IntrospectionException;
import java.beans.PropertyDescriptor;
import java.lang.reflect.Array;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.SortedMap;
import java.util.Queue;
import java.util.Set;
import java.util.TreeMap;

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.LinkedBlockingQueue;

import javax.activation.DataHandler;
import javax.xml.datatype.DatatypeConfigurationException;
import javax.xml.datatype.DatatypeFactory;
import javax.xml.datatype.XMLGregorianCalendar;
import javax.xml.namespace.QName;
import javax.xml.stream.XMLStreamReader;

import org.apache.axiom.om.*;
import org.apache.axiom.util.base64.Base64Utils;
import org.apache.axis2.AxisFault;
import org.apache.axis2.classloader.BeanInfoCache;
import org.apache.axis2.context.MessageContext;
import org.apache.axis2.databinding.typemapping.SimpleTypeMapper;
import org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl;
import org.apache.axis2.deployment.util.BeanExcludeInfo;
import org.apache.axis2.description.AxisService;
import org.apache.axis2.description.java2wsdl.TypeTable;
import org.apache.axis2.engine.ObjectSupplier;
import org.apache.axis2.util.Loader;
import org.apache.axis2.util.StreamWrapper;
import org.w3c.dom.Document;

public class BeanUtil {
   
    private static int nsCount = 1;

    /**
     * To Serilize Bean object this method is used, this will create an object array using given
     * bean object
     */
    public static XMLStreamReader getPullParser(Object beanObject,
                                                QName beanName,
                                                TypeTable typeTable,
                                                boolean qualified,
                                                boolean processingDocLitBare) {

        Class beanClass = beanObject.getClass();
        List<Object> propertyQnameValueList = getPropertyQnameList(beanObject,
                                                           beanClass, beanName, typeTable, qualified, processingDocLitBare);

        ArrayList<QName> objectAttributes = new ArrayList<QName>();

        if ((typeTable != null)) {
            QName qNamefortheType = typeTable.getQNamefortheType(getClassName(beanClass));
            if (qNamefortheType != null) {
                objectAttributes.add(new QName(Constants.XSI_NAMESPACE, "type", "xsi"));
                objectAttributes.add(qNamefortheType);
            }
        }

        return new ADBXMLStreamReaderImpl(beanName, propertyQnameValueList.toArray(), objectAttributes.toArray(),
                                          typeTable, qualified);

    }

    private static String getClassName(Class type) {
        String name = type.getName();
        if (name.indexOf("$") > 0) {
            name = name.replace('$', '_');
        }
        return name;
    }


    private static BeanInfo getBeanInfo(Class beanClass, Class beanSuperclass) throws IntrospectionException {
        return BeanInfoCache.getCachedBeanInfo(beanClass, beanSuperclass);
    }

    private static BeanInfo getBeanInfo(Class beanClass) throws IntrospectionException {
        return getBeanInfo(beanClass, null);
    }

    private static List<Object> getPropertyQnameList(Object beanObject,
                                                     Class<?> beanClass,
                                                     QName beanName,
                                                     TypeTable typeTable,
                                                     boolean qualified,
                                                     boolean processingDocLitBare) {
        List<Object> propertyQnameValueList;
        Class<?> supperClass = beanClass.getSuperclass();

        if (!getQualifiedName(supperClass.getPackage()).startsWith("java.")) {
            propertyQnameValueList = getPropertyQnameList(beanObject,
                                                          supperClass, beanName, typeTable, qualified, processingDocLitBare);
        } else {
            propertyQnameValueList = new ArrayList<Object>();
        }

        try {
            QName elemntNameSpace = null;
            if (typeTable != null && qualified) {
                QName qNamefortheType = typeTable.getQNamefortheType(beanClass.getName());
                if (qNamefortheType == null) {
                    qNamefortheType = typeTable.getQNamefortheType(beanClass.getPackage().getName());
                }
                if (qNamefortheType == null) {
                    throw new AxisFault("Mapping qname not fond for the package: " +
                                        beanObject.getClass().getPackage().getName());
                }

                elemntNameSpace = new QName(qNamefortheType.getNamespaceURI(), "elementName", qNamefortheType.getPrefix());
            }
            AxisService axisService = null;
            if (MessageContext.getCurrentMessageContext() != null) {
                axisService = MessageContext.getCurrentMessageContext().getAxisService();
            }

            BeanExcludeInfo beanExcludeInfo = null;
            if (axisService != null && axisService.getExcludeInfo() != null) {
                beanExcludeInfo = axisService.getExcludeInfo().getBeanExcludeInfoForClass(beanClass.getName());
            }
            BeanInfo beanInfo = getBeanInfo(beanClass, beanClass.getSuperclass());
            PropertyDescriptor[] properties = beanInfo.getPropertyDescriptors();
            for (PropertyDescriptor property : properties) {
                String propertyName = property.getName();
                Class<?> ptype = property.getPropertyType();
                if (propertyName.equals("class") ||
                    beanExcludeInfo != null && beanExcludeInfo.isExcludedProperty(propertyName) || ptype == null) {
                    continue;
                }

                Method readMethod = property.getReadMethod();
                if (readMethod == null) {
                    Class propertyType = property.getPropertyType();
                    if (propertyType == java.lang.Boolean.class) {
                        Method writeMethod = property.getWriteMethod();
                        if (writeMethod != null) {
                            String tmpWriteMethodName = writeMethod.getName();
                            PropertyDescriptor tmpPropDesc =
                                    new PropertyDescriptor(property.getName(),
                                            beanObject.getClass(),
                                            "is" + tmpWriteMethodName.substring(3),
                                            tmpWriteMethodName);
                            readMethod = tmpPropDesc.getReadMethod();
                        }
                    }
                }
                Object value;
                if (readMethod != null) {
                    readMethod.setAccessible(true);
                    value = readMethod.invoke(beanObject);
                } else {
                    throw new AxisFault("Property '" + propertyName + "' in bean class '"
                                        + beanClass.getName() + "'is not readable.");
                }

                if (SimpleTypeMapper.isSimpleType(ptype)) {
                    addTypeQname(elemntNameSpace, propertyQnameValueList, property,
                                 beanName, processingDocLitBare);
                    propertyQnameValueList.add(
                            value == null ? null : SimpleTypeMapper.getStringValue(value));
                } else if(SimpleTypeMapper.isDomDocument(ptype)){
                    addTypeQname(elemntNameSpace, propertyQnameValueList, property,
                            beanName, processingDocLitBare);
                    OMFactory fac = OMAbstractFactory.getOMFactory();
                    propertyQnameValueList.add(convertDOMtoOM(fac, value));
                    
                } else if (ptype.isArray()) {
                    if (SimpleTypeMapper.isSimpleType(ptype.getComponentType())) {
                        if (value != null) {
                            if (Byte.TYPE.equals(ptype.getComponentType())) {
                                addTypeQname(elemntNameSpace, propertyQnameValueList,
                                             property, beanName, processingDocLitBare);
                                propertyQnameValueList.add(Base64Utils.encode((byte[]) value));
                            } else {
                                int i1 = Array.getLength(value);
                                for (int j = 0; j < i1; j++) {
                                    Object o = Array.get(value, j);
                                    addTypeQname(elemntNameSpace, propertyQnameValueList,
                                                 property, beanName, processingDocLitBare);
                                    propertyQnameValueList.add(o == null ? null :
                                                               SimpleTypeMapper.getStringValue(o));
                                }
                            }
                        } else {
                            addTypeQname(elemntNameSpace, propertyQnameValueList, property,
                                         beanName, processingDocLitBare);
                            propertyQnameValueList.add(value);
                        }
                    } else {
                        if (value != null) {
                            for (Object o : (Object[]) value) {
                                addTypeQname(elemntNameSpace, propertyQnameValueList,
                                             property, beanName, processingDocLitBare);   
                                QName propertyQName = null;
                                if (elemntNameSpace != null) {
                                    propertyQName = new QName(
                                            elemntNameSpace.getNamespaceURI(),
                                            propertyName,
                                            elemntNameSpace.getPrefix());
                                } else {
                                    propertyQName = new QName(propertyName);

                                }
                                
                                if (SimpleTypeMapper
                                        .isObjectArray(o.getClass())
                                        || SimpleTypeMapper
                                                .isMultidimensionalObjectArray(o
                                                        .getClass())) {
                                    /**
                                     * If it is a Object[] we need to add instance type
                                     * attributes to the response message.
                                     * Copied from ADBXMLStreamReaderImpl. 
                                     * For inner Arrary Complex types we use the special local name array - "array"
                                     */
                                    QName itemName;
                                    if (qualified) {
                                        itemName = new QName(elemntNameSpace.getNamespaceURI(),
                                                Constants.INNER_ARRAY_COMPLEX_TYPE_NAME,
                                                elemntNameSpace.getPrefix());
                                    } else {
                                        itemName = new QName(Constants.INNER_ARRAY_COMPLEX_TYPE_NAME);
                                    }
                                    propertyQnameValueList.add(getOMElement(propertyQName , (Object[]) o,
                                            itemName, qualified, typeTable));
                                } else {
                                    if(SimpleTypeMapper.isObjectArray(value.getClass())){
                                        OMFactory fac = OMAbstractFactory.getOMFactory();
                                        OMElement element = fac.createOMElement(propertyQName);
                                        element.addChild(fac.createOMText(SimpleTypeMapper.getStringValue(o)));  
                                        addInstanceTypeAttribute(fac, element, o, typeTable);
                                        propertyQnameValueList.add(element);
                                    } else {
                                        propertyQnameValueList.add(o);
                                    }
                                }
                               
                            }
                        } else {
                            addTypeQname(elemntNameSpace, propertyQnameValueList, property,
                                         beanName, processingDocLitBare);
                            propertyQnameValueList.add(value);
                        }
                    }
                } else  if (SimpleTypeMapper.isCollection(ptype) && value != null) { 
                    if (typeTable != null) {
                        OMFactory fac = OMAbstractFactory.getOMFactory();
                        QName qNamefortheType = null;
                        qNamefortheType = (QName) typeTable
                                .getComplexSchemaMap().get(getClassName(beanClass));
                        Type genericType = property.getReadMethod().getGenericReturnType();
                        OMElement collection = BeanUtil.getCollectionElement(
                                fac, genericType,
                                (Collection) value, propertyName,null,
                                qNamefortheType,typeTable,
                                qualified);
//                      addTypeQname(elemntNameSpace, propertyQnameValueList,
//                              property, beanName, processingDocLitBare);
                        Iterator childItr = collection.getChildren();
                        while(childItr.hasNext()){
                            addTypeQname(elemntNameSpace, propertyQnameValueList,
                                    property, beanName, processingDocLitBare);
                            propertyQnameValueList.add(childItr.next());
                        }
                    
                    } else {
                        Collection<?> objList = (Collection<?>) value;
                        if (objList != null && objList.size() > 0) {
                            //this was given error , when the array.size = 0
                            // and if the array contain simple type , then the ADBPullParser asked
                            // PullParser from That simpel type
                            for (Object o : objList) {
                                if (SimpleTypeMapper.isSimpleType(o)) {
                                    addTypeQname(elemntNameSpace, propertyQnameValueList,
                                            property, beanName, processingDocLitBare);
                                    propertyQnameValueList.add(o);
                                } else {
                                    addTypeQname(elemntNameSpace, propertyQnameValueList,
                                            property, beanName, processingDocLitBare);
                                    propertyQnameValueList.add(o);
                                }
                            }

                        } else {
                            addTypeQname(elemntNameSpace, propertyQnameValueList, property,
                                    beanName, processingDocLitBare);
                            propertyQnameValueList.add(value);
                        }
                    }
                    
                } else if (SimpleTypeMapper.isMap(ptype) && value != null) {
                    OMFactory fac = OMAbstractFactory.getOMFactory();
                    QName qNamefortheType = (QName) typeTable
                            .getComplexSchemaMap().get(getClassName(beanClass));
                    OMNamespace ns = fac.createOMNamespace(
                                        qNamefortheType.getNamespaceURI(),
                                        qNamefortheType.getPrefix());
                    List<OMElement> mapEntries = getMapElement(fac,
                            ptype, (Map) value, typeTable, qualified);
                    OMElement map = fac.createOMElement(propertyName,
                                        qNamefortheType.getNamespaceURI(),
                                        qNamefortheType.getPrefix());
                    for (OMElement ele : mapEntries) {
                        map.addChild(ele);
                    }
                    addTypeQname(elemntNameSpace, propertyQnameValueList,
                            property, beanName, processingDocLitBare);
                    propertyQnameValueList.add(map);
                } else if (SimpleTypeMapper.isEnum(ptype)){
                    addTypeQname(elemntNameSpace, propertyQnameValueList, property,
                                 beanName, processingDocLitBare);
                    propertyQnameValueList.add(
                            value == null ? null : SimpleTypeMapper.getStringValue(value.toString()));
                }else {
                    addTypeQname(elemntNameSpace, propertyQnameValueList, property,
                                 beanName, processingDocLitBare);
                    if (Object.class.equals(ptype) && value != null) {
                        //this is required to match this element prefix as
                        //root element's prefix.
                        QName qNamefortheType = (QName) typeTable
                                .getComplexSchemaMap().get(
                                        getClassName(beanClass));
                        OMFactory fac = OMAbstractFactory.getOMFactory();
                        QName elementName;
                        OMElement element;
                        if (elemntNameSpace != null) {
                            elementName = new QName(
                                    elemntNameSpace.getNamespaceURI(),
                                    property.getName(),
                                    qNamefortheType.getPrefix());
                        } else {
                            elementName = new QName(property.getName());
                        }
                        
                        if(SimpleTypeMapper.isSimpleType(value)){
                            element = fac.createOMElement(elementName);
                            element.addChild(fac.createOMText(SimpleTypeMapper
                                    .getStringValue(value)));
                        }else{
                             XMLStreamReader xr = BeanUtil.getPullParser(value,
                                     elementName, typeTable, qualified, false);
                             OMXMLParserWrapper stAXOMBuilder =
                                     OMXMLBuilderFactory.createStAXOMBuilder(
                                             OMAbstractFactory.getOMFactory(), new StreamWrapper(xr));
                             element = stAXOMBuilder.getDocumentElement();
                             
                            
                        }
                        addInstanceTypeAttribute(fac, element, value, typeTable);
                        propertyQnameValueList.add(element);
                        continue;
                    }

                    propertyQnameValueList.add(value);
                }
            }

            return propertyQnameValueList;

        } catch (java.io.IOException e) {
            throw new RuntimeException(e);
        } catch (java.beans.IntrospectionException e) {
            throw new RuntimeException(e);
        } catch (java.lang.reflect.InvocationTargetException e) {
            throw new RuntimeException(e);
        } catch (java.lang.IllegalAccessException e) {
            throw new RuntimeException(e);
        }
    }

    private static void addTypeQname(QName elemntNameSpace,
                                     List<Object> propertyQnameValueList,
                                     PropertyDescriptor propDesc,
                                     QName beanName,
                                     boolean processingDocLitBare) {
        if (elemntNameSpace != null) {
            propertyQnameValueList.add(new QName(elemntNameSpace.getNamespaceURI(),
                                                 propDesc.getName(), elemntNameSpace.getPrefix()));
        } else {
            if (processingDocLitBare) {
                propertyQnameValueList.add(new QName(propDesc.getName()));
            } else {
                propertyQnameValueList.add(new QName(beanName.getNamespaceURI(), propDesc.getName(), beanName.getPrefix()));
            }

        }
    }

    /**
     * to get the pull parser for a given bean object , generate the wrpper element using class
     * name
     *
     * @param beanObject
     */
    public static XMLStreamReader getPullParser(Object beanObject) {
        String className = beanObject.getClass().getName();
        if (className.indexOf(".") > 0) {
            className = className.substring(className.lastIndexOf('.') + 1,
                                            className.length());
        }
        return getPullParser(beanObject, new QName(className), null, false, false);
    }

    public static Object deserialize(Class beanClass,
                                     OMElement beanElement,
                                     ObjectSupplier objectSupplier,
                                     String arrayLocalName)
            throws AxisFault {
        Object beanObj;
        try {
            // Added this block as a fix for issues AXIS2-2055 and AXIS2-1899
            // to support polymorphism in POJO approach.
            // Retrieve the type name of the instance from the 'type' attribute
            // and retrieve the class.
            String instanceTypeName = null;
            if (beanClass != null && !beanClass.isArray()) {
                instanceTypeName = beanElement.getAttributeValue(new QName(
                        Constants.XSI_NAMESPACE, "type"));
            }
            boolean hexBin = false;
            if (instanceTypeName != null) {
                MessageContext messageContext = MessageContext.getCurrentMessageContext();
                // we can have this support only at the server side. we need to find the axisservice
                // to get the type table.
                if (messageContext != null) {
                    AxisService axisService = messageContext.getAxisService();
                    if (axisService != null) {
                        QName typeQName = beanElement.resolveQName(instanceTypeName);
                        //Need this flag to differentiate "xsd:hexBinary" and "xsd:base64Binary" data. 
                        if(org.apache.ws.commons.schema.constants.Constants.XSD_HEXBIN.equals(typeQName)){
                            hexBin = true;
                        }
                        TypeTable typeTable = axisService.getTypeTable();
                        String className = typeTable.getClassNameForQName(typeQName);
                        if (className != null) {
                            try {
                                beanClass = Loader.loadClass(axisService.getClassLoader(), className);
                            } catch (ClassNotFoundException ce) {
                                throw AxisFault.makeFault(ce);
                            }
                        } else {
                            throw new AxisFault("Unknow type " + typeQName);
                        }
                    }
                }
            }

            // check for nil attribute:
            QName nilAttName = new QName(Constants.XSI_NAMESPACE, Constants.NIL, "xsi");
            if (beanElement.getAttribute(nilAttName) != null) {
                return null;
            }
            
            if(beanClass.getName().equals(DataHandler.class.getName())){
                return SimpleTypeMapper.getDataHandler(beanElement,hexBin);
            }

            if (beanClass.isArray()) {
                ArrayList<Object> valueList = new ArrayList<Object>();
                Class arrayClassType = beanClass.getComponentType();
                if ("byte".equals(arrayClassType.getName())) {
                    // find the part first and decode it
                    OMElement partElement = null;
                    for (Iterator iter = beanElement.getChildElements(); iter.hasNext();) {
                        partElement = (OMElement) iter.next();
                        if (partElement.getLocalName().equals(arrayLocalName)) {
                            break;
                        }
                    }
                    return Base64Utils.decode(partElement.getText());
                } else {
                    Iterator parts = beanElement.getChildElements();
                    OMElement omElement;
                    while (parts.hasNext()) {
                        Object objValue = parts.next();
                        if (objValue instanceof OMElement) {
                            omElement = (OMElement) objValue;
                            if ((arrayLocalName != null) && !arrayLocalName.equals(omElement.getLocalName())) {
                                continue;
                            }
                            // this is a multi dimentional array so always inner element is array
                            Object obj = deserialize(arrayClassType,
                                                     omElement,
                                                     objectSupplier, "array");

                            valueList.add(obj);
                        }
                    }
                    return ConverterUtil.convertToArray(arrayClassType, valueList);
                }
            }else if(SimpleTypeMapper.isDomDocument(beanClass)){
                return convertOMtoDOM(beanElement);
                
            } else if (XMLGregorianCalendar.class.getName().equals(
                    beanClass.getName())) {
                return getXMLGregorianCalendar(beanElement);

            } else {
                if (SimpleTypeMapper.isSimpleType(beanClass)) {
                    return getSimpleTypeObjectChecked(beanClass, beanElement);
                } else if ("java.lang.Object".equals(beanClass.getName())) {
                    return beanElement.getFirstOMChild();
                }

                //use a comaprator to ignore the case of the bean element
                //names eg. if the property descriptor is getServiceName it
                //should accept child element with ServiceName as well.
                //but currently accepts only serviceName
                Comparator comparator = new Comparator() {
                    public int compare(Object o1, Object o2) {
                        String string1 = (String) o1;
                        String string2 = (String) o2;
                        return string1.compareToIgnoreCase(string2);
                    }
                };
                Map<String, PropertyDescriptor> properties = new TreeMap<String, PropertyDescriptor>(comparator);


                BeanInfo beanInfo = getBeanInfo(beanClass);
                PropertyDescriptor[] propDescs = beanInfo.getPropertyDescriptors();
                for (PropertyDescriptor proprty : propDescs) {
                    properties.put(proprty.getName(), proprty);
                }
                Iterator elements = beanElement.getChildren();
                beanObj = objectSupplier.getObject(beanClass);
                while (elements.hasNext()) {
                    // the beanClass could be an abstract one.
                    // so create an instance only if there are elements, in
                    // which case a concrete subclass is available to instantiate.
                    OMElement parts;
                    Object objValue = elements.next();
                    if (objValue instanceof OMElement) {
                        parts = (OMElement) objValue;
                    } else {
                        continue;
                    }
                    OMAttribute attribute = parts.getAttribute(
                            new QName("http://www.w3.org/2001/XMLSchema-instance", "nil", "xsi"));

                    // if parts/@href != null then need to find element with id and deserialize.
                    // before that first check whether we already have it in the hashtable
                    String partsLocalName = parts.getLocalName();
                    PropertyDescriptor prty = properties.remove(partsLocalName);
                    if (prty != null) {
                        Class parameters = prty.getPropertyType();
                        if (prty.getName().equals("class"))
                            continue;

                        Object partObj;
                        boolean isNil = false;
                        if (attribute != null) {
                            String nilValue = attribute.getAttributeValue();
                            if ("true".equals(nilValue) || "1".equals(nilValue)) {
                                isNil = true;
                            }
                        }
                        if (isNil) {
                            partObj = null;
                        } else {
                            if (SimpleTypeMapper.isSimpleType(parameters)) {
                                partObj = SimpleTypeMapper.getSimpleTypeObject(parameters, parts);
                            } else if (SimpleTypeMapper.isHashSet(parameters)) {
                                partObj = SimpleTypeMapper.getHashSet((OMElement)
                                        parts.getParent(), prty.getName());
                            } else if (SimpleTypeMapper.isCollection(parameters)) {
                                Type type = prty.getReadMethod().getGenericReturnType();
                                partObj = processGenericCollection(parts, type, null, objectSupplier);  

                            } else if (SimpleTypeMapper.isDataHandler(parameters)) {
                                partObj = SimpleTypeMapper.getDataHandler(parts);
                            } else if (parameters.isArray()) {
                                partObj = deserialize(parameters, (OMElement) parts.getParent(),
                                                      objectSupplier, prty.getName());
                            } else if (SimpleTypeMapper.isMap(parameters)){
                                partObj = null;
                                final Type type = prty.getReadMethod().getGenericReturnType();
                                if (type instanceof ParameterizedType) {
                                    ParameterizedType aType = (ParameterizedType) type;
                                    Type[] parameterArgTypes = aType.getActualTypeArguments();
                                    partObj = processGenericsMapElement(parameterArgTypes
                                          , (OMElement) parts.getParent(), null, parts.getChildren(), objectSupplier, beanClass);
                                } else {
                                    Type[] parameterArgTypes = {Object.class,Object.class}; 
                                    partObj = processGenericsMapElement(parameterArgTypes
                                             , (OMElement) parts.getParent(), null, parts.getChildren(), objectSupplier, beanClass);
                                }
                            }else if (SimpleTypeMapper.isEnum(parameters)) {
                                partObj =processEnumObject(parameters , parts);
                            } else {
                                partObj = deserialize(parameters, parts, objectSupplier, null);
                            }
                        }
                        Object[] parms = new Object[]{partObj};
                        Method writeMethod = prty.getWriteMethod();
                        if (writeMethod != null) {
                            writeMethod.setAccessible(true);
                            writeMethod.invoke(beanObj, parms);
                        }
                    }
                }
                return beanObj;
            }
        } catch (IllegalAccessException e) {
            throw new AxisFault("IllegalAccessException : " + e);
        } catch (InvocationTargetException e) {
            throw new AxisFault("InvocationTargetException : " + e);
        } catch (IntrospectionException e) {
            throw new AxisFault("IntrospectionException : " + e);
        } catch (DatatypeConfigurationException e) {
            throw new AxisFault("DatatypeConfigurationException : " + e);            
        }


    }

    public static Object deserialize(Class beanClass,
                                     OMElement beanElement,
                                     MultirefHelper helper,
                                     ObjectSupplier objectSupplier) throws AxisFault {
        Object beanObj;
        try {
            HashMap<String, PropertyDescriptor> properties = new HashMap<String, PropertyDescriptor>();
            BeanInfo beanInfo = getBeanInfo(beanClass);
            PropertyDescriptor[] propDescs = beanInfo.getPropertyDescriptors();
            for (PropertyDescriptor proprty : propDescs) {
                properties.put(proprty.getName(), proprty);
            }

            beanObj = objectSupplier.getObject(beanClass);
            Iterator elements = beanElement.getChildren();
            while (elements.hasNext()) {
                Object child = elements.next();
                OMElement parts;
                if (child instanceof OMElement) {
                    parts = (OMElement) child;
                } else {
                    continue;
                }
                String partsLocalName = parts.getLocalName();
                PropertyDescriptor prty = properties.get(
                        partsLocalName.toLowerCase());
                if (prty != null) {
                    Class parameters = prty.getPropertyType();
                    if (prty.getName().equals("class"))
                        continue;
                    Object partObj;
                    OMAttribute attr = MultirefHelper.processRefAtt(parts);
                    if (attr != null) {
                        String refId = MultirefHelper.getAttvalue(attr);
                        partObj = helper.getObject(refId);
                        if (partObj == null) {
                            partObj = helper.processRef(parameters, refId, objectSupplier);
                        }
                    } else {
                        partObj = SimpleTypeMapper.getSimpleTypeObject(parameters, parts);
                        if (partObj == null) {
                            partObj = deserialize(parameters, parts, objectSupplier, null);
                        }
                    }
                    Object[] parms = new Object[]{partObj};
                    Method writeMethod = prty.getWriteMethod();
                    if (writeMethod != null) {
                        writeMethod.setAccessible(true);
                        writeMethod.invoke(beanObj, parms);
                    }
                }
            }
        } catch (IllegalAccessException e) {
            throw new AxisFault("IllegalAccessException : " + e);
        } catch (InvocationTargetException e) {
            throw new AxisFault("InvocationTargetException : " + e);
        } catch (IntrospectionException e) {
            throw new AxisFault("IntrospectionException : " + e);
        }
        return beanObj;
    }


    /**
     * To get JavaObjects from XML element , the element most of the time contains only one element
     * in that case that element will be converted to the JavaType specified by the javaTypes array
     * The algo is as follows, get the childerns of the response element , and if it conatian more
     * than one element then check the retuen type of that element and conver that to corresponding
     * JavaType
     *
     * @param response  OMElement
     * @param javaTypes Array of JavaTypes
     * @return Array of objects
     * @throws AxisFault
     */
    public static Object[] deserialize(OMElement response,
                                       Object[] javaTypes,
                                       ObjectSupplier objectSupplier) throws AxisFault {
        return BeanUtil.deserialize(response, javaTypes, objectSupplier, null, null);
    }

    public static Object[] deserialize(OMElement response,
                                       Object[] javaTypes,
                                       ObjectSupplier objectSupplier,
                                       String[] parameterNames,
                                       Method method) throws AxisFault {
        /*
         * Take the number of parameters in the method and , only take that much of child elements
         * from the OMElement , other are ignore , as an example
         * if the method is , foo(String a , int b)
         * and if the OMElemet
         * <foo>
         *  <arg0>Val1</arg0>
         *  <arg1>Val2</arg1>
         *  <arg2>Val3</arg2>
         *
         * only the val1 and Val2 take into account
         */
        int length = javaTypes.length;
        int count = 0;
        Object[] retObjs = new Object[length];

        /*
        * If the body first child contains , then there can not be any other element withot
        * refs , so I can assume if the first child of the body first element has ref then
        * the message has to handle as mutiref message.
        * as an exmple if the body is like below
        * <foo>
        *  <arg0 href="#0"/>
        * </foo>
        *
        * then there can not be any element without refs , meaning following we are not handling
        * <foo>
        *  <arg0 href="#0"/>
        *  <arg1>absbsbs</arg1>
        * </foo>
        */
        Iterator parts = response.getChildren();
        //to handle multirefs
        //have to check the instanceof
        MultirefHelper helper = new MultirefHelper((OMElement) response.getParent());
        //to support array . if the parameter type is array , then all the omelemnts with that paramtre name
        // has to  get and add to the list
        Class classType;
        String currentLocalName;
        Type[] genericParameterTypes = null;
        if (method != null) {
            genericParameterTypes = method.getGenericParameterTypes();
        }
        Type genericType = null;
        while (parts.hasNext() && count < length) {
            Object objValue = parts.next();
            OMElement omElement;
            if (objValue instanceof OMElement) {
                omElement = (OMElement) objValue;
            } else {
                continue;
            }

            // if the local part is not match. this means element is not present
            // due to min occurs zero.
            // we need to hard code arg and item since that has been used in RPCService client
            // and some test cases
            while ((parameterNames != null) &&
                   (!omElement.getQName().getLocalPart().startsWith("arg")) &&
                   (!omElement.getQName().getLocalPart().startsWith("item")) &&
                   !omElement.getQName().getLocalPart().equals(parameterNames[count])) {
                // POJO handles OMElement in a differnt way so need this check for OMElement
                Class paramClassType = (Class) javaTypes[count];
                if (!paramClassType.getName().equals(OMElement.class.getName())) {
                    count++;
                } else {
                    break;
                }
            }

            currentLocalName = omElement.getLocalName();
            classType = (Class) javaTypes[count];
            if (genericParameterTypes != null) {
                genericType = genericParameterTypes[count];
            }
            /*
             * In bare invocation "parameterNames" comes as null value.
             */
            boolean bare = false;
            if(parameterNames == null){
                bare = true;
            }
           
            omElement = processElement(classType, omElement, helper, parts,
                                       currentLocalName, retObjs, count, objectSupplier, genericType, bare);
            while (omElement != null) {
                count++;
                // if the local part is not match. this means element is not present
                // due to min occurs zero.
                // we need to hard code arg and item since that has been used in RPCService client
                // and some test cases
                while ((parameterNames != null) &&
                       (!omElement.getQName().getLocalPart().startsWith("arg")) &&
                       (!omElement.getQName().getLocalPart().startsWith("item")) &&
                       !omElement.getQName().getLocalPart().equals(parameterNames[count])) {
                    // POJO handles OMElement in a differnt way so need this check for OMElement
                    Class paramClassType = (Class) javaTypes[count];
                    if (!paramClassType.getName().equals(OMElement.class.getName())) {
                        count++;
                    } else {
                        break;
                    }
                }

                currentLocalName = omElement.getLocalName();
                classType = (Class) javaTypes[count];
                if (genericParameterTypes != null) {
                    genericType = genericParameterTypes[count];
                }
                omElement = processElement((Class) javaTypes[count], omElement,
                                           helper, parts, omElement.getLocalName(), retObjs, count,
                                           objectSupplier, genericType);
            }
            count++;
        }

        // Ensure that we have at least a zero element array
        for (int i = 0; i < length; i++) {
            Class clazz = (Class) javaTypes[i];
            if (retObjs[i] == null && clazz.isArray()) {
                retObjs[i] = Array.newInstance(clazz.getComponentType(), 0);
            }
        }

        helper.clean();
        return retObjs;
    }

    private static OMElement processElement(Class classType,
            OMElement omElement, MultirefHelper helper, Iterator parts,
            String currentLocalName, Object[] retObjs, int count,
            ObjectSupplier objectSupplier, Type genericType) throws AxisFault {

        return processElement(classType, omElement, helper, parts,
                currentLocalName, retObjs, count, objectSupplier, genericType, false);

    }
    private static OMElement processElement(Class classType, OMElement omElement,
                                            MultirefHelper helper, Iterator parts,
                                            String currentLocalName,
                                            Object[] retObjs,
                                            int count,
                                            ObjectSupplier objectSupplier,
                                            Type genericType, boolean bare) throws AxisFault {
        Object objValue;
        boolean isRef = false;
        OMAttribute omatribute = MultirefHelper.processRefAtt(omElement);
        if (omatribute != null) {
            isRef = true;
        }
        if (classType.isArray()) {
            boolean done = true;
            ArrayList<Object> valueList = new ArrayList<Object>();
            Class arrayClassType = classType.getComponentType();
            if ("byte".equals(arrayClassType.getName())) {
                retObjs[count] =
                        processObject(omElement, arrayClassType, helper, true, objectSupplier, genericType);
                return null;
            } else {
                valueList.add(processObject(omElement, arrayClassType, helper, true,
                                            objectSupplier, genericType));
            }
            while (parts.hasNext()) {
                objValue = parts.next();
                if (objValue instanceof OMElement) {
                    omElement = (OMElement) objValue;
                } else {
                    continue;
                }
                if (!currentLocalName.equals(omElement.getLocalName())) {
                    done = false;
                    break;
                }
                Object o = processObject(omElement, arrayClassType,
                                         helper, true, objectSupplier, genericType);
                valueList.add(o);
            }
            if (valueList.size() == 1 && valueList.get(0) == null) {
                retObjs[count] = null;
            } else {
                retObjs[count] = ConverterUtil.convertToArray(arrayClassType,
                                                              valueList);
            }
            if (!done) {
                return omElement;
            }
            
        } else if(SimpleTypeMapper.isCollection(classType) && ! isRef){
            if(bare){
                OMElement[] toReturn = new OMElement[1];
                parts = omElement.getChildren();
                retObjs[count] = processGenericCollection(omElement.getFirstElement(), toReturn, genericType, helper, objectSupplier, parts,bare);
                OMNode node = omElement.getNextOMSibling();
                while(node != null){
                    if(OMElement.class.isAssignableFrom(node.getClass())){
                        return (OMElement) node;
                    } else {
                        node = node.getNextOMSibling();
                    }
                }
            
            } else {
            OMElement[] toReturn = new OMElement[1];
                retObjs[count] = processGenericCollection(omElement, toReturn, genericType, helper, objectSupplier, parts,bare);
                 if (toReturn[0] != null) {
                     return toReturn[0];
                 }
            }
        } else if (SimpleTypeMapper.isEnum(classType)) {
            /* handling enum types */
            retObjs[count] = processEnumObject(classType, omElement);
        } else{
            //handling refs
            retObjs[count] = processObject(omElement, classType, helper, false, objectSupplier, genericType);
            
            
        }
        return null;
    }

    private static Collection<Object> processGenericsElement(Type classType, OMElement omElement,
                                               MultirefHelper helper, Iterator parts,
                                               ObjectSupplier objectSupplier,
                                               Type genericType) throws AxisFault {
        Object objValue;
        Collection<Object> valueList = getCollectionInstance(genericType);
        while (parts.hasNext()) {
            objValue = parts.next();
            Object o;
            if (objValue instanceof OMElement) {
                omElement = (OMElement) objValue;
            } else {
                continue;
            }
            if (classType instanceof ParameterizedType) {
                ParameterizedType parameterizedClassType = (ParameterizedType) classType;
                if (Collection.class
                        .isAssignableFrom((Class<?>) parameterizedClassType
                                .getRawType())) {
                    o = processGenericCollection(omElement.getFirstElement(),
                            classType, helper, objectSupplier);
                } else if (Map.class
                        .isAssignableFrom((Class<?>) parameterizedClassType
                                .getRawType())) {
                    o = processGenericsMapElement( 
                            parameterizedClassType.getActualTypeArguments(),
                            omElement, helper, omElement.getChildren(), objectSupplier,
                            parameterizedClassType);
                } else {
                    o = processObject(omElement, (Class) classType,
                             helper, true, objectSupplier, genericType);
                }
                
            } else {
                o = processObject(omElement, (Class) classType,
                         helper, true, objectSupplier, genericType);
                
            }
            
            valueList.add(o);
            
        }
        return valueList;
    }


    public static Object processObject(OMElement omElement,
                                       Class classType,
                                       MultirefHelper helper,
                                       boolean isArrayType,
                                       ObjectSupplier objectSupplier,
                                       Type generictype) throws AxisFault {
        boolean hasRef = false;
        OMAttribute omatribute = MultirefHelper.processRefAtt(omElement);
        String ref = null;
        if (omatribute != null) {
            hasRef = true;
            ref = MultirefHelper.getAttvalue(omatribute);
        }
        if (OMElement.class.isAssignableFrom(classType)) {
            if (hasRef) {
                OMElement elemnt = helper.getOMElement(ref);
                if (elemnt == null) {
                    return helper.processOMElementRef(ref);
                } else {
                    return elemnt;
                }
            } else
                return omElement;
        } else {
            if (hasRef) {
                if (helper.getObject(ref) != null) {
                    return helper.getObject(ref);
                } else {
                    return helper.processRef(classType, generictype, ref, objectSupplier);
                }
            } else {
                OMAttribute attribute = omElement.getAttribute(
                        new QName("http://www.w3.org/2001/XMLSchema-instance", "nil", "xsi"));
                if (attribute != null) {
                    return null;
                }
                if (SimpleTypeMapper.isSimpleType(classType)) {
                    if (isArrayType && "byte".equals(classType.getName())) {
                        String value = omElement.getText();
                        return Base64Utils.decode(value);
                    } else {
                        return getSimpleTypeObjectChecked(classType, omElement);
                    }
                } else if (SimpleTypeMapper.isCollection(classType)) {
                    return processGenericCollection(omElement, generictype, null, objectSupplier); 

                } else if (SimpleTypeMapper.isDataHandler(classType)) {
                    return SimpleTypeMapper.getDataHandler(omElement);
                    
                } else if(SimpleTypeMapper.isDomDocument(classType)){
                    return convertOMtoDOM(omElement);
                } else if(SimpleTypeMapper.isMap(classType)){
                    if (generictype != null && (generictype instanceof ParameterizedType)) {
                        ParameterizedType aType = (ParameterizedType) generictype;
                        Type[] parameterArgTypes = aType.getActualTypeArguments();
                        Iterator parts = omElement.getChildElements();
                        return processGenericsMapElement(parameterArgTypes
                             , omElement, helper, parts, objectSupplier, generictype);
                    } else {
                        Type[] parameterArgTypes = {Object.class,Object.class}; 
                        Iterator parts = omElement.getChildElements();
                        return processGenericsMapElement(parameterArgTypes,
                                omElement, helper, parts, objectSupplier, generictype);   
                    }
                
                }else if(SimpleTypeMapper.isEnum(classType)){
                    return processEnumObject(classType, omElement);
                }else {
                    return BeanUtil.deserialize(classType, omElement, objectSupplier, null);
                }
            }
        }
    }

    /*This method check is service method required enum type instance as method parameter
    * if so return required enum object
    *
    * @param classType method required instance type
    * @param omElement OMElement
    * @return an Enum object
    * */
    public static Object processEnumObject(Class classType , OMElement omElement)throws AxisFault{
          /*
            *reason to add this block is check is soap sending a string but service require Enum
            * then this convert string to relevant enum object and add to retObjs[] as object
            * */
          String paraArgString = omElement.getText();
         Object enumIbj;
        if (paraArgString == null || paraArgString.length() == 0) {
            enumIbj = null;
        }else{
            enumIbj = Enum.valueOf(classType , paraArgString);
        }
        return enumIbj;

    }


    public static OMElement getOMElement(QName opName,
                                         Object[] args,
                                         QName partName,
                                         boolean qualifed,
                                         TypeTable typeTable) {
        ArrayList<Object> objects;
        objects = new ArrayList<Object>();
        int argCount = 0;
        for (Object arg : args) {
            if (arg == null) {
                if (partName == null) {
                    objects.add("item" + argCount);
                } else {
                    objects.add(partName);
                }
                objects.add(arg);
                continue;
            }

            if (arg instanceof Object[]) {
                // at the client side the partname is always null. At client side this means user try to
                // invoke a service with an array argument.
                if (partName == null) {
                    Object array[] = (Object[]) arg;
                    for (Object o : array) {
                        if (o == null) {
                            objects.add("item" + argCount);
                            objects.add(o);
                        } else {
                            if (SimpleTypeMapper.isSimpleType(o)) {
                                objects.add("item" + argCount);
                                objects.add(SimpleTypeMapper.getStringValue(o));
                            } else {
                                objects.add(new QName("item" + argCount));
                                if (o instanceof OMElement) {
                                    OMFactory fac = OMAbstractFactory.getOMFactory();
                                    OMElement wrappingElement;
                                    wrappingElement = fac.createOMElement("item" + argCount, null);
                                    wrappingElement.addChild((OMElement) o);
                                    objects.add(wrappingElement);
                                } else {
                                    objects.add(o);
                                }
                            }
                        }
                    }
                } else {
                    // this happens at the server side. this means it is an multidimentional array.
                    objects.add(partName);
                    if (SimpleTypeMapper.isObjectArray(arg.getClass())
                            || SimpleTypeMapper
                                    .isMultidimensionalObjectArray(arg
                                            .getClass())) {
                        /**
                         * If it is a Object[] we need to add instance type
                         * attributes to the response message.
                         * Copied from ADBXMLStreamReaderImpl. 
                         * For inner Arrary Complex types we use the special local name array - "array"
                         */
                        QName itemName = new QName(partName.getNamespaceURI(),
                                Constants.INNER_ARRAY_COMPLEX_TYPE_NAME,
                                partName.getPrefix());
                        objects.add(getOMElement(partName, (Object[]) arg,
                                itemName, qualifed, typeTable));
                    } else {
                        objects.add(arg);
                    }
                }
            } else {
                if (SimpleTypeMapper.isSimpleType(arg)) { 
                    OMElement element;
                    OMFactory fac = OMAbstractFactory.getOMFactory();
                    if(partName != null){
                        element = fac.createOMElement(partName, null);
                    }else{
                        String eleName = "arg" + argCount;
                        element = fac.createOMElement(eleName, null);
                    }
                    element.addChild(fac.createOMText(SimpleTypeMapper
                            .getStringValue(arg)));
                    if (SimpleTypeMapper.isObjectArray(args.getClass())) {
                        addInstanceTypeAttribute(fac, element, arg, typeTable);
                    }
                    objects.add(element.getQName());
                    objects.add(element);
                } else {
                    if (partName == null) {
                        objects.add(new QName("arg" + argCount));
                    } else {
                        objects.add(partName);
                    }
                    if (arg instanceof OMElement) {
                        OMFactory fac = OMAbstractFactory.getOMFactory();
                        OMElement wrappingElement;
                        if (partName == null) {
                            wrappingElement = fac.createOMElement("arg" + argCount, null);
                            wrappingElement.addChild((OMElement) arg);
                        } else {
                            wrappingElement = fac.createOMElement(partName, null);
                            wrappingElement.addChild((OMElement) arg);
                        }
                        objects.add(wrappingElement);
                    } else if (arg instanceof byte[]) {
                        objects.add(Base64Utils.encode((byte[]) arg));
                    } else if (SimpleTypeMapper.isDataHandler(arg.getClass())) {
                        OMFactory fac = OMAbstractFactory.getOMFactory();
                        OMElement wrappingElement;
                        if (partName == null) {
                            wrappingElement = fac.createOMElement("arg" + argCount, null);
                        } else {
                            wrappingElement = fac.createOMElement(partName, null);
                        }
                        OMText text = fac.createOMText((DataHandler)arg, true);
                        wrappingElement.addChild(text);
                        objects.add(wrappingElement);
                    }else if (SimpleTypeMapper.isEnum(arg.getClass())) {
                        // in here i can return enum instances but for now i return it as a simple string
                        objects.add(arg.toString());
                    } else {
                        objects.add(arg);
                    }
                }
            }
            argCount++;
        }

        XMLStreamReader xr =
                new ADBXMLStreamReaderImpl(opName, objects.toArray(), null, typeTable, qualifed);

        StreamWrapper parser = new StreamWrapper(xr);
        OMXMLParserWrapper stAXOMBuilder =
                OMXMLBuilderFactory.createStAXOMBuilder(
                        OMAbstractFactory.getSOAP11Factory(), parser);
        return stAXOMBuilder.getDocumentElement();
    }

    /**
     * @deprecated Please use getUniquePrefix
     */
    public static synchronized String getUniquePrifix() {
        return getUniquePrefix();
    }

    /**
     * increments the namespace counter and returns a new prefix
     *
     * @return unique prefix
     */
    public static synchronized String getUniquePrefix() {
        if (nsCount > 1000) {
            nsCount = 1;
        }
        return "s" + nsCount++;
    }


    private static String getQualifiedName(Package packagez) {
        if (packagez != null) {
            return packagez.getName();
        } else {
            return "";
        }
    }

    private static Object getSimpleTypeObjectChecked(Class classType,
                                                     OMElement omElement) throws AxisFault {
        try {
            return SimpleTypeMapper.getSimpleTypeObject(classType, omElement);
        } catch (NumberFormatException e) {
            MessageContext msgContext = MessageContext.getCurrentMessageContext();
            QName faultCode = msgContext != null ?
                              msgContext.getEnvelope().getVersion().getSenderFaultCode() :
                              null;

            throw new AxisFault("Invalid value \"" + omElement.getText() + "\" for element " +
                                omElement.getLocalName(), faultCode, e);
        }
    }
    
    /**
     * Adds the instance type attribute to the passed OMElement.
     *  
     *  e.g - <sam:obj xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     *                xmlns:xsd="http://www.w3.org/2001/XMLSchema"
     *                xsi:type="xsd:string">
     *                String Value
     *        </sam:obj> 
     *
     *
     * @param fac the SOAPFactory instance.
     * @param element the child OMElement to add attributes.
     * @param resObject the java reflection method
     * @param resObject the res object
     * @param typeTable the type table of particular Axis2 service
     */
    public static void addInstanceTypeAttribute(OMFactory fac,
            OMElement element, Object resObject,
            TypeTable typeTable) {
        if(typeTable == null){
            return;
        }
        OMNamespace xsiNS = fac.createOMNamespace(Constants.XSI_NAMESPACE,
                Constants.DEFAULT_XSI_NAMESPACE_PREFIX);
        OMNamespace xsdNS = fac.createOMNamespace(Constants.XSD_NAMESPACE,
                Constants.DEFAULT_XSD_NAMESPACE_PREFIX);
        element.declareNamespace(xsiNS);
        element.declareNamespace(xsdNS);
        QName xsdType = typeTable.getSchemaTypeName(resObject.getClass()
                .getName());
        String attrValue = xsdType.getPrefix() + ":" + xsdType.getLocalPart();
        element.addAttribute(Constants.XSI_TYPE_ATTRIBUTE, attrValue, xsiNS);
    }
    
    /**
     * Gets the DOOM implementation of org.w3c.dom.Document  
     *
     * @param omElement the OMelement
     * @return the DOOM document
     */
    public static OMDocument convertOMtoDOM(OMContainer omElement) {
        // use an Axiom meta factory with feature "dom" to get org.w3c.dom.Document
        OMFactory doomFactory = OMAbstractFactory.getMetaFactory(
                OMAbstractFactory.FEATURE_DOM).getOMFactory();
        OMXMLParserWrapper doomBuilder = OMXMLBuilderFactory.createStAXOMBuilder(doomFactory,
                omElement.getXMLStreamReader());
        OMDocument domElement = doomBuilder.getDocument();
        return domElement;
    }
    
    /**
     * Convert DOM Document to a OMElement.
     *
     * @param fac the fac
     * @param document the document
     * @return the OMElement
     */
    public static OMElement convertDOMtoOM(OMFactory fac, Object document) {
        if( document == null ) {
            return null;
        }
        if (document instanceof OMDocument) {
            return ((OMDocument)document).getOMDocumentElement();
        
        } else {
            return OMXMLBuilderFactory.createOMBuilder((Document)document, false).getDocumentElement(true);
        }
    }
    
    /**
     * This method deserialize OM model in to a instance of java.util.Map
     *
     * @param parameterArgTypes the parameter argument types of Map <k,V>
     * @param omElement the OMElement
     * @param helper the helper
     * @param parts the parts
     * @param objectSupplier the object supplier
     * @param genericType the generic type
     * @return a instance of java.util.Map
     * @throws AxisFault the axis fault
     */
    public static Map<Object,Object> processGenericsMapElement(Type[] parameterArgTypes,
            OMElement omElement, MultirefHelper helper, Iterator parts,
            ObjectSupplier objectSupplier, Type genericType) throws AxisFault {
        Object objValue;
        Map<Object,Object> valueMap = getMapInstance(genericType) ;
        while (parts.hasNext()) {
            objValue = parts.next();
            if (objValue instanceof OMElement) {
                omElement = (OMElement) objValue;
            } else {
                continue;
            }
            
            if(omElement != null){
                Iterator entryParts = omElement.getChildren();
                Object entryKey = null;
                Object entryValue = null;
                while (entryParts.hasNext()) {
                    objValue = entryParts.next();
                    if (objValue instanceof OMElement) {
                        omElement = (OMElement) objValue;
                    } else {
                        continue;
                    }
                    if (omElement.getLocalName().equals(
                            org.apache.axis2.Constants.MAP_KEY_ELEMENT_NAME)) {
                        entryKey = processMapParameterObject( parameterArgTypes[0], omElement,
                                helper, objectSupplier, genericType);
                        continue;
                    }
                    if (omElement.getLocalName().equals(
                            org.apache.axis2.Constants.MAP_VALUE_ELEMENT_NAME)) {
                        entryValue = processMapParameterObject( parameterArgTypes[1],
                                omElement, helper, objectSupplier, genericType);
                        continue;
                    }
                }
                if(entryKey != null){
                    valueMap.put(entryKey, entryValue);
                }
            }

        }
        return valueMap;
    }
    
    
    /**
     * This method convert a instance of java.util.Map into
     * OM object model for serialization. 
     *
     * @param fac the OMFactory
     * @param type of the java.util.Map
     * @param results the results values
     * @param typeTable the type table
     * @param elementFormDefault the element form default
     * @return list of OMElement
     */
    public static List<OMElement> getMapElement(OMFactory fac, Type type,
            Map results, TypeTable typeTable, boolean elementFormDefault) {
        Iterator<Object> keyItr = results.keySet().iterator();
        List<OMElement> list = new ArrayList<OMElement>();
        OMNamespace ns = null;
        Type keyType = Object.class;
        Type valueType = Object.class;
        if (elementFormDefault) {
            ns = fac.createOMNamespace(
                    org.apache.axis2.Constants.AXIS2_MAP_NAMESPACE_URI,
                    org.apache.axis2.Constants.AXIS2_MAP_NAMESPACE_PREFIX);
        }
        
        if (type instanceof ParameterizedType) {
            ParameterizedType aType = (ParameterizedType) type;
            Type[] parameterArgTypes = aType.getActualTypeArguments();
            keyType = parameterArgTypes[0];
            valueType = parameterArgTypes[1];
        }

        while (keyItr.hasNext()) {
            OMElement omEntry;
            Object key = keyItr.next();
            Object value;
            if (key != null) {
                value = results.get(key);
                List<Object> properties = new ArrayList<Object>();
                QName keyName;
                QName valueName;
                if (elementFormDefault) {
                    keyName = new QName(ns.getNamespaceURI(),
                            org.apache.axis2.Constants.MAP_KEY_ELEMENT_NAME,
                            ns.getPrefix());
                    valueName = new QName(ns.getNamespaceURI(),
                            org.apache.axis2.Constants.MAP_VALUE_ELEMENT_NAME,
                            ns.getPrefix());
                } else {
                    keyName = new QName(
                            org.apache.axis2.Constants.MAP_KEY_ELEMENT_NAME);
                    valueName = new QName(
                            org.apache.axis2.Constants.MAP_VALUE_ELEMENT_NAME);
                }

                Object kValue = getMapParameterElement(fac,
                        org.apache.axis2.Constants.MAP_KEY_ELEMENT_NAME, key,
                        keyType, typeTable, ns, elementFormDefault);
                
                Object vValue = getMapParameterElement(fac,
                        org.apache.axis2.Constants.MAP_VALUE_ELEMENT_NAME,
                        value, valueType, typeTable, ns, elementFormDefault);
                
                if(Iterator.class.isAssignableFrom(kValue.getClass())){
                    Iterator valItr = (Iterator) kValue;
                    while (valItr.hasNext()) {
                        properties.add(keyName);
                        properties.add(valItr.next());
                    }
                } else {
                    properties.add(keyName);
                    properties.add(kValue);
                }

                
                if(vValue != null && Iterator.class.isAssignableFrom(vValue.getClass())){
                    Iterator valItr = (Iterator) vValue;
                    while (valItr.hasNext()) {
                        properties.add(valueName);
                        properties.add(valItr.next());
                    }
                } else {
                    properties.add(valueName);
                    properties.add(vValue);
                }
                
                QName entryQName;
                if (elementFormDefault) {
                    entryQName = new QName(ns.getNamespaceURI(),
                            org.apache.axis2.Constants.MAP_ENTRY_ELEMENT_NAME,
                            ns.getPrefix());
                } else {
                    entryQName = new QName(
                            org.apache.axis2.Constants.MAP_ENTRY_ELEMENT_NAME);

                }
                XMLStreamReader pullParser = new ADBXMLStreamReaderImpl(
                        entryQName, properties.toArray(), null,
                        typeTable, elementFormDefault);

                OMXMLParserWrapper builder = OMXMLBuilderFactory.createStAXOMBuilder(
                        new StreamWrapper(pullParser));
                omEntry = builder.getDocumentElement();
                list.add(omEntry);
            }
        }
        return list;
    }
    
    /**
     * Helper method to deserialize each parameter of Map.
     *
     * @param paraType the parameter type
     * @param omElement the OMElement
     * @param helper the helper
     * @param objectSupplier the object supplier
     * @param genericType the generic type
     * @return the object
     * @throws AxisFault the axis fault
     */
    private static Object processMapParameterObject(Type paraType, OMElement omElement,
            MultirefHelper helper, ObjectSupplier objectSupplier,
            Type genericType) throws AxisFault {
        if (paraType instanceof ParameterizedType) {
            if (Map.class.isAssignableFrom((Class)
                    ((ParameterizedType) paraType).getRawType())) {
                return processGenericsMapElement(
                        ((ParameterizedType) paraType).getActualTypeArguments(),
                        omElement, helper, omElement.getChildren(),
                        objectSupplier, paraType);
            } else if (Collection.class.isAssignableFrom((Class) 
                    ((ParameterizedType) paraType).getRawType())) {
                return processGenericCollection(
                        omElement,
                        (ParameterizedType) paraType,
                        helper, objectSupplier);
            } else {
                throw new AxisFault("Map parameter does not support for "
                        + ((ParameterizedType) paraType).getRawType());
            }

        } else {
            return processObject(omElement, (Class) paraType, helper, true,
                    objectSupplier, genericType);
        }
    }
    
    /**
     * This method instantiate a Map instance according to the expected 
     * parameter type of the service method. a instance HashMap<Object, Object> 
     * returns as the default value and in case of Exception.   
     *
     * @param genericType the generic type
     * @return the map instance 
     */
    private static Map<Object, Object> getMapInstance(Type genericType) {
        Class rowType;
        if (genericType instanceof ParameterizedType) {
            rowType = (Class) ((ParameterizedType) genericType).getRawType();
        } else {
            rowType = (Class) genericType;
        }
        
        if (Map.class.getName().equals(rowType.getName())) {
            return new HashMap<Object, Object>();
            
        } else if (ConcurrentMap.class.getName().equals(rowType.getName())) {
            return new ConcurrentHashMap<Object, Object>();
            
        } else if (SortedMap.class.getName().equals(rowType.getName())) {
            return new TreeMap<Object, Object>();
            
        } 
//        TODO - Enable this logic once the Axis2 move to Java 1.6.
//        else if (NavigableMap.class.getName().equals(rowType.getName())) {
//            return new TreeMap<Object, Object>();
//            
//        }  else if (ConcurrentNavigableMap.class.getName().equals(rowType.getName())) {
//            return new ConcurrentSkipListMap<Object, Object>();
//        }
//        
        else {
            try {
                return (Map<Object, Object>) rowType.newInstance();
            } catch (Exception e) {
                return new HashMap<Object, Object>();
            }
        }
    }
    
    /**
     * Process the provided return  value and constructs OMElement accordingly.  
     *
     * @param fac the OMFactory instance
     * @param elementName the element name for return OMElement
     * @param value the actual return value
     * @param valueType the value type of return value
     * @param typeTable the type table
     * @param ns the OMNamespace
     * @param elementFormDefault the element form default
     * @return the map parameter object
     */
    private static Object getMapParameterElement(OMFactory fac,
            String elementName, Object value, Type valueType,
            TypeTable typeTable, OMNamespace ns, boolean elementFormDefault) {
         //TODO - key/value can be a Collection, Array , Dom document ,OMElement etc
        if(value == null) {
            return null;
        }
        if (SimpleTypeMapper.isMap(value.getClass())) {
            List<OMElement> childList = getMapElement(fac, valueType,
                    (Map) value, typeTable, elementFormDefault);
            OMElement omValue;
            if(elementFormDefault) {
                omValue = fac.createOMElement(elementName,
                        ns.getNamespaceURI(), ns.getPrefix());
            } else {
                omValue = fac.createOMElement(elementName, null);
                
            }
            for (OMElement child : childList) {
                omValue.addChild(child);
            }
            return omValue;
            
        } else if (SimpleTypeMapper.isCollection(value.getClass())) {
            QName elementQName;
            if(elementFormDefault) {
               elementQName = new QName(ns.getNamespaceURI(), elementName,
                        ns.getPrefix());
            } else {
               elementQName = new QName(elementName);
                
            }
            
            return getCollectionElement(fac, valueType, (Collection) value,
                    elementName, null, elementQName, typeTable,
                    elementFormDefault).getChildren();
            
        } else if(SimpleTypeMapper.isDomDocument((Class)valueType)) {
            return convertDOMtoOM(fac, value);
            
        } else if (SimpleTypeMapper.isObjectType((Class) valueType)) {
            OMElement omValue;
            omValue = fac.createOMElement(elementName, ns);
            if (SimpleTypeMapper.isSimpleType(value)) {
                omValue.addChild(fac.createOMText(SimpleTypeMapper
                        .getStringValue(value)));
            } else {
                QName name;
                if(elementFormDefault) {
                    name = new QName(ns.getNamespaceURI(), elementName,
                            ns.getPrefix());
                } else {
                    name = new QName(elementName);
                }
                XMLStreamReader xr = BeanUtil.getPullParser(value, name,
                        typeTable, true, false);
                OMXMLParserWrapper stAXOMBuilder = OMXMLBuilderFactory
                        .createStAXOMBuilder(OMAbstractFactory.getOMFactory(),
                                new StreamWrapper(xr));
                omValue = stAXOMBuilder.getDocumentElement();

            }
            addInstanceTypeAttribute(fac, omValue, value, typeTable);
            return omValue;
            
        } else if (SimpleTypeMapper.isSimpleType(value)) {
            OMElement omValue;
            omValue = fac.createOMElement(elementName, ns);
            omValue.addChild(fac.createOMText(SimpleTypeMapper
                    .getStringValue(value)));
            return omValue;
        } 
        return value;
    }
    
    /**
     * Process generic collection.
     *
     * @param omElement the om element
     * @param generictype the generictype
     * @param helper the helper
     * @param objectSupplier the object supplier
     * @return the collection
     * @throws AxisFault the axis fault
     */
    public static Collection<Object> processGenericCollection(OMElement omElement,
            Type generictype, MultirefHelper helper,
            ObjectSupplier objectSupplier) throws AxisFault {
    QName partName = omElement.getQName();
    Type parameter = Object.class;
    if (generictype != null && (generictype instanceof ParameterizedType)) {
        ParameterizedType aType = (ParameterizedType) generictype;
        Type[] parameterArgTypes = aType.getActualTypeArguments();
        parameter = parameterArgTypes[0];
    }
    /*
     * Fix for AXIS2-5090. Use siblings with same QName instead of look for
     * children because list elements available on same level.
     */
    Iterator<OMElement> parts = omElement.getParent().getChildrenWithName(partName);
    return processGenericsElement(parameter, omElement, helper, parts,
        objectSupplier, generictype);
    }
    
    /**
     * Process collection.
     *
     * @param omElement the om element
     * @param toReturn the to return
     * @param generictype the generictype
     * @param helper the helper
     * @param objectSupplier the object supplier
     * @param parts the parts
     * @param bare the bare
     * @return the collection
     * @throws AxisFault the axis fault
     */
    public static Collection<Object> processGenericCollection(OMElement omElement,
        OMElement[] toReturn, Type generictype, MultirefHelper helper,
        ObjectSupplier objectSupplier, Iterator parts, boolean bare)
        throws AxisFault {
        String currentLocalName = omElement.getLocalName();
        Type parameter = Object.class;
        List<OMElement> eleList = new ArrayList<OMElement>();
        // in 'Bare' style no need to add first element to the list.
        if (!bare) {
            eleList.add(omElement);
        }

        if (generictype != null && (generictype instanceof ParameterizedType)) {
            ParameterizedType aType = (ParameterizedType) generictype;
            Type[] parameterArgTypes = aType.getActualTypeArguments();
            parameter = parameterArgTypes[0];
        }

        while (parts.hasNext()) {
            Object objValue = parts.next();
            OMElement currElement;
            if (objValue instanceof OMElement) {
                currElement = (OMElement) objValue;
            } else {
                continue;
            }
            if (currentLocalName.equals(currElement.getLocalName())) {
                eleList.add(currElement);
            } else {
                // This just a container to bring back un-proceeded OMEleemnt.
                toReturn[0] = currElement;
                break;
            }
        }
        return processGenericsElement(parameter, omElement, helper,
            eleList.iterator(), objectSupplier, generictype);
    }

    /**
     * Gets the collection element.
     *
     * @param fac the fac
     * @param type the type
     * @param results the results
     * @param name the name
     * @param innerName the inner name
     * @param elementQName the element q name
     * @param typeTable the type table
     * @param elementFormDefault the element form default
     * @return the collection element
     */
    public static OMElement getCollectionElement(OMFactory fac, Type type,
        Collection results, String name, String innerName,
        QName elementQName, TypeTable typeTable, boolean elementFormDefault) {

        String elementName = (innerName == null) ? name : innerName;
        Iterator<Object> itr = results.iterator();
        List<Object> properties = new ArrayList<Object>();
        OMNamespace ns = fac.createOMNamespace(elementQName.getNamespaceURI(),
            elementQName.getPrefix());
        Type valueType = Object.class;
        if (type instanceof ParameterizedType) {
            ParameterizedType aType = (ParameterizedType) type;
            Type[] parameterArgTypes = aType.getActualTypeArguments();
            valueType = parameterArgTypes[0];
        }

        while (itr.hasNext()) {
            Object value = itr.next();
            if (value != null) {
                value = getCollectionItemElement(fac, elementName, value,
                        valueType, typeTable, ns, elementFormDefault);
                QName valueQName;
                if (elementFormDefault) {
                    valueQName = new QName(ns.getNamespaceURI(), elementName,
                            ns.getPrefix());
                } else {
                    valueQName = new QName(elementName);
                }
                properties.add(valueQName);
                properties.add(value);
            }
        }
        QName eleQName;
        if (elementFormDefault) {
            eleQName = new QName(ns.getNamespaceURI(),
                    elementQName.getLocalPart(), ns.getPrefix());
        } else {
            eleQName = new QName(elementQName.getLocalPart());
        }
        XMLStreamReader pullParser = new ADBXMLStreamReaderImpl(eleQName, properties.toArray(), null, typeTable,
            elementFormDefault);

        OMXMLParserWrapper builder = OMXMLBuilderFactory.createStAXOMBuilder(
            new StreamWrapper(pullParser));
        return builder.getDocumentElement();
    }

    /**
     * Gets the collection item element.
     *
     * @param fac the fac
     * @param elementName the element name
     * @param value the value
     * @param valueType the value type
     * @param typeTable the type table
     * @param ns the ns
     * @param elementFormDefault the element form default
     * @return the collection item element
     */
    private static Object getCollectionItemElement(OMFactory fac,
            String elementName, Object value, Type valueType,
            TypeTable typeTable, OMNamespace ns, boolean elementFormDefault) {
        if (SimpleTypeMapper.isMap(value.getClass())) {
            List<OMElement> childList = getMapElement(fac, valueType,
                (Map) value, typeTable, elementFormDefault);
            OMElement omValue = fac.createOMElement(elementName,
                ns.getNamespaceURI(), ns.getPrefix());
            for (OMElement child : childList) {
                omValue.addChild(child);
            }
            return omValue;
    
        } else if (SimpleTypeMapper.isCollection(value.getClass())) {
            return getCollectionElement(
                fac,
                valueType,
                (Collection) value,
                elementName,
                Constants.INNER_ARRAY_COMPLEX_TYPE_NAME,
                new QName(ns.getNamespaceURI(), elementName, ns.getPrefix()),
                typeTable, elementFormDefault);
        } else if (SimpleTypeMapper.isObjectType((Class) valueType)) {
            OMElement omValue;
            omValue = fac.createOMElement(elementName, ns);
            if (SimpleTypeMapper.isSimpleType(value)) {
                omValue.addChild(fac.createOMText(SimpleTypeMapper
                    .getStringValue(value)));
            } else {
                QName name;
                if (elementFormDefault) {
                    name = new QName(ns.getNamespaceURI(), elementName,
                            ns.getPrefix());
                } else {
                    name = new QName(elementName);
                }
                XMLStreamReader xr = BeanUtil.getPullParser(value, name,
                        typeTable, true, false);
                OMXMLParserWrapper stAXOMBuilder = OMXMLBuilderFactory
                        .createStAXOMBuilder(OMAbstractFactory.getOMFactory(),
                                new StreamWrapper(xr));
                omValue = stAXOMBuilder.getDocumentElement();

            }
            addInstanceTypeAttribute(fac, omValue, value, typeTable);
            return omValue;
        }
        return value;
    }
    
    /**
     * Gets the collection instance object according to the genericType passed.
     *
     * @param genericType the generic type
     * @return the collection instance
     */
    private static Collection<Object> getCollectionInstance(Type genericType) {
        Class rowType;
        if (genericType instanceof ParameterizedType) {
            rowType = (Class) ((ParameterizedType) genericType).getRawType();
        } else {
            rowType = (Class) genericType;
        }

        if (Collection.class.getName().equals(rowType.getName())
            || List.class.getName().equals(rowType.getName())) {
            return new ArrayList<Object>();

        } else if (Set.class.getName().equals(rowType.getName())) {
            return new HashSet<Object>();

        } else if (Queue.class.getName().equals(rowType.getName())) {
            return new LinkedList<Object>();

        } else if (BlockingQueue.class.getName().equals(rowType.getName())) {
            return new LinkedBlockingQueue<Object>();

        } 
//        TODO - Enable this logic once the Axis2 move to Java 1.6.
//        else if (BlockingDeque.class.getName().equals(rowType.getName())) {
//        return new LinkedBlockingDeque<Object>();
//
//        }else if (NavigableSet.class.getName().equals(rowType.getName())
//            || SortedSet.class.getName().equals(rowType.getName())) {
//        return new TreeSet<Object>();
//
//        }
        else {
            try {
                return (Collection<Object>) rowType.newInstance();
            } catch (Exception e) {
                return new ArrayList<Object>();
            }
        }
    }
    
    private static XMLGregorianCalendar getXMLGregorianCalendar(
            OMElement beanElement) throws DatatypeConfigurationException {
        String greCal = beanElement.getText();
        XMLGregorianCalendar xmlCal = DatatypeFactory.newInstance()
                .newXMLGregorianCalendar(greCal);
        return xmlCal;
    }

}