/*******************************************************************************
 * Copyright (c) 1998, 2013 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:
 *     David McCann - 2.5.0 - Sept.14, 2012 - Initial Implementation
 ******************************************************************************/
package org.eclipse.persistence.tools.dbws;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import javax.xml.bind.JAXBElement;
import javax.xml.namespace.QName;

import org.eclipse.persistence.descriptors.ClassDescriptor;
import org.eclipse.persistence.jaxb.xmlmodel.JavaType;
import org.eclipse.persistence.jaxb.xmlmodel.JavaType.JavaAttributes;
import org.eclipse.persistence.jaxb.xmlmodel.XmlAbstractNullPolicy;
import org.eclipse.persistence.jaxb.xmlmodel.XmlAccessType;
import org.eclipse.persistence.jaxb.xmlmodel.XmlAttribute;
import org.eclipse.persistence.jaxb.xmlmodel.XmlBindings;
import org.eclipse.persistence.jaxb.xmlmodel.XmlElement;
import org.eclipse.persistence.jaxb.xmlmodel.XmlIsSetNullPolicy;
import org.eclipse.persistence.jaxb.xmlmodel.XmlMarshalNullRepresentation;
import org.eclipse.persistence.jaxb.xmlmodel.XmlNsForm;
import org.eclipse.persistence.jaxb.xmlmodel.XmlNullPolicy;
import org.eclipse.persistence.jaxb.xmlmodel.XmlRootElement;
import org.eclipse.persistence.jaxb.xmlmodel.XmlBindings.JavaTypes;
import org.eclipse.persistence.jaxb.xmlmodel.XmlSchema;
import org.eclipse.persistence.jaxb.xmlmodel.XmlSchema.XmlNs;
import org.eclipse.persistence.jaxb.xmlmodel.XmlSchemaType;
import org.eclipse.persistence.jaxb.xmlmodel.XmlType;
import org.eclipse.persistence.mappings.DatabaseMapping;
import org.eclipse.persistence.oxm.XMLDescriptor;
import org.eclipse.persistence.oxm.XMLField;
import org.eclipse.persistence.oxm.mappings.XMLBinaryDataMapping;
import org.eclipse.persistence.oxm.mappings.XMLCompositeCollectionMapping;
import org.eclipse.persistence.oxm.mappings.XMLCompositeDirectCollectionMapping;
import org.eclipse.persistence.oxm.mappings.XMLCompositeObjectMapping;
import org.eclipse.persistence.oxm.mappings.XMLDirectMapping;
import org.eclipse.persistence.oxm.mappings.XMLMapping;
import org.eclipse.persistence.oxm.mappings.nullpolicy.AbstractNullPolicy;
import org.eclipse.persistence.oxm.mappings.nullpolicy.IsSetNullPolicy;
import org.eclipse.persistence.oxm.mappings.nullpolicy.NullPolicy;
import org.eclipse.persistence.oxm.mappings.nullpolicy.XMLNullRepresentationType;

import static org.eclipse.persistence.oxm.XMLConstants.EMPTY_STRING;
import static org.eclipse.persistence.tools.dbws.Util.DOT;
import static org.eclipse.persistence.tools.dbws.Util.XML_MIME_PREFIX;

/**
 * This class is responsible for generating one or more EclipseLink XmlBindings
 * objects based on a given list of XMLDescriptors.
 * 
 */
public class XmlBindingsGenerator {
    public static final String SIMPLE_XML_FORMAT_PKG = "org.eclipse.persistence.internal.xr.sxf"; 
    public static final String DATAHANDLER_CLASSNAME = "javax.activation.DataHandler";

