/*

 * Copyright (c) 2008, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

package com.sun.servicetag;

import java.io.*;

import java.net.URL;

import java.util.Collection;

import java.util.Map;

import java.util.Set;

import org.w3c.dom.Document;

import org.w3c.dom.Element;

import org.w3c.dom.Node;

import org.w3c.dom.NodeList;

import org.xml.sax.SAXException;

import org.xml.sax.InputSource;

import javax.xml.XMLConstants;

import javax.xml.parsers.DocumentBuilder;

import javax.xml.parsers.DocumentBuilderFactory;

import javax.xml.parsers.ParserConfigurationException;

import javax.xml.validation.Schema;

import javax.xml.validation.SchemaFactory;

import javax.xml.validation.Validator;

// For write operation

import javax.xml.transform.OutputKeys;

import javax.xml.transform.Transformer;

import javax.xml.transform.TransformerException;

import javax.xml.transform.TransformerFactory;

import javax.xml.transform.TransformerConfigurationException;

import javax.xml.transform.dom.DOMSource;

import javax.xml.transform.stream.StreamResult;

/**

 * XML Support Class for Product Registration.

 */

class RegistrationDocument {

    private static final String REGISTRATION_DATA_SCHEMA =

            "/com/sun/servicetag/resources/product_registration.xsd";

    private static final String REGISTRATION_DATA_VERSION = "1.0";

    private static final String SERVICE_TAG_VERSION = "1.0";

    final static String ST_NODE_REGISTRATION_DATA = "registration_data";

    final static String ST_ATTR_REGISTRATION_VERSION = "version";

    final static String ST_NODE_ENVIRONMENT = "environment";

    final static String ST_NODE_HOSTNAME = "hostname";

    final static String ST_NODE_HOST_ID = "hostId";

    final static String ST_NODE_OS_NAME = "osName";

    final static String ST_NODE_OS_VERSION = "osVersion";

    final static String ST_NODE_OS_ARCH = "osArchitecture";

    final static String ST_NODE_SYSTEM_MODEL = "systemModel";

    final static String ST_NODE_SYSTEM_MANUFACTURER = "systemManufacturer";

    final static String ST_NODE_CPU_MANUFACTURER = "cpuManufacturer";

    final static String ST_NODE_SERIAL_NUMBER = "serialNumber";

    final static String ST_NODE_REGISTRY = "registry";

    final static String ST_ATTR_REGISTRY_URN = "urn";

    final static String ST_ATTR_REGISTRY_VERSION = "version";

    final static String ST_NODE_SERVICE_TAG = "service_tag";

    final static String ST_NODE_INSTANCE_URN = "instance_urn";

    final static String ST_NODE_PRODUCT_NAME = "product_name";

    final static String ST_NODE_PRODUCT_VERSION = "product_version";

    final static String ST_NODE_PRODUCT_URN = "product_urn";

    final static String ST_NODE_PRODUCT_PARENT_URN = "product_parent_urn";

    final static String ST_NODE_PRODUCT_PARENT = "product_parent";

    final static String ST_NODE_PRODUCT_DEFINED_INST_ID = "product_defined_inst_id";

    final static String ST_NODE_PRODUCT_VENDOR = "product_vendor";

    final static String ST_NODE_PLATFORM_ARCH = "platform_arch";

    final static String ST_NODE_TIMESTAMP = "timestamp";

    final static String ST_NODE_CONTAINER = "container";

    final static String ST_NODE_SOURCE = "source";

    final static String ST_NODE_INSTALLER_UID = "installer_uid";

    static RegistrationData load(InputStream in) throws IOException {

        Document document = initializeDocument(in);

        // Gets the registration URN

        Element root = getRegistrationDataRoot(document);

        Element registryRoot =

                getSingletonElementFromRoot(root, ST_NODE_REGISTRY);

        String urn = registryRoot.getAttribute(ST_ATTR_REGISTRY_URN);

        // Construct a new RegistrationData object from the DOM tree

        // Initialize the environment map and service tags

        RegistrationData regData = new RegistrationData(urn);

        addServiceTags(registryRoot, regData);

        Element envRoot = getSingletonElementFromRoot(root, ST_NODE_ENVIRONMENT);

        buildEnvironmentMap(envRoot, regData);

        return regData;

    }

    static void store(OutputStream os, RegistrationData registration)

            throws IOException {

        // create a new document with the root node

        Document document = initializeDocument();

        // create the nodes for the environment map and the service tags

        // in the registration data

        addEnvironmentNodes(document,

                            registration.getEnvironmentMap());

        addServiceTagRegistry(document,

                              registration.getRegistrationURN(),

                              registration.getServiceTags());

        transform(document, os);

    }

    // initialize a document from an input stream

