/*
 * 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.commons.jxpath.ri;

import java.lang.ref.SoftReference;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Vector;

import org.apache.commons.jxpath.CompiledExpression;
import org.apache.commons.jxpath.ExceptionHandler;
import org.apache.commons.jxpath.Function;
import org.apache.commons.jxpath.Functions;
import org.apache.commons.jxpath.JXPathContext;
import org.apache.commons.jxpath.JXPathException;
import org.apache.commons.jxpath.JXPathFunctionNotFoundException;
import org.apache.commons.jxpath.JXPathInvalidSyntaxException;
import org.apache.commons.jxpath.JXPathNotFoundException;
import org.apache.commons.jxpath.JXPathTypeConversionException;
import org.apache.commons.jxpath.Pointer;
import org.apache.commons.jxpath.ri.axes.InitialContext;
import org.apache.commons.jxpath.ri.axes.RootContext;
import org.apache.commons.jxpath.ri.compiler.Expression;
import org.apache.commons.jxpath.ri.compiler.LocationPath;
import org.apache.commons.jxpath.ri.compiler.Path;
import org.apache.commons.jxpath.ri.compiler.TreeCompiler;
import org.apache.commons.jxpath.ri.model.NodePointer;
import org.apache.commons.jxpath.ri.model.NodePointerFactory;
import org.apache.commons.jxpath.ri.model.VariablePointerFactory;
import org.apache.commons.jxpath.ri.model.beans.BeanPointerFactory;
import org.apache.commons.jxpath.ri.model.beans.CollectionPointerFactory;
import org.apache.commons.jxpath.ri.model.container.ContainerPointerFactory;
import org.apache.commons.jxpath.ri.model.dynamic.DynamicPointerFactory;
import org.apache.commons.jxpath.util.ClassLoaderUtil;
import org.apache.commons.jxpath.util.ReverseComparator;
import org.apache.commons.jxpath.util.TypeUtils;

/**
 * The reference implementation of JXPathContext.
 */
public class JXPathContextReferenceImpl extends JXPathContext {

    /**
     * Change this to {@code false} to disable soft caching of CompiledExpressions.
     */
    public static final boolean USE_SOFT_CACHE = true;
    private static final Compiler COMPILER = new TreeCompiler();
    private static Map<String, Object> compiled = new HashMap<>();
    private static int cleanupCount;
    private static NodePointerFactory[] nodeFactoryArray;
    // The frequency of the cache cleanup
    private static final int CLEANUP_THRESHOLD = 500;
    private static final Vector<NodePointerFactory> nodeFactories = new Vector<>();
    static {
        nodeFactories.add(new CollectionPointerFactory());
        nodeFactories.add(new BeanPointerFactory());
        nodeFactories.add(new DynamicPointerFactory());
        nodeFactories.add(new VariablePointerFactory());
        // DOM factory is only registered if DOM support is on the classpath
        final NodePointerFactory domFactory = (NodePointerFactory) allocateConditionally("org.apache.commons.jxpath.ri.model.dom.DOMPointerFactory",
                "org.w3c.dom.Node");
        if (domFactory != null) {
            nodeFactories.add(domFactory);
        }
        // JDOM factory is only registered if JDOM is on the classpath
        final NodePointerFactory jdomFactory = (NodePointerFactory) allocateConditionally("org.apache.commons.jxpath.ri.model.jdom.JDOMPointerFactory",
                "org.jdom.Document");
        if (jdomFactory != null) {
            nodeFactories.add(jdomFactory);
        }
        // DynaBean factory is only registered if BeanUtils are on the classpath
        final NodePointerFactory dynaBeanFactory = (NodePointerFactory) allocateConditionally(
                "org.apache.commons.jxpath.ri.model.dynabeans." + "DynaBeanPointerFactory", "org.apache.commons.beanutils.DynaBean");
        if (dynaBeanFactory != null) {
            nodeFactories.add(dynaBeanFactory);
        }
        nodeFactories.add(new ContainerPointerFactory());
        createNodeFactoryArray();
    }

