#region Imported Libraries
		
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows.Controls;
using Microsoft.Scripting.Hosting;
using System.IO;
using System.Windows.Input;
using IronRuby;
using Microsoft.Scripting;
using System.Windows;
using System.Threading;
using System.Reflection;

#endregion

#region Namespace Declaration
		
namespace Org.TechA.Wpf.UserControls
{
    internal sealed class IronRubyConsolePresenter
    {
        #region Private Members

        private readonly IronRubyConsoleModel _model;
        private readonly IronRubyConsole _view;

		#endregion

        #region Constructor

        /// <summary>
        /// Default Constructor.
        /// </summary>
        /// <param name="view">
        /// The View.
        /// </param>
		internal IronRubyConsolePresenter(UserControl view)
        {
            //set the model and the view
            _view = (IronRubyConsole)view;
            _model = SetupModel();
            //set the default scope vars
            SetDefaultScopeVariables(_model.Scopes[0]);
            //setup the view
            InitializeView();
            //subscribe to all the view events
            WireupEvents();
        } 

	    #endregion

        #region Accessor Mutators

        /// <summary>
        /// The View.
        /// </summary>
        internal IronRubyConsole View
        {
            get { return _view; }
        }

        /// <summary>
        /// The Model.
        /// </summary>
        internal IronRubyConsoleModel Model
        {
            get { return _model; }
        } 

        #endregion

        #region Event Subscriptions
		
        /// <summary>
        /// Wireup all the views events.
        /// </summary>
        internal void WireupEvents()
        {
            _view.txtUserCodeInput.KeyDown += 
                new KeyEventHandler(txtUserCodeInput_KeyDown);
            _view.mitmPrintState.Click += 
                new RoutedEventHandler(mitmPrintState_Click);
            _view.mitmAbout.Click += 
                new RoutedEventHandler(mitmAbout_Click);
            _view.mitmAddScope.Click += 
                new RoutedEventHandler(mitmAddScope_Click);
            _view.mitmClearScreen.Click += 
                new RoutedEventHandler(mitmClearScreen_Click);
            _view.VariablesAdded += 
                new Action<Dictionary<string, object>>(_view_VariablesAdded);
        }

        void _view_VariablesAdded(Dictionary<string, object> obj)
        {
            foreach (var key in obj.Keys)
            {
                _model.Scopes[0].SetVariable(key, obj[key]);
            }
        }

        /// <summary>
        /// Clears the IronRuby output screen.
        /// </summary>
        /// <param name="sender">
        /// The menu item.
        /// </param>
        /// <param name="e">
        /// The routed event arguments.
        /// </param>
        void mitmClearScreen_Click(object sender, RoutedEventArgs e)
        {
            _view.txtIronRubyOutput.Clear();
        }

        /// <summary>
        /// Menu item click event for added a scope.
        /// </summary>
        /// <param name="sender">
        /// The menu item.
        /// </param>
        /// <param name="e">
        /// The Routed event args.
        /// </param>
        void mitmAddScope_Click(object sender, RoutedEventArgs e)
        {
        }

