/* 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.artifacts.services;

import com.vividsolutions.jts.geom.Envelope;

import org.dive4elements.artifactdatabase.XMLService;
import org.dive4elements.artifacts.CallMeta;
import org.dive4elements.artifacts.GlobalContext;
import org.dive4elements.artifacts.common.ArtifactNamespaceContext;
import org.dive4elements.artifacts.common.utils.Config;
import org.dive4elements.artifacts.common.utils.XMLUtils;
import org.dive4elements.artifacts.common.utils.XMLUtils.ElementCreator;
import org.dive4elements.river.utils.GeometryUtils;

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

import javax.xml.xpath.XPathConstants;

import org.apache.log4j.Logger;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;

/**
 * This service provides information about the supported rivers by this
 * application.
 *
 * @author <a href="mailto:ingo.weinzierl@intevation.de">Ingo Weinzierl</a>
 */
public class MapInfoService extends XMLService {

    /** XPath that points to the river.*/
    public static final String XPATH_RIVER = "/mapinfo/river/text()";

    public static final String XPATH_MAPTYPE = "/mapinfo/maptype/text()";

    private static final String XPATH_RIVER_PROJECTION =
        "/artifact-database/*[local-name()=$maptype]/"
        + "river[@name=$river]/srid/@value";

    private static final String XPATH_RIVER_BACKGROUND =
        "/artifact-database/*[local-name()=$maptype]/"
        + "river[@name=$river]/background-wms";

    private static final String XPATH_RIVER_WMS =
        "/artifact-database/*[local-name()=$maptype]/"
        + "river[@name=$river]/river-wms";


    /** The log used in this service.*/
    private static Logger log = Logger.getLogger(MapInfoService.class);


    /**
     * The default constructor.
     */
    public MapInfoService() {
    }

    protected static String getStringXPath(
        String              query,
        Map<String, String> variables
    ) {
        return (String)XMLUtils.xpath(
            Config.getConfig(), query, XPathConstants.STRING,
            null, variables);
    }

    protected static Node getNodeXPath(
        String              query,
        Map<String, String> variables
    ) {
        return (Node)XMLUtils.xpath(
            Config.getConfig(), query, XPathConstants.NODE,
            null, variables);
    }

    @Override
    public Document processXML(
        Document      data,
        GlobalContext globalContext,
        CallMeta      callMeta
    ) {
        log.debug("MapInfoService.process");

        Document result   = XMLUtils.newDocument();
        ElementCreator cr = new ElementCreator(result, null, null);

        Element mapinfo = cr.create("mapinfo");
        result.appendChild(mapinfo);

        String river = extractRiver(data);
        if (river == null || river.length() == 0) {
            log.warn("Cannot generate information: river is empty!");
            return result;
        }

        String mapType = extractMaptype(data);
        if (mapType == null
        || !(mapType.equals("floodmap") || mapType.equals("rivermap"))) {
            mapType = "floodmap";
        }

        Element root = cr.create("river");
        cr.addAttr(root, "name", river);
        mapinfo.appendChild(root);

        Envelope env = GeometryUtils.getRiverBoundary(river);
        if (env != null) {
            String bounds = GeometryUtils.jtsBoundsToOLBounds(env);
            if (log.isDebugEnabled()) {
                log.debug("River '" + river + "' bounds: " + bounds);
            }

            Element bbox = cr.create("bbox");
            cr.addAttr(bbox, "value", bounds);
            root.appendChild(bbox);
        }

        Map<String, String> vars = new HashMap<String, String>();
        vars.put("maptype", mapType);
        vars.put("river", river);

        String sridStr = getStringXPath(XPATH_RIVER_PROJECTION, vars);

        if (sridStr != null && sridStr.length() > 0) {
            Element srid = cr.create("srid");
            cr.addAttr(srid, "value", sridStr);
            root.appendChild(srid);
        }

        if (log.isDebugEnabled()) {
            log.debug("processXML: " + XMLUtils.toString(root));
        }

        root.appendChild(
            createWMSElement("background-wms",
                XPATH_RIVER_BACKGROUND, vars, cr));

        root.appendChild(
            createWMSElement("river-wms",
                XPATH_RIVER_WMS, vars, cr));

        return result;
    }


    protected Element createWMSElement(
        String elementName,
        String xpath,
        Map<String, String> vars,
        ElementCreator cr)
    {
        log.debug("createWMSElement()");

        Element el = cr.create(elementName);
        Element wms = (Element)getNodeXPath(xpath, vars);

        if (wms != null) {
            cr.addAttr(el, "url", wms.getAttribute("url"));
            cr.addAttr(el, "layers", wms.getAttribute("layers"));

            log.debug("createWMSElement: " + XMLUtils.toString(el));
        }
        else {
            log.debug("createWMSElement: wms == null");
        }

        return el;
    }


    private static String extractRiver(Document data) {
        return XMLUtils.xpathString(
            data, XPATH_RIVER, ArtifactNamespaceContext.INSTANCE);
    }

    private static String extractMaptype(Document data) {
        return XMLUtils.xpathString(
            data, XPATH_MAPTYPE, ArtifactNamespaceContext.INSTANCE);
    }
}
// vim:set ts=4 sw=4 si et sta sts=4 fenc=utf8 :