package org.eclipse.dltk.core.internal.rse;

import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.Writer;
import java.net.URI;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Random;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.Status;
import org.eclipse.dltk.compiler.util.Util;
import org.eclipse.dltk.core.DLTKCore;
import org.eclipse.dltk.core.environment.IDeployment;
import org.eclipse.dltk.core.environment.IEnvironment;
import org.eclipse.dltk.core.environment.IExecutionEnvironment;
import org.eclipse.dltk.core.environment.IExecutionLogger;
import org.eclipse.dltk.core.internal.rse.perfomance.RSEPerfomanceStatistics;
import org.eclipse.dltk.internal.launching.execution.EFSDeployment;
import org.eclipse.dltk.utils.TextUtils;
import org.eclipse.osgi.util.NLS;
import org.eclipse.rse.core.model.IHost;
import org.eclipse.rse.core.subsystems.ISubSystem;
import org.eclipse.rse.services.clientserver.messages.SystemMessageException;
import org.eclipse.rse.services.files.IFileService;
import org.eclipse.rse.services.shells.IHostShell;
import org.eclipse.rse.services.shells.IShellService;
import org.eclipse.rse.subsystems.files.core.servicesubsystem.IFileServiceSubSystem;
import org.eclipse.rse.subsystems.shells.core.subsystems.servicesubsystem.IShellServiceSubSystem;

public class RSEExecEnvironment implements IExecutionEnvironment {

	private static final String EXEC_BIN_SH = "exec /bin/sh "; //$NON-NLS-1$
	private static final String TOKEN_PREFIX = "DLTK_INITIAL_PREFIX_EXECUTION_STRING:"; //$NON-NLS-1$

	private final RSEEnvironment environment;
	private static int counter = -1;

	private static final Map<IHost, Map<String, String>> hostToEnvironment = new HashMap<>();

	public RSEExecEnvironment(RSEEnvironment env) {
		this.environment = env;
	}

	@Override
	public IDeployment createDeployment() {
		if (RSEPerfomanceStatistics.PERFOMANCE_TRACING) {
			RSEPerfomanceStatistics
					.inc(RSEPerfomanceStatistics.DEPLOYMENTS_CREATED);
		}
		if (!getEnvironment().connect()) {
			return null;
		}
		String tmpDir = getTempDir();
		if (tmpDir != null) {
			String rootPath = tmpDir + environment.getSeparator()
					+ getTempName("dltk", ".tmp"); //$NON-NLS-1$ //$NON-NLS-2$
			URI rootUri = createRemoteURI(environment.getHost(), rootPath);
			try {
				return new EFSDeployment(environment, rootUri);
			} catch (CoreException e) {
				if (DLTKCore.DEBUG) {
					e.printStackTrace();
				}
			}
		}
		return null;
	}

	private URI createRemoteURI(IHost host, String rootPath) {
		return RSEEnvironment.getURIFor(host, rootPath);
	}

	@SuppressWarnings("unchecked")
	private <SUBSYSTEM extends ISubSystem> SUBSYSTEM getSubSystem(IHost host,
			Class<SUBSYSTEM> clazz) {
		ISubSystem[] subsys = host.getSubSystems();
		for (int i = 0; i < subsys.length; i++) {
			if (clazz.isInstance(subsys[i]))
				return (SUBSYSTEM) subsys[i];
		}
		return null;
	}

	private String getTempName(String prefix, String suffix) {
		if (counter == -1) {
			counter = new Random().nextInt() & 0xffff;
		}
		counter++;
		return prefix + Integer.toString(counter) + suffix;
	}

	private String getTempDir() {
		final IHost host = environment.getHost();
		final IShellServiceSubSystem system = getSubSystem(host,
				IShellServiceSubSystem.class);
		if (system == null) {
			DLTKRSEPlugin.logWarning(NLS.bind(
					Messages.RSEExecEnvironment_hostNotFound, host.getName()));
			return null;
		}
		try {
			system.connect(new NullProgressMonitor(), false);
			final String tmp = system.getConnectorService().getTempDirectory();
			if (tmp != null && tmp.length() != 0) {
				return tmp;
			} else {
				return "/tmp"; //$NON-NLS-1$
			}
		} catch (Exception e) {
			if (DLTKCore.DEBUG) {
				e.printStackTrace();
			}
		}
		return null;
	}

