/*=============================================================================

  Project:   SharpImage
  Module:    siScriptManager.cs
  Language:  C#
  Author:    Dan Mueller
  Date:      $Date: 2007-07-06 10:57:00 +1000 (Fri, 06 Jul 2007) $
  Revision:  $Revision: 2 $

  Copyright (c) Queensland University of Technology (QUT) 2007.
  All rights reserved.

  This software is distributed WITHOUT ANY WARRANTY; without even
  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  PURPOSE.  See the above copyright notices for more information.
  
=============================================================================*/

using System;
using System.IO;
using System.Diagnostics;
using System.Collections;
using System.Collections.Generic;
using System.Text;
using System.Threading;
using System.Windows.Forms;
using System.Text.RegularExpressions;

using IronPython.Hosting;
using IronPython.Runtime.Exceptions;

using SharpImage.Main;

namespace SharpImage.Script
{
    #region siScriptCommandNotSupportedException
    //=========================================================================
    public class siScriptCommandNotSupportedException : ArgumentException
    {
        public siScriptCommandNotSupportedException(string message, string command)
            : base(message, command)
        {
        }
    }
    //=========================================================================
    #endregion

    #region siScriptManager Class
    //=========================================================================
    public class siScriptManager : IDisposable
    {
        #region Instance Variables
        //=====================================================================
        private bool m_IsDisposed = false;
        private bool m_HasScriptBeenFinalised = false;
        private bool m_HasScriptBeenCompleted = false;
        private TimeSpan m_SpanScriptStarted;
        //=====================================================================
        #endregion

        #region Construction and Disposal
        //=====================================================================
        /// <summary>
        /// Protected constructor.
        /// </summary>
        /// <param name="parent"></param>
        protected siScriptManager(IApplication parent)
        {
            this.m_ParentApplication = parent;
            this.m_Engine = new PythonEngine();
        }
        
        /// <summary>
        /// Public constructor.
        /// </summary>
        /// <param name="parent">The parent application.</param>
        /// <param name="scriptFilePath">The full file path of the script 
        ///                              to manage.</param>
        public siScriptManager(IApplication parent, string scriptFilePath) 
            : this(parent)
        {
            // Set member properties
            this.m_ScriptFilePath = scriptFilePath;

            // Initialise the Engine
            this.m_Engine = new PythonEngine();
            this.GetScriptPathHierarchy(true);
            this.Engine.Import("Site");
            this.Engine.Import("System");
            this.Engine.Import("clr");

            // Add IApplication to Engine.Globals
            this.Engine.Globals["ParentApplication"] = parent;
            this.Engine.Globals["ScriptFilePath"] = this.ScriptFilePath;

            // Add event handlers dictionary to Engine.Globals
            Dictionary<string, object> handlers = new Dictionary<string, object>();
            handlers["ScriptRegisterName"] = new ScriptStringHandler(this.RegisterScriptNameHandler);
            handlers["ScriptWriteLineToConsole"] = new ScriptStringHandler(this.OnScriptWriteLineToConsole);
            handlers["ScriptStarted"] = new ScriptEmptyHandler(this.OnScriptStarted);
            handlers["ScriptCompleted"] = new ScriptCompletedHandler(this.OnScriptCompleted);
            handlers["ScriptFinalised"] = new ScriptEmptyHandler(this.OnScriptFinalised);
            handlers["ScriptException"] = new ScriptExceptionHandler(this.OnScriptException);
            handlers["ScriptFilterStarted"] = new itk.itkTimedEventHandler(this.OnScriptFilterStarted);
            handlers["ScriptFilterEnded"] = new itk.itkTimedEventHandler(this.OnScriptFilterEnded);
            handlers["ScriptFilterProgress"] = new itk.itkProgressHandler(this.OnScriptFilterProgress);
            this.Engine.Globals["Handlers"] = handlers;
        }