    /**
     * Generate one or more XmlBindings based on a given list of
     * XML Descriptor instances.
     * 
     */
    public static List<XmlBindings> generateXmlBindings(List<ClassDescriptor> descriptors) {
        // group the descriptors by package name
        HashMap<String, List<XMLDescriptor>> descriptorMap = new HashMap<String, List<XMLDescriptor>>();
        for (ClassDescriptor cdesc : descriptors) {
            XMLDescriptor xdesc = (XMLDescriptor) cdesc;
            String packageName = getPackageName(xdesc.getJavaClassName());
            // don't process the simple-xml-format descriptor
            if (packageName.equals(SIMPLE_XML_FORMAT_PKG)) {
                continue;
            }
            List<XMLDescriptor> descriptorList = descriptorMap.get(packageName);
            if (descriptorList == null) {
                descriptorList = new ArrayList<XMLDescriptor>();
                descriptorMap.put(packageName, descriptorList);
            }
            descriptorList.add(xdesc);
        }

        List<XmlBindings> bindingsList = new ArrayList<XmlBindings>();
        // generate an XmlBindings for each package
        for (String pkg : descriptorMap.keySet()) {
            List<XMLDescriptor> xdescList = descriptorMap.get(pkg);
            
            XmlBindings xmlBindings = generateXmlBindings(pkg, xdescList);
            if (xmlBindings != null) {
                bindingsList.add(xmlBindings);
            }
        }
        return bindingsList;
    }
    
    /**
     * Generate an XmlBindings instance based on a list of XML descriptors.
     * 
     * OXM metadata files are processed on a per package basis, hence it is
     * assumed that the given list of descriptors are from the same package.
     * 
     */
    public static XmlBindings generateXmlBindings(String packageName, List<XMLDescriptor> descriptors) {
        String defaultNamespace = null;
        Map<String, String> prefixMap = new HashMap<String, String>();
        
        JavaTypes jTypes = new JavaTypes();
        for (XMLDescriptor xdesc : descriptors) {
            // get xml-schema info from one of the descriptors, and add prefix
            // mappings to the map
            if (xdesc.getNamespaceResolver() != null) {
                if (defaultNamespace == null) {
                    defaultNamespace = xdesc.getNamespaceResolver().getDefaultNamespaceURI();
                }
                Map<String, String> preMap = xdesc.getNamespaceResolver().getPrefixesToNamespaces();
                for (String pfx : preMap.keySet()) {
                    // ignore mime prefix/url for now
                    if (!pfx.equals(XML_MIME_PREFIX)) {
                        prefixMap.put(pfx, preMap.get(pfx));
                    }
                }
            }
            // generate a JavaType instance for the XML descriptor
            jTypes.getJavaType().add(generateJavaType(xdesc));
        }
        
        XmlBindings xmlBindings = null;
        // if there are no JavaTypes, there's nothing to do
        if (jTypes.getJavaType().size() > 0) {
            xmlBindings = new XmlBindings();
            xmlBindings.setJavaTypes(jTypes);
            xmlBindings.setPackageName(packageName);
            // handle XmlSchema
            if (defaultNamespace != null || !prefixMap.isEmpty()) {
                XmlSchema xSchema = new XmlSchema();
                xSchema.setNamespace(defaultNamespace == null ? EMPTY_STRING : defaultNamespace);
                xSchema.setElementFormDefault(XmlNsForm.QUALIFIED);
                // handle XmlNs
                if (!prefixMap.isEmpty()) {
                    XmlNs xmlNs;
                    for (String pfx : prefixMap.keySet()) {
                        xmlNs = new XmlNs();
                        xmlNs.setNamespaceUri(prefixMap.get(pfx));
                        xmlNs.setPrefix(pfx);
                        xSchema.getXmlNs().add(xmlNs);
                    }
                }
                xmlBindings.setXmlSchema(xSchema);
            }
        }
        return xmlBindings;
    }

