/**
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.apache.oodt.grid;

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Serializable;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerConfigurationException;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.w3c.dom.Text;
import org.xml.sax.SAXException;

import org.apache.oodt.commons.util.Base64;

/**
 * web-grid configuration. This holds all the runtime configuration of profile servers,
 * product servers, properties, and other settings for the web-grid container.
 *
 */
public class Configuration implements Serializable {
    /**
     * Creates a new <code>Configuration</code> instance.
     *
     * @param file File containing the serialized configuration.
     * @throws IOException if an I/O error occurs.
     * @throws SAXException if the file can't be parsed.
     */
    public Configuration(File file) throws IOException, SAXException {
        this.file = file;
        if (file.isFile() && file.length() > 0)
            parse(file);
    }

    /**
     * Convert the configuration to XML.
     *
     * @param owner Owning document.
     * @return XML representation of this configuration.
     */
    public Node toXML(Document owner) {
        Element elem = owner.createElement("configuration");                    // <configuration>
        elem.setAttribute("xmlns", NS);                                         // Set default namespace
        elem.setAttribute("https", httpsRequired? "true" : "false");            // Add https attribute
        elem.setAttribute("localhost", localhostRequired? "true" : "false");    // Add localhost attribute

        if (password != null && password.length > 0)                            // If we have a password
            elem.setAttribute("password", encode(password));                    // Add passowrd attribute

        for (Iterator i = productServers.iterator(); i.hasNext();) {            // For each product server
            ProductServer ps = (ProductServer) i.next();                        // Get the product server
            elem.appendChild(ps.toXML(owner));                                  // And add it under <configuration>
        }

        for (Iterator i = profileServers.iterator(); i.hasNext();) {            // For each profile server
            ProfileServer ps = (ProfileServer) i.next();                        // Get the profile server
            elem.appendChild(ps.toXML(owner));                                  // And add it under the <configuration>
        }

        if (!codeBases.isEmpty()) {                                             // Got any code bases?
            Element cbs = owner.createElement("codeBases");                     // Boo yah.  Make a parent for 'em
            elem.appendChild(cbs);                                              // Add parent
            for (Iterator i = codeBases.iterator(); i.hasNext();) {             // Then, for each code base
                URL url = (URL) i.next();                                       // Get the URL to it
                Element cb = owner.createElement("codeBase");                   // And make a <codeBase> for it
                cb.setAttribute("url", url.toString());                         // And an "url" attribute
                cbs.appendChild(cb);                                            // Add it
            }
        }

        if (!properties.isEmpty()) {                                            // If we have any properties>
            Element props = owner.createElement("properties");                  // Add <properties> under <configuration>
            props.setAttribute("xml:space", "preserve");                        // And make sure space is properly preserved
            elem.appendChild(props);                                            // Add the space attribute
            for (Iterator i = properties.entrySet().iterator(); i.hasNext();) { // For each property
                Map.Entry entry = (Map.Entry) i.next();                         // Get the property key/value pair
                String key = (String) entry.getKey();                           // Key is always a String
                String value = (String) entry.getValue();                       // So is the value
                Element prop = owner.createElement("property");                 // Create a <property> element
                props.appendChild(prop);                                        // Add it under the <properties>
                prop.setAttribute("key", key);                                  // Set the key as an attribute
                Text text = owner.createTextNode(value);                        // Make text to hold the value
                prop.appendChild(text);                                         // Add it under the <property>
            }
        }
        return elem;
    }

    /**
     * Get the properties.
     *
     * @return a <code>Properties</code> value.
     */
    public Properties getProperties() {
        return properties;
    }

    /**
     * Is localhost access required for the configuration?
     *
     * @return True if the configuration must be accessed from the localhost, false otherwise.
     */
    public boolean isLocalhostRequired() {
        return localhostRequired;
    }

    /**
     * Is https access required for the configuration?
     *
     * @return True if the configuration must be accessed via https, false if http is OK.
     */
    public boolean isHTTPSrequired() {
        return httpsRequired;
    }

    /**
     * Set if https is required to access the configuration.
     *
     * @param required True if the configuration must be accessed via https, false if http is OK.
     */
    public void setHTTPSrequired(boolean required) {
        httpsRequired = required;
    }

    /**
     * Set if localhost is required to access the configuration.
     *
     * @param required True if the configuration must be accessed from the localhost, false otherwise.
     */
    public void setLocalhostRequired(boolean required) {
        localhostRequired = required;
    }

    /**
     * Return the code bases.
     *
     * @return a <code>List</code> of {@link URL}s.
     */
    public List getCodeBases() {
        return codeBases;
    }

    /**
     * Get the product servers.
     *
     * @return a <code>List</code> of {@link ProductServer}s.
     */
    public List getProductServers() {
        return productServers;
    }