        /// <summary>
        /// Protected constructor.
        /// </summary>
        /// <param name="parent"></param>
        /// <param name="scriptFilePath"></param>
        /// <param name="command">The value to init the ScriptCommand property with.</param>
        /// <param name="parameters">The value to init the ScriptParameters property with.</param>
        protected siScriptManager(IApplication parent, string scriptFilePath, string command, string parameters)
            : this(parent, scriptFilePath)
        {
            this.m_ScriptCommand = command;
            this.m_ScriptParameters = parameters;
        }

        /// <summary>
        /// Deconstructor.
        /// </summary>
        ~siScriptManager()
        {
            this.Dispose();
        }

        /// <summary>
        /// Dispose of resources.
        /// </summary>
        public void Dispose()
        {
            if (this.m_IsDisposed)
                return;
            
            // Dispose of Engine resource
            if (this.m_Engine != null)
            {
                this.m_Engine.Shutdown();
                this.m_Engine.Dispose();
                this.m_Engine = null;
            }

            // Flag that we are disposed
            this.m_IsDisposed = true;

            // Tell the GC that the Finalize process no longer needs
            // to be run for this object.
            GC.SuppressFinalize(this);
        }
        //=====================================================================
        #endregion

        #region Properties
        //=====================================================================

        #region ParentApplication
        //=====================================================================
        private IApplication m_ParentApplication = null;

        /// <summary>
        /// Gets parent application.
        /// </summary>
        public IApplication ParentApplication
        {
            get { return this.m_ParentApplication; }
        }
        //=====================================================================
        #endregion

        #region Engine
        //=====================================================================
        private PythonEngine m_Engine = null;

        /// <summary>
        /// Gets the PythonEngine associated with this script.
        /// </summary>
        private PythonEngine Engine
        {
            get { return this.m_Engine; }
        }
        //=====================================================================
        #endregion

        #region Code
        //=====================================================================
        private CompiledCode m_Code = null;
        private bool m_IsCodeCompiled = false;

        /// <summary>
        /// Gets the CompiledCode associated with this script.
        /// This is only valid after calling CompileScript().
        /// </summary>
        protected CompiledCode Code
        {
            get { return this.m_Code; }
        }

        /// <summary>
        /// Gets if the code has been successfully compiled.
        /// </summary>
        protected bool IsCodeCompiled
        {
            get { return this.m_IsCodeCompiled; }
        }
        //=====================================================================
        #endregion

        #region ScriptFilePath
        //=====================================================================
        private string m_ScriptFilePath = string.Empty;

        /// <summary>
        /// Gets the full path of the script file associated with this 
        /// ScriptManager instance.
        /// </summary>
        public string ScriptFilePath
        {
            get { return this.m_ScriptFilePath; }
        }
        //=====================================================================
        #endregion

        #region ScriptName
        //=====================================================================
        private string m_ScriptName = string.Empty;

        /// <summary>
        /// Gets the name the script uses to identify itself. This property is 
        /// only valid after a successful call to InitializeScript().
        /// </summary>
        public string ScriptName
        {
            get { return this.m_ScriptName; }
        }
        //=====================================================================
        #endregion

        #region ScriptCommand
        //=====================================================================
        private string m_ScriptCommand = "run";

        /// <summary>
        /// Gets a specific command to execute.
        /// To run the script the command should be "run", to display help
        /// information the command should be "help". "run" is the default
        /// command for newly created ScriptManagers.
        /// </summary>
        public string ScriptCommand
        {
            get { return this.m_ScriptCommand; }
        }
        //=====================================================================
        #endregion

        #region ScriptParameters
        //=====================================================================
        private string m_ScriptParameters = string.Empty;

        /// <summary>
        /// Gets the parameters to initialise the script object.
        /// Each name-value pair is separated by a space.
        /// For example: "ThresholdLower=50 ThresholdUpper=100"
        /// </summary>
        public string ScriptParameters
        {
            get { return this.m_ScriptParameters; }
        }
        //=====================================================================
        #endregion

        //=====================================================================
        #endregion

