package de.intevation.flys.artifacts.services;

import java.io.InputStream;
import java.io.IOException;
import java.io.File;
import java.io.FileInputStream;

import java.sql.Connection;
import java.sql.SQLException;

import org.w3c.dom.Document;

import org.apache.log4j.Logger;

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

import de.intevation.artifacts.CallMeta;
import de.intevation.artifacts.ServiceFactory;

import de.intevation.artifactdatabase.DefaultService;

import de.intevation.artifacts.common.utils.Config;
import de.intevation.artifacts.common.utils.XMLUtils;

import de.intevation.artifacts.common.ArtifactNamespaceContext;

import de.intevation.flys.artifacts.services.meta.Builder;

import de.intevation.flys.backend.SessionHolder;

import org.hibernate.Session;

import org.hibernate.jdbc.Work;

public class MetaDataService
extends      DefaultService
{
    private static Logger log = Logger.getLogger(MetaDataService.class);

    public static final String XPATH_META_DATA_TEMPLATE =
        "/artifact-database/metadata/@template";

    public static final String XPATH_RIVER = "/art:river/text()";

    protected Builder builder;

    public MetaDataService() {
    }

    protected static Map<String, Object> extractParameters(Document data) {
        HashMap<String, Object> parameters = new HashMap<String, Object>();

        String river = XMLUtils.xpathString(
            data, XPATH_RIVER, ArtifactNamespaceContext.INSTANCE);

        if (river == null || (river = river.trim()).length() == 0) {
            river = "%"; // matches all rivers
        }

        parameters.put("river", river);

        return parameters;
    }

    @Override
    public Document process(
        Document data,
        Object   globalContext,
        CallMeta callMeta
    ) {
        log.debug("MetaDataService.process");

        final Document result = XMLUtils.newDocument();

        if (builder == null) {
            log.error("MetaDataService is not setup properly.");
            return result;
        }

        final Map<String, Object> parameters = extractParameters(data);

        Session session = SessionHolder.acquire();
        try {
            session.doWork(new Work() {
                @Override
                public void execute(Connection connection)
                throws SQLException
                {
                    log.debug("MetaDataService.execute");
                    builder.build(connection, result, parameters);
                }
            });
        }
        finally {
            session.close();
            SessionHolder.release();
        }

        return result;
    }

    @Override
    public void setup(ServiceFactory factory, Object globalContext) {
        log.debug("MetaDataService.setup");

        String path = Config.getStringXPath(XPATH_META_DATA_TEMPLATE);

        if (path == null) {
            log.error("no path to template file given");
            return;
        }

        path = Config.replaceConfigDir(path);

        File file = new File(path);

        if (!file.isFile() || !file.canRead()) {
            log.error("Cannot open template file '" + file + "'");
            return;
        }

        InputStream in = null;

        try {
            in = new FileInputStream(file);
            Document template = XMLUtils.parseDocument(in);
            if (template == null) {
                log.error("cannot parse meta data template");
            }
            else {
                builder = new Builder(template);
            }
        }
        catch (IOException ioe) {
            log.error(ioe);
        }
        finally {
            if (in != null) {
                try {
                    in.close();
                }
                catch (IOException ioe) {
                    log.error(ioe);
                }
            }
        }
    }
}
// vim:set ts=4 sw=4 si et sta sts=4 fenc=utf8 :