/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.

 *

 * Copyright 2009-2017 Oracle and/or its affiliates. All rights reserved.

 *

 * Oracle and Java are registered trademarks of Oracle and/or its affiliates.

 * Other names may be trademarks of their respective owners.

 *

 * The contents of this file are subject to the terms of either the GNU

 * General Public License Version 2 only ("GPL") or the Common

 * Development and Distribution License("CDDL") (collectively, the

 * "License"). You may not use this file except in compliance with the

 * License. You can obtain a copy of the License at

 * http://www.netbeans.org/cddl-gplv2.html

 * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the

 * specific language governing permissions and limitations under the

 * License.  When distributing the software, include this License Header

 * Notice in each file and include the License file at

 * nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the GPL Version 2 section of the License file that

 * accompanied this code. If applicable, add the following below the

 * License Header, with the fields enclosed by brackets [] replaced by

 * your own identifying information:

 * "Portions Copyrighted [year] [name of copyright owner]"

 *

 * Contributor(s):

 *

 * The Original Software is NetBeans. The Initial Developer of the Original

 * Software is Sun Microsystems, Inc. Portions Copyright 2009-2010 Sun

 * Microsystems, Inc. All Rights Reserved.

 *

 * If you wish your version of this file to be governed by only the CDDL

 * or only the GPL Version 2, indicate your decision by adding

 * "[Contributor] elects to include this software in this distribution

 * under the [CDDL or GPL Version 2] license." If you do not indicate a

 * single choice of license, a recipient has the option to distribute

 * your version of this file under either the CDDL, the GPL Version 2 or

 * to extend the choice of license to its licensees as provided above.

 * However, if you add GPL Version 2 code and therefore, elected the GPL

 * Version 2 license, then the option applies only if the new code is

 * made subject to such option by the copyright holder.

 */

/*

 * Utils.java

 * 

 * Created on 31.08.2007, 15:40:45

 * 

 * To change this template, choose Tools | Templates

 * and open the template in the editor.

 */

package org.netbeans.modules.xml.xpath.ext;

import java.util.ArrayList;

import java.util.Collection;

import java.util.List;

import java.util.Set;

import javax.xml.namespace.NamespaceContext;

import javax.xml.namespace.QName;

import org.netbeans.modules.xml.schema.model.ElementReference;

import org.netbeans.modules.xml.schema.model.Form;

import org.netbeans.modules.xml.schema.model.GlobalAttribute;

import org.netbeans.modules.xml.schema.model.GlobalElement;

import org.netbeans.modules.xml.schema.model.LocalAttribute;

import org.netbeans.modules.xml.schema.model.LocalElement;

import org.netbeans.modules.xml.schema.model.Schema;

import org.netbeans.modules.xml.schema.model.SchemaComponent;

import org.netbeans.modules.xml.schema.model.SchemaModel;

import org.netbeans.modules.xml.xpath.ext.schema.FindAllChildrenSchemaVisitor;

import org.netbeans.modules.xml.xpath.ext.schema.FindChildrenSchemaVisitor;

import org.netbeans.modules.xml.xpath.ext.schema.resolver.SchemaCompHolder;

import org.netbeans.modules.xml.xpath.ext.schema.resolver.WrappingSchemaContext;

import org.netbeans.modules.xml.xpath.ext.schema.resolver.XPathSchemaContext;

import org.netbeans.modules.xml.xpath.ext.schema.resolver.XPathSchemaContext.SchemaCompPair;

import org.netbeans.modules.xml.xpath.ext.spi.ExternalModelResolver;

import org.netbeans.modules.xml.xpath.ext.spi.XPathCastResolver;

import org.netbeans.modules.xml.xpath.ext.spi.XPathPseudoComp;

import org.netbeans.modules.xml.xpath.ext.visitor.ExpressionComparatorVisitor;

/**

 * Utility class.

 * 

 * @author nk160297

 */

public class XPathUtils {

    public static boolean equal(Object o1, Object o2) {

        if (o1 == o2) return true;

        return (o1 == null || o2 == null) ? false : o1.equals(o2);

    }

    /**

     * Converts the qName to a String. 

     * Only the prefix and the local part is used. 

     * The namespace URI is ignored. 

     * 

     * This method is intended to print an entity.

     */ 

