/*
 *  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.
 *
 */

/*
 *                        AT&T - PROPRIETARY
 *          THIS FILE CONTAINS PROPRIETARY INFORMATION OF
 *        AT&T AND IS NOT TO BE DISCLOSED OR USED EXCEPT IN
 *             ACCORDANCE WITH APPLICABLE AGREEMENTS.
 *
 *          Copyright (c) 2013 AT&T Knowledge Ventures
 *              Unpublished and Not for Publication
 *                     All Rights Reserved
 */
package org.apache.openaz.xacml.std.json;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.StringWriter;
import java.io.UnsupportedEncodingException;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.math.BigInteger;
import java.net.URI;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import javax.security.auth.x500.X500Principal;
import javax.xml.XMLConstants;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;

import org.apache.commons.codec.binary.Base64;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.openaz.xacml.api.Attribute;
import org.apache.openaz.xacml.api.AttributeValue;
import org.apache.openaz.xacml.api.DataType;
import org.apache.openaz.xacml.api.DataTypeFactory;
import org.apache.openaz.xacml.api.Identifier;
import org.apache.openaz.xacml.api.Request;
import org.apache.openaz.xacml.api.RequestAttributes;
import org.apache.openaz.xacml.api.RequestAttributesReference;
import org.apache.openaz.xacml.api.RequestReference;
import org.apache.openaz.xacml.api.SemanticString;
import org.apache.openaz.xacml.api.XACML3;
import org.apache.openaz.xacml.std.IdentifierImpl;
import org.apache.openaz.xacml.std.StdAttribute;
import org.apache.openaz.xacml.std.StdAttributeValue;
import org.apache.openaz.xacml.std.StdMutableRequest;
import org.apache.openaz.xacml.std.StdMutableRequestAttributes;
import org.apache.openaz.xacml.std.StdMutableRequestReference;
import org.apache.openaz.xacml.std.StdRequest;
import org.apache.openaz.xacml.std.StdRequestAttributesReference;
import org.apache.openaz.xacml.std.StdRequestDefaults;
import org.apache.openaz.xacml.std.datatypes.DataTypes;
import org.apache.openaz.xacml.std.datatypes.ExtendedNamespaceContext;
import org.apache.openaz.xacml.std.datatypes.StringNamespaceContext;
import org.apache.openaz.xacml.std.datatypes.XPathExpressionWrapper;
import org.apache.openaz.xacml.std.dom.DOMUtil;
import org.apache.openaz.xacml.util.FactoryException;
import org.w3c.dom.Document;
import org.w3c.dom.Node;

import com.fasterxml.jackson.annotation.JsonAutoDetect.Visibility;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.core.JsonLocation;
import com.fasterxml.jackson.core.JsonParseException;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;

/**
 * JSONRequest is used to convert JSON into {@link org.apache.openaz.xacml.api.Request} objects. Instances are
 * only generated by loading a file, string, or InputStream representing the Request.
 */
public class JSONRequest {
    private static final Log logger = LogFactory.getLog(JSONRequest.class);

    /*
     * Map of Data Type Identifiers used to map shorthand notation for DataTypes into the full Identifer. This
     * is loaded the first time a Request is processed. Loading is done using Reflection. The map contains
     * keys for both the short form and the long form of each DataType. For example both of the following are
     * in the table: http://www.w3.org/2001/XMLSchema#base64Binary =
     * http://www.w3.org/2001/XMLSchema#base64Binary base64Binary =
     * http://www.w3.org/2001/XMLSchema#base64Binary (Note difference in structure and usage from
     * JSONResponse.)
     */
    private static Map<String, Identifier> shorthandMap = null;

    /*
     * To check the individual data attributes for being the correct type, we need an instance of the
     * DataTypeFactory
     */
    private static DataTypeFactory dataTypeFactory = null;

    /*
     * Prevent creation of instances - this class contains only static methods that return other object types.
     */
    protected JSONRequest() {
    }

    //
    // HELPER METHODS used in Parsing
    //

    /**
     * Allow both JSON boolean and Strings containing JSON booleans. If value is null, assume it is optional
     * and just return null. If Boolean, return same value. If String, note in log that it was string and
     * return converted value. Otherwise throw exception.
     *
     * @param value
     * @param location
     * @return
     * @throws JSONStructureException
     */
    private static Boolean makeBoolean(Object value, String location) throws JSONStructureException {
        if (value == null || value instanceof Boolean) {
            return (Boolean)value;
        }
        try {
            Boolean b = DataTypes.DT_BOOLEAN.convert(value);
            logger.warn(location + " has string containing boolean, should be unquoted boolean value");
            return b;
        } catch (Exception e) {
            throw new JSONStructureException(location + " must be Boolean");
        }
    }

    /**
     * Check the given map for all components having been removed (i.e. everything in the map was known and
     * used). If anything remains, throw an exception based on the component and the keys left in the map
     */
    private static void checkUnknown(String component, Map<?, ?> map) throws JSONStructureException {
        if (map.size() == 0) {
            return;
        }

        String keys = null;
        Iterator<?> it = map.keySet().iterator();
        while (it.hasNext()) {
            if (keys == null) {
                keys = "'" + it.next().toString() + "'";
            } else {
                keys += ", '" + it.next().toString() + "'";
            }
        }

        String message = component + " contains unknown element" + ((map.size() == 1) ? " " : "s ") + keys;
        throw new JSONStructureException(message);
    }

