/*
 * 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.marmotta.kiwi.loader;

import static org.hamcrest.CoreMatchers.containsString;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.util.Properties;
import java.util.zip.GZIPOutputStream;

import org.apache.commons.io.IOUtils;
import org.apache.marmotta.commons.vocabulary.FOAF;
import org.apache.marmotta.kiwi.config.KiWiConfiguration;
import org.apache.marmotta.kiwi.persistence.h2.H2Dialect;
import org.hamcrest.CoreMatchers;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.contrib.java.lang.system.ExpectedSystemExit;
import org.junit.contrib.java.lang.system.StandardOutputStreamLog;
import org.junit.rules.TemporaryFolder;
import org.openrdf.model.ValueFactory;
import org.openrdf.model.vocabulary.RDF;
import org.openrdf.repository.Repository;
import org.openrdf.repository.RepositoryConnection;
import org.openrdf.repository.RepositoryException;
import org.openrdf.rio.RDFFormat;
import org.openrdf.rio.RDFParseException;

public class KiWiLoaderTest {

    @Rule
    public final TemporaryFolder temp = new TemporaryFolder();
    
    @Rule
    public final ExpectedSystemExit exit = ExpectedSystemExit.none();
    
    @Rule
    public final StandardOutputStreamLog stdOut = new StandardOutputStreamLog();
    
    private File confFile;
    private File dataFile;
    private Properties loaderProps;

    @Before
    public void setUp() throws IOException {
        // The config file
        confFile = temp.newFile("loader.properties");
        loaderProps = getLoaderProps();
        FileOutputStream fos = new FileOutputStream(confFile);
        loaderProps.store(fos, "");
        fos.close();
        
        // input file
        dataFile = temp.newFile("test-data.xml");
        copyResourceToFile("/org/apache/marmotta/kiwi/test/demo-data.foaf", dataFile);
        
    }
    
    private Properties getLoaderProps() throws IOException {
        Properties props = new Properties();

        props.setProperty("database.type", "h2");
        props.setProperty("database.url", String.format("jdbc:h2:%s/marmotta;MVCC=true;DB_CLOSE_ON_EXIT=FALSE;DB_CLOSE_DELAY=10", temp.newFolder("db").getAbsolutePath()));
        props.setProperty("database.user", "marmotta");
        props.setProperty("database.password", "marmotta");
        
        props.setProperty("kiwi.context", "http://test.example.com/");
        
        return props;
    }


    @Test
    public void testMain_NoArgs() {
        exit.expectSystemExitWithStatus(3);
        KiWiLoader.main(new String[] {});
        assertThat(stdOut.getLog(), containsString("Cannot import without database connection!"));
    }
    
    @Test
    public void testMain_ConfigNotFound() {
        exit.expectSystemExitWithStatus(1);
        KiWiLoader.main(new String[] {"-c", confFile.getAbsolutePath() + ".not-found"});
        assertThat(stdOut.getLog(), containsString("Could not read system-config.properties:"));
    }
    
    @Test
    public void testMain_FileNotFound() {
        final String fName = dataFile.getAbsolutePath() + ".not-found";
        KiWiLoader.main(new String[] {"-c", confFile.getAbsolutePath(), fName});
        assertThat(stdOut.getLog(), containsString("Could not read file " + fName + ", skipping..."));
    }
    
    @Test
    public void testMain() {
        KiWiLoader.main(new String[] {"-c", confFile.getAbsolutePath(), "-f", "application/rdf+xml", dataFile.getAbsolutePath()});
        assertThat(stdOut.getLog(), containsString("Importing " + dataFile.getAbsolutePath()));
        assertThat(stdOut.getLog(), containsString(String.format("Import completed (%s)", dataFile.getAbsolutePath())));
    }

    @Test
    public void testLoadFile() throws RepositoryException, RDFParseException,
            IOException {
        KiWiTestLoader loader = new KiWiTestLoader(getKiWiConfig(),
                "htto://example.com/test/", "htto://example.com/context/");
        loader.initialize();

        loader.load(dataFile.getAbsolutePath(), RDFFormat.RDFXML, false);

        final RepositoryConnection con = loader.getRepository().getConnection();
        try {
            con.begin();
            testRepoContent(con);
            con.commit();
        } finally {
            if (con.isActive()) {
                con.rollback();
            }
            con.close();
        }
        loader.shutdown();
    }

    @Test
    public void testLoadFile_GZ() throws RepositoryException, RDFParseException,
            IOException {
        File gz = temp.newFile(dataFile.getName() + ".gz");
        OutputStream os = new GZIPOutputStream(new FileOutputStream(gz));
        FileInputStream is = new FileInputStream(dataFile);
        IOUtils.copy(is, os);
        is.close();
        os.close();
        
        KiWiTestLoader loader = new KiWiTestLoader(getKiWiConfig(),
                "htto://example.com/test/", "htto://example.com/context/");
        loader.initialize();

        loader.load(gz.getAbsolutePath(), RDFFormat.RDFXML, true);

        final RepositoryConnection con = loader.getRepository().getConnection();
        try {
            con.begin();
            testRepoContent(con);
            con.commit();
        } finally {
            if (con.isActive()) { 
                con.rollback();
            }
            con.close();
        }
        loader.shutdown();
    }

    
    private void testRepoContent(RepositoryConnection con) throws RepositoryException {
        final ValueFactory vf = con.getValueFactory();
        assertThat(con.size(), CoreMatchers.equalTo(new Long(34)));
        assertTrue(con.hasStatement(vf.createURI("http://localhost:8080/LMF/resource/hans_meier"), RDF.TYPE, FOAF.Person, true));
        assertTrue(con.hasStatement(vf.createURI("http://localhost:8080/LMF/resource/sepp_huber"), RDF.TYPE, FOAF.Person, true));
        assertTrue(con.hasStatement(vf.createURI("http://localhost:8080/LMF/resource/anna_schmidt"), RDF.TYPE, FOAF.Person, true));
    }

    private KiWiConfiguration getKiWiConfig() {
        final Properties p = loaderProps;
        KiWiConfiguration config = new KiWiConfiguration("loader-test",
                p.getProperty("database.url"), p.getProperty("database.user"),
                p.getProperty("database.password"), new H2Dialect());

        return config;
    }

    @Test
    public void testLoadInputStream() throws RepositoryException, RDFParseException, IOException {
        KiWiTestLoader loader = new KiWiTestLoader(getKiWiConfig(),
                "htto://example.com/test/", "htto://example.com/context/");
        loader.initialize();

        loader.load(new FileInputStream(dataFile), RDFFormat.RDFXML);

        final RepositoryConnection con = loader.getRepository().getConnection();
        try {
            con.begin();
            testRepoContent(con);
            con.commit();
        } finally {
            if (con.isActive()) {
                con.rollback();
            }
            con.close();
        }
        loader.shutdown();
    }
    
    private static void copyResourceToFile(String resource, File file) throws IOException {
        final FileOutputStream os = new FileOutputStream(file);
        IOUtils.copy(KiWiLoaderTest.class.getResourceAsStream(resource), os);
        os.close();
    }
    
    protected static class KiWiTestLoader extends KiWiLoader {

        public KiWiTestLoader(KiWiConfiguration kiwi, String baseUri,
                String context) {
            super(kiwi, baseUri, context);
        }
        
        public Repository getRepository() {
            return super.repository;
        }
        
    }
    

}