    /**
     * Process a given XMLDescriptor and return a JavaType instance.
     * 
     */
    protected static JavaType generateJavaType(XMLDescriptor xdesc) {
        String defaultNamespace = null;
        if (xdesc.getNamespaceResolver() != null) {
            defaultNamespace = xdesc.getNamespaceResolver().getDefaultNamespaceURI();
        }
        String schemaContext = null;
        if (xdesc.getSchemaReference() != null) {
            schemaContext = xdesc.getSchemaReference().getSchemaContext();
        }
        
        JavaType jType = new JavaType();
        jType.setName(getClassName(xdesc.getJavaClassName()));
        jType.setXmlAccessorType(XmlAccessType.FIELD);
        
        // handle XmlType
        if (schemaContext != null) {
            XmlType xType = new XmlType();
            xType.setName(schemaContext.substring(1, schemaContext.length()));
            if (defaultNamespace != null) {
                xType.setNamespace(defaultNamespace);
            }
            jType.setXmlType(xType);
        }        
        // handle XmlRootElement
        XmlRootElement xmlRootElt = new XmlRootElement();
        xmlRootElt.setName(xdesc.getDefaultRootElement());
        if (defaultNamespace != null) {
            xmlRootElt.setNamespace(defaultNamespace);
        }
        jType.setXmlRootElement(xmlRootElt);
        jType.setJavaAttributes(new JavaAttributes());
        // generate an XmlAttribute or XmlElement for each mapping
        for (Iterator<DatabaseMapping> xmapIt = xdesc.getMappings().iterator(); xmapIt.hasNext();) {
            XMLMapping xMap = (XMLMapping) xmapIt.next();
            if (((XMLField) xMap.getField()).getXPathFragment().isAttribute()) {
                JAXBElement<XmlAttribute> jAtt = generateXmlAttribute(xMap);
                if (jAtt != null) {
                    jType.getJavaAttributes().getJavaAttribute().add(jAtt);
                }
            } else {
                JAXBElement<XmlElement> jElt = generateXmlElement(xMap);
                if (jElt != null) {
                    jType.getJavaAttributes().getJavaAttribute().add(jElt);
                }
            }
        }
        return jType;
    }

    /**
     * Process a given XMLMapping and return a JAXBElement<XmlAttribute>.
     * 
     * Expected mappings are:
     * <ul>
     * <li>org.eclipse.persistence.oxm.mappings.XMLBinaryDataMapping
     * <li>org.eclipse.persistence.oxm.mappings.XMLCompositeDirectCollectionMapping
     * <li>org.eclipse.persistence.oxm.mappings.XMLDirectMapping
     * </ul>
     */
    protected static JAXBElement<XmlAttribute> generateXmlAttribute(XMLMapping xmap) {
        XmlAttribute xAtt = null;
        if (xmap instanceof XMLDirectMapping) {
            // could be an XMLBinaryDataMapping instance
            if (xmap instanceof XMLBinaryDataMapping) {
                xAtt = processXMLBinaryDataMappingAttribute((XMLBinaryDataMapping) xmap);
            } else {
                xAtt = processXMLDirectMappingAttribute((XMLDirectMapping) xmap);
            }
        } else if (xmap instanceof XMLCompositeDirectCollectionMapping) {
            xAtt = processXMLCompositeDirectCollectionMappingAttribute((XMLCompositeDirectCollectionMapping) xmap);
        }
        if (xAtt == null) {
            return null;
        }
        return new JAXBElement<XmlAttribute>(new QName("http://www.eclipse.org/eclipselink/xsds/persistence/oxm", "xml-attribute"), XmlAttribute.class, xAtt);
    }
    
    /**
     * Process a given XMLMapping and return a JAXBElement<XmlElement>.
     * 
     * Expected mappings are:
     * <ul>
     * <li>org.eclipse.persistence.oxm.mappings.XMLBinaryDataMapping
     * <li>org.eclipse.persistence.oxm.mappings.XMLCompositeCollectionMapping
     * <li>org.eclipse.persistence.oxm.mappings.XMLCompositeDirectCollectionMapping
     * <li>org.eclipse.persistence.oxm.mappings.XMLCompositeObjectMapping
     * <li>org.eclipse.persistence.oxm.mappings.XMLDirectMapping
     * </ul>
     */
    protected static JAXBElement<XmlElement> generateXmlElement(XMLMapping xmap) {
        XmlElement xElt = null;
        if (xmap instanceof XMLCompositeObjectMapping) {
            xElt = processXMLCompositeObjectMapping((XMLCompositeObjectMapping) xmap);
        } else if (xmap instanceof XMLCompositeCollectionMapping) {
            xElt = processXMLCompositeCollectionMapping((XMLCompositeCollectionMapping) xmap);
        } else if (xmap instanceof XMLCompositeDirectCollectionMapping) {
            xElt = processXMLCompositeDirectCollectionMapping((XMLCompositeDirectCollectionMapping) xmap);
        } else if (xmap instanceof XMLDirectMapping) {
            // could be an XMLBinaryDataMapping instance
            if (xmap instanceof XMLBinaryDataMapping) {
                xElt = processXMLBinaryDataMapping((XMLBinaryDataMapping) xmap);
            } else {
                xElt = processXMLDirectMapping((XMLDirectMapping) xmap);
            }
        }
        if (xElt == null) {
            return null;
        }
        return new JAXBElement<XmlElement>(new QName("http://www.eclipse.org/eclipselink/xsds/persistence/oxm", "xml-element"), XmlElement.class, xElt);
    }