    /**
     * Convert a JSON representation of an XPathExpression into the internal objects. XPathExpression is the
     * only DataType that has a complex multi-part description. It includes - XPathCategory - required - XPath
     * - required - Namespaces - optional; a list of complex structures
     *
     * @param valueMap
     * @return
     * @throws JSONStructureException
     */
    private static AttributeValue<Object> convertXPathExpressionMapToAttributeValue(Map<?, ?> valueMap)
        throws JSONStructureException {
        // get required elements
        Object xpathCategoryObject = valueMap.remove("XPathCategory");
        Object xpathObject = valueMap.remove("XPath");
        if (!(xpathCategoryObject instanceof String) || !(xpathObject instanceof String)) {
            throw new JSONStructureException("XpathCategory and XPath must both be strings");
        }
        String xpathCategoryString = (String)xpathCategoryObject;
        String xpathString = (String)xpathObject;
        if (xpathCategoryString == null || xpathCategoryString.length() == 0 || xpathString == null
            || xpathString.length() == 0) {
            throw new JSONStructureException("XPathCategory or XPath missing or 0-length");
        }

        Identifier xpathCategoryId = new IdentifierImpl(xpathCategoryString);

        // get the Namespaces, if any.
        // Use StringNamespaceContext because we need to use the add functions to incrementally add the
        // namespaces
        StringNamespaceContext namespaceContext = null;

        Object namespacesObject = valueMap.remove("Namespaces");
        if (namespacesObject != null) {
            if (!(namespacesObject instanceof List)) {
                throw new JSONStructureException("Namespaces must be an array");
            }
            List<?> namespacesList = (List<?>)namespacesObject;

            if (namespacesList.size() > 0) {
                // create a NamespaceContext object to hold the namespaces
                namespaceContext = new StringNamespaceContext();

                for (Object n : namespacesList) {
                    if (!(n instanceof Map)) {
                        throw new JSONStructureException("Namespace within Namespaces array must be object");
                    }
                    Map<?, ?> namespaceMap = (Map<?, ?>)n;

                    Object namespaceObject = namespaceMap.remove("Namespace");
                    if (namespaceObject == null || !(namespaceObject instanceof String)) {
                        throw new JSONStructureException(
                                                         "Namespace object within Namespaces array must contain Namespace string member");
                    }

                    Object prefixObject = namespaceMap.remove("Prefix");
                    if (prefixObject != null && !(prefixObject instanceof String)) {
                        throw new JSONStructureException(
                                                         "Namespace object within Namespaces array Prefix must be string");
                    }

                    checkUnknown("Namespaces item", namespaceMap);

                    // add this namespace to the NamespaceContext
                    try {
                        namespaceContext.add((String)prefixObject, (String)namespaceObject);
                    } catch (Exception e) {
                        throw new JSONStructureException("Unable to add namespace prefix='" + prefixObject
                                                         + "' URI='" + namespaceObject + "'");
                    }
                }
            }
        }

        // create the XPathExpressionWrapper to contain this value
        XPathExpressionWrapper xpathExpressionWrapper = new XPathExpressionWrapper(namespaceContext,
                                                                                   xpathString);

        AttributeValue<Object> attributeValue = new StdAttributeValue<Object>(
                                                                              DataTypes.DT_XPATHEXPRESSION
                                                                                  .getId(),
                                                                              xpathExpressionWrapper,
                                                                              xpathCategoryId);

        checkUnknown("XPathExpression", valueMap);

        return attributeValue;
    }

    /**
     * Use reflection to load the map with all the names of all DataTypes, both the long name and the
     * shorthand, and point each name to the appropriate Identifier. The shorthand map is used differently in
     * JSONRequest than in JSONResponse, so there are similarities and differences in the implementation. This
     * is done once the first time a Request is processed.
     */
    private static void initShorthandMap() throws JSONStructureException {
        Field[] declaredFields = XACML3.class.getDeclaredFields();
        shorthandMap = new HashMap<String, Identifier>();
        for (Field field : declaredFields) {
            if (Modifier.isStatic(field.getModifiers()) && field.getName().startsWith("ID_DATATYPE")
                && Modifier.isPublic(field.getModifiers())) {
                try {
                    Identifier id = (Identifier)field.get(null);
                    String longName = id.stringValue();
                    // most names start with 'http://www.w3.org/2001/XMLSchema#'
                    int sharpIndex = longName.lastIndexOf("#");
                    if (sharpIndex <= 0) {
                        // some names start with 'urn:oasis:names:tc:xacml:1.0:data-type:'
                        // or urn:oasis:names:tc:xacml:2.0:data-type:
                        if (longName.contains(":data-type:")) {
                            sharpIndex = longName.lastIndexOf(":");
                        } else {
                            continue;
                        }
                    }
                    String shortName = longName.substring(sharpIndex + 1);
                    // put both the full name and the short name in the table
                    shorthandMap.put(longName, id);
                    shorthandMap.put(shortName, id);
                } catch (Exception e) {
                    throw new JSONStructureException("Error loading ID Table, e=" + e);
                }
            }
        }
    }

    //
    // MAIN PARSING CODE
    //

    /**
     * Handle a List of Attributes for a Category
     *
     * @param categoryID
     * @param attributes
     * @param stdMutableRequest
     * @throws JSONStructureException
     */
    private static List<Attribute> parseAttribute(Identifier categoryID, ArrayList<?> attributes)
        throws JSONStructureException {
        Iterator<?> iterAttributes = attributes.iterator();

        List<Attribute> collectedAttributes = new ArrayList<Attribute>();

        while (iterAttributes.hasNext()) {
            Map<?, ?> attributeMap = (Map<?, ?>)iterAttributes.next();
            if (!(attributeMap instanceof Map)) {
                throw new JSONStructureException("Expect Attribute content to be Map got "
                                                 + attributeMap.getClass());
            }
            Attribute attribute = parseAttribute(categoryID, attributeMap);
            collectedAttributes.add(attribute);
        }

        // return list of all attributes for this Category
        return collectedAttributes;
    }

