package de.intevation.flys.artifacts.services.meta;

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

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.apache.log4j.Logger;

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

import org.hibernate.Session;

import org.hibernate.jdbc.Work;

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

import de.intevation.flys.artifacts.FLYSArtifact;

import de.intevation.flys.backend.SessionHolder;

import de.intevation.artifactdatabase.data.StateData;


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

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

    private static DataCage INSTANCE;

    protected Builder builder;

    public DataCage() {
    }

    public DataCage(Builder builder) {
        this.builder = builder;
    }

    public Builder getBuilder() {
        return builder;
    }

    protected static void artifactToParameters(
        FLYSArtifact        artifact, 
        Map<String, Object> parameters
    ) {
        parameters.put("current-state-id", artifact.getCurrentStateId());

        for (StateData sd: artifact.getAllData()) {
            Object value = sd.getValue();
            if (value == null) {
                continue;
            }
            String key = sd.getName().replace('.', '-');
            parameters.put(key, value);
        }
    }

    public void  recommend(
        FLYSArtifact        artifact,
        String []           outs,
        Map<String, Object> extraParameters,
        Node                result
    ) {
        Map<String, Object> parameters = new HashMap<String, Object>();

        if (extraParameters != null) {
            parameters.putAll(extraParameters);
        }

        if (artifact != null) {
            artifactToParameters(artifact, parameters);
        }

        parameters.put("artifact-outs", outs);

        parameters.put("parameters", parameters);

        recommend(parameters, result);
    }

    public void recommend(
        final Map<String, Object> parameters,
        final Node                result
    ) {
        if (builder == null) {
            log.error("builder not configured properly.");
            return;
        }

        Session session = SessionHolder.HOLDER.get();

        session.doWork(new Work() {
            @Override
            public void execute(Connection connection)
            throws SQLException
            {
                builder.build(connection, result, parameters);
            }
        });
    }

    public static synchronized DataCage getInstance() {
        if (INSTANCE == null) {
            INSTANCE = createDataCage();
        }
        return INSTANCE;
    }

    protected static Builder createBuilder(File file) {
        log.debug("DataCage.createBuilder");

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

        InputStream in = null;

        try {
            in = new FileInputStream(file);

            Document template = XMLUtils.parseDocument(in);

            if (template == null) {
                log.error("cannot parse meta data template");
            }
            else {
                return new Builder(template);
            }
        }
        catch (IOException ioe) {
            log.error(ioe);
        }
        finally {
            if (in != null) {
                try {
                    in.close();
                }
                catch (IOException ioe) {
                    log.error(ioe);
                }
            }
        }
        return null;
    }

    protected static DataCage createDataCage() {
        log.debug("DataCage.createDataCage");

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

        path = Config.replaceConfigDir(path);

        return new DataCage(createBuilder(new File(path)));
    }
}
// vim:set ts=4 sw=4 si et sta sts=4 fenc=utf-8 :