    /**
     * Process a given XMLMapping and return an XmlAttribute.
     * 
     */
    protected static XmlAttribute processXMLMapping(XMLField xfld, String attName, String xpath, String attClassification, 
            AbstractNullPolicy nullPolicy, String containerName, boolean inlineBinary, boolean isSWARef, String mimeType) {

        XmlAttribute xAtt = new XmlAttribute();
        xAtt.setJavaAttribute(attName);
        xAtt.setXmlPath(xpath);
        if (xfld.isRequired()) {
            xAtt.setRequired(true);
        }
        if (inlineBinary) {
            xAtt.setXmlInlineBinaryData(true);
        }
        if (isSWARef) {
            xAtt.setXmlAttachmentRef(true);
        }
        if (attClassification != null) {
            xAtt.setType(attClassification);
        }
        if (containerName != null) {
            xAtt.setContainerType(containerName);
        }
        if (mimeType != null) {
            xAtt.setXmlMimeType(mimeType);
        }
        QName schemaType = xfld.getSchemaType();
        if (schemaType != null) {
            XmlSchemaType xSchemaType = new XmlSchemaType();
            xSchemaType.setName(schemaType.getLocalPart());
            xAtt.setXmlSchemaType(xSchemaType);
        }
        if (!isDefaultNullPolicy(nullPolicy)) {
            XmlAbstractNullPolicy xmlNullPolicy;
            
            if (nullPolicy instanceof NullPolicy) {
                xmlNullPolicy = new XmlNullPolicy();
                ((XmlNullPolicy) xmlNullPolicy).setIsSetPerformedForAbsentNode(nullPolicy.getIsSetPerformedForAbsentNode());
            } else {
                xmlNullPolicy = new XmlIsSetNullPolicy();
            }
            xmlNullPolicy.setEmptyNodeRepresentsNull(nullPolicy.isNullRepresentedByEmptyNode());
            xmlNullPolicy.setXsiNilRepresentsNull(nullPolicy.isNullRepresentedByXsiNil());
            xmlNullPolicy.setNullRepresentationForXml(XmlMarshalNullRepresentation.fromValue(nullPolicy.getMarshalNullRepresentation().toString()));

            xAtt.setXmlAbstractNullPolicy(new JAXBElement<XmlAbstractNullPolicy>(new QName("http://www.eclipse.org/eclipselink/xsds/persistence/oxm", "xml-null-policy"), XmlAbstractNullPolicy.class, xmlNullPolicy));
        }
        return xAtt;
    }

    /**
     * Process a given XMLBinaryDataMapping and return an XmlAttribute.
     * 
     */
    protected static XmlAttribute processXMLBinaryDataMappingAttribute(XMLBinaryDataMapping xmap) {
        // JAXB expects a DataHandler in the object model for SwaRef
        String attClassName = xmap.getAttributeClassificationName();
        if (xmap.isSwaRef()) {
            attClassName = DATAHANDLER_CLASSNAME;
        }
        
        return processXMLMapping(
                (XMLField)xmap.getField(), 
                xmap.getAttributeName(), 
                xmap.getXPath(), 
                attClassName, 
                xmap.getNullPolicy(), 
                null,
                xmap.shouldInlineBinaryData(),
                xmap.isSwaRef(),
                xmap.getMimeType());
    }
 

