/* Copyright (C) 2011, 2012, 2013 by Bundesanstalt für Gewässerkunde
 * Software engineering by Intevation GmbH
 *
 * This file is Free Software under the GNU AGPL (>=v3)
 * and comes with ABSOLUTELY NO WARRANTY! Check out the
 * documentation coming with Dive4Elements River for details.
 */

package org.dive4elements.river.exports;

import java.util.ArrayList;
import java.util.List;

import org.w3c.dom.Element;
import org.w3c.dom.NodeList;

import org.dive4elements.river.exports.process.Processor;

import org.apache.log4j.Logger;

import org.dive4elements.artifacts.CallContext;

import org.dive4elements.river.artifacts.resources.Resources;
import org.dive4elements.river.artifacts.D4EArtifact;

public class DiagramAttributes
{
    private static Logger log = Logger.getLogger(DiagramAttributes.class);

    public static class AxisAttributes {
        // TODO: More Attributes
        private String name;

        public AxisAttributes() {
        }

        public AxisAttributes(String name) {
            this.name = name;
        }

        public String getName() {
            return name;
        }
    } // class AxisAttributes

    public static class AxisProcessor {
        private Processor processor;
        private String axisName;

        public AxisProcessor() {
        }

        public AxisProcessor(Processor processor, String axisName) {
            this.processor = processor;
            this.axisName  = axisName;
        }

        public Processor getProcessor() {
            return processor;
        }

        public String getAxisName() {
            return axisName;
        }
    } // class AxisProcessor

    public static class Argument {
        private String expression;
        private String type;

        public Argument() {
        }

        public Argument(String expression, String type) {
            this.expression = expression;
            this.type = type;
        }

        public Object evaluate(D4EArtifact artifact, CallContext context) {
            if (expression.startsWith("artifact.")) {
                String value = artifact.getDataAsString(
                    expression.substring("artifact.".length()));
                return convert(value);
            }
            if (expression.startsWith("context.")) {
                return context.getContextValue(
                    expression.substring("context.".length()));
            }
            return expression;
        }

        private Object convert(String value) {
            if (value == null || type == null) {
                return value;
            }
            if ("double".equals(type)) {
                return Double.valueOf(value);
            }
            if ("int".equals(type)) {
                return Integer.valueOf(value);
            }
            // TODO: more types
            return value;
        }
    } // class Argument

    public static class Title {

        private String key;
        private String def;
        private List<Argument> arguments;

        public Title() {
            arguments = new ArrayList<Argument>(5);
        }

        public Title(String key) {
            this(key, key);
        }

        public Title(String key, String def) {
            this();
            this.key = key;
            this.def = def;
        }

        public String getKey() {
            return key;
        }

        public void addArgument(Argument argument) {
            arguments.add(argument);
        }

        public String evalute(D4EArtifact artifact, CallContext context) {
            if (key == null || key.isEmpty()) {
                return def;
            }
            Object [] args = new Object[arguments.size()];
            for (int i = 0; i < args.length; ++i) {
                args[i] = arguments.get(i).evaluate(artifact, context);
            }
            return Resources.getMsg(context.getMeta(), key, def, args);
        }
    } // class Title

    private List<AxisAttributes> axesAttrs;
    private List<AxisProcessor> axesProcessors;

    private Title title;
    private Title subtitle;

    public DiagramAttributes() {
        axesAttrs      = new ArrayList<AxisAttributes>(5);
        axesProcessors = new ArrayList<AxisProcessor>(5);
    }

    public DiagramAttributes(Element config) {
        this();
        parseAxis(config);
        parseProcessors(config);
        parseTitle(config);
    }

    private void parseAxis(Element config) {
        NodeList axisNodes = config.getElementsByTagName("axis");

        for (int i = 0, N = axisNodes.getLength(); i < N; ++i) {
            Element axisElement = (Element)axisNodes.item(i);
            String name = axisElement.getAttribute("name").trim();
            if (!name.isEmpty()) {
                axesAttrs.add(new AxisAttributes(name));
            }
        }
    }

    public List<AxisProcessor> getAxesProcessors() {
        return axesProcessors;
    }

    public Title getTitle() {
        return title;
    }

    public Title getSubtitle() {
        return subtitle;
    }

    private void parseProcessors(Element config) {
        NodeList processorNodes = config.getElementsByTagName("processor");

        for (int i = 0, N = processorNodes.getLength(); i < N; ++i) {
            Element processorElement = (Element)processorNodes.item(i);
            String className = processorElement.getAttribute("class").trim();
            String axisName = processorElement.getAttribute("axis").trim();
            if (className.isEmpty() || axisName.isEmpty()) {
                continue;
            }

            try {
                Processor processor =
                    (Processor)Class.forName(className).newInstance();
                axesProcessors.add(new AxisProcessor(processor, axisName));
            }
            catch (ClassNotFoundException cnfe) {
                log.error(cnfe, cnfe);
            }
            catch (InstantiationException ie) {
                log.error(ie, ie);
            }
            catch (IllegalAccessException ia) {
                log.error(ia, ia);
            }
            catch (ClassCastException cce) {
                log.error(cce, cce);
            }
        }
    }

    private void parseTitle(Element config) {
        title = extractTitle(config, "title");
    }

    private void parseSubtitle(Element config) {
        subtitle = extractTitle(config, "subtitle");
    }

    private static Title extractTitle(Element config, String tagName) {
        NodeList titleNodes = config.getElementsByTagName(tagName);
        if (titleNodes.getLength() < 1) {
            return null;
        }
        Element titleElement = (Element)titleNodes.item(0);
        String key = titleElement.getAttribute("key");
        String def = titleElement.getAttribute("default");
        Title title = new Title(key, def);
        NodeList argumentNodes = titleElement.getElementsByTagName("arg");
        for (int i = 0, N = argumentNodes.getLength(); i < N; ++i) {
            Element argumentElement = (Element)argumentNodes.item(i);
            String expression = argumentElement.getAttribute("expr");
            String type = argumentElement.getAttribute("type");
            title.addArgument(new Argument(expression, type));
        }
        return title;
    }
}
// vim:set ts=4 sw=4 si et sta sts=4 fenc=utf8 :