/*******************************************************************************
 * Copyright (c) 1998, 2012 Oracle and/or its affiliates. All rights reserved.
 * This program and the accompanying materials are made available under the 
 * terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0 
 * which accompanies this distribution. 
 * The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
 * and the Eclipse Distribution License is available at 
 * http://www.eclipse.org/org/documents/edl-v10.php.
 *
 * Contributors:
 *     Oracle - initial API and implementation from Oracle TopLink
 ******************************************************************************/  
package org.eclipse.persistence.sdo.helper;

import java.util.Date;
import java.util.Iterator;
import java.util.List;

import org.eclipse.persistence.oxm.XMLConstants;
import org.eclipse.persistence.sdo.SDOConstants;
import org.eclipse.persistence.sdo.SDODataObject;
import org.eclipse.persistence.exceptions.ConversionException;
import org.eclipse.persistence.exceptions.SDOException;
import org.eclipse.persistence.internal.oxm.XMLConversionManager;
import commonj.sdo.DataObject;
import commonj.sdo.Property;
import commonj.sdo.Sequence;
import commonj.sdo.helper.DataHelper;
import commonj.sdo.impl.HelperProvider;

/**
 * <p><b>Purpose</b>: Perform operations based on SDO XPath against DataObjects.
 * </p>
 */

public class XPathEngine {
    private static final int SET = 1;
    private static final int ISSET = 2;
    private static final int UNSET = 3;
    protected static XPathEngine defaultXPathEngine;

    private XPathEngine() {
    }

    public static XPathEngine getInstance() {
        if (defaultXPathEngine == null) {
            defaultXPathEngine = new XPathEngine();
        }
        return defaultXPathEngine;
    }

    /**Handle queries about setting status of a property through path base access.
     *
     * @param path      the String representation of path based access
     * @param caller    the DataObject that pass path information in
     * @return          true if queried property is set, otherwise false
     */
    public boolean isSet(String path, DataObject caller) {
        try {
            return processPath(path, null, caller, false, ISSET);
            // return lastDataObject.isSet(lastProperty);// spec. did not mention exception
        } catch (Exception e) {
            return false;// spec. did not mention exception
        }
    }

    /**Unset the value of a property through the path base access.
     *
     * @param path      the String representation of path based access
     * @param caller    the DataObject that pass path information in
     */
    public void unset(String path, DataObject caller) {        
        processPath(path, null, caller, false, UNSET);        
    }

    /**Set a property's value through the path base access.
     *
     * @param path      the String representation of path based access
     * @param value     the value to be set as the target property's value
     * @param caller    the DataObject that pass path information in
     * @param convertValue     boolean used for set if we should convert the value 
     */
    public void set(String path, Object value, DataObject caller, boolean convertValue) {
        processPath(path, value, caller, convertValue, SET);
    }

    /**When accessing values corresponding to properties of DataObject by path base accessors,
     * the accessed getters will pass informations to this method to process information and
     * acquire wanted values.
     *
     * @param path          the String representation of path based access
     * @param caller        the DataObject that pass path information in
     * @return              the value gotten by accessing through path
     */
    public Object get(String path, DataObject caller) {// path like "a/b/c"
        if ((path == null) || path.equals(SDOConstants.EMPTY_STRING)) {
            return null;
        }
        if (path.equals("..")) {
            return caller.getContainer();
        }
        if (path.equals(SDOConstants.SDO_XPATH_TO_ROOT)) {
            return ((SDODataObject)caller).getRootObject();
        }
        path = getLocalName(path);

        int index = path.indexOf('/');
        if (index > -1) {
            int openBracketIndex = path.indexOf('[');
            int closeBracketIndex = path.indexOf(']');
            if(index > openBracketIndex && index < closeBracketIndex) {
                return getValueForFragment(path, caller);
            }
            if (index == (path.length() - 1)) {
                return getValueForFragment(path.substring(0, index), caller);
            } else {
                Object value = getValueForFragment(path.substring(0, index), caller);
                DataObject currentDataObject = (DataObject) value;
                return get(path.substring(index + 1, path.length()), currentDataObject);
            }
        }
        return getValueForFragment(path, caller);
    }
    