    /**
     * Given the map of the parsed JSON representation of an Attribute, create the Attribute from the map.
     *
     * @param categoryID
     * @param attributeMap
     * @param stdMutableRequest
     * @return
     * @throws JSONStructureException
     */
    private static Attribute parseAttribute(Identifier categoryID, Map<?, ?> attributeMap)
        throws JSONStructureException {

        // TODO - ASSUME that the spec will remove the requirement that we MUST "handle" JavaScript special
        // values NaN, INF, -INF, none of which make sense on this interface.

        // TODO - ASSUME that the spec will fix inconsistency between AttributeId and Id (both are mentioned),
        // but we have code using both so allow both on input.
        Object idString = attributeMap.remove("AttributeId");
        if (idString == null) {
            //
            // This is an annoying message, and since we have PEP's that already use it
            // make this a debugging message. Otherwise it will clog our log file.
            //
            if (logger.isDebugEnabled()) {
                logger.debug("Attribute missing AttributeId, looking for Id");
            }
            idString = attributeMap.remove("Id");
            if (idString == null) {
                throw new JSONStructureException("Attribute missing AttributeId (and Id)");
            }
        } else {
            // we have the AttributeId - should not also have Id
            if (attributeMap.remove("Id") != null) {
                throw new JSONStructureException("Found both AttributeId '" + idString
                                                 + "' and Id field.  Please use only AttributeId.");
            }
        }
        if (!(idString instanceof String)) {
            throw new JSONStructureException("AttributeId must be String, got " + idString.getClass());
        }
        Identifier id = new IdentifierImpl(idString.toString());

        Object Value = attributeMap.remove("Value");
        if (Value == null) {
            throw new JSONStructureException("Attribute missing Value");
        }

        String Issuer = (String)attributeMap.remove("Issuer");

        Object includeInResultObject = attributeMap.remove("IncludeInResult");
        Boolean includeInResult = makeBoolean(includeInResultObject, "IncludeInResult");
        if (includeInResult == null) {
            includeInResult = Boolean.FALSE;
        }

        //
        // Data Type is complicated because:
        // - it may use shorthand (e.g. "integer" instead of full Id)
        // - it may be missing and have to be inferred
        // - inference on Arrays of values is tricky
        // - arrays must all use the same DataType
        // - we are limited in the data types that the Jackson parser is able to infer
        //
        Object DataType = attributeMap.remove("DataType");
        if (DataType != null && !(DataType instanceof String)) {
            throw new JSONStructureException("DataType must be String, got " + DataType.getClass());
        }
        // get Identifier for either long-form or shorthand notation of DataType
        String dataTypeString = null;
        if (DataType != null) {
            dataTypeString = DataType.toString();
        }
        Identifier dataTypeId = shorthandMap.get(dataTypeString);

        // check for unknown DataType
        if (DataType != null && dataTypeId == null) {
            // attribute contained a DataType but it was not known
            throw new JSONStructureException("Unknown DataType '" + dataTypeString + "'");
        }

        // At this point the dataTypeId may be null if no explicit DataType was given.
        // In that case we need to infer the data type from the value object.
        // The best we can do is infer based on the JSON data type, so we recognize boolean, integer, and
        // double, and everything else is handled as a string.
        // Unfortunately the value may be an array of values, so we need to look at all of them before making
        // a decision.
        // The algorithm for arrays is:
        // - take the dataType of the first element in the array as the array's data type
        // - if the array is of type Integer and we see a Double, make the array be Double.
        // Try to determine the over-all type for the list based on the contents.
        // The only mixing that is allowed is Integers and Doubles, in which case the list is Double

        // Values are converted to the current DataType wherever possible.
        // This includes converting doubles, integers and booleans into Strings if the DataType is String.
        // Auto-conversions generate warning messages to the logger.

        // TODO - ASSUME that we need to infer data type for array if not given. Spec is inconsistent on this
        // point, but author seems to want to do it.
        // TODO - Also ASSUME that
        // - everything other than JSON integer, double and boolean is handled as a string, and
        // - the only mixture of data types allowed within the same array is integer and double, yielding the
        // DataType for the array = Double, and
        // - an array of the same JSON data type has the same data type; for strings this means type=string
        // irrespective of what the strings represent (e.g. Date, URI, etc).

        if (Value instanceof List) {
            List<?> valueList = (List<?>)Value;
            // if nothing in the list then we don't care about the type
            if (valueList.size() > 0) {
                Identifier inferredDataTypeId = null;
                if (dataTypeId == null) {
                    // DataType was not given in Attribute - must infer it
                    for (Object item : (List<?>)Value) {
                        // figure out what data type to use for this array
                        if (inferredDataTypeId == null) {
                            // first item, need to set provisional inferred data type
                            if (item instanceof Boolean) {
                                inferredDataTypeId = DataTypes.DT_BOOLEAN.getId();
                            } else if (item instanceof Integer) {
                                inferredDataTypeId = DataTypes.DT_INTEGER.getId();
                            } else if (item instanceof Double) {
                                inferredDataTypeId = DataTypes.DT_DOUBLE.getId();
                            } else {
                                inferredDataTypeId = DataTypes.DT_STRING.getId();
                            }

                        } else if (inferredDataTypeId.equals(DataTypes.DT_INTEGER.getId())
                            && item instanceof Double) {
                            // special case - Double seen in Integer list means whole list is really
                            // Double
                            inferredDataTypeId = DataTypes.DT_DOUBLE.getId();
                        }
                    }
                    // we have inferred a data type for the whole array
                    dataTypeId = inferredDataTypeId;

                }
            }
        } else {
            // single-value attribute
            if (dataTypeId == null) {
                // single value with no DataType defined - Infer the XACML DataType for JSON data types
                if (Value instanceof Integer) {
                    dataTypeId = DataTypes.DT_INTEGER.getId();
                } else if (Value instanceof Double) {
                    dataTypeId = DataTypes.DT_DOUBLE.getId();
                } else if (Value instanceof Boolean) {
                    dataTypeId = DataTypes.DT_BOOLEAN.getId();
                } else {
                    // the Default DataType if none is given is String
                    dataTypeId = DataTypes.DT_STRING.getId();
                }
            }
            // all other data types are not explicitly checked for compatibility
        }

        // we now have the DataType to convert the values into.

        // create a single Attribute to return (it may contain multiple AttributeValues)
        Attribute attribute = null;

        DataType<?> dataType = dataTypeFactory.getDataType(dataTypeId);

        // Variable to use for reporting errors
        Object incomingValue = null;
        try {
            if (Value instanceof List) {
                // this attribute has a list of values
                List<AttributeValue<?>> attributeValueList = new ArrayList<AttributeValue<?>>();
                for (Object o : (List<?>)Value) {
                    // for error reporting we make a copy visible to the Catch clause
                    incomingValue = o;
                    AttributeValue<Object> attributeValue;
                    if (dataType.getId().equals(DataTypes.DT_XPATHEXPRESSION.getId())) {
                        if (!(o instanceof Map)) {
                            throw new JSONStructureException(
                                                             "XPathExpression must contain object, not simple value");
                        }
                        attributeValue = convertXPathExpressionMapToAttributeValue((Map<?, ?>)o);
                    } else {
                        Object convertedValue = dataType.convert(o);
                        attributeValue = new StdAttributeValue<Object>(dataTypeId, convertedValue);
                        if ((convertedValue instanceof Integer || convertedValue instanceof Boolean || convertedValue instanceof Double) && o instanceof String
                            || convertedValue instanceof Double && o instanceof Integer
                            || convertedValue instanceof String && (o instanceof Integer
                                                                     || o instanceof Boolean || o instanceof Double)) {
                            // we converted a String to something else
                            logger.warn("Attribute Id '" + id.stringValue() + "' Value '" + incomingValue
                                        + "' in Array auto-converted from '" + o.getClass().getName()
                                        + "' to type '" + dataType.getId().stringValue());
                        }
                    }
                    attributeValueList.add(attributeValue);
                }
                attribute = new StdAttribute(categoryID, id, attributeValueList, Issuer, includeInResult);
            } else {
                // for error reporting we make a copy visible to the Catch clause
                incomingValue = Value;
                // this attribute has a single value
                AttributeValue<Object> attributeValue;
                if (dataType.getId().equals(DataTypes.DT_XPATHEXPRESSION.getId())) {
                    if (!(Value instanceof Map)) {
                        throw new JSONStructureException(
                                                         "XPathExpression must contain object, not simple value");
                    }
                    attributeValue = convertXPathExpressionMapToAttributeValue((Map<?, ?>)Value);
                } else {
                    Object convertedValue = dataType.convert(Value);
                    attributeValue = new StdAttributeValue<Object>(dataTypeId, convertedValue);
                    // some auto-conversions should be logged because they shouldn't be necessary
                    if ((convertedValue instanceof BigInteger || convertedValue instanceof Boolean || convertedValue instanceof Double) && Value instanceof String
                        || convertedValue instanceof Double && Value instanceof Integer
                        || convertedValue instanceof String && (Value instanceof Integer
                                                                 || Value instanceof Boolean || Value instanceof Double)) {
                        // we converted a String to something else
                        logger.warn("Attribute Id '" + id.stringValue() + "' Value '" + incomingValue
                                    + "' auto-converted from '" + Value.getClass().getName() + "' to type '"
                                    + dataType.getId().stringValue());
                    }
                }
                attribute = new StdAttribute(categoryID, id, attributeValue, Issuer, includeInResult);
            }
        } catch (Exception e) {
            throw new JSONStructureException("In Id='" + id.stringValue()
                                             + "' Unable to convert Attribute Value '" + incomingValue
                                             + "' to type '" + dataTypeId.stringValue() + "'");
        }

        checkUnknown(id.stringValue() + "Attribute '" + idString.toString() + "'", attributeMap);

        return attribute;
    }