        /// <summary>
        /// About window menu item 
        /// click event hanlder.
        /// </summary>
        /// <param name="sender">
        /// The Menu Item.
        /// </param>
        /// <param name="e">
        /// The routed event arguments.
        /// </param>
        void mitmAbout_Click(object sender, RoutedEventArgs e)
        {
            AboutDialog dlg = new AboutDialog();
            dlg.ShowDialog();
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        void mitmPrintState_Click(object sender, RoutedEventArgs e)
        {
            var scope = _model.Scopes[0];
            var source =
                   scope.Engine
                   .CreateScriptSourceFromString("puts 'PRINTING VARIABLES FROM DEFAULT SCOPE';" +
                                                 "puts '************************************************'");
            var result = source.Execute(scope);

            foreach(var varName in scope.GetVariableNames())
            {
                //get the variable by name
                var variable = scope.GetVariable(varName);
                //get the script source from string which will
                //simply print the name of the variable
                source = scope.Engine
                    .CreateScriptSourceFromString("puts 'Variable Name is [" + 
                    varName + "] and value is [" + variable + "]'");
                result = source.Execute(scope);
                _model.Writer.WriteLine(FormatResult(result));              
            }

            source =
                   scope.Engine
                   .CreateScriptSourceFromString("puts; puts '************************************************'");
            result = source.Execute(scope);
        }

	    #endregion

        #region Private Worker Methods

        /// <summary>
        /// Setup of the View.
        /// </summary>
        private void InitializeView()
        {
            FocusHelper.Focus(_view.txtUserCodeInput);
            _view.txtUserCodeInput.SelectionStart = 1;
        }
        
        /// <summary>
        /// Setup the IronRuby Runtime, Engine
        /// and create a default scope.
        /// </summary>
        private IronRubyConsoleModel SetupModel()
        {
            var runtime = Ruby.CreateRuntime();

            // give ruby access to all our assemblies
            foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies())
            {
                runtime.LoadAssembly(assembly); 
            }

            var writer = SetupIO(runtime);
            var engine = runtime.GetEngine("Ruby");
            var default_scope = engine.CreateScope();
            
            var model = new IronRubyConsoleModel(writer, engine);
            model.Scopes.Add(default_scope);

            return model;
        }

        /// <summary>
        /// Setup the IO classes that will have
        /// the IronRuby runtime have its IO 
        /// redirected to.
        /// </summary>
        /// <param name="runtime">
        /// The IronRuby runtime.
        /// </param>
        /// <returns>
        /// The Texwriter that the IronRuby
        /// runtime will write to.
        /// </returns>
        private TextWriter SetupIO(ScriptRuntime runtime)
        {
            var writer = new TextBoxWriter(_view.txtIronRubyOutput);
            var stream = new TextWriterStream(writer);
            runtime.IO.SetOutput(stream, writer);
            runtime.IO.SetErrorOutput(stream, writer);

            return writer;
        }

        /// <summary>
        /// Formats the result of the of
        /// execution of code by a ScriptSource.
        /// </summary>
        /// <param name="obj">
        /// The result of running a given script.
        /// </param>
        /// <returns>
        /// Returns the formatted result from
        /// running a given script.
        /// </returns>
        private string FormatResult(object obj)
        {
            var prefix = "=> ";
            var result = default(string);

            if (obj == null)
                result = "nil";
            else
                result = obj.ToString();

            return prefix + result;
        }

        /// <summary>
        /// Runs the code typed in the console window.
        /// </summary>
        /// <param name="theCode">
        /// The code string.
        /// </param>
        private void RunCode(string theCode)
        {
            _model.Writer.WriteLine(">>> " + theCode);

            try
            {
                var scriptSource = _model.Engine.
                    CreateScriptSourceFromString(theCode,
                    SourceCodeKind.Statements);
                var result = scriptSource.Execute(_model.Scopes[0]);
                _model.Writer.WriteLine(FormatResult(result));
            }
            catch (Exception e)
            {
                _model.Writer.WriteLine(e.Message);
            }
        }

        /// <summary>
        /// Sets any variables required
        /// for the default scope.
        /// </summary>
        /// <param name="scope">
        /// The default scope.
        /// </param>
        private void SetDefaultScopeVariables(ScriptScope scope)
        {
            scope.SetVariable("scopename", "Default");
            scope.SetVariable("windowcount", Application.Current.Windows.Count);
        }

        #endregion

        #region Event Delegates
		
        /// <summary>
        /// The user entry code textbox
        /// key down event handler.
        /// </summary>
        /// <param name="sender">
        /// The code text box.
        /// </param>
        /// <param name="e">
        /// The keys event args.
        /// </param>
        void txtUserCodeInput_KeyDown(object sender, KeyEventArgs e)
        {
            if (e.Key == Key.Enter)
            {
                RunCode(this._view.txtUserCodeInput.Text);
                e.Handled = true;
                this._view.txtUserCodeInput.Clear();
            }
        } 

	    #endregion
    }
}

#endregion