        #region Events and Delegates
        //=====================================================================
        public delegate void ScriptHandler(siScriptManager manager);
        private delegate void ScriptEmptyHandler();
        private delegate void ScriptCompletedHandler(bool success);
        private delegate void ScriptStringHandler(string info);
        private delegate void ScriptExceptionHandler(Exception ex);

        #region ScriptFinalised
        //============================================================================
        private ScriptHandler m_EventStorage_ScriptFinalised;

        /// <summary>
        /// An event raised when the itk.itkProcessObject has
        /// started processing.
        /// </summary>
        public event ScriptHandler ScriptFinalised
        {
            add { this.m_EventStorage_ScriptFinalised += value; }
            remove { this.m_EventStorage_ScriptFinalised -= value; }
        }

        /// <summary>
        /// Raise the ScriptCompleted event.
        /// </summary>
        /// <param name="time"></param>
        public void RaiseScriptFinalised()
        {
            // Check we have not already raised this event
            if (!this.m_HasScriptBeenFinalised)
            {
                // Flag we have raised the finalised event
                this.m_HasScriptBeenFinalised = true;

                // Raise event
                if (this.m_EventStorage_ScriptFinalised != null)
                    this.m_EventStorage_ScriptFinalised(this);
            }
        }
        //============================================================================
        #endregion

        //=====================================================================
        #endregion

        #region Public Static Methods
        //=====================================================================
        /// <summary>
        /// Creates a ScriptManager from the given command string.
        /// Returns null if an error occurred while executing the command.
        /// The error is displayed in the script console.
        /// </summary>
        /// <param name="parent"></param>
        /// <param name="command"></param>
        /// <param name="currentDirectory">The absolute path of the current directory.</param>
        /// <returns>The newly created script manager waiting to be
        ///          executed OR null on error.</returns>
        public static siScriptManager CreateFromCommand(IApplication parent, 
                                                        string command,
                                                        string currentDirectory)
        {
            siScriptManager result = null;

            try
            {
                // Check command is not empty
                if (command == null || command.Length == 0)
                    throw new siScriptCommandNotSupportedException("You entered an empty command. Please enter either 'run <script>' or help '<script>'.", "None");
                
                // Create regular expression to parse command
                string commands = "(run)|(help)";
                string pattern = @"(?<command>(" + commands + @")*)( *)(?<scriptname>\w*)( *)(?<parameters>(.)*)";
                Regex regex = new Regex(pattern, RegexOptions.Compiled | RegexOptions.IgnoreCase | RegexOptions.Singleline);
                Match match = regex.Match(command);

                if (match.Success)
                {
                    string commandParsed = match.Groups["command"].Value;
                    string scriptnameParsed = match.Groups["scriptname"].Value;
                    string parametersParsed = match.Groups["parameters"].Value.Trim(' ');

                    // Search for script
                    string scriptFullPath = siScriptManager.SearchForScript(currentDirectory, scriptnameParsed);
                    if (scriptFullPath != null && scriptFullPath.Length > 0 && File.Exists(scriptFullPath))
                        // Create new manager
                        result = new siScriptManager(parent, scriptFullPath, commandParsed, parametersParsed);
                    else
                        // Script full path is invalid
                        throw new FileNotFoundException("Could not find script '" + scriptnameParsed + "'.");

                }
                else
                {
                    throw new siScriptCommandNotSupportedException("The given command '" + command + "' is not supported.", command);
                }
            }
            catch (Exception ex)
            {
                // Display the error in the console
                siScriptManager dummy = new siScriptManager(parent);
                dummy.OnScriptException(ex);
                dummy.OnScriptCompleted(false);
                dummy.OnScriptFinalised();
                return null;
            }

            return result;
        }
        //=====================================================================
        #endregion

