/*=============================================================================#
 # Copyright (c) 2008, 2020 Stephan Wahlbrink and others.
 # 
 # This program and the accompanying materials are made available under the
 # terms of the Eclipse Public License 2.0 which is available at
 # https://www.eclipse.org/legal/epl-2.0, or the Apache License, Version 2.0
 # which is available at https://www.apache.org/licenses/LICENSE-2.0.
 # 
 # SPDX-License-Identifier: EPL-2.0 OR Apache-2.0
 # 
 # Contributors:
 #     Stephan Wahlbrink <sw@wahlbrink.eu> - initial API and implementation
 #=============================================================================*/

package org.eclipse.statet.internal.r.console.ui.launching;

import java.net.InetAddress;
import java.net.MalformedURLException;
import java.rmi.RemoteException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.SubMonitor;
import org.eclipse.debug.core.ILaunch;
import org.eclipse.debug.core.ILaunchConfiguration;
import org.eclipse.debug.core.ILaunchManager;
import org.eclipse.debug.core.model.IProcess;
import org.eclipse.debug.core.model.LaunchConfigurationDelegate;
import org.eclipse.debug.ui.IDebugUIConstants;
import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.statushandlers.StatusManager;

import org.eclipse.statet.jcommons.rmi.RMIAddress;
import org.eclipse.statet.jcommons.rmi.RMIRegistry;
import org.eclipse.statet.jcommons.rmi.RMIRegistryManager;
import org.eclipse.statet.jcommons.status.ProgressMonitor;
import org.eclipse.statet.jcommons.status.StatusException;
import org.eclipse.statet.jcommons.status.WarningStatus;
import org.eclipse.statet.jcommons.ts.core.SystemRunnable;
import org.eclipse.statet.jcommons.ts.core.Tool;
import org.eclipse.statet.jcommons.ts.core.ToolService;

import org.eclipse.statet.ecommons.debug.core.util.LaunchUtils;
import org.eclipse.statet.ecommons.debug.ui.util.UnterminatedLaunchAlerter;
import org.eclipse.statet.ecommons.runtime.core.util.StatusUtils;
import org.eclipse.statet.ecommons.ui.util.UIAccess;

import org.eclipse.statet.internal.r.console.ui.Messages;
import org.eclipse.statet.internal.r.console.ui.RConsoleUIPlugin;
import org.eclipse.statet.nico.core.runtime.ILogOutput;
import org.eclipse.statet.nico.core.runtime.ToolRunner;
import org.eclipse.statet.nico.core.util.HistoryTrackingConfiguration;
import org.eclipse.statet.nico.core.util.TrackingConfiguration;
import org.eclipse.statet.nico.ui.NicoUITools;
import org.eclipse.statet.nico.ui.console.NIConsoleColorAdapter;
import org.eclipse.statet.nico.ui.util.WorkbenchStatusHandler;
import org.eclipse.statet.r.console.core.IRDataAdapter;
import org.eclipse.statet.r.console.core.RProcess;
import org.eclipse.statet.r.console.core.RWorkspace;
import org.eclipse.statet.r.console.ui.RConsole;
import org.eclipse.statet.r.console.ui.launching.RConsoleLaunching;
import org.eclipse.statet.r.console.ui.tools.REnvAutoUpdater;
import org.eclipse.statet.r.console.ui.tools.REnvIndexAutoUpdater;
import org.eclipse.statet.r.core.RCore;
import org.eclipse.statet.r.core.pkgmanager.IRPkgManager;
import org.eclipse.statet.r.core.renv.IREnvConfiguration;
import org.eclipse.statet.r.launching.core.ILaunchDelegateAddon;
import org.eclipse.statet.r.launching.core.RLaunching;
import org.eclipse.statet.r.nico.RWorkspaceConfig;
import org.eclipse.statet.r.nico.impl.RjsController;
import org.eclipse.statet.r.nico.impl.RjsController.RjsConnection;
import org.eclipse.statet.rj.data.RDataUtils;
import org.eclipse.statet.rj.data.UnexpectedRDataException;
import org.eclipse.statet.rj.renv.core.REnvConfiguration;
import org.eclipse.statet.rj.server.RjsComConfig;
import org.eclipse.statet.rj.services.FunctionCall;
import org.eclipse.statet.rj.services.RVersion;


/**
 * Launch delegate for RJ based R console using local RJ server
 */
public class RConsoleRJLaunchDelegate extends LaunchConfigurationDelegate {
	
	
	static final long TIMEOUT= 60L * 1000000000L;
	
	static final RVersion VERSION_2_12_0= new RVersion(2, 12, 0);
	
