package fr.ifremer.adagio.core.action;

/*
 * #%L
 * SIH-Adagio :: Shared
 * $Id:$
 * $HeadURL:$
 * %%
 * Copyright (C) 2012 - 2014 Ifremer
 * %%
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU Affero General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 * #L%
 */

import java.io.File;
import java.io.IOException;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.List;
import java.util.Properties;
import java.util.Set;

import org.apache.commons.io.FileUtils;
import org.apache.commons.lang3.ArrayUtils;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.nuiton.i18n.I18n;

import com.google.common.base.Charsets;
import com.google.common.base.Preconditions;
import com.google.common.base.Predicate;
import com.google.common.collect.Lists;
import com.google.common.collect.Sets;
import com.google.common.io.Files;

import fr.ifremer.adagio.core.config.AdagioConfiguration;
import fr.ifremer.adagio.synchro.SynchroTechnicalException;
import fr.ifremer.adagio.synchro.dao.DaoUtils;

public class AllegroCoreNewEmptyDbAction {
    /* Logger */
    private static final Log log = LogFactory.getLog(AllegroCoreNewEmptyDbAction.class);

    private static String HSQLDB_SRC_DATABASE_CREATE_SCRIPT = "changelog/allegro.script";

    public void run() {
        AdagioConfiguration config = AdagioConfiguration.getInstance();

        // Log target connection
        if (log.isInfoEnabled()) {
            log.info("Creating a new empty database...");
        }

        // Check output directory validity
        File outputDirectory = config.getLiquibaseOutputFile();
        if (outputDirectory == null) {
            log.error("No output directory. Please use the option: --output <OUTPUT_DIRECTORY>");
            System.exit(1);
        }
        if (log.isInfoEnabled()) {
            log.info(" Output directory: " + outputDirectory);
        }
        if (outputDirectory.exists() && !outputDirectory.isDirectory()) {
            log.error("Not a directory: " + outputDirectory);
            System.exit(1);
        }

        // Make sure the directory could be created
        try {
            FileUtils.forceMkdir(outputDirectory);
        } catch (IOException e) {
            throw new SynchroTechnicalException(
                    I18n.t("adagio.persistence.newEmptyDatabase.mkdir.error", outputDirectory),
                    e);
        }

        if (ArrayUtils.isNotEmpty(outputDirectory.listFiles())) {
            log.error("The output directory should be empty: " + outputDirectory);
            System.exit(1);
        }

        // Set the database directory into the configuration
        config.setDbDirectory(outputDirectory);

        // Get connections properties :
        Properties targetConnectionProperties = config.getConnectionProperties();

        // Check connections
        if (!checkConnection(config, targetConnectionProperties)) {
            return;
        }

        try {
            // Create the database
            createEmptyDb(targetConnectionProperties);
        } catch (SQLException e) {
            throw new SynchroTechnicalException(
                    I18n.t("adagio.persistence.newEmptyDatabase.create.error"),
                    e);
        } catch (IOException e) {
            throw new SynchroTechnicalException(
                    I18n.t("adagio.persistence.newEmptyDatabase.create.error"),
                    e);
        }

        try {
            // Shutdown database at end
            DaoUtils.shutdownDatabase(targetConnectionProperties);
        } catch (SQLException e) {
            throw new SynchroTechnicalException(
                    I18n.t("adagio.persistence.newEmptyDatabase.shutdown.error"),
                    e);
        }
    }

    protected boolean checkConnection(
            AdagioConfiguration config,
            Properties targetConnectionProperties) {

        // Log target connection
        if (log.isInfoEnabled()) {
            log.info("Connecting to target database...");
            log.info(String.format(" Database directory: %s", config.getDbDirectory()));
            log.info(String.format(" JDBC Driver: %s", config.getJdbcDriver()));
            log.info(String.format(" JDBC URL: %s", config.getJdbcURL()));
            log.info(String.format(" JDBC Username: %s", config.getJdbcUsername()));
        }

        // Check target connection
        boolean isValidConnection = DaoUtils.isValidConnectionProperties(targetConnectionProperties);
        if (!isValidConnection) {
            log.error("Connection error: could not connect to target database.");
            return false;
        }

        return true;
    }

    public void createEmptyDb(Properties targetConnectionProperties) throws SQLException, IOException {

        File scriptFile = new File(HSQLDB_SRC_DATABASE_CREATE_SCRIPT);
        Preconditions.checkState(scriptFile.exists(), "Could not find db script at " + scriptFile);

        if (log.isInfoEnabled()) {
            log.info("Will use create script: " + scriptFile);
        }
        Connection connection = DaoUtils.createConnection(targetConnectionProperties);
        try {
            List<String> importScriptSql = getImportScriptSql(scriptFile);
            for (String sql : importScriptSql) {
                PreparedStatement statement = null;
                try {
                    statement = connection.prepareStatement(sql);
                    statement.execute();
                } catch (SQLException sqle) {
                    log.warn("SQL command failed : " + sql, sqle);
                    throw sqle;
                } finally {
                    DaoUtils.closeSilently(statement);
                }

            }
            connection.commit();
        } finally {
            DaoUtils.closeSilently(connection);
        }
    }

    protected List<String> getImportScriptSql(File scriptFile) throws IOException {
        List<String> lines = Files.readLines(scriptFile, Charsets.UTF_8);

        List<String> result = Lists.newArrayListWithCapacity(lines.size());

        Predicate<String> predicate = new Predicate<String>() {

            Set<String> forbiddenStarts = Sets.newHashSet(
                    "SET ",
                    "CREATE USER ",
                    "CREATE SCHEMA ",
                    "GRANT DBA TO ");

            @Override
            public boolean apply(String input) {
                boolean accept = true;
                for (String forbiddenStart : forbiddenStarts) {
                    if (input.startsWith(forbiddenStart)) {
                        accept = false;
                        break;
                    }
                }
                return accept;
            }
        };
        for (String line : lines) {
            if (predicate.apply(line.trim().toUpperCase())) {
                if (line.contains("\\u000a")) {
                    line = line.replaceAll("\\\\u000a", "\n");
                }
                result.add(line);
            }
        }
        return result;
    }
}