        #region Public Methods
        //=====================================================================
        /// <summary>
        /// Executes the script. Any exceptions are caught and displayed in
        /// the ParentApplication.ScriptConsole.
        /// </summary>
        public void ExecuteScript()
        {
            const bool IGNORE_CASE = true;
            
            if (this.CompileScript())
            {
                if (string.Compare(this.ScriptCommand, "run", IGNORE_CASE) == 0)
                    this.RunScript();
                else if (string.Compare(this.ScriptCommand, "help", IGNORE_CASE) == 0)
                    this.WriteScriptHelp();
                else if (this.ScriptCommand == null || this.ScriptCommand.Length == 0)
                    // Assume the "run" command
                    this.RunScript();
                else
                    throw new siScriptCommandNotSupportedException("The given command '" + this.ScriptCommand + "' is not supported.", this.ScriptCommand);
            }
        }        

        /// <summary>
        /// Calls the IronPython script Run() method.
        /// </summary>
        public void RunScript()
        {
            try
            {
                // Call the Initialize function
                Dictionary<string, object> locals = new Dictionary<string, object>();
                locals["Function"] = "Run";
                this.Code.Execute(this.Engine.DefaultModule, locals);
            }
            catch (Exception ex)
            {
                // Display the error in the console
                this.OnScriptException(ex);
                this.OnScriptCompleted(false);
                this.OnScriptFinalised();
            }
        }

        /// <summary>
        /// Shows the help information associated with the script.
        /// </summary>
        public void WriteScriptHelp()
        {
            try
            {
                if (this.CompileScript())
                {
                    // Call the Initialize function
                    Dictionary<string, object> locals = new Dictionary<string, object>();
                    locals["Function"] = "WriteHelp";
                    this.Code.Execute(this.Engine.DefaultModule, locals);
                    this.RaiseScriptFinalised();
                }
            }
            catch (Exception ex)
            {
                // Display the error in the console
                this.OnScriptException(ex);
                this.OnScriptCompleted(false);
                this.OnScriptFinalised();
            }
        }
        //=====================================================================
        #endregion

        #region Private Methods
        //=====================================================================
        
        #region Script Compile and Exception Methods
        //=====================================================================
        /// <summary>
        /// Compile the script. Any compilation errors are caught and 
        /// displayed in the IApplication.ScriptConsole.
        /// </summary>
        /// <returns>true AND the script was successfully compiled OR
        ///          false AND the script failed to be compiled.</returns>
        private bool CompileScript()
        {
            // Check the code has not already been compiled
            if (this.IsCodeCompiled)
                return true;
            try
            {
                // Check the file exists
                if (!File.Exists(this.ScriptFilePath))
                {
                    throw new FileNotFoundException("The script '" + this.ScriptFilePath + "' was not found.");
                }
                
                // Try to compile the file
                string scriptBody = this.ReadScriptAndAppendHouseKeeping();
                this.m_Code = this.Engine.Compile(scriptBody, this.ScriptFilePath);
                this.m_IsCodeCompiled = true;
                return true;
            }
            catch (PythonSyntaxErrorException ex)
            {
                // Display the error in the console
                this.OnScriptException(ex);
                this.OnScriptCompleted(false);
                this.OnScriptFinalised();
            }
            catch (Exception ex)
            {
                // Display the error in the console
                this.OnScriptException(ex);
                this.OnScriptCompleted(false);
                this.OnScriptFinalised();
            }

            // If we get here we caught an exception
            return false;
        }

        /// <summary>
        /// Writes the Python formatted exception to the ScriptConsole.
        /// </summary>
        /// <remarks>This method is thread-safe.</remarks>
        /// <param name="ex"></param>
        private void OnScriptException(Exception ex)
        {
            // Make the call thread-safe
            if (this.ParentApplication.InvokeRequired)
            {
                this.ParentApplication.Invoke(new ScriptExceptionHandler(this.OnScriptException), ex);
                return;
            }

            // Do not display the exception if the script has already been finalised or completed
            if (this.m_HasScriptBeenFinalised || this.m_HasScriptBeenCompleted)
                return;
                
            // Display the exception
            string exFormatted = ex.ToString();
            if (this.Engine != null)
                exFormatted = this.Engine.FormatException(ex);
            this.ParentApplication.ScriptConsole.WriteNewLine();
            this.ParentApplication.ScriptConsole.WriteLine(exFormatted);

            // Update status label
            this.ParentApplication.SetApplicationAsReady(0);
        }