	static class ConfigRunnable implements SystemRunnable {
		
		
		private final Tool tool;
		private final boolean enableRHelp;
		private final boolean enableRGraphics;
		private final boolean enableRDbgExt;
		private final boolean enableRDbg;
		
		public ConfigRunnable(final Tool tool, final boolean enableRHelp,
				final boolean enableRGraphics,
				final boolean enableRDbgExt, final boolean enableRDbg) {
			this.tool= tool;
			this.enableRHelp= enableRHelp;
			this.enableRGraphics= enableRGraphics;
			this.enableRDbgExt= enableRDbgExt;
			this.enableRDbg= enableRDbg;
		}
		
		
		@Override
		public String getTypeId() {
			return "r/integration"; //$NON-NLS-1$
		}
		
		@Override
		public String getLabel() {
			return "Initialize R-StatET Tools";
		}
		
		@Override
		public boolean canRunIn(final Tool tool) {
			return (tool == this.tool);
		}
		
		@Override
		public boolean changed(final int event, final Tool process) {
			if ((event & MASK_EVENT_GROUP) == REMOVING_EVENT_GROUP) {
				return false;
			}
			return true;
		}
		
		@Override
		public void run(final ToolService service, final ProgressMonitor m) throws StatusException {
			final IRDataAdapter r= (IRDataAdapter) service;
			r.briefAboutToChange();
			try {
				final RVersion rVersion= r.getPlatform().getRVersion();
				if (rVersion.compareTo(VERSION_2_12_0) < 0) {
					r.evalVoid("library('rj')", m); //$NON-NLS-1$
				}
				else {
					r.evalVoid("library('rj', quietly= TRUE)", m); //$NON-NLS-1$
				}
				if (this.enableRHelp) {
					final FunctionCall fcall= r.createFunctionCall(".statet.initHelp"); //$NON-NLS-1$
					fcall.evalVoid(m);
				}
				if (this.enableRGraphics) {
					try {
						final FunctionCall fcall= r.createFunctionCall(".rj.initGD"); //$NON-NLS-1$
						fcall.addLogi("default", true); //$NON-NLS-1$
						RDataUtils.checkSingleLogiValue(fcall.evalData(m));
					}
					catch (final StatusException | UnexpectedRDataException e) {
						r.handleStatus(new WarningStatus(RConsoleUIPlugin.BUNDLE_ID,
								"The graphic device for the R Graphic view cannot be initialized.", e),
								m );
					}
				}
				{	final FunctionCall fcall= r.createFunctionCall(".statet.initDebug"); //$NON-NLS-1$
					fcall.addLogi("mode", this.enableRDbg); //$NON-NLS-1$
					fcall.addLogi("ext", this.enableRDbgExt); //$NON-NLS-1$
					fcall.evalVoid(m);
				}
			}
			finally {
				r.briefChanged(RWorkspace.REFRESH_COMPLETE);
			}
		}
		
	}
	
	static RWorkspaceConfig createWorkspaceConfig(final ILaunchConfiguration configuration) throws CoreException {
		final RWorkspaceConfig config= new RWorkspaceConfig();
		config.setEnableObjectDB(configuration.getAttribute(RConsoleLaunching.ATTR_OBJECTDB_ENABLED, true));
		config.setEnableAutoRefresh(configuration.getAttribute(RConsoleLaunching.ATTR_OBJECTDB_AUTOREFRESH_ENABLED, true));
		return config;
	}
	
	static void initConsoleOptions(final RjsController controller,
			final REnvConfiguration rEnvConfig,
			final ILaunchConfiguration configuration, final String mode,
			final boolean isStartup) throws CoreException {
		if (rEnvConfig != null) {
			final IRPkgManager manager= RCore.getRPkgManager(rEnvConfig.getREnv());
			REnvAutoUpdater.connect(controller, manager);
			REnvIndexAutoUpdater.connect(controller.getTool(), manager);
		}
		controller.addStartupRunnable(new ConfigRunnable(
				controller.getTool(),
				(rEnvConfig != null && configuration.getAttribute(RConsoleOptionsTab.ATTR_INTEGRATION_RHELP_ENABLED, true)),
				configuration.getAttribute(RConsoleOptionsTab.ATTR_INTEGRATION_RGRAPHICS_ASDEFAULT, true),
				configuration.getAttribute(RConsoleOptionsTab.ATTR_INTEGRATION_RDBGEXT_ENABLED, true),
				mode.equals(ILaunchManager.DEBUG_MODE) ));
		if (isStartup) {
			RConsoleLaunching.scheduleStartupSnippet(controller, configuration);
		}
	}
	
	
	private ILaunchDelegateAddon addon;
	
	
	public RConsoleRJLaunchDelegate() {
	}
	