    private static Document initializeDocument(InputStream in) throws IOException {

        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();

        try {

            // XML schema for validation

            SchemaFactory sf = SchemaFactory.newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI);

            URL xsdUrl = RegistrationDocument.class.getResource(REGISTRATION_DATA_SCHEMA);

            Schema schema = sf.newSchema(xsdUrl);

            Validator validator = schema.newValidator();

            DocumentBuilder builder = factory.newDocumentBuilder();

            Document doc = builder.parse(new InputSource(in));

            validator.validate(new DOMSource(doc));

            return doc;

        } catch (SAXException sxe) {

            IllegalArgumentException e = new IllegalArgumentException("Error generated in parsing");

            e.initCause(sxe);

            throw e;

        } catch (ParserConfigurationException pce) {

            // Parser with specific options can't be built

            // should not reach here

        }

    }

    // initialize a new document for the registration data

    private static Document initializeDocument() throws IOException {

        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();

        try {

            DocumentBuilder builder = factory.newDocumentBuilder();

            Document doc = builder.newDocument();

            // initialize the document with the registration_data root

            Element root = doc.createElement(ST_NODE_REGISTRATION_DATA);

            doc.appendChild(root);

            root.setAttribute(ST_ATTR_REGISTRATION_VERSION, REGISTRATION_DATA_VERSION);

            return doc;

        } catch (ParserConfigurationException pce) {

            // Parser with specified options can't be built

            // should not reach here

        }

    }

    // Transform the current DOM tree with the given output stream.

    private static void transform(Document document, OutputStream os) {

        try {

            // Use a Transformer for output

            TransformerFactory tFactory = TransformerFactory.newInstance();

            tFactory.setAttribute("indent-number", new Integer(3));

            Transformer transformer = tFactory.newTransformer();

            transformer.setOutputProperty(OutputKeys.INDENT, "yes");

            transformer.setOutputProperty(OutputKeys.METHOD, "xml");

            transformer.setOutputProperty(OutputKeys.ENCODING, "UTF-8");

            transformer.setOutputProperty(OutputKeys.STANDALONE, "yes");

            transformer.transform(new DOMSource(document),

                new StreamResult(new BufferedWriter(new OutputStreamWriter(os, "UTF-8"))));

        } catch (UnsupportedEncodingException ue) {

            // Should not reach here

        } catch (TransformerConfigurationException tce) {

            // Error generated by the parser

            // Should not reach here

        } catch (TransformerException te) {

            // Error generated by the transformer

        }

    }

    private static void addServiceTagRegistry(Document document,

                                              String registryURN,

                                              Set<ServiceTag> svcTags) {

        // add service tag registry node and its attributes

        Element reg = document.createElement(ST_NODE_REGISTRY);

        reg.setAttribute(ST_ATTR_REGISTRY_URN, registryURN);

        reg.setAttribute(ST_ATTR_REGISTRY_VERSION, SERVICE_TAG_VERSION);

        Element root = getRegistrationDataRoot(document);

        root.appendChild(reg);

        // adds the elements for the service tags

        for (ServiceTag st : svcTags) {

            addServiceTagElement(document, reg, st);

        }

    }

    private static void addServiceTagElement(Document document,

                                             Element registryRoot,

                                             ServiceTag st) {

        Element svcTag = document.createElement(ST_NODE_SERVICE_TAG);

        registryRoot.appendChild(svcTag);

        addChildElement(document, svcTag,

                        ST_NODE_INSTANCE_URN, st.getInstanceURN());

        addChildElement(document, svcTag,

                        ST_NODE_PRODUCT_NAME, st.getProductName());

        addChildElement(document, svcTag,

                        ST_NODE_PRODUCT_VERSION, st.getProductVersion());

        addChildElement(document, svcTag,

                        ST_NODE_PRODUCT_URN, st.getProductURN());

        addChildElement(document, svcTag,

                        ST_NODE_PRODUCT_PARENT_URN, st.getProductParentURN());

        addChildElement(document, svcTag,

                        ST_NODE_PRODUCT_PARENT, st.getProductParent());

        addChildElement(document, svcTag,

                        ST_NODE_PRODUCT_DEFINED_INST_ID,

                        st.getProductDefinedInstanceID());

        addChildElement(document, svcTag,

                        ST_NODE_PRODUCT_VENDOR, st.getProductVendor());

        addChildElement(document, svcTag,

                        ST_NODE_PLATFORM_ARCH, st.getPlatformArch());

        addChildElement(document, svcTag,

                        ST_NODE_TIMESTAMP, Util.formatTimestamp(st.getTimestamp()));

        addChildElement(document, svcTag,

                        ST_NODE_CONTAINER, st.getContainer());

        addChildElement(document, svcTag,

                        ST_NODE_SOURCE, st.getSource());

        addChildElement(document, svcTag,

                        ST_NODE_INSTALLER_UID,

                        String.valueOf(st.getInstallerUID()));

    }

    private static void addChildElement(Document document, Element root,

                                        String element, String text) {

        Element node = document.createElement(element);

        node.appendChild(document.createTextNode(text));

        root.appendChild(node);

    }

    // Constructs service tags from the document

    private static void addServiceTags(Element registryRoot,

                                       RegistrationData registration) {

        NodeList children = registryRoot.getElementsByTagName(ST_NODE_SERVICE_TAG);

        int length = (children == null ? 0 : children.getLength());

        for (int i = 0; i < length; i++) {

            Element svcTagElement = (Element) children.item(i);

            ServiceTag st = getServiceTag(svcTagElement);

            registration.addServiceTag(st);

        }

    }

    // build environment map from the document

    private static void buildEnvironmentMap(Element envRoot,

                                         RegistrationData registration) {

        registration.setEnvironment(ST_NODE_HOSTNAME, getTextValue(envRoot, ST_NODE_HOSTNAME));

        registration.setEnvironment(ST_NODE_HOST_ID, getTextValue(envRoot, ST_NODE_HOST_ID));

        registration.setEnvironment(ST_NODE_OS_NAME, getTextValue(envRoot, ST_NODE_OS_NAME));

        registration.setEnvironment(ST_NODE_OS_VERSION, getTextValue(envRoot, ST_NODE_OS_VERSION));

        registration.setEnvironment(ST_NODE_OS_ARCH, getTextValue(envRoot, ST_NODE_OS_ARCH));

        registration.setEnvironment(ST_NODE_SYSTEM_MODEL, getTextValue(envRoot, ST_NODE_SYSTEM_MODEL));

        registration.setEnvironment(ST_NODE_SYSTEM_MANUFACTURER, getTextValue(envRoot, ST_NODE_SYSTEM_MANUFACTURER));

        registration.setEnvironment(ST_NODE_CPU_MANUFACTURER, getTextValue(envRoot, ST_NODE_CPU_MANUFACTURER));

        registration.setEnvironment(ST_NODE_SERIAL_NUMBER, getTextValue(envRoot, ST_NODE_SERIAL_NUMBER));

    }

    // add the nodes representing the environment map in the document

    private static void addEnvironmentNodes(Document document,

                                            Map<String, String> envMap) {

        Element root = getRegistrationDataRoot(document);

        Element env = document.createElement(ST_NODE_ENVIRONMENT);

        root.appendChild(env);

        Set<Map.Entry<String, String>> keys = envMap.entrySet();

        for (Map.Entry<String, String> entry : keys) {

            addChildElement(document, env, entry.getKey(), entry.getValue());

        }

    }

    private static Element getRegistrationDataRoot(Document doc) {

        Element root = doc.getDocumentElement();

        if (!root.getNodeName().equals(ST_NODE_REGISTRATION_DATA)) {

            throw new IllegalArgumentException("Not a " +

                    ST_NODE_REGISTRATION_DATA +

                    " node \"" + root.getNodeName() + "\"");

        }

        return root;

    }

    private static Element getSingletonElementFromRoot(Element root, String name) {

        NodeList children = root.getElementsByTagName(name);

        int length = (children == null ? 0 : children.getLength());

        if (length != 1) {

            throw new IllegalArgumentException("Invalid number of " + name +

                    " nodes = " + length);

        }

        Element e = (Element) children.item(0);

        if (!e.getNodeName().equals(name)) {

            throw new IllegalArgumentException("Not a  " + name +

                    " node \"" + e.getNodeName() + "\"");

        }

        return e;

    }

    // Constructs one ServiceTag instance from a service tag element root

    private static ServiceTag getServiceTag(Element svcTagElement) {

        return new ServiceTag(

            getTextValue(svcTagElement, ST_NODE_INSTANCE_URN),

            getTextValue(svcTagElement, ST_NODE_PRODUCT_NAME),

            getTextValue(svcTagElement, ST_NODE_PRODUCT_VERSION),

            getTextValue(svcTagElement, ST_NODE_PRODUCT_URN),

            getTextValue(svcTagElement, ST_NODE_PRODUCT_PARENT),

            getTextValue(svcTagElement, ST_NODE_PRODUCT_PARENT_URN),

            getTextValue(svcTagElement, ST_NODE_PRODUCT_DEFINED_INST_ID),

            getTextValue(svcTagElement, ST_NODE_PRODUCT_VENDOR),

            getTextValue(svcTagElement, ST_NODE_PLATFORM_ARCH),

            getTextValue(svcTagElement, ST_NODE_CONTAINER),

            getTextValue(svcTagElement, ST_NODE_SOURCE),

            Util.getIntValue(getTextValue(svcTagElement, ST_NODE_INSTALLER_UID)),

            Util.parseTimestamp(getTextValue(svcTagElement, ST_NODE_TIMESTAMP))

        );

    }

    private static String getTextValue(Element e, String tagName) {

        String value = "";

        NodeList nl = e.getElementsByTagName(tagName);

        if (nl != null && nl.getLength() > 0) {

            Element el = (Element) nl.item(0);

            Node node = el.getFirstChild();

            if (node != null) {

                value = node.getNodeValue();

            }

        }

        return value;

    }

}