        /// <summary>
        /// Record the name of the script.
        /// </summary>
        /// <param name="name"></param>
        private void RegisterScriptNameHandler(string name)
        {
            this.m_ScriptName = name;
        }
        //=====================================================================
        #endregion

        #region Script Helper Methods
        //=====================================================================
        /// <summary>
        /// Adds the path hierarchy to the engine probe paths.
        /// Eg. if ScriptFilePath = "C:/temp/scripting/filtering/filter.py",
        /// the following paths will the added to the engine:
        /// "C:/temp/scripting/filtering", "C:/temp/scripting", "C:/temp",
        /// and "C:/"
        /// </summary>
        /// <param name="addToEngine">If true the paths are added to the engine, otherwise they simply returned.</param>
        /// <returns></returns>
        private List<String> GetScriptPathHierarchy(bool addToEngine)
        {
            List<String> result = new List<String>();
            bool stillAddingPaths = true;
            string currentPath = Path.GetDirectoryName(this.ScriptFilePath);

            while (stillAddingPaths)
            {
                // Add to result
                result.Add(currentPath);
                
                // Add the path
                if (addToEngine)
                    this.Engine.AddToPath(currentPath);

                // Get the next path
                currentPath = Path.GetDirectoryName(currentPath);
                stillAddingPaths = Path.IsPathRooted(currentPath);
            }

            return result;
        }
        
        /// <summary>
        /// Reads the script from this.ScriptFilePath, and appends various
        /// housekeeping commands at the end of the script.
        /// </summary>
        /// <param name="filename"></param>
        private string ReadScriptAndAppendHouseKeeping()
        {
            // Read the script text
            string scriptBody = File.ReadAllText(this.ScriptFilePath);

            // Try to extract the correct case of the class name
            string scriptClassNameUserCase = Path.GetFileNameWithoutExtension(this.ScriptFilePath) + "Script";
            string scriptClassSearchString = "class " + scriptClassNameUserCase;
            int indexClassName = scriptBody.IndexOf(scriptClassSearchString, StringComparison.OrdinalIgnoreCase);

            if (indexClassName == -1)
            {
                // Could not extract the class name
                throw new ApplicationException("Could not find class '" + scriptClassNameUserCase + "' in script: " + this.ScriptFilePath + ".");
            }
            else
            {
                // Append the housekeeping code
                string scriptClassName = scriptBody.Substring(indexClassName, scriptClassSearchString.Length);
                scriptClassName = scriptClassName.Replace("class ", "");
                scriptBody += "\r\n";
                scriptBody += "script = " + scriptClassName + "()\r\n";
                scriptBody += "script.ParentApplication = ParentApplication\r\n";
                scriptBody += "script.FilePath = ScriptFilePath\r\n";
                scriptBody += "script.Handlers = Handlers\r\n";

                // Append the user specified name-value pair parameters
                if (this.ScriptParameters != null && this.ScriptParameters.Length > 0)
                {
                    // Setup for Default parameter
                    string patternDefault = @"^(\s*)((\042|\047)*)(?<value>(\p{L}|\p{N}|\p{P})+?)((\042|\047)*)(\s*)$";
                    Regex regexDefault = new Regex(patternDefault, RegexOptions.Compiled | RegexOptions.IgnoreCase | RegexOptions.Singleline | RegexOptions.ExplicitCapture);
                    Match matchDefault = regexDefault.Match(this.ScriptParameters);
                    
                    // Setup for NameValue parameters
                    string patternNameValue = @"((\s*)(?<name>\w+)(\s*)(=)(\s*)(?<value>\S+)(\s*))*";
                    Regex regexNameValue = new Regex(patternNameValue, RegexOptions.Compiled | RegexOptions.IgnoreCase | RegexOptions.Singleline | RegexOptions.ExplicitCapture);
                    Match matchNameValue = regexNameValue.Match(this.ScriptParameters);
                    
                    // Parse the parameters
                    if (matchDefault.Success)
                    {
                        try
                        {
                            string value = matchDefault.Groups["value"].Captures[0].ToString();
                            scriptBody += "script.Default = \"" + value + "\"\r\n";
                        }
                        catch (Exception ex)
                        {
                            throw new ApplicationException("Invalid script parameter list: '" + this.ScriptParameters + "'.", ex);
                        }
                    }
                    else if (matchNameValue.Success)
                    {
                        try
                        {
                            for (int i = 0; i < matchNameValue.Groups["name"].Captures.Count; i++)
                            {
                                string name = matchNameValue.Groups["name"].Captures[i].ToString();
                                string value = matchNameValue.Groups["value"].Captures[i].ToString();
                                scriptBody += "script." + name + " = " + value + "\r\n";
                            }
                        }
                        catch (Exception ex)
                        {
                            throw new ApplicationException("Invalid script parameter list: '" + this.ScriptParameters + "'.", ex);
                        }
                    }
                    else if (this.ScriptParameters.Length > 0)
                    {
                        throw new ApplicationException("Invalid script parameter list: '" + this.ScriptParameters + "'.");
                    }
                }

                // Append the code to call the correct function
                scriptBody += "getattr(script, Function)()\r\n";
                return scriptBody;
            }
        }