        /**extract wanted fragment from the string representation of path and pass processed result to
     * method setIsSetUnSet for further operation.
     *
     * @param path      the String representation of path based access
     * @param value     the value to be set as the target property's value
     * @param caller    the DataObject that pass path information in
     * @param convertValue     boolean used for set if we should convert the value
     * @param _case     an int value indicating what kind of operation to use: set, isset or unset.
     * @return          true if operation is isset and property's value is set, otherwise false.
     */
    private boolean processPath(String path, Object value, DataObject caller, boolean convertValue, int _case) {
        path = getLocalName(path);
        int lastSlashIndex = path.lastIndexOf('/');
        String frag;
        if (-1 < lastSlashIndex) {// case 1: a/b/c
            frag = path.substring(lastSlashIndex + 1);
            return setIsSetUnSet(frag, path, caller, value, lastSlashIndex, convertValue, _case);
        } else {// case 2 : "a"
            frag = path;
            return setIsSetUnSet(frag, path, caller, value, lastSlashIndex, convertValue, _case);
        }
    }  

    /**According to the requirement, correspondingly perform isset, unset or set function.
     *
     * @param frag              one string fragment in the path
     * @param path              the String representation of path based access
     * @param caller            the DataObject that pass path information in
     * @param value             the value to be set as the target property's value
     * @param lastSlashIndex    the last index of '/' in the path string
     * @param convertValue     boolean used for set if we should convert the value
     * @param _case             an int value indicating what kind of operation to use: set, isset or unset.
     * @return                  true if operation is isset and property's value is set, otherwise false.
     */
    private boolean setIsSetUnSet(String frag, String path, DataObject caller, Object value, int lastSlashIndex, boolean convertValue, int _case) {
        int indexOfDot = frag.lastIndexOf('.');
        int indexOfOpenBracket = frag.lastIndexOf('[');
        int indexOfCloseBracket = frag.lastIndexOf(']');
        int numInLastProperty = getNumberInFrag(frag, indexOfDot, indexOfOpenBracket, indexOfCloseBracket);
        String lastPropertyName = getPropertyNameInFrag(frag, numInLastProperty, indexOfDot, indexOfOpenBracket);// get last property name on path for case 1
        DataObject lastDataObject;
        if (-1 < lastSlashIndex) {
            Object lastObject = get(path.substring(0, lastSlashIndex), caller);// get last dataobject on path
            // If trying to access a list element from a null list, this object will be
            // an instance of ListWrapper, not DataObject, but the error message is the same
            // as if it was a null DataObject
            if (lastObject == null || lastObject instanceof ListWrapper) {
                throw SDOException.cannotPerformOperationOnProperty(lastPropertyName, path);
            }
            lastDataObject = (SDODataObject) lastObject;
        } else {
            lastDataObject = caller;
        }
        Property lastProperty = lastDataObject.getInstanceProperty(lastPropertyName);// get property of this dataobject
        
        switch (_case) {
        case SET:                        
            if (lastProperty == null) {
                lastProperty = ((SDODataObject)lastDataObject).defineOpenContentProperty(lastPropertyName, value);
            }if(lastProperty != null){
              set(lastProperty, lastDataObject, numInLastProperty, value,convertValue);
            }
            return false;
        case ISSET:
            if(lastProperty == null){
             return false; 
            }
            return isSet(lastProperty, lastDataObject);
        case UNSET:
            if(lastProperty == null){
             return false; 
            }
            unSet(lastProperty, lastDataObject, numInLastProperty);
            return false;
        default:
            return false;
        }
    }

    /** Method that returns whether a property is set.
     *
     * @param lastProperty      the property to queries.
     * @param lastDataObject    the DataObject, owner of the queried property
     * @return      return true, if property's value is set, otherwise false.
     */
    private boolean isSet(Property lastProperty, DataObject lastDataObject) {
        return lastDataObject.isSet(lastProperty);
    }

    /** Method that unset a certain property's value.
     *
     * @param lastProperty      the property to queries.
     * @param lastDataObject    the DataObject, owner of the queried property
     */
    private void unSet(Property lastProperty, DataObject lastDataObject, int numInLastProperty) {
        if (numInLastProperty == -1) {
            lastDataObject.unset(lastProperty);
        } else {
            List objects = lastDataObject.getList(lastProperty);
            if (numInLastProperty <= objects.size()) {
                objects.remove(numInLastProperty);
            }
        }
    }