    /**
     * Convert the contents of a Content element from XML into XML Node
     *
     * @param xmlContent
     * @return Node
     * @throws Exception
     */
    public static Node parseXML(String xmlContent) throws JSONStructureException {

        if (xmlContent == null || xmlContent.length() == 0) {
            return null;
        }

        //
        // First of all, the String is possible escaped.
        //
        // The meaning of "escaped" is defined in section 4.2.3.1 in the JSON spec
        //
        String unescapedContent = xmlContent.replace("\\\"", "\"");
        unescapedContent = unescapedContent.replace("\\\\", "\\");

        // logger.info("Escaped content: \n" + unescapedContent);

        try (InputStream is = new ByteArrayInputStream(unescapedContent.getBytes("UTF-8"))) {
            Document doc = DOMUtil.loadDocument(is);
            if (doc != null) {
                return doc.getDocumentElement();
            }
            return null;
        } catch (Exception ex) {
            throw new JSONStructureException("Unable to parse Content '" + xmlContent + "'");
        }
    }

    /**
     * Helper to parse all components of one Category or default Category
     *
     * @param categoryMap
     * @param request
     */
    private static void parseCategory(Map<?, ?> categoryMap, String categoryName,
                                      Identifier defaultCategoryId, StdMutableRequest stdMutableRequest)
        throws JSONStructureException {

        Identifier categoryId = defaultCategoryId;
        Object categoryIDString = ((Map<?, ?>)categoryMap).remove("CategoryId");
        if (categoryIDString == null && defaultCategoryId == null) {
            throw new JSONStructureException("Category is missing CategoryId");
        }
        if (categoryIDString != null) {
            if (!(categoryIDString instanceof String)) {
                throw new JSONStructureException("Expect '" + categoryName + "' CategoryId to be String got "
                                                 + categoryIDString.getClass());
            } else {
                // TODO Spec says CategoryId may be shorthand, but none have been specified
                categoryId = new IdentifierImpl(categoryIDString.toString());
            }
        }
        // if we know the category, make sure user gave correct Id
        if (defaultCategoryId != null && !defaultCategoryId.equals(categoryId)) {
            throw new JSONStructureException(categoryName + " given CategoryId '" + categoryId
                                             + "' which does not match default id '" + defaultCategoryId
                                             + "'");
        }

        // get the Id, a.k.a xmlId
        String xmlId = (String)((Map<?, ?>)categoryMap).remove("Id");

        // get the Attributes for this Category, if any
        List<Attribute> attributeList = new ArrayList<Attribute>();
        Object attributesMap = ((Map<?, ?>)categoryMap).remove("Attribute");
        if (attributesMap != null) {
            if (attributesMap instanceof ArrayList) {
                attributeList = parseAttribute(categoryId, (ArrayList<?>)attributesMap);
            } else if (attributesMap instanceof Map) {
                // underlying code expects only collections of Attributes, so create a collection of one to
                // pass this single value
                ArrayList<Map<?, ?>> listForOne = new ArrayList<Map<?, ?>>();
                listForOne.add((Map<?, ?>)attributesMap);
                attributeList = parseAttribute(categoryId, listForOne);
            } else {
                throw new JSONStructureException("Category '" + categoryName
                                                 + "' saw unexpected Attribute class "
                                                 + attributesMap.getClass());
            }
        }

        // Get the Content node for this Category, if any
        Node contentRootNode = null;
        Object content = categoryMap.remove("Content");
        if (content != null) {
            if (content instanceof String) {
                //
                // Is it Base64 Encoded?
                //
                if (Base64.isBase64(((String)content).getBytes())) {
                    //
                    // Attempt to decode it
                    //
                    byte[] realContent = Base64.decodeBase64((String)content);
                    //
                    // Now what is it? JSON or XML? Should be XML.
                    //
                    try {
                        contentRootNode = parseXML(new String(realContent, "UTF-8"));
                    } catch (UnsupportedEncodingException e) {
                        throw new JSONStructureException("Category '" + categoryName
                                                         + "' Unsupported encoding in Content");
                    }
                } else {
                    //
                    // No, so what is it? Should be XML escaped
                    //
                    contentRootNode = parseXML((String)content);
                }
            } else if (content instanceof byte[]) {
                //
                // Should be Base64
                //
                if (Base64.isBase64(((String)content).getBytes())) {
                    //
                    // Attempt to decode it
                    //
                    byte[] realContent = Base64.decodeBase64((String)content);
                    //
                    // Now what is it? JSON or XML? Should be XML.
                    //
                    try {
                        contentRootNode = parseXML(new String(realContent, "UTF-8"));
                    } catch (UnsupportedEncodingException e) {
                        throw new JSONStructureException("Category '" + categoryName
                                                         + "' Unsupported encoding in Content");
                    }
                } else {
                    throw new JSONStructureException("Category '" + categoryName
                                                     + "' Content expected Base64 value");
                }
            } else {
                throw new JSONStructureException("Category '" + categoryName
                                                 + "' Unable to determine what Content is "
                                                 + content.getClass());
            }
        }

        checkUnknown(categoryName, categoryMap);

        StdMutableRequestAttributes attributeCategory = new StdMutableRequestAttributes(categoryId,
                                                                                        attributeList,
                                                                                        contentRootNode,
                                                                                        xmlId);

        stdMutableRequest.add(attributeCategory);

    }