    /**
     * Process a given XMLCompositeDirectCollectionMapping and return an XmlAttribute.
     * 
     */
    protected static XmlAttribute processXMLCompositeDirectCollectionMappingAttribute(XMLCompositeDirectCollectionMapping xmap) {
        return processXMLMapping(
                (XMLField)xmap.getField(), 
                xmap.getAttributeName(), 
                xmap.getXPath(), 
                null, 
                xmap.getNullPolicy(), 
                xmap.getContainerPolicy().getContainerClassName(),
                false,
                false,
                null);
    }
    
    /**
     * Process a given XMLDirectMapping and return an XmlAttribute.
     * 
     */
    protected static XmlAttribute processXMLDirectMappingAttribute(XMLDirectMapping xmap) {
        return processXMLMapping(
                (XMLField)xmap.getField(), 
                xmap.getAttributeName(), 
                xmap.getXPath(), 
                xmap.getAttributeClassificationName(), 
                xmap.getNullPolicy(), 
                null,
                false,
                false,
                null);
    }    

    /**
     * Process a given XMLMapping and return an XmlElement.
     * 
     */
    protected static XmlElement processXMLMapping(XMLField xfld, String attName, String xpath, String attClassification, 
            AbstractNullPolicy nullPolicy, boolean isCDATA, String containerName, boolean inlineBinary, boolean isSWARef, String mimeType) {

        XmlElement xElt = new XmlElement();
        xElt.setJavaAttribute(attName);
        xElt.setXmlPath(xpath);
        if (xfld.isRequired()) {
            xElt.setRequired(true);
        }
        if (isCDATA) {
            xElt.setCdata(true);
        }
        if (inlineBinary) {
            xElt.setXmlInlineBinaryData(true);
        }
        if (isSWARef) {
            xElt.setXmlAttachmentRef(true);
        }
        if (attClassification != null) {
            xElt.setType(attClassification);
        }
        if (containerName != null) {
            xElt.setContainerType(containerName);
        }
        if (mimeType != null) {
            xElt.setXmlMimeType(mimeType);
        }
        QName schemaType = xfld.getSchemaType();
        if (schemaType != null) {
            XmlSchemaType xSchemaType = new XmlSchemaType();
            xSchemaType.setName(schemaType.getLocalPart());
            xElt.setXmlSchemaType(xSchemaType);
        }
        if (!isDefaultNullPolicy(nullPolicy)) {
            XmlAbstractNullPolicy xmlNullPolicy;
            
            if (nullPolicy instanceof NullPolicy) {
                xmlNullPolicy = new XmlNullPolicy();
                ((XmlNullPolicy) xmlNullPolicy).setIsSetPerformedForAbsentNode(nullPolicy.getIsSetPerformedForAbsentNode());
            } else {
                xmlNullPolicy = new XmlIsSetNullPolicy();
            }
            xmlNullPolicy.setEmptyNodeRepresentsNull(nullPolicy.isNullRepresentedByEmptyNode());
            xmlNullPolicy.setXsiNilRepresentsNull(nullPolicy.isNullRepresentedByXsiNil());
            xmlNullPolicy.setNullRepresentationForXml(XmlMarshalNullRepresentation.fromValue(nullPolicy.getMarshalNullRepresentation().toString()));

            xElt.setXmlAbstractNullPolicy(new JAXBElement<XmlAbstractNullPolicy>(new QName("http://www.eclipse.org/eclipselink/xsds/persistence/oxm", "xml-null-policy"), XmlAbstractNullPolicy.class, xmlNullPolicy));
        }
        return xElt;
    }

    /**
     * Process a given XMLDirectMapping and return an XmlElement.
     * 
     */
    protected static XmlElement processXMLDirectMapping(XMLDirectMapping xmap) {
        return processXMLMapping(
                (XMLField)xmap.getField(), 
                xmap.getAttributeName(), 
                xmap.getXPath(), 
                xmap.getAttributeClassificationName(), 
                xmap.getNullPolicy(), 
                xmap.isCDATA(),
                null,
                false,
                false,
                null);
    }