    /** Set a property's value.
     *
     * @param lastProperty      the property to queries.
     * @param lastDataObject    the DataObject, owner of the queried property
     * @param numInLastProperty the index number in the value list of the above property
     * @param value             the value to be set as the target property's value
     * @param convertValue     boolean used for set if we should convert the value 
     */
    private void set(Property lastProperty, DataObject lastDataObject, int numInLastProperty, Object value, boolean convertValue) {
        if (numInLastProperty == -1) {
            if (lastDataObject != null) {
                if(convertValue){
                  DataHelper dataHelper = ((SDODataObject)lastDataObject).getType().getHelperContext().getDataHelper(); 
                  value = dataHelper.convert(lastProperty, value);
                }
                lastDataObject.set(lastProperty, value);
            } else {
                throw new IllegalArgumentException("lastDataObject is null");
            }
        } else {// case like set("a/b.1", List) will cause a list be added into a existed list
            List objects = lastDataObject.getList(lastProperty);

            if (convertValue) {
                DataHelper dataHelper = ((SDODataObject)lastDataObject).getType().getHelperContext().getDataHelper(); 
                value =  dataHelper.convert(lastProperty.getType(), value);
            }
            
            Sequence seq = lastDataObject.getSequence();
            if (seq != null) {
                seq.setValue(numInLastProperty, value);
            } else {
                objects.set(numInLastProperty, value);
            }
        }
    }

    private String getLocalName(String qualifiedName) {
        int index = qualifiedName.indexOf(':');
        if (index > -1) {
            int bracketIndex = qualifiedName.indexOf('[');
            if(bracketIndex > -1 && bracketIndex < index) {
                return qualifiedName;
            }
            String local = qualifiedName.substring(index + 1, qualifiedName.length());
            return local;
        } else {
            return qualifiedName;
        }
    }

    /** Process the passed in fragment, extract the position information if available,
     *  acquire the property name hidden in this fragment and check if this fragment is
     *  actually query base. Then perform corresponding actions to access values.
     *
     * @param frag      one string fragment in the path
     * @param caller    a DataObject that originally took the path information
     * @return          values to be accessed
     */
    private Object getValueForFragment(String frag, DataObject caller) {
        int indexOfDot = frag.lastIndexOf('.');
        int indexOfOpenBracket = frag.indexOf('[');
        int indexOfCloseBracket = frag.lastIndexOf(']');
        int position = getNumberInFrag(frag, indexOfDot, indexOfOpenBracket, indexOfCloseBracket);
        String propertyName = getPropertyNameInFrag(frag, position, indexOfDot, indexOfOpenBracket);
        int equalSignIndex = isQueryPath(frag, indexOfOpenBracket, indexOfCloseBracket);
        if (equalSignIndex == -1) {// not query path, note:
            return getObjectByFragment(propertyName, position, caller);
        }
        return getDataObjectFromQuery(frag, indexOfOpenBracket, indexOfCloseBracket, equalSignIndex, caller, propertyName);
    }

    /** Extract the property name hidden in a fragment of path
     *
     * @param frag          one string fragment in the path
     * @param position      the index of values to be accessed
     * @param indexOfDot    the index of . in the fragment
     * @param indexOfOpenBracket    the indexof [ in the fragment
     * @return              the property name hidden in this fragment
     */
    private String getPropertyNameInFrag(String frag, int position, int indexOfDot, int indexOfOpenBracket) {
        int startIndex = 0;
        int atIndex = frag.indexOf('@');
        if (atIndex != -1 && (indexOfOpenBracket == -1 || atIndex < indexOfOpenBracket)) {
            startIndex += 1;
        }
        if (indexOfOpenBracket != -1) {
            return frag.substring(startIndex, indexOfOpenBracket);
        }
        if ((indexOfDot != -1) && (position != -1)) {
            return frag.substring(startIndex, indexOfDot);
        }
        return frag.substring(startIndex);
    }

    /** Judge if positional path belongs to bracket case or dot case, then perform
     * different actions.
     *
     * @param frag                  one string fragment in the path
     * @param indexOfDot            the index of . in the fragment
     * @param indexOfOpenBracket    the index of [ in the fragment
     * @param indexOfCloseBracket   the index of ] in the fragment
     * @return      the position hidden in fragment
     */
    private int getNumberInFrag(String frag, int indexOfDot, int indexOfOpenBracket, int indexOfCloseBracket) {
        if ((indexOfOpenBracket != -1) && (indexOfCloseBracket != -1) && (indexOfOpenBracket < indexOfCloseBracket)) {
            return acquireNumberInBrackets(frag, indexOfOpenBracket, indexOfCloseBracket);
        }
        if (indexOfDot != -1) {
            return acquireNumberAtDot(frag, indexOfDot);
        }
        return -1;
    }