    /**
     * Load the "Default Category" objects, if any. This is used for the special cases of AccessSubject,
     * Action, Resource, and Environment
     *
     * @param jsonRequestMap
     * @param categoryName
     * @param categoryIdString
     * @param stdMutableRequest
     * @throws JSONStructureException
     */
    private static void parseDefaultCategory(Map<?, ?> jsonRequestMap, String categoryName,
                                             String categoryIdString, StdMutableRequest stdMutableRequest)
        throws JSONStructureException {
        Object categoryMap = jsonRequestMap.remove(categoryName);
        if (categoryMap != null) {
            Identifier defaultIdentifier = new IdentifierImpl(categoryIdString);
            // The contents may be either a single item (whose attributes are in a Map)
            // or a list of items
            if (categoryMap instanceof Map) {
                // default category contains a single object
                parseCategory((Map<?, ?>)categoryMap, categoryName, defaultIdentifier, stdMutableRequest);
            } else if (categoryMap instanceof List) {
                // Array (for Multiple Decision) of this default category - create separate element for each
                // item in list using same CategoryId for all
                List<?> categoryList = (List<?>)categoryMap;
                for (Object subCategory : categoryList) {
                    if (!(subCategory instanceof Map)) {
                        throw new JSONStructureException(
                                                         categoryName
                                                             + " array can only contain objects within curly braces");
                    }
                    parseCategory((Map<?, ?>)subCategory, categoryName, defaultIdentifier, stdMutableRequest);
                }
            } else {
                // do not understand this
                throw new JSONStructureException(
                                                 categoryName
                                                     + " must have one object contained within curly braces ({}) or an array of objects ([{}{}])");
            }
        }

    }

    //
    // Primary interface methods
    //

    /**
     * Parse and JSON string into a {@link org.apache.openaz.xacml.api.Request} object.
     *
     * @param jsonString
     * @return
     * @throws JSONStructureException
     */
    public static Request load(String jsonString) throws JSONStructureException {
        Request request = null;
        try (InputStream is = new ByteArrayInputStream(jsonString.getBytes("UTF-8"))) {
            request = JSONRequest.load(is);
        } catch (Exception ex) {
            throw new JSONStructureException("Exception loading String Request: " + ex.getMessage(), ex);
        }
        return request;
    }

    /**
     * Read a file containing the JSON description of a XACML Request and parse it into a
     * {@link org.apache.openaz.xacml.api.Request} Object. This is only used for testing. In normal operation a
     * Request arrives through the RESTful interface and is processed using
     * <code>load(String jsonString)</code>.
     *
     * @param fileRequest
     * @return
     * @throws JSONStructureException
     */
    public static Request load(File fileRequest) throws JSONStructureException {
        Request request = null;
        try (FileInputStream fis = new FileInputStream(fileRequest)) {
            request = JSONRequest.load(fis);
        } catch (Exception ex) {
            throw new JSONStructureException("Exception loading File Request: " + ex.getMessage(), ex);
        }
        return request;
    }