    public static String qNameObjectToString(QName qName) {

        String prefix = qName.getPrefix();

        if (prefix == null || prefix.length() == 0) {

            return qName.getLocalPart();

        } else {

            return prefix + ":" + qName.getLocalPart();

        }

    }

    /**

     * Converts the qName to a String. 

     * Only the prefix and the namespace URI is used. 

     * The local part is ignored. 

     * 

     * This method is intended to print a namespace which is held in a QName.

     */ 

    public static String gNameNamespaceToString(QName qName) {

        String prefix = qName.getPrefix();

        String nsUri = qName.getNamespaceURI();

        //

        if (prefix == null || prefix.length() == 0) {

            return "{" + nsUri + "}";

        } else {

            return "{" + nsUri + "}" + prefix;

        }

    }

    /**

     * Check if the namespace URI is specified for the name. 

     * If the name isn't specified, then try resolve it from the prefix.

     * Returns the corrected name if possible. Otherwise returns old name.

     * @param nsContext

     * @param name

     * @return

     */

    public static QName resolvePrefix(NamespaceContext nsContext, QName name) {

        String nsUri = name.getNamespaceURI();

        if (nsUri == null || nsUri.length() == 0 && nsContext != null) {

            //

            String nsPrefix = name.getPrefix();

            nsUri = nsContext.getNamespaceURI(nsPrefix);

            //

            if (nsUri != null) {

                String localPart = name.getLocalPart();

                QName newName = new QName(nsUri, localPart);

                name = newName;

            }

        }

        //

        return name;

    }

    public static boolean equalsIgnorNsUri(QName qName1, QName qName2) {

        return (qName1.getLocalPart().equals(qName2.getLocalPart())) && 

                (qName1.getPrefix().equals(qName2.getPrefix()));

    }

    public static boolean samePredicatesArr(

            XPathPredicateExpression[] predArr1, 

            XPathPredicateExpression[] predArr2) {

        //

        if (predArr1 == predArr2) {

            return true;

        }

        if (predArr1 == null || predArr2 == null) {

            return false;

        }

        //

        // Compare predicates count

        int size1 = predArr1 == null ? 0 : predArr1.length;

        int size2 = predArr2 == null ? 0 : predArr2.length;

        if (size1 != size2) {

            return false;

        }

        // Compare predicates one by one

        //

        // It is implied that the order is the same. 

        // So the same sets of predicates but with different order 

        // are considered different. 

        for (int index = 0; index < size1; index++) {

            XPathPredicateExpression predicate1 = predArr1[index];

            XPathPredicateExpression predicate2 = predArr2[index];

            //

            XPathExpression predExpr1 = predicate1.getPredicate();

            XPathExpression predExpr2 = predicate2.getPredicate();

            //

            if (predExpr1 instanceof XPathSchemaContextHolder &&

                    predExpr2 instanceof XPathSchemaContextHolder) {

                // If both predicate expressions are schema context holders,

                // then compare contexts.

                //

                XPathSchemaContext ctxt1 =

                        ((XPathSchemaContextHolder)predExpr1).getSchemaContext();

                XPathSchemaContext ctxt2 =

                        ((XPathSchemaContextHolder)predExpr2).getSchemaContext();

                //

                if (!equal(ctxt1, ctxt2)) {

                    return false;

                }

            } else {

                if (!ExpressionComparatorVisitor.equals(predExpr1, predExpr2)) {

                    return false;

                }

            }

        }

        return true;

    }

    /**

     * Determines if a namespace prefix is required for the specified schema component. 

     * @param sComp

     * @return

     */

    public static boolean isPrefixRequired(SchemaComponent sComp) {

        if (sComp instanceof LocalElement) {

            Form form = ((LocalElement)sComp).getFormEffective();

            if (form == Form.QUALIFIED) {

                return true;

            } else {

                return false;

            }

        } else if (sComp instanceof GlobalElement) {

            return true;

        } else if (sComp instanceof LocalAttribute) {

            Form form = ((LocalAttribute)sComp).getFormEffective();

            if (form == Form.QUALIFIED) {

                return true;

            } else {

                return false;

            }

        } else if (sComp instanceof GlobalElement || 

                sComp instanceof ElementReference || 

                sComp instanceof GlobalAttribute) {

            // all global objects have to be with a prefix

            return true;

        }

        //

        assert true : "Unsupported schema component in the BPEL mapper tree!"; // NOI18N

        return false;

    }

