/*
 * 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.maven.scm;

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Calendar;
import java.util.Date;
import java.util.TimeZone;

import org.apache.maven.scm.manager.ScmManager;
import org.apache.maven.scm.repository.ScmRepository;
import org.codehaus.plexus.ContainerConfiguration;
import org.codehaus.plexus.PlexusConstants;
import org.codehaus.plexus.util.FileUtils;
import org.codehaus.plexus.util.StringUtils;
import org.codehaus.plexus.util.cli.CommandLineUtils;
import org.codehaus.plexus.util.cli.CommandLineUtils.StringStreamConsumer;
import org.codehaus.plexus.util.cli.Commandline;
import org.junit.Before;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import static org.junit.Assume.assumeTrue;

/**
 * Base class for all SCM tests. Consumers will typically
 * extend this class while tck test would extend ScmTckTestCase.
 * <br>
 * This class basically defines default locations for the
 * test environment and implements convenience methods.
 *
 * @author <a href="mailto:jason@maven.org">Jason van Zyl</a>
 *
 */
public abstract class ScmTestCase extends PlexusJUnit4TestCase {
    protected static final TimeZone GMT_TIME_ZONE = TimeZone.getTimeZone("GMT");

    private static boolean debugExecute;

    private ScmManager scmManager;

    @Before
    @Override
    public void setUp() throws Exception {
        super.setUp();

        deleteDirectory(getRepositoryRoot());
        assertFalse(getRepositoryRoot().exists());
        deleteDirectory(getWorkingCopy());
        assertFalse(getWorkingCopy().exists());
        deleteDirectory(getWorkingDirectory());
        assertFalse(getWorkingDirectory().exists());
        deleteDirectory(getAssertionCopy());
        assertFalse(getAssertionCopy().exists());
        deleteDirectory(getUpdatingCopy());
        assertFalse(getUpdatingCopy().exists());

        scmManager = null;
    }

    @Override
    public void customizeContainerConfiguration(final ContainerConfiguration configuration) {
        configuration.setClassPathScanning(PlexusConstants.SCANNING_INDEX).setAutoWiring(true);
    }

    /**
     * @return default location of the test read/write repository
     */
    protected File getRepositoryRoot() {
        return PlexusJUnit4TestCase.getTestFile("target/scm-test/repository");
    }

    /**
     * @return Location of the revisioned (read only) repository
     */
    protected File getRepository() {
        return PlexusJUnit4TestCase.getTestFile("/src/test/repository");
    }

    /**
     * @return location of the working copy (always checkout)
     */
    protected File getWorkingCopy() {
        return PlexusJUnit4TestCase.getTestFile("target/scm-test/working-copy");
    }

    /**
     * Legacy method - same as getWorkingCopy()
     *
     * @return location of the working copy (always checkout)
     */
    protected File getWorkingDirectory() {
        return getWorkingCopy();
    }

    /**
     * @return default location for doing assertions on a working tree
     */
    protected File getAssertionCopy() {
        return PlexusJUnit4TestCase.getTestFile("target/scm-test/assertion-copy");
    }

    /**
     * @return default location for doing update operations on a working tree
     */
    protected File getUpdatingCopy() {
        return PlexusJUnit4TestCase.getTestFile("target/scm-test/updating-copy");
    }

    protected ScmManager getScmManager() throws Exception {
        if (scmManager == null) {
            scmManager = lookup(ScmManager.class);
        }

        return scmManager;
    }

    protected ScmRepository makeScmRepository(String scmUrl) throws Exception {
        return getScmManager().makeScmRepository(scmUrl);
    }

    public void assertPath(String expectedPath, String actualPath) throws Exception {
        assertEquals(expectedPath.replace('\\', '/'), actualPath.replace('\\', '/'));
    }

    protected void assertFile(File root, String fileName) throws Exception {
        File file = new File(root, fileName);

        assertTrue("Missing file: '" + file.getAbsolutePath() + "'.", file.exists());

        assertTrue("File isn't a file: '" + file.getAbsolutePath() + "'.", file.isFile());

        String expected = fileName;

        String actual = FileUtils.fileRead(file);

        assertEquals(
                "The file doesn't contain the expected contents. File: " + file.getAbsolutePath(), expected, actual);
    }

    protected void assertResultIsSuccess(ScmResult result) {
        if (result.isSuccess()) {
            return;
        }

        printOutputError(result);

        fail("The command result success flag was false.");
    }

    protected void printOutputError(ScmResult result) {
        System.err.println("----------------------------------------------------------------------");
        System.err.println("Provider message");
        System.err.println("----------------------------------------------------------------------");
        System.err.println(result.getProviderMessage());
        System.err.println("----------------------------------------------------------------------");

        System.err.println("----------------------------------------------------------------------");
        System.err.println("Command output");
        System.err.println("----------------------------------------------------------------------");
        System.err.println(result.getCommandOutput());
        System.err.println("----------------------------------------------------------------------");
    }