    /**
     * Get the profile servers.
     *
     * @return a <code>List</code> of {@link ProfileServer}s.
     */
    public List getProfileServers() {
        return profileServers;
    }

    /**
     * Get the administrator password.
     *
     * @return Administrator password.
     */
    public byte[] getPassword() {
        return password;
    }

    /**
     * Set the administrator password.
     *
     * @param password Administrator password.
     */
    public void setPassword(byte[] password) {
        if (password == null)
            throw new IllegalArgumentException("Non-null passwords not allowed");
        this.password = password;
    }

    /**
     * Save the configuration.
     *
     * @throws IOException if an I/O error occurs.
     */
    public synchronized void save() throws IOException {
        BufferedWriter writer = null;                           // Start w/no writer
        try {                                                   // Then try ...
            writer = new BufferedWriter(new FileWriter(file));  // Create a writer
            Document doc;                                       // As for the doc...
            synchronized (DOCUMENT_BUILDER) {                   // Using the document builder...
                doc = DOCUMENT_BUILDER.newDocument();           // Create an empty document
            }
            Node root = toXML(doc);                             // Convert this config to XML
            doc.appendChild(root);                              // Add it to the doc
            DOMSource source = new DOMSource(doc);              // Use the source Luke
            StreamResult result = new StreamResult(writer);     // And serialize it to the writer
            TRANSFORMER.transform(source, result);              // Serialize
        } catch (TransformerException ex) {
            throw new IllegalStateException("Unexpected TransformerException: " + ex.getMessage());
        } finally {
            if (writer != null) try {                           // And if we got a writer, try ...
                writer.close();                                 // to close it
            } catch (IOException ignore) {}                     // Ignoring any error
        }
    }

    /**
     * Parse a serialized configuration document.
     *
     * @param file File to parse
     * @throws IOException if an I/O error occurs.
     * @throws SAXException if a parse error occurs.
     */
    private void parse(File file) throws IOException, SAXException {
        Document doc;                                                               // Start with a doc ...
        synchronized (DOCUMENT_BUILDER) {                                           // And using the DOCUMENT_BUILDER
            doc = DOCUMENT_BUILDER.parse(file);                                     // Try to parse the file
        }
        Element root = doc.getDocumentElement();                                    // Assume the root element is <configuration>

        String httpsAttr = root.getAttribute("https");                              // Get the https attribute
        httpsRequired = httpsAttr != null && "true".equals(httpsAttr);              // See if it's "true"

        String localhostAttr = root.getAttribute("localhost");                      // Get the localhost attribute
        localhostRequired = localhostAttr != null && "true".equals(localhostAttr);  // See if it's "true"

        String passwordAttr = root.getAttribute("password");                        // Get the password attribute
        if (passwordAttr != null && passwordAttr.length() > 0)                      // If it's there, and non-empty
            password = decode(passwordAttr);                                        // Then decode it

        NodeList children = root.getChildNodes();                                   // Get the child nodes
        for (int i = 0; i < children.getLength(); ++i) {                            // For each child node
            Node child = children.item(i);                                          // Get the child
            if (child.getNodeType() == Node.ELEMENT_NODE) {                         // An element?
                if ("server".equals(child.getNodeName())) {                         // A <server>?
                    Server server = Server.create(this, (Element) child);           // Create the correct server

                    // Keep these in separate sets?
                    if (server instanceof ProductServer)                            // Is a product server?
                        productServers.add(server);                                 // Add to product servers
                    else if (server instanceof ProfileServer)                       // Is a profile server?
                        profileServers.add(server);                                 // Add to profile servers
                    else throw new IllegalArgumentException("Unexpected server type " + server + " in " + file);
                } else if ("properties".equals(child.getNodeName())) {              // Is it a <properties>?
                    NodeList props = child.getChildNodes();                         // Get its children
                    for (int j = 0; j < props.getLength(); ++j) {                   // For each child
                        Node node = props.item(j);                                  // Get the chld
                        if (node.getNodeType() == Node.ELEMENT_NODE                 // And element?
                            && "property".equals(node.getNodeName())) {             // And it's <property>?
                            Element propNode = (Element) node;                      // Great, use it as an element
                            String key = propNode.getAttribute("key");              // Get its key attribute
                            if (key == null || key.length() == 0)                   // Make sure it's there
                                throw new SAXException("Required 'key' attribute missing from "
                                    + "<property> element");
                            properties.setProperty(key, text(propNode));            // And set it
                        }
                    }
                } else if ("codeBases".equals(child.getNodeName())) {               // And yadda
                    NodeList cbs = child.getChildNodes();                           // yadda
                    for (int j = 0; j < cbs.getLength(); ++j) {                     // yadda.
                        Node node = cbs.item(j);
                        if (node.getNodeType() == Node.ELEMENT_NODE
                            && "codeBase".equals(node.getNodeName())) {
                            Element cbNode = (Element) node;
                            String u = cbNode.getAttribute("url");
                            if (u == null || u.length() == 0)
                                throw new SAXException("Required 'url' attribute missing from "
                                    + "<codeBase> element");
                            try {
                                codeBases.add(new URL(u));
                            } catch (MalformedURLException ex) {
                                throw new SAXException("url attribute " + u + " isn't a valid URL");
                            }
                        }
                    }
                }
            }
        }
    }

