#region ================== Copyright (c) 2020 Boris Iwanski

/*
 * This program is free software: you can redistribute it and/or modify
 *
 * it under the terms of the GNU 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 General Public License
 * along with this program.If not, see<http://www.gnu.org/licenses/>.
 */

#endregion

#region ================== Namespaces

using System;
using System.Diagnostics;
using System.IO;
using System.Threading;
using System.Windows.Forms;
using CodeImp.DoomBuilder.Map;
using CodeImp.DoomBuilder.Windows;
using CodeImp.DoomBuilder.UDBScript.Wrapper;
using CodeImp.DoomBuilder.UDBScript.API;
using Jint;
using Jint.Runtime;
using Jint.Runtime.Interop;
using Esprima;

#endregion

namespace CodeImp.DoomBuilder.UDBScript
{
	class ScriptRunner
	{
		#region ================== Variables

		private ScriptInfo scriptinfo;
		Engine engine;
		Stopwatch stopwatch;
		int oldprocessingcount;

		#endregion

		#region ================== Constructor

		public ScriptRunner(ScriptInfo scriptoption)
		{
			this.scriptinfo = scriptoption;
			stopwatch = new Stopwatch();
		}

		#endregion

		#region ================== Methods

		/// <summary>
		/// Stops the timer, pausing the script's runtime constraint
		/// </summary>
		public void StopTimer()
		{
			stopwatch.Stop();
		}

		/// <summary>
		/// Resumes the timer, resuming the script's runtime constraint
		/// </summary>
		public void ResumeTimer()
		{
			stopwatch.Start();
		}

		/// <summary>
		/// Shows a message box with an "OK" button
		/// </summary>
		/// <param name="message">Message to show</param>
		public void ShowMessage(object message)
		{
			BuilderPlug.Me.ScriptRunnerForm.InvokePaused(new Action(() => {
				if (message == null)
					message = string.Empty;

				stopwatch.Stop();
				MessageForm mf = new MessageForm("OK", null, message.ToString());
				DialogResult result = mf.ShowDialog();
				stopwatch.Start();

				if (result == DialogResult.Abort)
					throw new UserScriptAbortException();
			}));
		}

		/// <summary>
		/// Shows a message box with an "Yes" and "No" button
		/// </summary>
		/// <param name="message">Message to show</param>
		/// <returns>true if "Yes" was clicked, false if "No" was clicked</returns>
		public bool ShowMessageYesNo(object message)
		{
			return (bool)BuilderPlug.Me.ScriptRunnerForm.InvokePaused(new Func<bool>(() =>
			{
				if (message == null)
					message = string.Empty;

				stopwatch.Stop();
				MessageForm mf = new MessageForm("Yes", "No", message.ToString());
				DialogResult result = mf.ShowDialog();
				stopwatch.Start();

				if (result == DialogResult.Abort)
					throw new UserScriptAbortException();

				return result == DialogResult.OK ? true : false;
			}));
		}

		/// <summary>
		/// Exist the script prematurely without undoing its changes.
		/// </summary>
		/// <param name="s"></param>
		private void ExitScript(string s = null)
		{
			if (string.IsNullOrEmpty(s))
				throw new ExitScriptException();

			throw new ExitScriptException(s);
		}

		/// <summary>
		/// Exist the script prematurely with undoing its changes.
		/// </summary>
		/// <param name="s"></param>
		private void DieScript(string s = null)
		{
			if (string.IsNullOrEmpty(s))
				throw new DieScriptException();

			throw new DieScriptException(s);
		}

		public JavaScriptException CreateRuntimeException(string message)
		{
			return new JavaScriptException(engine.Realm.Intrinsics.Error, message);
		}