	@Override
	public Process exec(String[] cmdLine, IPath workingDir, String[] environment)
			throws CoreException {
		return exec(cmdLine, workingDir, environment, null);
	}

	@Override
	public Process exec(String[] cmdLine, IPath workingDir,
			String[] environment, IExecutionLogger logger) throws CoreException {
		if (RSEPerfomanceStatistics.PERFOMANCE_TRACING) {
			RSEPerfomanceStatistics
					.inc(RSEPerfomanceStatistics.EXECUTION_COUNT);
		}
		final long start = RSEPerfomanceStatistics.PERFOMANCE_TRACING ? System
				.currentTimeMillis() : 0;
		final IHost host = this.environment.getHost();

		// obtain IFileService
		final IFileServiceSubSystem fileService = getSubSystem(host,
				IFileServiceSubSystem.class);
		if (fileService == null) {
			throw new CoreException(newStatus(
					RSEStatusConstants.NO_FILE_SERVICE, NLS.bind(
							Messages.RSEExecEnvironment_NoFileServicerError,
							host.getAliasName()), null));
		}
		if (!getEnvironment().connect()) {
			throw new CoreException(newStatus(
					RSEStatusConstants.NO_FILE_SERVICE, NLS.bind(
							Messages.RSEExecEnvironment_NotConnected, host
									.getAliasName()), null));
		}

		// remote path for launcher file
		final String tmpLauncherDir = getTempDir();
		final String tmpLauncher = "dltk-" + fileService.getUserId() + System.currentTimeMillis() + ".sh"; //$NON-NLS-1$ //$NON-NLS-2$
		final String tmpLauncherPath = tmpLauncherDir
				+ fileService.getSeparatorChar() + tmpLauncher;

		// build commands
		final List<String> commands = new ArrayList<>();
		if (workingDir != null) {
			final String p = this.environment.convertPathToString(workingDir);
			commands.add("cd " + p); //$NON-NLS-1$
		} else {
			commands.add("cd /"); //$NON-NLS-1$
		}
		/*
		 * Sometimes environment variables aren't set by the runCommand() call,
		 * so use export.
		 */
		if (environment != null) {
			// TODO Skip environment variables which are already in shell?
			for (int i = 0; i < environment.length; i++) {
				final String env = environment[i];
				if (isSafeEnvironmentVariable(extractName(env))) {
					commands.add(buildExportCommand(env));
				}
			}
		}
		final String token = TOKEN_PREFIX + System.currentTimeMillis();
		final String echoCmd = "echo \"" + token + "\""; //$NON-NLS-1$ //$NON-NLS-2$
		commands.add(echoCmd);
		commands.add(buildCommand(cmdLine));
		commands.add(echoCmd);
		commands.add("rm -f " + tmpLauncherPath); //$NON-NLS-1$
		if (logger != null) {
			logger.logLine("launcher=" + tmpLauncherDir + '/' + tmpLauncher); //$NON-NLS-1$
			for (String command : commands) {
				logger.logLine("launcher:" + command); //$NON-NLS-1$
			}
			logger.logLine("launcher:END"); //$NON-NLS-1$
		}

		// save launcher to the remote location
		try {

			try (final OutputStream os = fileService.getFileService().getOutputStream(tmpLauncherDir, tmpLauncher,
					IFileService.TEXT_MODE, new NullProgressMonitor())) {

				try (final Writer writer = new OutputStreamWriter(new BufferedOutputStream(os, 4096),
						fileService.getRemoteEncoding())) {
					for (String command : commands) {
						writer.write(command);
						writer.write('\n');
					}
					writer.flush();
				}
			}
		} catch (Exception e) {
			final String msg = NLS.bind(Messages.RSEExecEnvironment_LauncherUploadError, host.getAliasName(),
					e.getMessage());
			throw new CoreException(newStatus(RSEStatusConstants.LAUNCHER_UPLOAD_ERROR, msg, e));
		}

		// execute uploaded launcher in remote shell
		final IShellServiceSubSystem shell = getSubSystem(host,
				IShellServiceSubSystem.class);
		if (shell == null) {
			throw new CoreException(newStatus(
					RSEStatusConstants.NO_SHELL_SERVICE, NLS.bind(
							Messages.RSEExecEnvironment_NoShellService, host
									.getAliasName()), null));
		}
		try {
			shell.connect(new NullProgressMonitor(), false);
		} catch (Exception e) {
			throw new CoreException(newStatus(RSEStatusConstants.CONNECT_ERROR,
					NLS.bind(Messages.RSEExecEnvironment_ErrorConnecting, host
							.getAliasName(), e.getMessage()), e));
		}

		if (!shell.isConnected()) {
			throw new CoreException(newStatus(
					RSEStatusConstants.NOT_CONNECTED_ERROR, NLS.bind(
							Messages.RSEExecEnvironment_NotConnected, host
									.getAliasName()), null));
		}
		// TODO try to use "exec" channel instead of "shell" one.
		final IShellService shellService = shell.getShellService();
		final String command = EXEC_BIN_SH + tmpLauncherPath;
		final IHostShell hostShell;
		try {
			hostShell = shellService.runCommand(Util.EMPTY_STRING, command,
					environment, new NullProgressMonitor());
		} catch (SystemMessageException e) {
			throw new CoreException(newStatus(
					RSEStatusConstants.COMMAND_RUN_ERROR, NLS.bind(
							Messages.RSEExecEnvironment_ErrorRunningCommand,
							host.getAliasName(), e.getMessage()), e));
		}

		// wrap shell as java.lang.Process and return
		try {
			return new MyHostShellProcessAdapter(hostShell, token, logger);
		} catch (Exception e) {
			hostShell.writeToShell(MyHostShellProcessAdapter.CTRL_C);
			hostShell.exit();
			throw new CoreException(newStatus(
					RSEStatusConstants.INTERNAL_ERROR, NLS.bind(
							Messages.RSEExecEnvironment_ProcessCreateError, e
									.getMessage()), e));
		} finally {
			if (RSEPerfomanceStatistics.PERFOMANCE_TRACING) {
				RSEPerfomanceStatistics.inc(
						RSEPerfomanceStatistics.EXECUTION_TIME, System
								.currentTimeMillis()
								- start);
			}
		}
	}