    /**
     * Read characters from the given <code>InputStream</code> and parse them into an XACML
     * {@link org.apache.openaz.xacml.api.Request} object.
     *
     * @param is
     * @return
     * @throws JSONStructureException
     */
    public static Request load(InputStream is) throws JSONStructureException {

        // TODO - ASSUME that order of members within an object does not matter (Different from XML, in JSON
        // everything is handled as Maps so order does not matter)

        // ensure shorthand map is set up
        if (shorthandMap == null) {
            initShorthandMap();
        }

        // ensure that we have an instance of the DataTypeFactory for generating AttributeValues by DataType
        if (dataTypeFactory == null) {
            try {
                dataTypeFactory = DataTypeFactory.newInstance();
                if (dataTypeFactory == null) {
                    throw new NullPointerException("No DataTypeFactory found");
                }
            } catch (FactoryException e) {
                throw new JSONStructureException("Unable to find DataTypeFactory, e=" + e);
            }
        }

        // create a new Request object to be filled in
        StdMutableRequest stdMutableRequest = null;

        String json = null;
        ObjectMapper mapper = null;
        try {

            // read the inputStream into a buffer (trick found online scans entire input looking for
            // end-of-file)
            java.util.Scanner scanner = new java.util.Scanner(is);
            scanner.useDelimiter("\\A");
            json = scanner.hasNext() ? scanner.next() : "";
            scanner.close();

            mapper = new ObjectMapper().setVisibility(PropertyAccessor.FIELD, Visibility.ANY);

            // TODO - ASSUME that any duplicated component is a bad thing (probably indicating an error in the
            // incoming JSON)
            mapper.configure(JsonParser.Feature.STRICT_DUPLICATE_DETECTION, true);

            Map<?, ?> root = mapper.readValue(json, Map.class);

            //
            // Does the request exist?
            //
            Map<?, ?> jsonRequestMap = (Map<?, ?>)root.remove("Request");
            if (jsonRequestMap == null) {
                throw new JSONStructureException("No \"Request\" property found.");
            }

            checkUnknown("Top-level message", root);

            stdMutableRequest = new StdMutableRequest();

            //
            // Is there a Category?
            //
            Object categoryList = jsonRequestMap.remove("Category");
            if (categoryList != null && !(categoryList instanceof List)) {
                throw new JSONStructureException("Category must contain list of objects, not '"
                                                 + categoryList.getClass() + "'");
            }
            if (categoryList != null) {
                //
                // Iterate each Category
                //
                Iterator<?> iter = ((List<?>)categoryList).iterator();
                while (iter.hasNext()) {
                    Object category = iter.next();
                    if (!(category instanceof Map)) {
                        throw new JSONStructureException(
                                                         "Category list must contain objects contained within curly braces ({})");
                    }

                    parseCategory((Map<?, ?>)category, "Category", null, stdMutableRequest);

                }
            }

            // The following may be either a single instance or an array. This allows multiple decisions to
            // work with the Default Category objects.
            // Example:
            // "AccessSubject" : [ {attributes group one},
            // {attributes group two}
            // ]

            //
            // Look for default Shorthand AccessSubject
            //
            parseDefaultCategory(jsonRequestMap, "AccessSubject",
                                 "urn:oasis:names:tc:xacml:1.0:subject-category:access-subject",
                                 stdMutableRequest);
            //
            // Provide backward compatibility for our PEP's
            //
            parseDefaultCategory(jsonRequestMap, "Subject",
                                 "urn:oasis:names:tc:xacml:1.0:subject-category:access-subject",
                                 stdMutableRequest);

            //
            // Look for default Shorthand Action
            //
            parseDefaultCategory(jsonRequestMap, "Action",
                                 "urn:oasis:names:tc:xacml:3.0:attribute-category:action", stdMutableRequest);

            //
            // Look for default Shorthand Resource
            //
            parseDefaultCategory(jsonRequestMap, "Resource",
                                 "urn:oasis:names:tc:xacml:3.0:attribute-category:resource",
                                 stdMutableRequest);

            //
            // Look for default Shorthand Environment
            //
            parseDefaultCategory(jsonRequestMap, "Environment",
                                 "urn:oasis:names:tc:xacml:3.0:attribute-category:environment",
                                 stdMutableRequest);

            //
            // Look for default Shorthand RecipientSubject
            //
            parseDefaultCategory(jsonRequestMap, "RecipientSubject",
                                 "urn:oasis:names:tc:xacml:1.0:subject-category:recipient-subject",
                                 stdMutableRequest);

            //
            // Look for default Shorthand IntermediarySubject
            //
            parseDefaultCategory(jsonRequestMap, "IntermediarySubject",
                                 "urn:oasis:names:tc:xacml:1.0:subject-category:intermediary-subject",
                                 stdMutableRequest);

            //
            // Look for default Shorthand Codebase
            //
            parseDefaultCategory(jsonRequestMap, "Codebase",
                                 "urn:oasis:names:tc:xacml:1.0:subject-category:codebase", stdMutableRequest);

            //
            // Look for default Shorthand RequestingMachine
            //
            parseDefaultCategory(jsonRequestMap, "RequestingMachine",
                                 "urn:oasis:names:tc:xacml:1.0:subject-category:requesting-machine",
                                 stdMutableRequest);

            //
            // MultiRequest
            //
            Map<?, ?> multiRequests = (Map<?, ?>)jsonRequestMap.remove("MultiRequests");
            if (multiRequests != null) {
                if (!(multiRequests instanceof Map)) {
                    throw new JSONStructureException(
                                                     "MultiRequests must be object structure, not single value");
                }

                List<?> requestReferenceList = (List<?>)multiRequests.remove("RequestReference");
                if (requestReferenceList == null) {
                    throw new JSONStructureException("MultiRequest must contain a RequestReference element");
                }
                if (requestReferenceList.size() < 1) {
                    throw new JSONStructureException(
                                                     "MultiRequest must contain at least one element in the RequestReference list");
                }

                checkUnknown("MultiRequest", multiRequests);

                for (Object requestReferenceMapObject : requestReferenceList) {
                    if (!(requestReferenceMapObject instanceof Map)) {
                        throw new JSONStructureException("MultiRequest RequestReference must be object");
                    }
                    Map<?, ?> requestReferenceMap = (Map<?, ?>)requestReferenceMapObject;

                    // each object within the list must contain a ReferenceId and only a ReferenceId
                    Object referenceIdListObject = requestReferenceMap.remove("ReferenceId");
                    if (referenceIdListObject == null) {
                        throw new JSONStructureException(
                                                         "MultiRequest RequestReference list element must contain ReferenceId");
                    }
                    List<?> referenceIdList = (List<?>)referenceIdListObject;
                    if (referenceIdList.size() == 0) {
                        // the spec does not disallow empty list RequestReference objects
                        continue;
                    }

                    checkUnknown("RequestReference", requestReferenceMap);

                    // create reference corresponding to RequestReference list element
                    StdMutableRequestReference requestReference = new StdMutableRequestReference();

                    for (Object referenceId : referenceIdList) {
                        // add attributes to the reference
                        // Since the order of the JSON is not constrained, we could process this section
                        // before the section containing attribute being referenced,
                        // so we cannot do a cross-check here to verify that the attribute reference exists.
                        // That will happen later when the PDP attempts to find the attribute.
                        StdRequestAttributesReference requestAttributesReference = new StdRequestAttributesReference(
                                                                                                                     (String)referenceId);
                        requestReference.add(requestAttributesReference);
                    }
                    stdMutableRequest.add(requestReference);
                }
            }

            //
            // ReturnPolicyIdList
            //
            // If omitted this is set to a default of false by the StdMutableRequest constructor.
            //
            Object returnPolicyIdList = jsonRequestMap.remove("ReturnPolicyIdList");
            Boolean returnPolicyIdListBoolean = makeBoolean(returnPolicyIdList, "ReturnPolicyIdList");
            if (returnPolicyIdList != null) {
                stdMutableRequest.setReturnPolicyIdList(returnPolicyIdListBoolean);
            }

            //
            // CombinedDecision
            //
            // If omitted this is set to a default of false by the StdMutableRequest constructor.
            //
            Object combinedDecision = jsonRequestMap.remove("CombinedDecision");
            Boolean combinedDecisionBoolean = makeBoolean(combinedDecision, "CombinedDecision");
            if (combinedDecision != null) {
                stdMutableRequest.setCombinedDecision(combinedDecisionBoolean);
            }

            //
            // XPath
            //

            // The JSON spec says that this has a default value, implying that if it is missing in the Request
            // we should fill it in.
            // However the XML (DOM) version does not do that. If the value is missing it leaves the
            // requestDefaults object blank.
            // We are following the XML approach and ignoring the Default value for this field in the spec.

            // TODO - Assume that no value for XPathVersion means "leave as null", not "fill in the default
            // value from spec. This violates the JSON spec
            Object xPath = jsonRequestMap.remove("XPathVersion");
            if (xPath != null) {
                // XPath is given in the JSON input
                if (!(xPath instanceof String)) {
                    throw new JSONStructureException("XPathVersion not a URI passed as a String");
                }
                URI xPathUri = null;
                try {
                    xPathUri = new URI(xPath.toString());
                } catch (Exception e) {
                    throw new JSONStructureException("XPathVersion not a valid URI: '" + xPath + "'", e);
                }

                StdRequestDefaults requestDefaults = new StdRequestDefaults(xPathUri);
                stdMutableRequest.setRequestDefaults(requestDefaults);
            }

            checkUnknown("Request", jsonRequestMap);

        } catch (JsonParseException e) {
            // try to point to problem area in JSON input, if possible
            JsonLocation location = e.getLocation();
            String locationOfError = "(unavailable)";
            if (location != null && location != JsonLocation.NA) {
                String jsonText = json;
                if (location.getLineNr() > 1) {
                    String[] jsonArray = jsonText.split("\\r?\\n|\\r");
                    jsonText = jsonArray[location.getLineNr()];
                }
                if (location.getCharOffset() < jsonText.length()) {
                    if (location.getCharOffset() > 0) {
                        locationOfError = jsonText.substring((int)location.getCharOffset() - 1);
                    }
                    if (locationOfError.length() > 30) {
                        locationOfError = locationOfError.substring(0, 30);
                    }
                }
            }
            throw new JSONStructureException("Unable to parse JSON starting at text'" + locationOfError
                                             + "', input was '" + json + "', exception: " + e, e);
        } catch (JsonMappingException e) {
            throw new JSONStructureException("Unable to map JSON '" + json + "', exception: " + e, e);
        } catch (IOException e) {
            throw new JSONStructureException("Unable to read JSON input, exception: " + e, e);
        }

        // all done
        return new StdRequest(stdMutableRequest);
    }