		/// <summary>
		/// Imports the code of all script library files in a single string
		/// </summary>
		/// <param name="engine">Scripting engine to load the code into</param>
		/// <param name="errortext">Errors that occured while loading the library code</param>
		/// <returns>true if there were no errors, false if there were errors</returns>
		private bool ImportLibraryCode(Engine engine, out string errortext)
		{
			string path = Path.Combine(General.AppPath, "UDBScript", "Libraries");
			string[] files = Directory.GetFiles(path, "*.js", SearchOption.AllDirectories);

			errortext = string.Empty;

			foreach (string file in files)
			{
				try
				{
					ParserOptions po = new ParserOptions(file.Remove(0, General.AppPath.Length));
					engine.Execute(File.ReadAllText(file), po);
				}
				catch (ParserException e)
				{
					MessageBox.Show("There was an error while loading the library " + file + ":\n\n" + e.Message, "Script error", MessageBoxButtons.OK, MessageBoxIcon.Error);

					return false;
				}
				catch (JavaScriptException e)
				{
					if (e.Error.Type != Jint.Runtime.Types.String)
					{
						UDBScriptErrorForm sef = new UDBScriptErrorForm(e.Message, e.StackTrace);
						sef.ShowDialog();
					}
					else
						General.Interface.DisplayStatus(StatusType.Warning, e.Message); // We get here if "throw" is used in a script

					return false;
				}
			}

			return true;
		}

		/// <summary>
		/// Handles the different exceptions we're expecting, and withdraws the undo snapshot if necessary.
		/// </summary>
		/// <param name="e">The exception to handle</param>
		public void HandleExceptions(Exception e)
		{
			bool abort = false;

			if(e is UserScriptAbortException)
			{
				General.Interface.DisplayStatus(StatusType.Warning, "Script aborted");
				abort = true;
			}
			else if(e is ParserException)
			{
				MessageBox.Show("There is an error while parsing the script:\n\n" + e.Message, "Script error", MessageBoxButtons.OK, MessageBoxIcon.Error);
				abort = true;
			}
			else if(e is JavaScriptException)
			{
				if (((JavaScriptException)e).Error.Type != Jint.Runtime.Types.String)
				{
					UDBScriptErrorForm sef = new UDBScriptErrorForm(e.Message, e.StackTrace);
					sef.ShowDialog();
				}
				else
					General.Interface.DisplayStatus(StatusType.Warning, e.Message); // We get here if "throw" is used in a script

				abort = true;
			}
			else if(e is ExitScriptException)
			{
				if (!string.IsNullOrEmpty(e.Message))
					General.Interface.DisplayStatus(StatusType.Ready, e.Message);
			}
			else if(e is DieScriptException)
			{
				if (!string.IsNullOrEmpty(e.Message))
					General.Interface.DisplayStatus(StatusType.Warning, e.Message);

				abort = true;
			}
			else if(e is ExecutionCanceledException)
			{
				abort = true;
			}
			else // Catch anything else we didn't think about
			{
				UDBScriptErrorForm sef = new UDBScriptErrorForm(e.Message, e.StackTrace);
				sef.ShowDialog();

				abort = true;
			}

			if (abort)
				General.Map.UndoRedo.WithdrawUndo();
		}