	private static final List<String> UNSAFE_ENV_VARS = Arrays
			.asList(TextUtils
					.split(
							"GROUPS;BASH_ARGC;BASH_ARGV;BASH_SOURCE;BASH_LINENO;BASH_VERSINFO;EUID;PPID;SHELLOPTS;UID", ';')); //$NON-NLS-1$

	/**
	 * @param envVarName
	 * @return
	 */
	@Override
	public boolean isSafeEnvironmentVariable(String envVarName) {
		return !UNSAFE_ENV_VARS.contains(envVarName);
	}

	private static String buildExportCommand(String envEntry) {
		return toShellArguments(envEntry) + ";export " + extractName(envEntry); //$NON-NLS-1$
	}

	private static Status newStatus(int code, String msg,
			final Throwable exception) {
		return new Status(IStatus.ERROR, DLTKRSEPlugin.PLUGIN_ID, code, msg,
				exception);
	}

	/**
	 * @param environmentEntry
	 * @return
	 */
	private static String extractName(String environmentEntry) {
		final int pos = environmentEntry.indexOf('=');
		return pos > 0 ? environmentEntry.substring(0, pos) : environmentEntry;
	}

	private static int scanMissingQuote(String cmd) {
		int quote1 = -1;
		int quote2 = -1;
		for (int i = 0; i < cmd.length(); i++) {
			final char ch = cmd.charAt(i);
			if (ch == '"' && quote1 == -1) {
				quote2 = quote2 == -1 ? i : -1;
			} else if (ch == '\'' && quote2 == -1) {
				quote1 = quote1 == -1 ? i : -1;
			}
		}
		if (quote1 != -1 || quote2 != -1) {
			if (quote1 == -1) {
				return quote2;
			} else if (quote2 == -1) {
				return quote1;
			} else {
				return Math.min(quote1, quote2);
			}
		}
		return -1;
	}

	private static String toShellArguments(String cmd) {
		final int quote = scanMissingQuote(cmd);
		if (quote != -1) {
			return toShellArguments(cmd.substring(0, quote))
					+ "\\" //$NON-NLS-1$
					+ cmd.charAt(quote)
					+ toShellArguments(cmd.substring(quote + 1));
		}
		boolean quote1 = false;
		boolean quote2 = false;
		final StringBuilder sb = new StringBuilder(cmd.length() * 2);
		for (int i = 0; i < cmd.length(); i++) {
			final char ch = cmd.charAt(i);
			if (ch == '"' && !quote1) {
				quote2 = !quote2;
			} else if (ch == '\'' && !quote2) {
				quote1 = !quote1;
			}
			if (ch == ' ' && !quote1 && !quote2) {
				sb.append('\\');
			}
			sb.append(ch);
		}
		return sb.toString();
	}