    /**
     * Call this with a custom NodePointerFactory to add support for additional types of objects. Make sure the factory returns a name that puts it in the right
     * position on the list of factories.
     *
     * @param factory NodePointerFactory to add
     */
    public static void addNodePointerFactory(final NodePointerFactory factory) {
        synchronized (nodeFactories) {
            nodeFactories.add(factory);
            nodeFactoryArray = null;
        }
    }

    /**
     * Checks if existenceCheckClass exists on the class path. If so, allocates an instance of the specified class, otherwise returns null.
     *
     * @param className               to instantiate
     * @param existenceCheckClassName guard class
     * @return className instance
     */
    public static Object allocateConditionally(final String className, final String existenceCheckClassName) {
        try {
            try {
                ClassLoaderUtil.getClass(existenceCheckClassName, true);
            } catch (final ClassNotFoundException ex) {
                return null;
            }
            return ClassLoaderUtil.getClass(className, true).getConstructor().newInstance();
        } catch (final Exception ex) {
            throw new JXPathException("Cannot allocate " + className, ex);
        }
    }

    /**
     * Create the default node factory array.
     */
    private static synchronized void createNodeFactoryArray() {
        if (nodeFactoryArray == null) {
            nodeFactoryArray = nodeFactories.toArray(new NodePointerFactory[nodeFactories.size()]);
            Arrays.sort(nodeFactoryArray, (a, b) -> {
                final int orderA = a.getOrder();
                final int orderB = b.getOrder();
                return orderA - orderB;
            });
        }
    }

    /**
     * Gets the registered NodePointerFactories.
     *
     * @return NodePointerFactory[]
     */
    public static NodePointerFactory[] getNodePointerFactories() {
        return nodeFactoryArray;
    }

    /**
     * Removes support for additional types of objects.
     *
     * @param factory NodePointerFactory to remove
     * @return true if this implementation contained the specified element
     * @since 1.4.0.0
     */
    public static boolean removeNodePointerFactory(final NodePointerFactory factory) {
        synchronized (nodeFactories) {
            final boolean remove = nodeFactories.remove(factory);
            nodeFactoryArray = null;
            return remove;
        }
    }

    /** Namespace resolver */
    protected NamespaceResolver namespaceResolver;
    private Pointer rootPointer;
    private Pointer contextPointer;

    /**
     * Constructs a new JXPathContextReferenceImpl.
     *
     * @param parentContext parent context
     * @param contextBean   Object
     */
    protected JXPathContextReferenceImpl(final JXPathContext parentContext, final Object contextBean) {
        this(parentContext, contextBean, null);
    }

    /**
     * Constructs a new JXPathContextReferenceImpl.
     *
     * @param parentContext  parent context
     * @param contextBean    Object
     * @param contextPointer context pointer
     */
    public JXPathContextReferenceImpl(final JXPathContext parentContext, final Object contextBean, final Pointer contextPointer) {
        super(parentContext, contextBean);
        synchronized (nodeFactories) {
            createNodeFactoryArray();
        }
        if (contextPointer != null) {
            this.contextPointer = contextPointer;
            this.rootPointer = NodePointer.newNodePointer(new QName(null, "root"), contextPointer.getRootNode(), getLocale());
        } else {
            this.contextPointer = NodePointer.newNodePointer(new QName(null, "root"), contextBean, getLocale());
            this.rootPointer = this.contextPointer;
        }
        NamespaceResolver parentNR = null;
        if (parentContext instanceof JXPathContextReferenceImpl) {
            parentNR = ((JXPathContextReferenceImpl) parentContext).getNamespaceResolver();
        }
        namespaceResolver = new NamespaceResolver(parentNR);
        namespaceResolver.setNamespaceContextPointer((NodePointer) this.contextPointer);
    }

    /**
     * Checks if the path follows the JXPath restrictions on the type of path that can be passed to create... methods.
     *
     * @param expr Expression to check
     */
    private void checkSimplePath(final Expression expr) {
        if (!(expr instanceof LocationPath) || !((LocationPath) expr).isSimplePath()) {
            throw new JXPathInvalidSyntaxException(
                    "JXPath can only create a path if it uses exclusively " + "the child:: and attribute:: axes and has " + "no context-dependent predicates");
        }
    }