		/// <summary>
		/// Sets everything up for running the script. This has to be done on the UI thread.
		/// </summary>
		/// <param name="cancellationtoken">Cancellation token to cancel the running script</param>
		public void PreRun(CancellationToken cancellationtoken)
		{
			string importlibraryerrors;

			// If the script requires a higher version of UDBScript than this version ask the user if they want
			// to execute it anyways. Remember the choice for this session if "yes" was selected.
			if (scriptinfo.Version > BuilderPlug.UDB_SCRIPT_VERSION && !scriptinfo.IgnoreVersion)
			{
				if (MessageBox.Show("The script requires a higher version of the feature set than this version of UDBScript supports. Executing this script might fail\n\nRequired feature version: " + scriptinfo.Version + "\nUDBScript feature version: " + BuilderPlug.UDB_SCRIPT_VERSION + "\n\nExecute anyway?", "UDBScript feature version too low", MessageBoxButtons.YesNo, MessageBoxIcon.Warning) == DialogResult.No)
					return;

				scriptinfo.IgnoreVersion = true;
			}

			// Make sure the option value gets saved if an option is currently being edited
			BuilderPlug.Me.EndOptionEdit();
			General.Interface.Focus();

			// Set engine options
			Options options = new Options();
			options.CancellationToken(cancellationtoken);
			options.AllowOperatorOverloading();
			options.SetTypeResolver(new TypeResolver
			{
				MemberFilter = member => member.Name != nameof(GetType)
			});

			// Create the script engine
			engine = new Engine(options);
			engine.SetValue("showMessage", new Action<object>(ShowMessage));
			engine.SetValue("showMessageYesNo", new Func<object, bool>(ShowMessageYesNo));
			engine.SetValue("exit", new Action<string>(ExitScript));
			engine.SetValue("die", new Action<string>(DieScript));
			engine.SetValue("QueryOptions", TypeReference.CreateTypeReference(engine, typeof(QueryOptions)));
			engine.SetValue("ScriptOptions", scriptinfo.GetScriptOptionsObject());
			engine.SetValue("Map", new MapWrapper());
			engine.SetValue("GameConfiguration", new GameConfigurationWrapper());
			engine.SetValue("Angle2D", TypeReference.CreateTypeReference(engine, typeof(Angle2DWrapper)));
			engine.SetValue("Vector3D", TypeReference.CreateTypeReference(engine, typeof(Vector3DWrapper)));
			engine.SetValue("Vector2D", TypeReference.CreateTypeReference(engine, typeof(Vector2DWrapper)));
			engine.SetValue("Line2D", TypeReference.CreateTypeReference(engine, typeof(Line2DWrapper)));
			engine.SetValue("UniValue", TypeReference.CreateTypeReference(engine, typeof(UniValue)));
			engine.SetValue("Data", TypeReference.CreateTypeReference(engine, typeof(DataWrapper)));

			// These can not be directly instanciated and don't have static method, but it's required to
			// for example use "instanceof" in scripts
			engine.SetValue("Linedef", TypeReference.CreateTypeReference(engine, typeof(LinedefWrapper)));
			engine.SetValue("Sector", TypeReference.CreateTypeReference(engine, typeof(SectorWrapper)));
			engine.SetValue("Sidedef", TypeReference.CreateTypeReference(engine, typeof(SidedefWrapper)));
			engine.SetValue("Thing", TypeReference.CreateTypeReference(engine, typeof(ThingWrapper)));
			engine.SetValue("Vertex", TypeReference.CreateTypeReference(engine, typeof(VertexWrapper)));

#if DEBUG
			engine.SetValue("log", new Action<object>(Console.WriteLine));
#endif

			// Import all library files into the current engine
			if (ImportLibraryCode(engine, out importlibraryerrors) == false)
				return;

			// Tell the mode that a script is about to be run
			General.Editing.Mode.OnScriptRunBegin();

			General.Map.UndoRedo.CreateUndo("Run script " + scriptinfo.Name);
			General.Map.Map.ClearAllMarks(false);

			General.Map.Map.IsSafeToAccess = false;

			// Disable all processing. Has to be done as many times as it was enabled.
			// Save old value since after running the script we need to enable it as many times
			oldprocessingcount = General.Interface.ProcessingCount;
			for (int i = 0; i < oldprocessingcount; i++)
				General.Interface.DisableProcessing();
		}

		/// <summary>
		/// Runs the script
		/// </summary>
		public void Run(IProgress<int> progress, IProgress<string> status, IProgress<string> log)
		{
			engine.SetValue("ProgressInfo", new ProgressInfo(progress, status, log));
			// Read the current script file
			string script = File.ReadAllText(scriptinfo.ScriptFile);

			// Run the script file
			ParserOptions po = new ParserOptions(scriptinfo.ScriptFile.Remove(0, General.AppPath.Length));

			stopwatch.Start();
			engine.Execute(script, po);
			stopwatch.Stop();
		}

		/// <summary>
		/// Cleanups and updates after the script stopped running. Has to be called from the UI thread.
		/// </summary>
		public void PostRun()
		{
			General.Map.Map.IsSafeToAccess = true;

			// Do some updates
			General.Map.Map.Update();
			General.Map.ThingsFilter.Update();
			//General.Interface.RedrawDisplay();

			// Tell the mode that running the script ended
			General.Editing.Mode.OnScriptRunEnd();

			// Enable processing again, if required
			for (int i = 0; i < oldprocessingcount; i++)
				General.Interface.EnableProcessing();
		}

		#endregion
	}
}