    /**check if information in brackets is qury or not.
     *
     * @param frag                 a fragment in path
     * @param openBracketIndex     index of open bracket in fragment
     * @param closeBracketIndex    index of close bracket in fragment
     * @return
     */
    private int isQueryPath(String frag, int openBracketIndex, int closeBracketIndex) {
        if ((openBracketIndex != -1) && (closeBracketIndex != -1) && (openBracketIndex < closeBracketIndex)) {
            return frag.substring(openBracketIndex, closeBracketIndex).indexOf('=');
        }
        return -1;
    }

    // extract value from query and acquire dataobject that meets this requirement

    /**Access the DataObject value by using the fragment containing query informations.
     *
     * @param frag                  one string fragment in the path
     * @param openBracketIndex      the index of open bracket in a fragment
     * @param closeBracketIndex     the index of close bracket in a fragment
     * @param equalsignIndex        the index of equalsign in string fragment quoted by brackets
     * @param caller                the DataObject that passes the path information in
     * @param callerProperty        the name of the property
     * @return                      the DataObject as value of the property having name as the above callerProperty
     */
    private DataObject getDataObjectFromQuery(String frag, int openBracketIndex, int closeBracketIndex, int equalsignIndex, DataObject caller, String callerProperty) {
        try {
            // trim off any whitespace for property names
            String propertyNameOfQryDataObject = frag.substring(openBracketIndex + 1, equalsignIndex + openBracketIndex).trim();            
            List objects = caller.getList(caller.getInstanceProperty(callerProperty));
            String query = frag.substring(equalsignIndex + openBracketIndex + 1, closeBracketIndex);
            String value = null;
            int firstQuoteIndex = query.indexOf('\'');
            int lastQuoteIndex = query.lastIndexOf('\'');
            if ((firstQuoteIndex == -1) && (lastQuoteIndex == -1)) {// !! note: case: [number=1'23'] is assume not to happen !!
                firstQuoteIndex = query.indexOf("\"");
                lastQuoteIndex = query.lastIndexOf("\"");
            }
            if ((firstQuoteIndex != -1) && (lastQuoteIndex != -1) && (firstQuoteIndex < lastQuoteIndex)) {// quoted string existed
                value = query.substring(firstQuoteIndex + 1, lastQuoteIndex);
            } else {
                // if the value is not enclosed on quotes, trim off any whitespace
                value = query.trim();
            }
            Iterator iterObjects = objects.iterator();
            Object queryValue = value;
            Object actualValue = null;
            while (iterObjects.hasNext()) {
                DataObject cur = (DataObject)iterObjects.next();
                Property p = cur.getInstanceProperty(propertyNameOfQryDataObject);
                if(p != null){
                  try {
                      queryValue = XMLConversionManager.getDefaultXMLManager().convertObject(queryValue, p.getType().getInstanceClass());
                  } catch (ConversionException e) {
                      //do nothing, skip
                  }
  
                  if (!p.isMany()) {
                      actualValue = cur.get(p);
                      if (actualValue.equals(queryValue)) {
                          return cur;
                      }
                  } else {// case p is many type
                      List values = cur.getList(p);
                      Iterator iterValues = values.iterator();
  
                      while (iterValues.hasNext()) {
                          actualValue = iterValues.next();
                          if (actualValue.equals(queryValue)) {
                              return cur;
                          }
                      }
                  }
                }
            }

            return null;
        } catch (IllegalArgumentException e) {
            return null;
        }
    }

    // process a portion of path, find out if it is positional or not.
    // if it is, then check it is using '.' or '[ ]' and perform corresponding
    // process.

    /** Check if position exists, then either acquire value through position or directly.
     *
     * @param propertyName      the name of property of the caller
     * @param position          the index of values to be accessed
     * @param caller            the DataObject containing property with the passed in property name
     * @return                  the values to be accessed
     */
    private Object getObjectByFragment(String propertyName, int position, DataObject caller) {
        Property prop = caller.getInstanceProperty(propertyName);
        if (prop == null){
          return null;
        }
        
        if (prop.isMany() && position > -1) {
            return caller.getList(prop).get(position);
        } else {
            return caller.get(prop);        	
        }
    }