    /**
     * Compile the given expression.
     *
     * @param xpath to compile
     * @return Expression
     */
    private Expression compileExpression(final String xpath) {
        Expression expr;
        synchronized (compiled) {
            if (USE_SOFT_CACHE) {
                expr = null;
                final SoftReference<Expression> ref = (SoftReference) compiled.get(xpath);
                if (ref != null) {
                    expr = ref.get();
                }
            } else {
                expr = (Expression) compiled.get(xpath);
            }
        }
        if (expr != null) {
            return expr;
        }
        expr = (Expression) Parser.parseExpression(xpath, getCompiler());
        synchronized (compiled) {
            if (USE_SOFT_CACHE) {
                if (cleanupCount++ >= CLEANUP_THRESHOLD) {
                    final Iterator<Entry<String, Object>> it = compiled.entrySet().iterator();
                    while (it.hasNext()) {
                        final Entry<String, ?> me = it.next();
                        if (((SoftReference<Expression>) me.getValue()).get() == null) {
                            it.remove();
                        }
                    }
                    cleanupCount = 0;
                }
                compiled.put(xpath, new SoftReference<>(expr));
            } else {
                compiled.put(xpath, expr);
            }
        }
        return expr;
    }

    @Override
    protected CompiledExpression compilePath(final String xpath) {
        return new JXPathCompiledExpression(xpath, compileExpression(xpath));
    }
//    private Object getNativeContextNode(Expression expression) {
//        Object node = getNativeContextNode(getContextBean());
//        if (node == null) {
//            return null;
//        }
//
//        List vars = expression.getUsedVariables();
//        if (vars != null) {
//            return null;
//        }
//
//        return node;
//    }
//    private Object getNativeContextNode(Object bean) {
//        if (bean instanceof Number || bean instanceof String || bean instanceof Boolean) {
//            return bean;
//        }
//        if (bean instanceof Node) {
//            return (Node)bean;
//        }
//
//        if (bean instanceof Container) {
//            bean = ((Container)bean).getValue();
//            return getNativeContextNode(bean);
//        }
//
//        return null;
//    }

    @Override
    public Pointer createPath(final String xpath) {
        return createPath(xpath, compileExpression(xpath));
    }

    /**
     * Create the given path.
     *
     * @param xpath String
     * @param expr  compiled Expression
     * @return resulting Pointer
     */
    public Pointer createPath(final String xpath, final Expression expr) {
        try {
            final Object result = expr.computeValue(getEvalContext());
            Pointer pointer;
            if (result instanceof Pointer) {
                pointer = (Pointer) result;
            } else if (result instanceof EvalContext) {
                final EvalContext ctx = (EvalContext) result;
                pointer = ctx.getSingleNodePointer();
            } else {
                checkSimplePath(expr);
                // This should never happen
                throw new JXPathException("Cannot create path:" + xpath);
            }
            return ((NodePointer) pointer).createPath(this);
        } catch (final Throwable ex) {
            throw new JXPathException("Exception trying to create XPath " + xpath, ex);
        }
    }

    /**
     * Create the given path setting its value to value.
     *
     * @param xpath String
     * @param expr  compiled Expression
     * @param value Object
     * @return resulting Pointer
     */
    public Pointer createPathAndSetValue(final String xpath, final Expression expr, final Object value) {
        try {
            return setValue(xpath, expr, value, true);
        } catch (final Throwable ex) {
            throw new JXPathException("Exception trying to create XPath " + xpath, ex);
        }
    }

    @Override
    public Pointer createPathAndSetValue(final String xpath, final Object value) {
        return createPathAndSetValue(xpath, compileExpression(xpath), value);
    }

    /**
     * Gets the absolute root context.
     *
     * @return EvalContext
     */
    public EvalContext getAbsoluteRootContext() {
        return new InitialContext(new RootContext(this, getAbsoluteRootPointer()));
    }