    //
    // Generate JSON string from a Request object created by another means (e.g. XML).
    //

    /**
     * Convert the {@link org.apache.openaz.xacml.api.Request} into an JSON string with pretty-printing.
     *
     * @param request
     * @return
     * @throws Exception
     */
    public static String toString(Request request) throws Exception {
        return toString(request, true);
    }

    /**
     * Convert the {@link org.apache.openaz.xacml.api.Response} into an JSON string, pretty-printing is
     * optional. 
     *
     * @param response
     * @param prettyPrint
     * @return
     * @throws Exception
     */
    public static String toString(Request request, boolean prettyPrint) throws Exception {
        String outputString = null;
        try (ByteArrayOutputStream os = new ByteArrayOutputStream()) {
            convert(request, os, prettyPrint);
            outputString = new String(os.toByteArray(), "UTF-8");
        } catch (Exception ex) {
            throw ex;
        }
        return outputString;
    }

    /**
     * Convert the {@link org.apache.openaz.xacml.api.Request} object into a string suitable for output.
     * IMPORTANT: This method does NOT close the outputStream. It is the responsibility of the caller to (who
     * opened the stream) to close it.
     *
     * @param request
     * @param outputStream
     * @throws java.io.IOException
     * @throws JSONStructureException
     */
    public static void convert(Request request, OutputStream outputStream) throws IOException,
        JSONStructureException {
        convert(request, outputStream, false);
    }

