package org.apache.tuscany.maven.plugin.surefire;

/*
 * 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.
 */

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.jar.JarEntry;
import java.util.jar.JarOutputStream;
import java.util.jar.Manifest;

import org.apache.maven.surefire.booter.SurefireBooterForkException;
import org.apache.maven.surefire.booter.shade.org.codehaus.plexus.util.cli.Commandline;
import org.apache.maven.surefire.util.UrlUtils;
import org.codehaus.plexus.util.StringUtils;

/**
 * Derived from surefire-booter 2.4.3
 * Configuration for forking tests.
 *
 */
@SuppressWarnings("unchecked")
public class ForkConfiguration {
    public static final String FORK_ONCE = "once";

    public static final String FORK_ALWAYS = "always";

    public static final String FORK_NEVER = "never";

    private String forkMode;

    private boolean useSystemClassLoader;
    private boolean useManifestOnlyJar;

    private Properties systemProperties;

    private String jvmExecutable;

    private String argLine;

    private Map environmentVariables;

    private File workingDirectory;

    private boolean debug;

    private String debugLine;

    public void setForkMode(String forkMode) {
        if ("pertest".equalsIgnoreCase(forkMode)) {
            this.forkMode = FORK_ALWAYS;
        } else if ("none".equalsIgnoreCase(forkMode)) {
            this.forkMode = FORK_NEVER;
        } else if (forkMode.equals(FORK_NEVER) || forkMode.equals(FORK_ONCE) || forkMode.equals(FORK_ALWAYS)) {
            this.forkMode = forkMode;
        } else {
            throw new IllegalArgumentException("Fork mode " + forkMode + " is not a legal value");
        }
    }

    public boolean isForking() {
        return !FORK_NEVER.equals(forkMode);
    }

    public void setUseSystemClassLoader(boolean useSystemClassLoader) {
        this.useSystemClassLoader = useSystemClassLoader;
    }

    public boolean isUseSystemClassLoader() {
        return useSystemClassLoader;
    }

    public void setSystemProperties(Properties systemProperties) {
        this.systemProperties = (Properties)systemProperties.clone();
    }

    public void setJvmExecutable(String jvmExecutable) {
        this.jvmExecutable = jvmExecutable;
    }

    public void setArgLine(String argLine) {
        this.argLine = argLine;
    }

    public void setDebugLine(String debugLine) {
        this.debugLine = debugLine;
    }

    public void setEnvironmentVariables(Map environmentVariables) {
        this.environmentVariables = new HashMap(environmentVariables);
    }

    public void setWorkingDirectory(File workingDirectory) {
        this.workingDirectory = workingDirectory;
    }

    public String getForkMode() {
        return forkMode;
    }

    public Properties getSystemProperties() {
        return systemProperties;
    }

    /**
     * @throws SurefireBooterForkException
     * @deprecated use the 2-arg alternative.
     */
    public Commandline createCommandLine(List classPath) throws SurefireBooterForkException {
        return createCommandLine(classPath, false);
    }

    public Commandline createCommandLine(List classPath, boolean useJar) throws SurefireBooterForkException {
        Commandline cli = new Commandline();

        cli.setExecutable(jvmExecutable);

        if (argLine != null) {
            cli.createArg().setLine(argLine);
        }

        if (environmentVariables != null) {
            Iterator iter = environmentVariables.keySet().iterator();

            while (iter.hasNext()) {
                String key = (String)iter.next();

                String value = (String)environmentVariables.get(key);

                cli.addEnvironment(key, value);
            }
        }

        if (debugLine != null && !"".equals(debugLine)) {
            cli.createArg().setLine(debugLine);
        }

        if (useJar) {
            File jarFile;
            try {
                jarFile = createJar(classPath);
            } catch (IOException e) {
                throw new SurefireBooterForkException("Error creating archive file", e);
            }

            cli.createArg().setValue("-jar");

            cli.createArg().setValue(jarFile.getAbsolutePath());
        } else {
            cli.createArg().setValue("-classpath");

            cli.createArg().setValue(StringUtils.join(classPath.iterator(), File.pathSeparator));

            cli.createArg().setValue(OSGiSurefireBooter.class.getName());
        }

        cli.setWorkingDirectory(workingDirectory.getAbsolutePath());

        return cli;
    }

    /**
     * Create a jar with just a manifest containing a Main-Class entry for SurefireBooter and a Class-Path entry
     * for all classpath elements.
     *
     * @param classPath List<String> of all classpath elements.
     * @return
     * @throws IOException
     */
    private File createJar(List classPath) throws IOException {
        File file = File.createTempFile("surefirebooter", ".jar");
        if (!debug) {
            file.deleteOnExit();
        }
        FileOutputStream fos = new FileOutputStream(file);
        JarOutputStream jos = new JarOutputStream(fos);
        jos.setLevel(JarOutputStream.STORED);
        JarEntry je = new JarEntry("META-INF/MANIFEST.MF");
        jos.putNextEntry(je);

        Manifest man = new Manifest();

        // we can't use StringUtils.join here since we need to add a '/' to
        // the end of directory entries - otherwise the jvm will ignore them.
        String cp = "";
        for (Iterator it = classPath.iterator(); it.hasNext();) {
            String el = (String)it.next();
            // NOTE: if File points to a directory, this entry MUST end in '/'.
            cp += UrlUtils.getURL(new File(el)).toExternalForm() + " ";
        }

        man.getMainAttributes().putValue("Manifest-Version", "1.0");
        man.getMainAttributes().putValue("Class-Path", cp.trim());
        man.getMainAttributes().putValue("Main-Class", OSGiSurefireBooter.class.getName());

        man.write(jos);
        jos.close();

        return file;
    }

    public void setDebug(boolean debug) {
        this.debug = debug;
    }

    public boolean isDebug() {
        return debug;
    }

    public void setUseManifestOnlyJar(boolean useManifestOnlyJar) {
        this.useManifestOnlyJar = useManifestOnlyJar;
    }

    public boolean isUseManifestOnlyJar() {
        return useManifestOnlyJar;
    }
}