	public RConsoleRJLaunchDelegate(final ILaunchDelegateAddon addon) {
		this.addon= addon;
	}
	
	
	@Override
	public void launch(final ILaunchConfiguration configuration, final String mode, 
			final ILaunch launch, final IProgressMonitor monitor) throws CoreException {
		final SubMonitor m= LaunchUtils.initProgressMonitor(configuration, monitor, 25);
		final long timestamp= System.currentTimeMillis();
		
		final IWorkbenchPage page= UIAccess.getActiveWorkbenchPage(false);
		
		m.worked(1);
		if (m.isCanceled()) {
			return;
		}
		
		// load tracking configurations
		final List<TrackingConfiguration> trackingConfigs;
		{	final List<String> trackingIds= configuration.getAttribute(RConsoleOptionsTab.TRACKING_ENABLED_IDS, Collections.EMPTY_LIST);
			trackingConfigs= new ArrayList<>(trackingIds.size());
			for (final String id : trackingIds) {
				final TrackingConfiguration trackingConfig;
				if (id.equals(HistoryTrackingConfiguration.HISTORY_TRACKING_ID)) {
					trackingConfig= new HistoryTrackingConfiguration(id);
				}
				else {
					trackingConfig= new TrackingConfiguration(id);
				}
				RConsoleOptionsTab.TRACKING_UTIL.load(trackingConfig, configuration);
				trackingConfigs.add(trackingConfig);
			}
		}
		
		m.worked(1);
		if (m.isCanceled()) {
			return;
		}
		
		// r env
		final IREnvConfiguration rEnv= RLaunching.getREnvConfig(configuration, true);
		
		final RMIRegistry registry;
		boolean requireCodebase;
		{	final String s= System.getProperty("org.eclipse.statet.r.console.rmiRegistryPort");
			int port= -1;
			if (s != null && s.length() > 0) {
				try {
					m.subTask(Messages.LaunchDelegate_CheckingRegistry_subtask);
					port= Integer.parseInt(s);
					final RMIAddress registryAddress= new RMIAddress(InetAddress.getLoopbackAddress(), port, null);
					registry= new RMIRegistry(registryAddress, true);
					requireCodebase= true;
				}
				catch (final NumberFormatException e) {
					throw new CoreException(new Status(IStatus.ERROR, RConsoleUIPlugin.BUNDLE_ID, 0,
							"The registry port specified by 'org.eclipse.statet.r.console.rmiRegistryPort' is invalid.", e ));
				}
				catch (final MalformedURLException e) {
					throw new CoreException(new Status(IStatus.ERROR, RConsoleUIPlugin.BUNDLE_ID, 0,
							"The registry port specified by 'org.eclipse.statet.r.console.rmiRegistryPort' is invalid.", e ));
				}
				catch (final RemoteException e) {
					throw new CoreException(new Status(IStatus.ERROR, RConsoleUIPlugin.BUNDLE_ID, 0,
							"Connection setup to the registry specified by 'org.eclipse.statet.r.console.rmiRegistryPort' failed.", e ));
				}
			}
			else {
				try {
					registry= RMIRegistryManager.INSTANCE.getEmbeddedPrivateRegistry(
							StatusUtils.convertChild(m.newChild(1)) );
				}
				catch (final StatusException e) {
					throw StatusUtils.convert(e);
				}
				requireCodebase= false;
			}
		}
		
		m.worked(1);
		if (m.isCanceled()) {
			return;
		}
		
		// start server
		m.subTask(Messages.LaunchDelegate_StartREngine_subtask);
		try {
			final RMIAddress rmiAddress= new RMIAddress(InetAddress.getLoopbackAddress(), registry.getAddress().getPort(),
					"rjs-local-" + System.currentTimeMillis() ); //$NON-NLS-1$
			final RJEngineLaunchDelegate engineLaunchDelegate= new RJEngineLaunchDelegate(
					rmiAddress.getAddress(), requireCodebase, rEnv);
			
			RjsComConfig.setRMIClientSocketFactory(null);
			
			engineLaunchDelegate.launch(configuration, mode, launch, m.newChild(10));
			final IProcess[] processes= launch.getProcesses();
			if (processes.length == 0) {
				return;
			}
			
			m.worked(1);
			if (m.isCanceled()) {
				return;
			}
			
			// arguments
			final String[] rArgs= LaunchUtils.getProcessArguments(configuration, RConsoleLaunching.ATTR_OPTIONS);
			
			m.worked(1);
			if (m.isCanceled()) {
				return;
			}
			
			// create process
			UnterminatedLaunchAlerter.registerLaunchType(RConsoleLaunching.R_CONSOLE_CONFIGURATION_TYPE_ID);
			
			final RProcess process= new RProcess(launch, rEnv,
					LaunchUtils.createLaunchPrefix(configuration),
					rEnv.getName() + " / RJ " + LaunchUtils.createProcessTimestamp(timestamp), //$NON-NLS-1$
					rmiAddress.toString(),
					null, // wd is set at rjs startup
					timestamp );
			process.setAttribute(IProcess.ATTR_CMDLINE, rmiAddress.toString() + '\n' + Arrays.toString(rArgs));
			
			// Wait until the engine is started or died
			m.subTask(Messages.LaunchDelegate_WaitForR_subtask);
			final long t= System.nanoTime();
			WAIT: for (int i= 0; true; i++) {
				if (processes[0].isTerminated()) {
					final boolean silent= configuration.getAttribute(IDebugUIConstants.ATTR_CAPTURE_IN_CONSOLE, true);
					final IStatus logStatus= ToolRunner.createOutputLogStatus(
							processes[0].getAdapter(ILogOutput.class) );
					// move to R server?
					final StringBuilder sb= new StringBuilder();
					sb.append("Launching the R Console was cancelled, because it seems starting the R engine failed.");
					sb.append(engineLaunchDelegate.getDebugInfo());
					
					StatusManager.getManager().handle(new Status(silent ? IStatus.INFO : IStatus.ERROR,
							RConsoleUIPlugin.BUNDLE_ID, sb.toString(),
							(logStatus != null) ? new CoreException(logStatus) : null ),
							silent ? (StatusManager.LOG) : (StatusManager.LOG | StatusManager.SHOW) );
					return;
				}
				if (m.isCanceled()) {
					processes[0].terminate();
					throw new CoreException(Status.CANCEL_STATUS);
				}
				try {
					final String[] list= registry.getRegistry().list();
					for (final String entry : list) {
						if (entry.equals(rmiAddress.getName())) {
							break WAIT;
						}
					}
					if (i > 1 && System.nanoTime() - t > TIMEOUT) {
						break WAIT;
					}
				}
				catch (final RemoteException e) {
					if (i > 0 && System.nanoTime() - t > TIMEOUT / 3) {
						break WAIT;
					}
				}
				try {
					Thread.sleep(333);
				}
				catch (final InterruptedException e) {
					// continue, monitor and process is checked
				}
			}
			m.worked(5);
			
			final RjsConnection connection= RjsController.lookup(registry.getRegistry(), null, rmiAddress);
			
			final HashMap<String, Object> rjsProperties= new HashMap<>();
			rjsProperties.put(RjsComConfig.RJ_DATA_STRUCTS_LISTS_MAX_LENGTH_PROPERTY_ID,
					configuration.getAttribute(RConsoleLaunching.ATTR_OBJECTDB_LISTS_MAX_LENGTH, 10000));
			rjsProperties.put(RjsComConfig.RJ_DATA_STRUCTS_ENVS_MAX_LENGTH_PROPERTY_ID,
					configuration.getAttribute(RConsoleLaunching.ATTR_OBJECTDB_ENVS_MAX_LENGTH, 10000));
			rjsProperties.put("rj.session.startup.time", timestamp); //$NON-NLS-1$
			final RjsController controller= new RjsController(process, rmiAddress, connection, null,
					(RjsController.RJS_LOCAL | RjsController.RJS_SETUP_CONSOLE), rArgs, rjsProperties,
					engineLaunchDelegate.getWorkingDirectory(),
					createWorkspaceConfig(configuration), trackingConfigs);
			process.init(controller);
			RConsoleLaunching.registerDefaultHandlerTo(controller);
			
			m.worked(5);
			
			initConsoleOptions(controller, rEnv, configuration, mode, true);
			
			if (this.addon != null) {
				this.addon.init(configuration, mode, controller, m);
			}
			
			final RConsole console= new RConsole(process, new NIConsoleColorAdapter());
			NicoUITools.startConsoleLazy(console, page, 
					configuration.getAttribute(RConsoleLaunching.ATTR_PIN_CONSOLE, false));
			
			new ToolRunner().runInBackgroundThread(process, new WorkbenchStatusHandler());
		}
		finally {
			RjsComConfig.clearRMIClientSocketFactory();
		}
		
		m.done();
	}
	
}