    /**
     * Do the work of converting the {@link org.apache.openaz.xacml.api.Request} object to a string, allowing
     * for pretty-printing if desired. IMPORTANT: This method does NOT close the outputStream. It is the
     * responsibility of the caller to (who opened the stream) to close it.
     *
     * @param request
     * @param outputStream
     * @param prettyPrint
     * @throws java.io.IOException #throws JSONStructureException
     */
    public static void convert(Request request, OutputStream outputStream, boolean prettyPrint)
        throws IOException, JSONStructureException {

        if (request == null) {
            throw new NullPointerException("No Request in convert");
        }

        Map<String, Object> requestMap = new HashMap<String, Object>();

        // ReturnPolicyIdList
        requestMap.put("ReturnPolicyIdList", request.getReturnPolicyIdList());
        // Combined
        requestMap.put("CombinedDecision", request.getCombinedDecision());
        // XPath
        if (request.getRequestDefaults() != null) {
            requestMap.put("XPathVersion", request.getRequestDefaults().getXPathVersion());
        }

        // Categories
        Iterator<RequestAttributes> rait = request.getRequestAttributes().iterator();
        List<Map<String, Object>> generalCategoriesList = new ArrayList<Map<String, Object>>();
        while (rait.hasNext()) {
            RequestAttributes ra = rait.next();

            // create a new map for the category
            Map<String, Object> categoryMap = new HashMap<String, Object>();

            // fill in the category
            if (ra.getXmlId() != null) {
                categoryMap.put("Id", ra.getXmlId());
            }
            if (ra.getContentRoot() != null) {
                StringWriter writer = new StringWriter();
                Transformer transformer = null;
                try {
                    transformer = TransformerFactory.newInstance().newTransformer();
                    transformer.transform(new DOMSource(ra.getContentRoot()), new StreamResult(writer));
                } catch (Exception e) {
                    throw new JSONStructureException("Unable to Content node to string; e=" + e);
                }

                String xml = writer.toString();

                categoryMap.put("Content", xml);
            }

            Iterator<Attribute> attrIt = ra.getAttributes().iterator();
            List<Map<String, Object>> attributesList = new ArrayList<Map<String, Object>>();
            while (attrIt.hasNext()) {
                Attribute attr = attrIt.next();
                Map<String, Object> attrMap = new HashMap<String, Object>();
                attrMap.put("AttributeId", attr.getAttributeId().stringValue());
                if (attr.getIssuer() != null) {
                    attrMap.put("Issuer", attr.getIssuer());
                }
                attrMap.put("IncludeInResult", attr.getIncludeInResults());
                Collection<AttributeValue<?>> valuesCollection = attr.getValues();
                Iterator<AttributeValue<?>> valuesIt = valuesCollection.iterator();

                if (valuesCollection.size() == 1) {
                    // single-value
                    AttributeValue<?> attrValue = valuesIt.next();
                    attrMap.put("DataType", attrValue.getDataTypeId().stringValue());

                    attrMap.put("Value", jsonOutputObject(attrValue.getValue(), attrValue));

                } else if (valuesCollection.size() > 1) {
                    // multiple values
                    List<Object> attrValueList = new ArrayList<Object>();
                    while (valuesIt.hasNext()) {
                        AttributeValue<?> attrValue = valuesIt.next();
                        // assume all have the same type, so last one in list is fine
                        attrMap.put("DataType", attrValue.getDataTypeId().stringValue());

                        attrValueList.add(jsonOutputObject(attrValue.getValue(), attrValue));

                    }
                    attrMap.put("Value", attrValueList);

                }

                attributesList.add(attrMap);
            }
            if (attributesList.size() > 0) {
                categoryMap.put("Attribute", attributesList);
            }

            // We do not use the "Default" category objects because the XML may have multiples of the same
            // Category.
            // This is fine when the categories are contained in the array of Category objects,
            // but if we use the Default category objects we might end up with multiples of the same Category
            // name,
            // and the Jackson parser does not handle that well.
            // Example: This is ok because the AccessSubjects are independent items within the list:
            // { "Request" : {
            // "Category" : [
            // { "CategoryId" : ""subject", " },
            // { "CategoryId" : ""subject", " }
            // ]
            // }}
            //
            // This is NOT ok because the Subjects are seen as duplicate elements:
            // { "Request" : {
            // "AccessSubject" : {"},
            // "AccessSubject" : {"},
            // }}

            categoryMap.put("CategoryId", ra.getCategory().stringValue());
            generalCategoriesList.add(categoryMap);

        }

        if (generalCategoriesList.size() > 0) {
            requestMap.put("Category", generalCategoriesList);
        }

        // MultiRequests
        if (request.getMultiRequests() != null) {
            Collection<RequestReference> referenceCollection = request.getMultiRequests();

            Map<String, Object> multiRequestMap = new HashMap<String, Object>();
            List<Map<String, Object>> requestReferenceList = new ArrayList<Map<String, Object>>();

            Iterator<RequestReference> rrIt = referenceCollection.iterator();
            while (rrIt.hasNext()) {
                RequestReference rr = rrIt.next();
                Map<String, Object> requestReferenceMap = new HashMap<String, Object>();

                Collection<RequestAttributesReference> rarCollection = rr.getAttributesReferences();
                List<Object> ridList = new ArrayList<Object>();
                Iterator<RequestAttributesReference> rarIt = rarCollection.iterator();
                while (rarIt.hasNext()) {
                    RequestAttributesReference rar = rarIt.next();
                    ridList.add(rar.getReferenceId());
                }

                if (ridList.size() > 0) {
                    requestReferenceMap.put("ReferenceId", ridList);
                }

                if (requestReferenceMap.size() > 0) {
                    requestReferenceList.add(requestReferenceMap);
                }

                if (requestReferenceList.size() > 0) {
                    multiRequestMap.put("RequestReference", requestReferenceList);
                }
            }

            if (multiRequestMap.size() > 0) {
                requestMap.put("MultiRequests", multiRequestMap);
            }
        }

        //
        // Create the overall Request map
        //
        Map<String, Object> theWholeRequest = new HashMap<String, Object>();
        theWholeRequest.put("Request", requestMap);
        //
        // Create a string buffer
        //
        ObjectMapper mapper = new ObjectMapper().setVisibility(PropertyAccessor.FIELD, Visibility.ANY);
        mapper.configure(SerializationFeature.INDENT_OUTPUT, prettyPrint);
        try (OutputStreamWriter osw = new OutputStreamWriter(outputStream)) {

            // convert the request to json string
            String json = mapper.writeValueAsString(theWholeRequest);

            // write it
            osw.write(json);

            // force output
            osw.flush();
        } catch (Exception e) {
            logger.error("Failed to write to json string: " + e.getLocalizedMessage(), e);
        }

    }

    /**
     * Create the appropriate object for JSON output. This needs to be a Boolean, Integer or Double for those
     * data types so that the ObjectMapper knows how to format the JSON text. For objects implementing
     * stringValue we use that string. for XPathExpressions use the Path. Otherwise default to using toString.
     *
     * @param obj
     * @return
     */
    private static Object jsonOutputObject(Object obj, AttributeValue<?> attrValue)
        throws JSONStructureException {
        if (obj instanceof String || obj instanceof Boolean || obj instanceof BigInteger) {
            return obj;
        } else if (obj instanceof Double) {
            Double d = (Double)obj;
            if (d == Double.NaN) {
                return "NaN";
            } else if (d == Double.POSITIVE_INFINITY) {
                return "INF";
            } else if (d == Double.NEGATIVE_INFINITY) {
                return "-INF";
            }
            return obj;
        } else if (obj instanceof SemanticString) {
            return ((SemanticString)obj).stringValue();
        } else if (obj instanceof X500Principal || obj instanceof URI) {
            // something is very weird with X500Principal data type. If left on its own the output is a map
            // that includes encoding.
            return obj.toString();
        } else if (obj instanceof XPathExpressionWrapper) {
            // create a map containing the complex value for the XPathExpression
            Map<String, Object> xpathExpressionMap = new HashMap<String, Object>();
            Identifier xpathCategoryId = attrValue.getXPathCategory();
            if (xpathCategoryId == null) {
                throw new JSONStructureException("XPathExpression is missing XPathCategory");
            }
            xpathExpressionMap.put("XPathCategory", attrValue.getXPathCategory().stringValue());

            XPathExpressionWrapper xw = (XPathExpressionWrapper)obj;
            xpathExpressionMap.put("XPath", xw.getPath());

            ExtendedNamespaceContext namespaceContext = xw.getNamespaceContext();
            if (namespaceContext != null) {
                List<Object> namespaceList = new ArrayList<Object>();

                // get the list of all namespace prefixes
                Iterator<String> prefixIt = namespaceContext.getAllPrefixes();
                while (prefixIt.hasNext()) {
                    String prefix = prefixIt.next();
                    String namespaceURI = namespaceContext.getNamespaceURI(prefix);
                    Map<String, Object> namespaceMap = new HashMap<String, Object>();
                    if (prefix != null && !prefix.equals(XMLConstants.DEFAULT_NS_PREFIX)) {
                        namespaceMap.put("Prefix", prefix);
                    }
                    namespaceMap.put("Namespace", namespaceURI);
                    namespaceList.add(namespaceMap);
                }

                xpathExpressionMap.put("Namespaces", namespaceList);
            }
            return xpathExpressionMap;

        } else {
            throw new JSONStructureException("Unhandled data type='" + obj.getClass().getName() + "'");
        }
    }

}

/*
 * Place to put very long output strings for editing during debugging
 */