        /// <summary>
        /// Searches for the given script. The hint can be either a full 
        /// path, a name with extension, or a name without extension.
        /// This method firstly detects if hint is a rooted path, and
        /// returns the script full filename from the given path.
        /// Failing this (which will be most cases) this method then
        /// searches the current directory for the script. Failing this,
        /// any direct folders starting with "Script" (including any
        /// recursive folders under "Script") are searched. As a last
        /// resort this method searches all folders in currentDirectory
        /// recursively.
        /// </summary>
        /// <param name="currentDirectory">The current directory to start search.
        ///                                This parameter is ignored if hint is a rooted path.</param>
        /// <param name="hint"></param>
        /// <returns>null if script not found OR the absolute file 
        ///          path and name of the script if found.</returns>
        private static string SearchForScript(string currentDirectory, string hint)
        {
            string searchPath = string.Empty;
            
            // Check to see if the hint is a rooted path
            if (Path.IsPathRooted(hint))
            {
                // The hint is rooted - use this directory to search
                searchPath = Path.GetDirectoryName(hint);

                // Check that the rooted path exists
                if (searchPath == null || searchPath.Length == 0 ||
                    !Directory.Exists(searchPath))
                {
                    // The rooted path does not exist, override with current directory
                    searchPath = currentDirectory;
                }
            }
            else
            {
                // Use the current directory to search
                searchPath = currentDirectory;
            }

            // Check that search path exists
            if (searchPath == null || searchPath.Length == 0 ||
                !Directory.Exists(searchPath))
            {
                throw new FileNotFoundException("The search path does not exist: '" + searchPath + "'.");
            }

            // Get the filename
            string searchFilename = Path.GetFileNameWithoutExtension(hint);

            // Get the extension
            string searchExtension = Path.GetExtension(hint);
            if (searchExtension == null || searchExtension.Length == 0)
                searchExtension = ".py";

            // Construct file
            string searchFilenameWithExtension = searchFilename + searchExtension;

            // Search in current path
            string result = siScriptManager.SearchForFileInPath(searchPath, searchFilenameWithExtension, false);
            if (result != null && result.Length > 0)
                return result;

            // Search in all paths starting with "Script"
            foreach (string searchPathScript in Directory.GetDirectories(searchPath, "*Script*"))
            {
                result = siScriptManager.SearchForFileInPath(searchPathScript, searchFilenameWithExtension, true);
                if (result != null && result.Length > 0)
                    return result;
            }

            // Do a full recursive search
            foreach (string searchPathAll in Directory.GetDirectories(searchPath))
            {
                result = siScriptManager.SearchForFileInPath(searchPathAll, searchFilenameWithExtension, true);
                if (result != null && result.Length > 0)
                    return result;
            }

            // If we get here we did not find the script
            return null;
        }