    /**
     * Gets absolute root pointer.
     *
     * @return NodePointer
     */
    private NodePointer getAbsoluteRootPointer() {
        return (NodePointer) rootPointer;
    }

    /**
     * Returns a static instance of TreeCompiler.
     *
     * Override this to return an alternate compiler.
     *
     * @return Compiler
     */
    protected Compiler getCompiler() {
        return COMPILER;
    }

    @Override
    public Pointer getContextPointer() {
        return contextPointer;
    }

    /**
     * Gets the evaluation context.
     *
     * @return EvalContext
     */
    private EvalContext getEvalContext() {
        return new InitialContext(new RootContext(this, (NodePointer) getContextPointer()));
    }

    /**
     * Gets the named Function.
     *
     * @param functionName name
     * @param parameters   function args
     * @return Function
     */
    public Function getFunction(final QName functionName, final Object[] parameters) {
        final String namespace = functionName.getPrefix();
        final String name = functionName.getName();
        JXPathContext funcCtx = this;
        Function func;
        Functions funcs;
        while (funcCtx != null) {
            funcs = funcCtx.getFunctions();
            if (funcs != null) {
                func = funcs.getFunction(namespace, name, parameters);
                if (func != null) {
                    return func;
                }
            }
            funcCtx = funcCtx.getParentContext();
        }
        throw new JXPathFunctionNotFoundException("Undefined function: " + functionName.toString());
    }

    @Override
    public Pointer getNamespaceContextPointer() {
        return namespaceResolver.getNamespaceContextPointer();
    }

    /**
     * Gets the namespace resolver.
     *
     * @return NamespaceResolver
     */
    public NamespaceResolver getNamespaceResolver() {
        namespaceResolver.seal();
        return namespaceResolver;
    }

    @Override
    public String getNamespaceURI(final String prefix) {
        return namespaceResolver.getNamespaceURI(prefix);
    }

    @Override
    public Pointer getPointer(final String xpath) {
        return getPointer(xpath, compileExpression(xpath));
    }

    /**
     * Gets a pointer to the specified path/expression.
     *
     * @param xpath String
     * @param expr  compiled Expression
     * @return Pointer
     */
    public Pointer getPointer(final String xpath, final Expression expr) {
        Object result = expr.computeValue(getEvalContext());
        if (result instanceof EvalContext) {
            result = ((EvalContext) result).getSingleNodePointer();
        }
        if (result instanceof Pointer) {
            if (!isLenient() && !((NodePointer) result).isActual()) {
                throw new JXPathNotFoundException("No pointer for xpath: " + xpath);
            }
            return (Pointer) result;
        }
        return NodePointer.newNodePointer(null, result, getLocale());
    }

    /**
     * {@inheritDoc}
     *
     * @see org.apache.commons.jxpath.JXPathContext#getPrefix(java.lang.String)
     */
    @Override
    public String getPrefix(final String namespaceURI) {
        return namespaceResolver.getPrefix(namespaceURI);
    }

    @Override
    public JXPathContext getRelativeContext(final Pointer pointer) {
        final Object contextBean = pointer.getNode();
        if (contextBean == null) {
            throw new JXPathException("Cannot create a relative context for a non-existent node: " + pointer);
        }
        return new JXPathContextReferenceImpl(this, contextBean, pointer);
    }

    /**
     * Traverses the XPath and returns the resulting object. Primitive types are wrapped into objects.
     *
     * @param xpath expression
     * @return Object found
     */
    @Override
    public Object getValue(final String xpath) {
        final Expression expression = compileExpression(xpath);
// TODO: (work in progress) - trying to integrate with Xalan
//        Object ctxNode = getNativeContextNode(expression);
//        if (ctxNode != null) {
//            System.err.println("WILL USE XALAN: " + xpath);
//            CachedXPathAPI api = new CachedXPathAPI();
//            try {
//                if (expression instanceof Path) {
//                    Node node = api.selectSingleNode((Node)ctxNode, xpath);
//                    System.err.println("NODE: " + node);
//                    if (node == null) {
//                        return null;
//                    }
//                    return new DOMNodePointer(node, null).getValue();
//                }
//                else {
//                    XObject object = api.eval((Node)ctxNode, xpath);
//                    switch (object.getType()) {
//                    case XObject.CLASS_STRING: return object.str();
//                    case XObject.CLASS_NUMBER: return new Double(object.num());
//                    case XObject.CLASS_BOOLEAN: return new Boolean(object.bool());
//                    default:
//                        System.err.println("OTHER TYPE: " + object.getTypeString());
//                    }
//                }
//            }
//            catch (TransformerException e) {
//                // TODO Auto-generated catch block
//                e.printStackTrace();
//            }
//            return
//        }
        return getValue(xpath, expression);
    }