    /** Extract position (index) from a bracket fragment of path
     *
     * @param frag               a fragment of path
     * @param openBracketIndex   the index of [ in path
     * @param closeBracketIndex  the index of ] in path
     * @return                   the index hidden in fragment
     */
    private int acquireNumberInBrackets(String frag, int openBracketIndex, int closeBracketIndex) {
        String number = frag.substring(openBracketIndex + 1, closeBracketIndex);

        if (number.matches("[1-9][0-9]*")) {
            return Integer.parseInt(number) - 1;
            //value = number;
        }
        return -1;// throw Illegal path?
    }

    /**Extract the position (index) from a dot fragment of path
     *
     * @param frag      a fragment of path
     * @param dotIndex  the index of . in path
     * @return          the index hidden in the fragment
     */
    private int acquireNumberAtDot(String frag, int dotIndex) {
        int value = -1;
        String position = frag.substring(dotIndex + 1);
        if (position.matches("[0-9]+")) {
            value = Integer.parseInt(position);
            //value = position;
        }
        return value;
    }

    // dataobject a's property a has value dataobject b, dataobject b's property b has value dataobject c,
    //dataobject c's property c has value boolean,

    /** access the wanted values through path and convert it into required java class.
     * If conversion is not supported, exception is thrown.
     *
     * @param path      string representation of accessing path
     * @param cls       the java class that accessed value is to be converted to
     * @param caller    the DataObject that pass the path in
     * @return          values to be accessed
     * @throws ClassCastException
     */
    public Object convertObjectToValueByPath(String path, Class cls, DataObject caller) throws ClassCastException {
        if (null == path || XMLConstants.EMPTY_STRING.equals(path)) {
            throw new ClassCastException("Attempting null value conversion.");
        }
        try {
            int lastSlashIndex = path.lastIndexOf('/');
            SDODataObject lastDataObject;
            String lastPropertyName;
            Property lastProperty;
            int numInLastProperty = -1;

            // to do: if "/" or ".." lastDataObject = container or root
            if (-1 < lastSlashIndex) {// case 1 "a/b/c"
                String frag = path.substring(lastSlashIndex + 1);
                int indexOfDot = frag.lastIndexOf('.');
                int indexOfOpenBracket = frag.lastIndexOf('[');
                int indexOfCloseBracket = frag.lastIndexOf(']');
                numInLastProperty = getNumberInFrag(frag, indexOfDot, indexOfOpenBracket, indexOfCloseBracket);
                lastPropertyName = getPropertyNameInFrag(frag, numInLastProperty, indexOfDot, indexOfOpenBracket);//getPropertyNameFromFragment(path.substring(lastSlashIndex + 1));// get last property name on path for case 1
                lastDataObject = (SDODataObject)caller.getDataObject(path.substring(0, lastSlashIndex));// get last dataobject on path
                if(lastDataObject == null){
                  return null;
                }
                lastProperty = lastDataObject.getInstanceProperty(lastPropertyName);// get property of this dataobject
            } else {// case 2 "a"
                //to do: call eextractPositionAndPropertyName() here
                String frag = path;
                int indexOfDot = frag.lastIndexOf('.');
                int indexOfOpenBracket = frag.lastIndexOf('[');
                int indexOfCloseBracket = frag.lastIndexOf(']');
                numInLastProperty = getNumberInFrag(frag, indexOfDot, indexOfOpenBracket, indexOfCloseBracket);
                lastPropertyName = getPropertyNameInFrag(frag, numInLastProperty, indexOfDot, indexOfOpenBracket);//getPropertyNameFromFragment(path);// get last property name on path for case 1
                lastDataObject = (SDODataObject)caller;
                if(lastDataObject == null){
                  return null;
                }
                lastProperty = caller.getInstanceProperty(lastPropertyName);// get property of this dataobject
            }

            if ((lastProperty != null) && (cls == Date.class) && lastProperty.getType().equals(SDOConstants.SDO_STRING)) {// in case getDate, for string property, use DataHelper
                DataHelper dHelper = HelperProvider.getDefaultContext().getDataHelper();
                String dateString;
                if (numInLastProperty == -1) {
                    dateString = (String)lastDataObject.get(lastProperty);
                } else {
                    dateString = (String)(lastDataObject.getList(lastProperty)).get(numInLastProperty);
                }
                return dHelper.toDate(dateString);
            }
            return lastDataObject.convertObjectToValue(lastProperty, numInLastProperty, cls);
        } catch (IllegalArgumentException e) {// according to exception table 1st row, when get(Property) and get(Index) throw IllegalArgument, get(String) return null
            throw new ClassCastException("Conversion is not supported.");
            //return null;
        }
    }
}