        /// <summary>
        /// Searches for the given file in the given path.
        /// </summary>
        /// <param name="searchPath"></param>
        /// <param name="searchFilenameWithExtension"></param>
        /// <param name="recursive">true AND search all subfolders OR 
        ///                         false AND only search direct children.</param>
        /// <returns>null if file not found OR the absolute file 
        ///          path and name if found.</returns>
        private static string SearchForFileInPath(string searchPath, 
                                                  string searchFilenameWithExtension,
                                                  bool recursive)
        {
            // Search the searchPath
            string[] files = Directory.GetFiles(searchPath, searchFilenameWithExtension);

            // Check if we found anything
            if (files.Length == 1)
            {
                return files[0];
            }
            else if (files.Length > 1)
            {
                // We found more than one file!!!
                throw new FileNotFoundException("Found multiple files matching search criteria.");
            }

            // Check if we are doing a recursive search
            if (recursive)
            {
                foreach (string searchPathChild in Directory.GetDirectories(searchPath))
                {
                    string result = siScriptManager.SearchForFileInPath(searchPathChild,
                                                                      searchFilenameWithExtension,
                                                                      recursive);
                    if (result != null && result.Length > 0)
                        return result;
                }
            }

            // If we get here we did not find the file
            return null;
        }
        //=====================================================================
        #endregion

        #region Script Event Handlers
        //=====================================================================
        /// <summary>
        /// Handles when a script has started working.
        /// </summary>
        /// <remarks>This method is thread-safe.</remarks>
        private void OnScriptStarted()
        {
            // Make the call thread-safe
            if (this.ParentApplication.InvokeRequired)
            {
                this.ParentApplication.Invoke(new ScriptEmptyHandler(this.OnScriptStarted));
                return;
            }

            // Show the message and record starting time
            this.ParentApplication.SetApplicationAsWorking();
            DateTime timeScriptStarted = DateTime.Now;
            this.ParentApplication.ScriptConsole.WriteLine("---- " + this.ScriptName + ": Started at " + timeScriptStarted.ToString() + " ----");
            this.m_SpanScriptStarted = new TimeSpan(timeScriptStarted.Ticks);
        }

        /// <summary>
        /// Handles when a script has finished working.
        /// </summary>
        /// <param name="success">True and the script completed successfully, false and the script failed.</param>
        /// <remarks>This method is thread-safe.</remarks>
        private void OnScriptCompleted(bool success)
        {
            // Make the call thread-safe
            if (this.ParentApplication.InvokeRequired)
            {
                this.ParentApplication.Invoke(new ScriptCompletedHandler(this.OnScriptCompleted), success);
                return;
            }

            // Do not complete if the script has already been finalised
            if (this.m_HasScriptBeenFinalised || this.m_HasScriptBeenCompleted)
                return;

            // Save that this script has been completed
            this.m_HasScriptBeenCompleted = true;

            // Compute time to complete script
            DateTime timeScriptFinished = DateTime.Now;
            TimeSpan spanScriptFinished = new TimeSpan(timeScriptFinished.Ticks);
            TimeSpan spanTotal = spanScriptFinished - this.m_SpanScriptStarted;
            string sSpanTotal = spanTotal.Minutes.ToString("00") + ":" + spanTotal.Seconds.ToString("00") + ":" + spanTotal.Milliseconds.ToString("000");
            string scriptName = (this.ScriptName != null && this.ScriptName.Length > 0) ? this.ScriptName + ": " : string.Empty;
            string sCompleted = scriptName + "Completed in " + sSpanTotal;

            // Update user info depending on script success
            if (success)
            {
                // Update status label
                this.ParentApplication.SetApplicationStatusLabel(sCompleted);
                this.ParentApplication.SetApplicationAsReady(5500);

                // Update Console
                sCompleted = "==== " + scriptName + "Finished at " + timeScriptFinished.ToString() + ": Completed in " + sSpanTotal + " ====";
            }
            else
            {
                // Update Console
                sCompleted = "==== " + scriptName + "Failed at " + timeScriptFinished.ToString() + " ====";
                this.ParentApplication.SetApplicationAsReady(0);
            }
            this.ParentApplication.ScriptConsole.WriteLine(sCompleted);

            // Force Progress to 0
            this.ParentApplication.SetApplicationProgress(0);
        }