    /**

     * Checks if the specified Schema component has any subcomponents.

     * @param sComp

     * @return

     */

    public static boolean hasSubcomponents(SchemaComponent sComp) {

        FindAllChildrenSchemaVisitor checker = 

                new FindAllChildrenSchemaVisitor(true, true, true);

        checker.lookForSubcomponents(sComp);

        List<SchemaComponent> found = checker.getFound();

        return found != null && !found.isEmpty();

    }

    /**

     * Constructs a list of SchemaCompPair objects. Each SchemaCompPair represents 

     * a child Schema component of a parent. Parents are taken from the 

     * specified parent SchemaContext. The context can contain several schema

     * components. So children mean children of all possible parent components 

     * in current context. 

     * 

     * Childrent can be real children schema components or pseudo components. 

     * See XPathPseudoComp class.

     * 

     * @param xPathModel

     * @param parentSContext

     * @param lookForElements indicates if it necessary to add elements to 

     * the result list.

     * @param lookForAttributes indicates if it necessary to add attributes to 

     * the result list.

     * @param collectAny indicates if it necessary to add xsd:any or 

     * xsd:anyAttribute to the result list. 

     * @return result list

     */

    public static List<SchemaCompPair> findSubcomponents(

            XPathModel xPathModel, XPathSchemaContext parentSContext, 

            boolean lookForElements, boolean lookForAttributes, boolean collectAny) {

        //

        assert parentSContext != null;

        ArrayList<SchemaCompPair> result = new ArrayList<SchemaCompPair>();

        //

        XPathCastResolver castResolver = xPathModel == null ? null :

            xPathModel.getXPathCastResolver();

        Set<SchemaCompPair> parentCompPairSet = parentSContext.getSchemaCompPairs(); 

        //

        boolean processPseudoComp = 

                castResolver != null && parentCompPairSet.size() == 1;

        //

        for (SchemaCompPair parentCompPair : parentCompPairSet) {

            SchemaCompHolder parentCompHolder = parentCompPair.getCompHolder();

            //

            FindAllChildrenSchemaVisitor visitor = 

                    new FindAllChildrenSchemaVisitor(

                    lookForElements, lookForAttributes, false);

            visitor.lookForSubcomponents(parentCompHolder.getSchemaComponent());

            //

            List<SchemaComponent> foundComps = visitor.getFound();

            for (SchemaComponent foundComp : foundComps) {

                SchemaCompPair newPair = 

                        new SchemaCompPair(foundComp, parentCompHolder);

                result.add(newPair);

            }

            //

            if (processPseudoComp) {

                if (visitor.hasAny() || visitor.hasAnyAttribute()) {

                    List<XPathPseudoComp> pcList = 

                            castResolver.getPseudoCompList(parentSContext);

                    for (XPathPseudoComp pseudoComp : pcList) {

                        if (pseudoComp.isAttribute()) {

                            if (lookForAttributes && visitor.hasAnyAttribute()) {

                                SchemaCompHolder scHolder = 

                                        SchemaCompHolder.Factory.construct(pseudoComp);

                                SchemaCompPair newPair = 

                                        new SchemaCompPair(scHolder, parentCompHolder);

                                result.add(newPair);

                            }

                        } else {

                            if (lookForElements && visitor.hasAny()) {

                                SchemaCompHolder scHolder = 

                                        SchemaCompHolder.Factory.construct(pseudoComp);

                                SchemaCompPair newPair = 

                                        new SchemaCompPair(scHolder, parentCompHolder);

                                result.add(newPair);

                            }

                        }

                    }

                }

            }

        }

        //

        return result;

    }

    /**

     * Collects a list of SchemaCompHoder objects, which are global accessible.

     * 

     * @param xPathModel

     * @param lookForElements indicates if it necessary to add elements to 

     * the result list.

     * @param lookForAttributes indicates if it necessary to add attributes to 

     * the result list.

     * @param collectAny indicates if it necessary to add xsd:any or 

     * xsd:anyAttribute to the result list. 

     * @return result list

     */