    /**
     * Calls getValue(xpath), converts the result to the required type and returns the result of the conversion.
     *
     * @param xpath        expression
     * @param requiredType Class
     * @return Object
     */
    @Override
    public Object getValue(final String xpath, final Class requiredType) {
        final Expression expr = compileExpression(xpath);
        return getValue(xpath, expr, requiredType);
    }

    /**
     * Gets the value indicated.
     *
     * @param xpath String
     * @param expr  Expression
     * @return Object
     */
    public Object getValue(final String xpath, final Expression expr) {
        Object result = expr.computeValue(getEvalContext());
        if (result == null) {
            if (expr instanceof Path && !isLenient()) {
                throw new JXPathNotFoundException("No value for xpath: " + xpath);
            }
            return null;
        }
        if (result instanceof EvalContext) {
            final EvalContext ctx = (EvalContext) result;
            result = ctx.getSingleNodePointer();
            if (!isLenient() && result == null) {
                throw new JXPathNotFoundException("No value for xpath: " + xpath);
            }
        }
        if (result instanceof NodePointer) {
            result = ((NodePointer) result).getValuePointer();
            if (!isLenient()) {
                NodePointer.verify((NodePointer) result);
            }
            result = ((NodePointer) result).getValue();
        }
        return result;
    }

    /**
     * Gets the value indicated.
     *
     * @param xpath        expression
     * @param expr         compiled Expression
     * @param requiredType Class
     * @return Object
     */
    public Object getValue(final String xpath, final Expression expr, final Class requiredType) {
        Object value = getValue(xpath, expr);
        if (value != null && requiredType != null) {
            if (!TypeUtils.canConvert(value, requiredType)) {
                throw new JXPathTypeConversionException("Invalid expression type. '" + xpath + "' returns " + value.getClass().getName()
                        + ". It cannot be converted to " + requiredType.getName());
            }
            value = TypeUtils.convert(value, requiredType);
        }
        return value;
    }

    /**
     * Gets a VariablePointer for the given variable name.
     *
     * @param qName variable name
     * @return NodePointer
     */
    public NodePointer getVariablePointer(final QName qName) {
        return NodePointer.newNodePointer(qName, VariablePointerFactory.contextWrapper(this), getLocale());
    }

    /**
     * Traverses the XPath and returns a Iterator of all results found for the path. If the XPath matches no properties in the graph, the Iterator will not be
     * null.
     *
     * @param xpath expression
     * @return Iterator
     */
    @Override
    public Iterator iterate(final String xpath) {
        return iterate(xpath, compileExpression(xpath));
    }

    /**
     * Traverses the XPath and returns a Iterator of all results found for the path. If the XPath matches no properties in the graph, the Iterator will not be
     * null.
     *
     * @param xpath expression
     * @param expr  compiled Expression
     * @return Iterator
     */
    public Iterator iterate(final String xpath, final Expression expr) {
        return expr.iterate(getEvalContext());
    }

    /**
     * Traverses the XPath and returns an Iterator of Pointers. A Pointer provides easy access to a property. If the XPath matches no properties in the graph,
     * the Iterator be empty, but not null.
     *
     * @param xpath expression
     * @return Iterator
     */
    @Override
    public Iterator<Pointer> iteratePointers(final String xpath) {
        return iteratePointers(xpath, compileExpression(xpath));
    }