    /**
     * Process a given XMLBinaryDataMapping and return an XmlElement.
     * 
     */
    protected static XmlElement processXMLBinaryDataMapping(XMLBinaryDataMapping xmap) {
        // JAXB expects a DataHandler in the object model for SwaRef
        String attClassName = xmap.getAttributeClassificationName();
        if (xmap.isSwaRef()) {
            attClassName = DATAHANDLER_CLASSNAME;
        }
        
        return processXMLMapping(
                (XMLField)xmap.getField(), 
                xmap.getAttributeName(), 
                xmap.getXPath(), 
                attClassName, 
                xmap.getNullPolicy(), 
                xmap.isCDATA(),
                null,
                xmap.shouldInlineBinaryData(),
                xmap.isSwaRef(),
                xmap.getMimeType());
    }

    /**
     * Process a given XMLCompositeDirectCollectionMapping and return an XmlElement.
     * 
     */
    protected static XmlElement processXMLCompositeDirectCollectionMapping(XMLCompositeDirectCollectionMapping xmap) {
        return processXMLMapping(
                (XMLField)xmap.getField(), 
                xmap.getAttributeName(), 
                xmap.getXPath(), 
                null, 
                xmap.getNullPolicy(), 
                xmap.isCDATA(),
                xmap.getContainerPolicy().getContainerClassName(),
                false,
                false,
                null);
    }

    /**
     * Process a given XMLCompositeObjectMapping and return an XmlElement.
     * 
     */
    protected static XmlElement processXMLCompositeObjectMapping(XMLCompositeObjectMapping xmap) {
        return processXMLMapping(
                (XMLField)xmap.getField(), 
                xmap.getAttributeName(), 
                xmap.getXPath(), 
                xmap.getReferenceClassName(), 
                xmap.getNullPolicy(), 
                false,
                null,
                false,
                false,
                null);
    }

    /**
     * Process a given XMLCompositeCollectionMapping and return an XmlElement
     * 
     */
    protected static XmlElement processXMLCompositeCollectionMapping(XMLCompositeCollectionMapping xmap) {
        return processXMLMapping(
                (XMLField)xmap.getField(), 
                xmap.getAttributeName(), 
                xmap.getXPath(), 
                xmap.getReferenceClassName(), 
                xmap.getNullPolicy(), 
                false,
                xmap.getContainerPolicy().getContainerClassName(),
                false,
                false,
                null);
    }

    /**
     * Convenience methods that returns the package name for a given fully 
     * qualified Java class name.
     * 
     */
    protected static String getPackageName(String javaClassName) {
        // handle 'default' package
        if (javaClassName.lastIndexOf(DOT) == -1) {
            return EMPTY_STRING;
        }
        return javaClassName.substring(0, javaClassName.lastIndexOf(DOT));
    }
    
    /**
     * Convenience methods that returns the class name w/o package 
     * for a given fully qualified Java class name.
     * 
     */
    protected static String getClassName(String javaClassName) {
        // handle 'default' package
        if (javaClassName.lastIndexOf(DOT) == -1) {
            return javaClassName;
        }
        return javaClassName.substring(javaClassName.lastIndexOf(DOT)+1, javaClassName.length());
    }

    /**
     * Indicates is a given AbstractNullPolicy is the default.  This is useful
     * if it is not desirable to write out the default policy in the oxm
     * metadata file.
     * 
     * The default policy is NullPolicy, with the following set:
     * <ul>
     * <li>isNullRepresentedByXsiNil = false
     * <li>isNullRepresentedByEmptyNode = true
     * <li>isSetPerformedForAbsentNode = true
     * <li>marshalNullRepresentation = XMLNullRepresentationType.ABSENT_NODE
     * </ul>
     */
    protected static boolean isDefaultNullPolicy(AbstractNullPolicy nullPolicy) {
        // default policy is NullPolicy
        if (nullPolicy instanceof IsSetNullPolicy) {
            return false;
        }
        boolean xsiNil = nullPolicy.isNullRepresentedByXsiNil();
        boolean emptyNode = nullPolicy.isNullRepresentedByEmptyNode();
        boolean setForAbsent = nullPolicy.getIsSetPerformedForAbsentNode();
        XMLNullRepresentationType marshalNull = nullPolicy.getMarshalNullRepresentation();

        return (!xsiNil && emptyNode && setForAbsent && marshalNull == XMLNullRepresentationType.ABSENT_NODE);
    }
}