package de.intevation.flys.client.server.meta;

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

import de.intevation.flys.client.shared.model.DataCageTree;
import de.intevation.flys.client.shared.model.DataCageNode;

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

public class Converter
{
    public interface NodeConverter
    {
        DataCageNode convert(Element node, Converter converter);

    } // interface NodeConverter

    public static class NameConverter implements NodeConverter {
        public DataCageNode convert(Element node, Converter converter) {
            System.err.println("NameConverter called");
            DataCageNode out = new DataCageNode(node.getAttribute("name"));
            converter.convertChildren(out, node);
            return out;
        }
    } // class NameConverter

    public static class I18NConverter implements NodeConverter {
        public DataCageNode convert(Element node, Converter converter) {
            System.err.println("I18NConverter called");
            DataCageNode out =
                new DataCageNode("${" + node.getLocalName() + "}");
            converter.convertChildren(out, node);
            return out;
        }
    } // I18NConverter

    protected Map<String, NodeConverter> converters;

    protected void convertChildren(DataCageNode parent, Element sub) {
        System.err.println("convertChildren called");
        NodeList children = sub.getChildNodes();
        for (int i = 0, N = children.getLength(); i < N; ++i) {
            Node child = children.item(i);
            if (child.getNodeType() == Node.ELEMENT_NODE) {
                String name = child.getLocalName();
                NodeConverter converter = converters.get(name);
                if (converter != null) {
                    DataCageNode son = converter.convert(
                        (Element)child, this);
                    parent.addChild(son);
                }
            }
        } // for all children
    }

    public Converter() {
        converters = new HashMap<String, NodeConverter>();
        registerConverters();
    }

    protected void registerConverters() {
        System.err.println("register converters called");
        converters.put("datacage",                    new NameConverter());
        converters.put("river",                       new NameConverter());
        converters.put("gauge",                       new NameConverter());
        converters.put("historical",                  new NameConverter());
        converters.put("discharge-table-nn",          new I18NConverter());
        converters.put("discharge-table-gauge",       new I18NConverter());
        converters.put("fixations",                   new I18NConverter());
        converters.put("fixation",                    new I18NConverter());
        converters.put("columns",                     new I18NConverter());
        converters.put("column",                      new NameConverter());
        converters.put("flood-protections",           new I18NConverter());
        converters.put("flood-protection",            new I18NConverter());
        converters.put("flood-water-marks",           new I18NConverter());
        converters.put("flood-water-mark",            new I18NConverter());
        converters.put("water-levels",                new I18NConverter());
        converters.put("water-level",                 new I18NConverter());
        converters.put("extra-longitudinal-sections", new I18NConverter());
        converters.put("extra-longitudinal-section",  new I18NConverter());
        converters.put("longitudinal-section",        new I18NConverter());
    }

    public DataCageTree convert(Document document) {
        System.err.println("convert called");

        ArrayList<DataCageNode> roots = new ArrayList<DataCageNode>();
        NodeList nodes = document.getChildNodes();
        for (int i = 0, N = nodes.getLength(); i < N; ++i) {
            Node node = nodes.item(i);
            if (node.getNodeType() == Node.ELEMENT_NODE) {
                System.err.println("search for name: " + node.getLocalName());
                NodeConverter converter = converters.get(node.getLocalName());
                if (converter != null) {
                    roots.add(converter.convert((Element)node, this));
                }
            }
        }
        return roots.isEmpty()
            ? new DataCageTree()
            : new DataCageTree(roots.get(0));
    }
}
// vim:set ts=4 sw=4 si et sta sts=4 fenc=utf8 :