    /**
     * Traverses the XPath and returns an Iterator of Pointers. A Pointer provides easy access to a property. If the XPath matches no properties in the graph,
     * the Iterator be empty, but not null.
     *
     * @param xpath expression
     * @param expr  compiled Expression
     * @return Iterator
     */
    public Iterator<Pointer> iteratePointers(final String xpath, final Expression expr) {
        return expr.iteratePointers(getEvalContext());
    }

    @Override
    public void registerNamespace(final String prefix, final String namespaceURI) {
        if (namespaceResolver.isSealed()) {
            namespaceResolver = (NamespaceResolver) namespaceResolver.clone();
        }
        namespaceResolver.registerNamespace(prefix, namespaceURI);
    }

    @Override
    public void removeAll(final String xpath) {
        removeAll(xpath, compileExpression(xpath));
    }

    /**
     * Remove all matching nodes.
     *
     * @param xpath expression
     * @param expr  compiled Expression
     */
    public void removeAll(final String xpath, final Expression expr) {
        try {
            final ArrayList<NodePointer> list = new ArrayList<>();
            Iterator<NodePointer> it = expr.iteratePointers(getEvalContext());
            while (it.hasNext()) {
                list.add(it.next());
            }
            Collections.sort(list, ReverseComparator.INSTANCE);
            it = list.iterator();
            if (it.hasNext()) {
                final NodePointer pointer = it.next();
                pointer.remove();
                while (it.hasNext()) {
                    removePath(it.next().asPath());
                }
            }
        } catch (final Throwable ex) {
            throw new JXPathException("Exception trying to remove all for xpath " + xpath, ex);
        }
    }

    @Override
    public void removePath(final String xpath) {
        removePath(xpath, compileExpression(xpath));
    }

    /**
     * Remove the specified path.
     *
     * @param xpath expression
     * @param expr  compiled Expression
     */
    public void removePath(final String xpath, final Expression expr) {
        try {
            final NodePointer pointer = (NodePointer) getPointer(xpath, expr);
            if (pointer != null) {
                pointer.remove();
            }
        } catch (final Throwable ex) {
            throw new JXPathException("Exception trying to remove XPath " + xpath, ex);
        }
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public void setExceptionHandler(final ExceptionHandler exceptionHandler) {
        if (rootPointer instanceof NodePointer) {
            ((NodePointer) rootPointer).setExceptionHandler(exceptionHandler);
        }
    }

    @Override
    public void setNamespaceContextPointer(final Pointer pointer) {
        if (namespaceResolver.isSealed()) {
            namespaceResolver = (NamespaceResolver) namespaceResolver.clone();
        }
        namespaceResolver.setNamespaceContextPointer((NodePointer) pointer);
    }

    /**
     * Sets the value of XPath to value.
     *
     * @param xpath path
     * @param expr  compiled Expression
     * @param value Object
     */
    public void setValue(final String xpath, final Expression expr, final Object value) {
        try {
            setValue(xpath, expr, value, false);
        } catch (final Throwable ex) {
            throw new JXPathException("Exception trying to set value with XPath " + xpath, ex);
        }
    }

    /**
     * Sets the specified value.
     *
     * @param xpath  path
     * @param expr   compiled Expression
     * @param value  destination value
     * @param create whether to create missing node(s)
     * @return Pointer created
     */
    private Pointer setValue(final String xpath, final Expression expr, final Object value, final boolean create) {
        final Object result = expr.computeValue(getEvalContext());
        Pointer pointer;
        if (result instanceof Pointer) {
            pointer = (Pointer) result;
        } else if (result instanceof EvalContext) {
            final EvalContext ctx = (EvalContext) result;
            pointer = ctx.getSingleNodePointer();
        } else {
            if (create) {
                checkSimplePath(expr);
            }
            // This should never happen
            throw new JXPathException("Cannot set value for xpath: " + xpath);
        }
        if (create) {
            pointer = ((NodePointer) pointer).createPath(this, value);
        } else {
            pointer.setValue(value);
        }
        return pointer;
    }

    @Override
    public void setValue(final String xpath, final Object value) {
        setValue(xpath, compileExpression(xpath), value);
    }
}