/*
    * 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.compiler;
  
  import java.util.Collections;
  import java.util.Iterator;
  import java.util.Locale;
  
  import org.apache.commons.jxpath.NodeSet;
  import org.apache.commons.jxpath.Pointer;
  import org.apache.commons.jxpath.ri.EvalContext;
  import org.apache.commons.jxpath.ri.QName;
  import org.apache.commons.jxpath.ri.model.NodePointer;
  import org.apache.commons.jxpath.util.ValueUtils;
  
  /**
   * Common superclass for several types of nodes in the parse tree. Provides APIs for optimization of evaluation of expressions. Specifically, an expression only
   * needs to executed once during the evaluation of an XPath if that expression is context-independent. Expression.isContextDependent() provides that hint.
   */
  public abstract class Expression {
  
      /**
       * Pointer iterator
       */
      public static class PointerIterator implements Iterator {
  
          private final Iterator iterator;
          private final QName qname;
          private final Locale locale;
  
          // to what method does the following comment refer?
          /**
           * Constructs a new PointerIterator
           *
           * @param it     underlying Iterator
           * @param qname  name
           * @param locale Locale
           * @deprecated Use the method that takes a NamespaceManager
           */
          @Deprecated
          public PointerIterator(final Iterator it, final QName qname, final Locale locale) {
              this.iterator = it;
              this.qname = qname;
              this.locale = locale;
          }
  
          @Override
          public boolean hasNext() {
              return iterator.hasNext();
          }
  
          @Override
          public Object next() {
              final Object o = iterator.next();
              return o instanceof Pointer ? o : NodePointer.newNodePointer(qname, o, locale);
          }
  
          /**
           * Unsupported.
           */
          @Override
          public void remove() {
              throw new UnsupportedOperationException();
          }
      }
  
      /**
       * Value Iterator
       */
      public static class ValueIterator implements Iterator {
  
          private final Iterator iterator;
  
          /**
           * Constructs a new ValueIterator.
           *
           * @param it underlying Iterator, may contain pointers
           */
          public ValueIterator(final Iterator it) {
              this.iterator = it;
          }
  
          @Override
          public boolean hasNext() {
             return iterator.hasNext();
         }
 
         @Override
         public Object next() {
             final Object o = iterator.next();
             return o instanceof Pointer ? ((Pointer) o).getValue() : o;
         }
 
         /**
          * Unsupported.
          */
         @Override
         public void remove() {
             throw new UnsupportedOperationException();
         }
     }
 
     /** Zero */
     protected static final Double ZERO = Double.valueOf(0);
     /** One */
     protected static final Double ONE = Double.valueOf(1);
     /** NaN */
     protected static final Double NOT_A_NUMBER = Double.valueOf(Double.NaN);
     private boolean contextDependencyKnown;
     private boolean contextDependent;
 
     /**
      * Constructs a new instance.
      */
     public Expression() {
         // empty
     }
 
     /**
      * Evaluates the expression. If the result is a node set, returns the first element of the node set.
      *
      * @param context evaluation context
      * @return Object
      */
     public abstract Object compute(EvalContext context);
 
     /**
      * Implemented by subclasses and result is cached by isContextDependent()
      *
      * @return calculated context-dependentness as boolean
      */
     public abstract boolean computeContextDependent();
 
     /**
      * Evaluates the expression. If the result is a node set, returns the first element of the node set.
      *
      * @param context evaluation context
      * @return Object
      */
     public abstract Object computeValue(EvalContext context);
 
     /**
      * Returns true if this expression should be re-evaluated each time the current position in the context changes.
      *
      * @return boolean
      */
     public synchronized boolean isContextDependent() {
         if (!contextDependencyKnown) {
             contextDependent = computeContextDependent();
             contextDependencyKnown = true;
         }
         return contextDependent;
     }
 
     /**
      * Iterate over the values from the specified context.
      *
      * @param context evaluation context
      * @return value Iterator
      */
     public Iterator iterate(final EvalContext context) {
         final Object result = compute(context);
         if (result instanceof EvalContext) {
             return new ValueIterator((EvalContext) result);
         }
         if (result instanceof NodeSet) {
             return new ValueIterator(((NodeSet) result).getPointers().iterator());
         }
         return ValueUtils.iterate(result);
     }
 
     /**
      * Iterate over the pointers from the specified context.
      *
      * @param context evaluation context
      * @return pointer Iterator
      */
     public Iterator iteratePointers(final EvalContext context) {
         final Object result = compute(context);
         if (result == null) {
             return Collections.EMPTY_LIST.iterator();
         }
         if (result instanceof EvalContext) {
             return (EvalContext) result;
         }
         if (result instanceof NodeSet) {
             return new PointerIterator(((NodeSet) result).getPointers().iterator(), new QName(null, "value"),
                     context.getRootContext().getCurrentNodePointer().getLocale());
         }
         return new PointerIterator(ValueUtils.iterate(result), new QName(null, "value"), context.getRootContext().getCurrentNodePointer().getLocale());
     }
 }