/* 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.client.server;

import java.util.Iterator;
import java.util.List;

import org.apache.log4j.Logger;
import org.dive4elements.artifacts.common.ArtifactNamespaceContext;
import org.dive4elements.artifacts.common.utils.XMLUtils;
import org.dive4elements.artifacts.httpclient.exceptions.ConnectionException;
import org.dive4elements.artifacts.httpclient.http.HttpClient;
import org.dive4elements.artifacts.httpclient.http.HttpClientImpl;
import org.dive4elements.river.client.client.services.MetaDataService;
import org.dive4elements.river.client.server.auth.User;
import org.dive4elements.river.client.server.meta.Converter;
import org.dive4elements.river.client.shared.exceptions.ServerException;
import org.dive4elements.river.client.shared.model.AttrList;
import org.dive4elements.river.client.shared.model.DataCageNode;
import org.dive4elements.river.client.shared.model.DataCageTree;
import org.w3c.dom.Document;
import org.w3c.dom.Element;

/**
 * Service that returns certain meta-data from the backends data, polished to
 * inclusion into current project.
 */
public class MetaDataServiceImpl extends RemoteServiceServlet implements MetaDataService {

    private static final long serialVersionUID = 1L;

    /** Our very own log. */
    private static final Logger log = Logger.getLogger(MetaDataServiceImpl.class);

    private static final String ERROR_NO_META_DATA_FOUND = "error_no_meta_data_found";

    private static final class Prune {
        private final User user;

        public Prune(final User user) {
            this.user = user;
        }

        void execute(final DataCageTree tree) {

            final DataCageNode root = tree.getRoot();

            if (root == null || !root.hasChildren())
                return;

            recursivePrune(root);
        }

        private boolean recursivePrune(final DataCageNode node) {

            /* filter by user - features */
            if (!acceptUserFeatures(node))
                return false;

            /* recursively check all leafs, we only accepts real ones that have a factory */
            if (!node.hasChildren())
                return acceptLeaf(node);

            final List<DataCageNode> children = node.getChildren();

            for (final Iterator<DataCageNode> iterator = children.iterator(); iterator.hasNext();) {
                final DataCageNode dataCageNode = iterator.next();

                if (!recursivePrune(dataCageNode))
                    iterator.remove();
            }

            return !children.isEmpty();
        }

        private boolean acceptUserFeatures(final DataCageNode node) {
        final AttrList al = node.getAttributes();
            if (al == null)
                return true;

            final String module = al.getValue("module");
            if (module == null)
                return true;

            if (this.user == null || this.user.canUseFeature("module:" + module))
                return true;

            return false;
    }

        private boolean acceptLeaf(final DataCageNode node) {
            final AttrList al = node.getAttributes();
            if (al == null)
                return false;

            return al.hasAttribute("factory");
        }
    }

    /**
     * @param locale
     *            needed for i18n.
     * @param artifactId
     *            ID of masterartifact (can be null)
     * @param userId
     *            can be null
     * @param outs
     *            can be null
     * @param parameters
     *            can be null or parameters like
     *            "load-system:true;key:value"
     */
    @Override
    public DataCageTree getMetaData(final String locale, final String artifactId, final String userId, final String outs, final String parameters)
            throws ServerException {
        log.info("MetaDataService.getMetaData");

        // Create the query document.
        final String url = getServletContext().getInitParameter("server-url");

        final Document doc = XMLUtils.newDocument();

        final XMLUtils.ElementCreator ec = new XMLUtils.ElementCreator(doc, ArtifactNamespaceContext.NAMESPACE_URI, ArtifactNamespaceContext.NAMESPACE_PREFIX);

        final Element meta = ec.create("meta");

        if (artifactId != null) {
            final Element artifactEl = ec.create("artifact-id");
            artifactEl.setAttribute("value", artifactId);
            meta.appendChild(artifactEl);
        }

        if (userId != null) {
            final Element userEl = ec.create("user-id");
            userEl.setAttribute("value", userId);
            meta.appendChild(userEl);
        }

        if (outs != null) {
            final Element outsEl = ec.create("outs");
            outsEl.setAttribute("value", outs);
            meta.appendChild(outsEl);
        }

        if (parameters != null) {
            final Element paramsEl = ec.create("parameters");
            paramsEl.setAttribute("value", parameters);
            meta.appendChild(paramsEl);
        }

        doc.appendChild(meta);

        // Fire.
        final HttpClient client = new HttpClientImpl(url, locale);

        try {
            final User user = getUser();

            final Converter converter = new Converter();
            final DataCageTree tree = converter.convert(client.callService(url, "metadata", doc));

            new Prune(user).execute(tree);

            return tree;
        }
        catch (final ConnectionException ce) {
            ce.printStackTrace();
        }

        throw new ServerException(ERROR_NO_META_DATA_FOUND);
    }
}