        /// <summary>
        /// Handles when a script has silently finished working.
        /// </summary>
        /// <remarks>This method is thread-safe.</remarks>
        private void OnScriptFinalised()
        {
            // Make the call thread-safe
            if (this.ParentApplication.InvokeRequired)
            {
                this.ParentApplication.Invoke(new ScriptEmptyHandler(this.OnScriptFinalised));
                return;
            }

            // Raise the script finalised event
            this.RaiseScriptFinalised();
        }

        /// <summary>
        /// Writes a string from a script to the console.
        /// </summary>
        /// <remarks>This method is thread-safe.</remarks>
        /// <param name="message"></param>
        public void OnScriptWriteLineToConsole(string message)
        {
            // Make the call thread-safe
            if (this.ParentApplication.InvokeRequired)
            {
                this.ParentApplication.Invoke(new ScriptStringHandler(this.OnScriptWriteLineToConsole), message);
                return;
            }
           
            // Write the message
            this.ParentApplication.ScriptConsole.WriteLine(message);
        }

        /// <summary>
        /// Handles when a script has a filter start working.
        /// </summary>
        /// <remarks>This method is thread-safe.</remarks>
        /// <param name="process"></param>
        /// <param name="time"></param>
        private void OnScriptFilterStarted(itk.itkObject obj, DateTime time)
        {
            // Make the call thread-safe
            if (this.ParentApplication.InvokeRequired)
            {
                this.ParentApplication.Invoke(new itk.itkTimedEventHandler(this.OnScriptFilterStarted), obj, time);
                return;
            }

            // Show the message
            string sFilter = "Applying " + (obj as itk.itkProcessObject).Name + "...";
            this.ParentApplication.ScriptConsole.Write(sFilter);
            this.ParentApplication.SetApplicationStatusLabel(sFilter);
        }

        /// <summary>
        /// Handles when a filter in a script has finished working.
        /// </summary>
        /// <remarks>This method is thread-safe.</remarks>
        /// <param name="process"></param>
        /// <param name="time"></param>
        private void OnScriptFilterEnded(itk.itkObject obj, DateTime time)
        {
            // Make the call thread-safe
            if (this.ParentApplication.InvokeRequired)
            {
                this.ParentApplication.Invoke(new itk.itkTimedEventHandler(this.OnScriptFilterEnded), obj, time);
                return;
            }

            // Show the 'done' string
            this.ParentApplication.ScriptConsole.WriteLine("Done.");
        }

        /// <summary>
        /// Handle a change in progress for a filter in a script.
        /// </summary>
        /// <remarks>This method is thread-safe.</remarks>
        /// <param name="process"></param>
        /// <param name="progress"></param>
        private void OnScriptFilterProgress(itk.itkProcessObject process, float progress)
        {
            // Make the call thread-safe
            if (this.ParentApplication.InvokeRequired)
            {
                this.ParentApplication.Invoke(new itk.itkProgressHandler(this.OnScriptFilterProgress), process, progress);
                return;
            }

            // Update the progress
            this.ParentApplication.SetApplicationProgress((int)(progress * 100.0F));
        }
        //=====================================================================
        #endregion
                
        //=====================================================================
        #endregion
    }
    //=========================================================================
    #endregion
}