    public static List<SchemaComponent> findRootComponents(XPathModel xPathModel, 

            boolean lookForElements, boolean lookForAttributes, boolean collectAny) {

        //

        ArrayList<SchemaComponent> result = new ArrayList<SchemaComponent>();

        //

        ExternalModelResolver exModelResolver = xPathModel.getExternalModelResolver();

        //

        if (exModelResolver != null) {

            //

            // Look for all available root elements (attributes) 

            // in all available models

            // Pseudo components can be only inside of another schema components, 

            // So they can't be global. It doesn't necessary to look them here.

            Collection<SchemaModel> sModels = exModelResolver.getVisibleModels();

            for (SchemaModel sModel : sModels) {

                Schema schema = sModel.getSchema();

                if (schema != null) {

                    FindAllChildrenSchemaVisitor visitor =

                            new FindAllChildrenSchemaVisitor(

                            lookForElements, lookForAttributes, false);

                    visitor.lookForSubcomponents(schema);

                    //

                    List<SchemaComponent> foundComps = visitor.getFound();

                    result.addAll(foundComps);

                }

            }

        }

        //

        return result;

    }

    /**

     * Returns the list of SchemaCompHolder components, which are children 

     * of the specified parent schema component component (and context) 

     * and have specified name and namespace. 

     * Usually only one component has to be returned. 

     * Not only real schema components can be childrent but also pseudo components, 

     * which are result of casting xsd:any or xsd:anyAttribute. 

     * 

     * @param xPathModel

     * @param parentContext

     * @param parent 

     * @param soughtName required name

     * @param soughtNamespace required namespace

     * @param isAttribute indicates if an attribute or element is required

     * It can be null. 

     * @return

     */

    public static List<SchemaCompHolder> getChildren(

            XPathModel xPathModel, XPathSchemaContext parentContext,

            SchemaComponent parent, String soughtName, 

            String soughtNamespace, boolean isAttribute) {

        List<SchemaComponent> found = null;

        boolean hasAny = false;

        boolean hasAnyAttribute = false;

        ArrayList<SchemaCompHolder> result = new ArrayList<SchemaCompHolder>();

        //

        FindChildrenSchemaVisitor visitor =

                new FindChildrenSchemaVisitor(parentContext,

                soughtName, soughtNamespace, isAttribute);

        visitor.lookForSubcomponent(parent);

        found = visitor.getFound();

        hasAny = visitor.hasAny();

        hasAnyAttribute = visitor.hasAnyAttribute();

        //

        if (found == null || found.isEmpty()) {

            //

            // try looking for Pseudo Components here

            XPathCastResolver castResolver = xPathModel.getXPathCastResolver();

            if (castResolver != null) {

                List<XPathPseudoComp> pcList = 

                        castResolver.getPseudoCompList(parentContext);

                if (pcList != null) {

                    for (XPathPseudoComp pseudoComp : pcList) {

                        if (!hasAnyAttribute && isAttribute) {

                            // AnyAttribute isn't supported

                            continue;

                        }

                        //

                        if (!hasAny && !isAttribute) {

                            // Any isn't supported

                            continue;

                        }

                        //

                        if (isAttribute != pseudoComp.isAttribute()) {

                            continue;

                        }

                        //

                        if (!(soughtName.equals(pseudoComp.getName()))) {

                            // Different name

                            continue;

                        }

                        if (!(soughtNamespace.equals(pseudoComp.getNamespace()))) {

                            // different namespace

                            continue;

                        } 

                        //

                        SchemaCompHolder compHolder = 

                                SchemaCompHolder.Factory.construct(pseudoComp);

                        result.add(compHolder);

                    }

                }

            }

        } else {

            convertToHolders(found, result);

        }

        //

        return result;

    }

    /**

     * Converts the list of Schema components to the list of SC holders 

     * @param scList

     * @param target

     */

    private static void convertToHolders(List<SchemaComponent> scList, 

            ArrayList<SchemaCompHolder> target) {

        for (SchemaComponent sc : scList) {

            SchemaCompHolder newHolder = SchemaCompHolder.Factory.construct(sc);

            if (newHolder != null) {

                target.add(newHolder);

            }

        }

    }

    /**

     * Check if the input schema context is wrapping context, then takes 

     * unwrapped context recursively. 

     *

     * @param sContext

     * @return

     */

    public static XPathSchemaContext unwrap(XPathSchemaContext sContext) {

       if (sContext instanceof WrappingSchemaContext) {

           sContext = ((WrappingSchemaContext)sContext).getBaseContext();

           return unwrap(sContext);

       } else {

           return sContext;

       }

    }

}