/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */
package org.apache.rya.rdftriplestore;

import static com.google.common.base.Preconditions.checkNotNull;

import org.apache.rya.api.RdfCloudTripleStoreConfiguration;
import org.apache.rya.api.persist.RdfEvalStatsDAO;
import org.apache.rya.api.persist.RyaDAO;
import org.apache.rya.api.persist.RyaDAOException;
import org.apache.rya.api.persist.joinselect.SelectivityEvalDAO;
import org.apache.rya.rdftriplestore.inference.InferenceEngine;
import org.apache.rya.rdftriplestore.namespace.NamespaceManager;
import org.apache.rya.rdftriplestore.provenance.ProvenanceCollector;
import org.eclipse.rdf4j.model.ValueFactory;
import org.eclipse.rdf4j.model.impl.SimpleValueFactory;
import org.eclipse.rdf4j.sail.SailConnection;
import org.eclipse.rdf4j.sail.SailException;
import org.eclipse.rdf4j.sail.helpers.AbstractSail;

public class RdfCloudTripleStore<C extends RdfCloudTripleStoreConfiguration> extends AbstractSail {

    private C conf;

    protected RyaDAO<C> ryaDAO;
    protected InferenceEngine inferenceEngine;
    protected RdfEvalStatsDAO<C> rdfEvalStatsDAO;
    protected SelectivityEvalDAO<C> selectEvalDAO;
    private NamespaceManager namespaceManager;
    protected ProvenanceCollector provenanceCollector;

    private static final ValueFactory VF = SimpleValueFactory.getInstance();

    @Override
    protected SailConnection getConnectionInternal() throws SailException {
        return new RdfCloudTripleStoreConnection(this, conf, VF);
    }

    @Override
    protected void initializeInternal() throws SailException {
        checkNotNull(ryaDAO);

        if (this.conf == null) {
            this.conf = ryaDAO.getConf();
        }

        checkNotNull(this.conf);

        try {
            if (!ryaDAO.isInitialized()) {
                ryaDAO.setConf(this.conf);
                ryaDAO.init();
            }
        } catch (final RyaDAOException e) {
            throw new SailException(e);
        }

        if (rdfEvalStatsDAO != null && !rdfEvalStatsDAO.isInitialized()) {
            rdfEvalStatsDAO.setConf(this.conf);
            rdfEvalStatsDAO.init();
        }

        if (namespaceManager == null) {
            this.namespaceManager = new NamespaceManager(ryaDAO, this.conf);
        }
    }

    @Override
    protected void shutDownInternal() throws SailException {

        try {
            if (namespaceManager != null) {
                namespaceManager.shutdown();
            }
            if (inferenceEngine != null) {
                inferenceEngine.destroy();
            }
            if (rdfEvalStatsDAO != null) {
                rdfEvalStatsDAO.destroy();
            }
            ryaDAO.destroy();
        } catch (final Exception e) {
            throw new SailException(e);
        }
    }

    @Override
    public ValueFactory getValueFactory() {
        return VF;
    }

    @Override
    public boolean isWritable() throws SailException {
        return true;
    }

    public synchronized C getConf() {
        return conf;
    }

    public synchronized void setConf(final C conf) {
        this.conf = conf;
    }

    public RdfEvalStatsDAO<C> getRdfEvalStatsDAO() {
        return rdfEvalStatsDAO;
    }

    public void setRdfEvalStatsDAO(final RdfEvalStatsDAO<C> rdfEvalStatsDAO) {
        this.rdfEvalStatsDAO = rdfEvalStatsDAO;
    }

    public SelectivityEvalDAO<C> getSelectEvalDAO() {
        return selectEvalDAO;
    }

    public void setSelectEvalDAO(final SelectivityEvalDAO<C> selectEvalDAO) {
        this.selectEvalDAO = selectEvalDAO;
    }

    public synchronized RyaDAO<C> getRyaDAO() {
        return ryaDAO;
    }

    public synchronized void setRyaDAO(final RyaDAO<C> ryaDAO) {
        this.ryaDAO = ryaDAO;
    }

    public synchronized InferenceEngine getInferenceEngine() {
        return inferenceEngine;
    }

    public synchronized void setInferenceEngine(final InferenceEngine inferenceEngine) {
        this.inferenceEngine = inferenceEngine;
    }

    public NamespaceManager getNamespaceManager() {
        return namespaceManager;
    }

    public void setNamespaceManager(final NamespaceManager namespaceManager) {
        this.namespaceManager = namespaceManager;
    }

    public ProvenanceCollector getProvenanceCollector() {
        return provenanceCollector;
    }

    public void setProvenanceCollector(final ProvenanceCollector provenanceCollector) {
        this.provenanceCollector = provenanceCollector;
    }

}