/*
 * Copyright 2018 Mordechai Meisels
 * 
 * Licensed 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.update4j.mapper;

import java.io.IOException;
import java.io.Reader;
import java.io.Writer;
import java.nio.charset.StandardCharsets;
import java.security.InvalidKeyException;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.Signature;
import java.security.SignatureException;
import java.util.ArrayList;
import java.util.Base64;
import java.util.List;
import java.util.stream.Collectors;

import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import org.update4j.OS;
import org.update4j.Property;
import org.update4j.util.FileUtils;
import org.w3c.dom.Document;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;

/*
 * Everything that can be replaced by a property should be stored as strings.
 * Resolve them in Configuration::read.
 *
 */
public class ConfigMapper extends XmlMapper {

    public String timestamp;
    public String signature;
    public String baseUri;
    public String basePath;
    public String updateHandler;
    public String launcher;
    public final List<Property> properties;
    public final List<FileMapper> files;

    public ConfigMapper() {
        properties = new ArrayList<>();
        files = new ArrayList<>();
    }

    public ConfigMapper(Node node) {
        this();
        parse(node);
    }

    public ConfigMapper(ConfigMapper copy) {
        this();
        timestamp = copy.timestamp;
        signature = copy.signature;
        baseUri = copy.baseUri;
        basePath = copy.basePath;
        updateHandler = copy.updateHandler;
        launcher = copy.launcher;

        properties.addAll(copy.properties);
        files.addAll(copy.files.stream().map(FileMapper::new).collect(Collectors.toList()));
    }

    @Override
    public void parse(Node node) {
        if (!"configuration".equals(node.getNodeName()))
            return;

        timestamp = getAttributeValue(node, "timestamp");
        signature = getAttributeValue(node, "signature");

        NodeList children = node.getChildNodes();

        for (int i = 0; i < children.getLength(); i++) {
            Node n = children.item(i);
            if ("base".equals(n.getNodeName())) {
                baseUri = getAttributeValue(n, "uri");
                basePath = getAttributeValue(n, "path");
            } else if ("provider".equals(n.getNodeName())) {
                updateHandler = getAttributeValue(n, "updateHandler");
                launcher = getAttributeValue(n, "launcher");
            } else if ("properties".equals(n.getNodeName())) {
                parseProperties(n.getChildNodes());
            } else if ("files".equals(n.getNodeName())) {
                parseFiles(n.getChildNodes());
            }
        }

    }

    private void parseProperties(NodeList list) {
        for (int i = 0; i < list.getLength(); i++) {
            Node n = list.item(i);
            if ("property".equals(n.getNodeName())) {
                String key = getAttributeValue(n, "key");
                String value = getAttributeValue(n, "value");
                String os = getAttributeValue(n, "os");

                OS osEnum = null;
                if (os != null)
                    osEnum = OS.fromShortName(os);

                if (key != null && value != null) {
                    properties.add(new Property(key, value, osEnum));
                }
            }
        }
    }

    private void parseFiles(NodeList list) {
        for (int i = 0; i < list.getLength(); i++) {
            Node n = list.item(i);
            if ("file".equals(n.getNodeName())) {
                files.add(new FileMapper(n));
            }
        }
    }

    @Override
    public String toXml() {
        StringBuilder builder = new StringBuilder();

        builder.append("<configuration");

        // Since anybody can modify these fields, we don't take chances and escape them
        if (timestamp != null) {
            builder.append(" timestamp=\"" + escape(timestamp) + "\"");
        }
        if (signature != null) {
            builder.append(" signature=\"" + escape(signature) + "\"");
        }

        String children = getChildrenXml();

        if (!children.isEmpty()) {
            builder.append(">\n");
            builder.append(children);
            builder.append("</configuration>");
        } else {
            builder.append("/>\n");
        }

        return builder.toString();
    }

    private String getChildrenXml() {

        // no children
        if (baseUri == null && basePath == null && updateHandler == null && launcher == null && properties.isEmpty()
                        && files.isEmpty()) {
            return "";
        }

        StringBuilder builder = new StringBuilder();

        if (baseUri != null || basePath != null) {
            builder.append("    <base");

            if (baseUri != null) {
                builder.append(" uri=\"" + escape(baseUri) + "\"");
            }
            if (basePath != null) {
                builder.append(" path=\"" + escape(basePath) + "\"");
            }

            builder.append("/>\n");
        }
        if (updateHandler != null || launcher != null) {
            builder.append("    <provider");

            if (updateHandler != null) {
                builder.append(" updateHandler=\"" + escape(updateHandler) + "\"");
            }
            if (launcher != null) {
                builder.append(" launcher=\"" + escape(launcher) + "\"");
            }

            builder.append("/>\n");
        }

        if (!properties.isEmpty()) {
            builder.append("    <properties>\n");

            for (Property p : properties) {
                builder.append("        <property");

                builder.append(" key=\"" + escape(p.getKey()) + "\"");
                builder.append(" value=\"" + escape(p.getValue()) + "\"");

                if (p.getOs() != null)
                    builder.append(" os=\"" + p.getOs().getShortName() + "\"");

                builder.append("/>\n");
            }

            builder.append("    </properties>\n");
        }

        if (!files.isEmpty()) {
            builder.append("    <files>\n");

            for (FileMapper fm : files) {
                builder.append(fm.toXml());
            }

            builder.append("    </files>\n");
        }

        return builder.toString();
    }

    public String sign(PrivateKey key) {
        try {
            Signature sign = FileUtils.getSignature(key);
            sign.initSign(key);
            sign.update(getChildrenXml().getBytes(StandardCharsets.UTF_8));
            return Base64.getEncoder().encodeToString(sign.sign());
        } catch (InvalidKeyException | SignatureException e) {
            throw new RuntimeException(e);
        }
    }

    public void verifySignature(PublicKey key) {
        if (signature == null) {
            throw new SecurityException("No signature in configuration root node.");
        }

        try {
            Signature sign = FileUtils.getSignature(key);
            sign.initVerify(key);
            sign.update(getChildrenXml().getBytes(StandardCharsets.UTF_8));

            if (!sign.verify(Base64.getDecoder().decode(signature))) {
                throw new SecurityException("Signature verification failed.");
            }

        } catch (InvalidKeyException | SignatureException e) {
            throw new SecurityException(e);
        }
    }

    public static ConfigMapper read(Reader reader) throws IOException {
        try {
            Document doc = DocumentBuilderFactory.newInstance().newDocumentBuilder().parse(new InputSource(reader));
            NodeList list = doc.getChildNodes();
            for (int i = 0; i < list.getLength(); i++) {
                Node n = list.item(i);
                if ("configuration".equals(n.getNodeName())) {
                    return new ConfigMapper(n);
                }
            }

            throw new IllegalStateException("Root element must be 'configuration'.");
        } catch (SAXException | ParserConfigurationException e) {
            throw new IOException(e);
        }
    }

    public void write(Writer writer) throws IOException {
        write(writer, true);
    }

    public void write(Writer writer, boolean header) throws IOException {
        if (header) {
            writer.write("<?xml version=\"1.1\" encoding=\"UTF-8\" standalone=\"yes\"?>\n");
            writer.write("\n");
            writer.write("<!-- Generated by update4j. Licensed under Apache Software License 2.0 -->\n");
        }

        writer.write(toXml());
    }

}