	// public static void main(String[] args) {
	// System.out.println(toShellArguments("A='"));
	// System.out.println(toShellArguments("B1='\""));
	// System.out.println(toShellArguments("B1=\"'"));
	// System.out.println(toShellArguments("C=\" \""));
	// System.out.println(toShellArguments("D=\" \"'\" \""));
	// }

	private String buildCommand(String[] cmdLine) {
		StringBuffer cmd = new StringBuffer();
		for (int i = 0; i < cmdLine.length; i++) {
			if (i != 0) {
				cmd.append(" "); //$NON-NLS-1$
			}
			cmd.append(cmdLine[i]);
		}
		return cmd.toString();
	}

	@Override
	public Map<String, String> getEnvironmentVariables(boolean realyNeed) {
		if (!getEnvironment().connect()) {
			return null;
		}
		if (!realyNeed) {
			return new HashMap<>();
		}
		final long start = System.currentTimeMillis();
		synchronized (hostToEnvironment) {
			final Map<String, String> result = hostToEnvironment
					.get(environment.getHost());
			if (result != null) {
				return new HashMap<>(result);
			}
		}
		final Map<String, String> result = new HashMap<>();
		try {
			Process process = exec(new String[] { "set" }, Path.EMPTY, null); //$NON-NLS-1$
			if (process != null) {
				final BufferedReader input = new BufferedReader(
						new InputStreamReader(process.getInputStream()));
				Thread t = new Thread(NLS.bind(
						Messages.RSEExecEnvironment_fetchEnvVars, environment
								.getHost().getName())) {
					@Override
					public void run() {
						try {
							while (true) {
								String line = input.readLine();
								if (line == null) {
									break;
								}
								line = line.trim();
								int pos = line.indexOf("="); //$NON-NLS-1$
								if (pos != -1) {
									String varName = line.substring(0, pos);
									String varValue = line.substring(pos + 1);
									if (isValid(varName, varValue)) {
										result.put(varName, varValue);
									}
								}
							}
						} catch (IOException e) {
							if (DLTKCore.DEBUG)
								DLTKRSEPlugin.log(e);
						}
					}

					private boolean isValid(String varName, String varValue) {
						return !"".equals(varName) && !"_".equals(varName); //$NON-NLS-1$ //$NON-NLS-2$
					}
				};
				t.start();
				try {
					t.join(25000);// No more than 25 seconds
				} catch (InterruptedException e) {
					DLTKRSEPlugin.log(e);
				}
				process.destroy();
			}
		} catch (CoreException e) {
			DLTKRSEPlugin.log(e);
		}
		if (!result.isEmpty()) {
			synchronized (hostToEnvironment) {
				hostToEnvironment.put(environment.getHost(), Collections
						.unmodifiableMap(result));
			}
		}
		if (RSEPerfomanceStatistics.PERFOMANCE_TRACING) {
			final long end = System.currentTimeMillis();
			RSEPerfomanceStatistics
					.inc(RSEPerfomanceStatistics.ENVIRONMENT_RECEIVE_COUNT);
			RSEPerfomanceStatistics.inc(
					RSEPerfomanceStatistics.ENVIRONMENT_RECEIVE_TIME,
					(end - start));
		}
		return result;
	}

	@Override
	public IEnvironment getEnvironment() {
		return environment;
	}

	@Override
	public boolean isValidExecutableAndEquals(String possibleName, IPath path) {
		if (environment.getHost().getSystemType().isWindows()) {
			possibleName = possibleName.toLowerCase();
			String fName = path.removeFileExtension().toString().toLowerCase();
			String ext = path.getFileExtension();
			if (possibleName.equals(fName)
					&& ("exe".equalsIgnoreCase(ext) || "bat".equalsIgnoreCase(ext))) { //$NON-NLS-1$ //$NON-NLS-2$
				return true;
			}
		} else {
			String fName = path.lastSegment();
			if (fName.equals(possibleName)) {
				return true;
			}
		}
		return false;
	}
}