    /**
     * Encode a password.  This just hides it so it's not plain text, but it's just as
     * easy to decode it if you have a base-64 decoder handy.
     *
     * @param password a <code>byte[]</code> value.
     * @return a <code>String</code> value.
     */
    static String encode(byte[] password) {
        return new String(Base64.encode(password));
    }

    /**
     * Decode a password.
     *
     * @param password a <code>String</code> value.
     * @return a <code>byte[]</code> value.
     */
    static byte[] decode(String password) {
        return Base64.decode(password.getBytes());
    }

    /**
     * Get the text under an XML node.
     *
     * @param node a <code>Node</code> value.
     * @return a <code>String</code> value.
     */
    private static String text(Node node) {
        StringBuffer b = new StringBuffer();
        text0(node, b);
        return b.toString();
    }

    /**
     * Get the text from an XML node into a StringBuffer. 
     *
     * @param node a <code>Node</code> value.
     * @param b a <code>StringBuffer</code> value.
     */
    private static void text0(Node node, StringBuffer b) {
        NodeList children = node.getChildNodes();
        for (int i = 0; i < children.getLength(); ++i)
            text0(children.item(i), b);
        short type = node.getNodeType();
        if (type == Node.CDATA_SECTION_NODE || type == Node.TEXT_NODE)
            b.append(node.getNodeValue());
    }

    public boolean equals(Object obj) {
        if (obj == this) return true;
        if (obj instanceof Configuration) {
            Configuration rhs = (Configuration) obj;
            return codeBases.equals(rhs.codeBases) && productServers.equals(rhs.productServers)
                && profileServers.equals(rhs.profileServers) && Arrays.equals(password, rhs.password)
                && httpsRequired == rhs.httpsRequired && localhostRequired == rhs.localhostRequired
                && properties.equals(rhs.properties);
        }
        return false;
    }

    public int hashCode() {
        return codeBases.hashCode() ^ productServers.hashCode() ^ profileServers.hashCode();
    }

    /** List of {@link URL}s to code bases. */
    private List codeBases = new ArrayList();

    /** List of {@link ProductServer}s. */
    private List productServers = new ArrayList();

    /** List of {@link ProfileServer}s. */
    private List profileServers = new ArrayList();

    /** Admin password. */
    private byte[] password = DEFAULT_PASSWORD;

    /** True if https is requried. */
    private boolean httpsRequired;

    /** True if localhost access is required. */
    private boolean localhostRequired;

    /** Properties to set. */
    private Properties properties = new Properties();

    /** Where to save the file. */
    private transient File file;

    /** Default password. */
    static final byte[] DEFAULT_PASSWORD = { (byte)'h', (byte)'a', (byte)'n', (byte)'a', (byte)'l', (byte)'e', (byte)'i' };

    /** XML namespace */
    public static final String NS = "http://oodt.jpl.nasa.gov/web-grid/ns/";

    /** Sole document builder we'll need. */
    private static final DocumentBuilder DOCUMENT_BUILDER;

    /** Sole transfomer we'll need. */
    private static final Transformer TRANSFORMER;

    static {
        try {
            DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory.newInstance();
            documentBuilderFactory.setNamespaceAware(true);
            documentBuilderFactory.setValidating(false);
            documentBuilderFactory.setIgnoringElementContentWhitespace(false);
            documentBuilderFactory.setExpandEntityReferences(true);
            documentBuilderFactory.setIgnoringComments(true);
            documentBuilderFactory.setCoalescing(true);
            DOCUMENT_BUILDER = documentBuilderFactory.newDocumentBuilder();

            TransformerFactory transformerFactory = TransformerFactory.newInstance();
            TRANSFORMER = transformerFactory.newTransformer();
            TRANSFORMER.setOutputProperty(OutputKeys.METHOD, "xml");
            TRANSFORMER.setOutputProperty(OutputKeys.VERSION, "1.0");
            TRANSFORMER.setOutputProperty(OutputKeys.ENCODING, "UTF-8");
            TRANSFORMER.setOutputProperty(OutputKeys.OMIT_XML_DECLARATION, "no");
            TRANSFORMER.setOutputProperty(OutputKeys.INDENT, "yes");
            TRANSFORMER.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "4");
        } catch (ParserConfigurationException ex) {
            throw new IllegalStateException("Cannot create document builder");
        } catch (TransformerConfigurationException ex) {
            throw new IllegalStateException("Cannot create transformer");
        }
    }
}