    protected ScmFileSet getScmFileSet() {
        return new ScmFileSet(getWorkingCopy());
    }

    protected static void setDebugExecute(boolean debugExecute) {
        ScmTestCase.debugExecute = debugExecute;
    }

    /**
     * Execute the command line
     *
     * @param workingDirectory not null
     * @param executable       not null, should be a system command
     * @param arguments        not null
     * @throws Exception if any
     * @see CommandLineUtils#executeCommandLine(Commandline, org.codehaus.plexus.util.cli.StreamConsumer,
     *      org.codehaus.plexus.util.cli.StreamConsumer)
     */
    public static void execute(File workingDirectory, String executable, String arguments) throws Exception {
        Commandline cl = new Commandline();

        cl.setExecutable(executable);

        cl.setWorkingDirectory(workingDirectory.getAbsolutePath());

        cl.addArguments(CommandLineUtils.translateCommandline(arguments));

        StringStreamConsumer stdout = new CommandLineUtils.StringStreamConsumer();

        StringStreamConsumer stderr = new CommandLineUtils.StringStreamConsumer();

        System.out.println("Test command line: " + cl);

        int exitValue = CommandLineUtils.executeCommandLine(cl, stdout, stderr);

        if (debugExecute || exitValue != 0) {
            System.err.println("-----------------------------------------");
            System.err.println("Command line: " + cl);
            System.err.println("Working directory: " + cl.getWorkingDirectory());
            System.err.println("-----------------------------------------");
            System.err.println("Standard output: ");
            System.err.println("-----------------------------------------");
            System.err.println(stdout.getOutput());
            System.err.println("-----------------------------------------");

            System.err.println("Standard error: ");
            System.err.println("-----------------------------------------");
            System.err.println(stderr.getOutput());
            System.err.println("-----------------------------------------");
        }

        if (exitValue != 0) {
            fail("Exit value wasn't 0, was:" + exitValue);
        }
    }

    protected static void makeDirectory(File basedir, String fileName) {
        File dir = new File(basedir, fileName);

        if (!dir.exists()) {
            assertTrue(dir.mkdirs());
        }
    }

    protected static void makeFile(File basedir, String fileName) throws IOException {
        makeFile(basedir, fileName, fileName);
    }

    public static void makeFile(File basedir, String fileName, String contents) throws IOException {
        File file = new File(basedir, fileName);

        File parent = file.getParentFile();

        if (!parent.exists()) {
            assertTrue(parent.mkdirs());
        }

        try (FileWriter writer = new FileWriter(file)) {
            writer.write(contents);
        }
    }

    protected void deleteDirectory(File directory) throws IOException {
        FileUtils.deleteDirectory(directory);
    }

    public static Date getDate(int year, int month, int day) {
        return getDate(year, month, day, 0, 0, 0, null);
    }

    protected static Date getDate(int year, int month, int day, TimeZone tz) {
        return getDate(year, month, day, 0, 0, 0, tz);
    }

    protected static Date getDate(int year, int month, int day, int hourOfDay, int minute, int second, TimeZone tz) {
        Calendar cal = Calendar.getInstance();

        if (tz != null) {
            cal.setTimeZone(tz);
        }
        cal.set(year, month, day, hourOfDay, minute, second);
        cal.set(Calendar.MILLISECOND, 0);

        return cal.getTime();
    }

    public void assertCommandLine(String expectedCommand, File expectedWorkingDirectory, Commandline actualCommand)
            throws IOException {
        Commandline cl = new Commandline(expectedCommand);
        if (expectedWorkingDirectory != null) {
            cl.setWorkingDirectory(expectedWorkingDirectory.getAbsolutePath());
        }
        String expectedCommandLineAsExecuted = StringUtils.join(cl.getShellCommandline(), " ");
        String actualCommandLineAsExecuted = StringUtils.join(actualCommand.getShellCommandline(), " ");
        assertEquals(expectedCommandLineAsExecuted, actualCommandLineAsExecuted);
    }

    public static void checkScmPresence(String scmProviderCommand) {
        assumeTrue(
                "Skipping tests because the required command '" + scmProviderCommand + "' is not available.",
                ScmTestCase.isSystemCmd(scmProviderCommand));
    }

    /**
     * @param cmd the executable to run, not null.
     * @return true if and only if the command is on the path
     */
    public static boolean isSystemCmd(String cmd) {
        try {
            Runtime.getRuntime().exec(cmd);

            return true;
        } catch (IOException e) {
            return false;
        }
    }
}
