using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Microsoft.CSharp;
using Microsoft.VisualBasic;
using Microsoft.JScript;
using System.Threading;
using System.Reflection;
using System.CodeDom;
using System.CodeDom.Compiler;
using System.IO;

namespace ScriptPluginSystem
{
    class Scripting
    {
        public enum Language
        {
            CSharp, VisualBasic, JScript
        }
        class Script
        {
            private Assembly ScriptCode;//Assembly object representing the compiled script's executable code.
            public Script(string CodeToCompile, Language ProgrammingLanguage)
            {
                ScriptCode = new ScriptCompiler(ProgrammingLanguage).CompileScript(CodeToCompile);//Makes a compiler of the specified language, compiles the code passed to it as a string.
            }//Constructor.
            public object Evaluate(object[] parameters)
            {
                var ClassType = ScriptCode.GetType("Script.ScriptClass");//Gets the namespace and class from the script's assembly.
                MethodInfo MainMethod = ClassType.GetMethod("ScriptMain");//Gets the main method from the namespace and class.
                return MainMethod.Invoke(null, parameters);//Runs the script and returns the results.
            }
            public void Run()
            {//This method is the same as the above, except it takes no parameters and returns nothing.
                var ClassType = ScriptCode.GetType("Script.ScriptClass");
                MethodInfo MainMethod = ClassType.GetMethod("ScriptMain");
                MainMethod.Invoke(null, null);
            }
        }
        class ScriptCompiler
        {
            CodeDomProvider compiler;//This is our CodeDomProvider object, which compiles our code.
            CompilerParameters parameters = new CompilerParameters();//Parameters to pass to the compiler.
            public Assembly CompileScript(string Code)
            {//This method compiles code passed to it as a string and returns the compiled assembly.
                return compiler.CompileAssemblyFromSource(parameters, Code).CompiledAssembly;
            }//Returns a compiled assembly object.
            public ScriptCompiler(Language ProgrammingLanguage)
            {
                if (ProgrammingLanguage == Language.CSharp)
                {//If the language is C#, make a C# compiler.
                    compiler = new CSharpCodeProvider();
                }
                if (ProgrammingLanguage == Language.JScript)
                {//If the language is JScript/Javascript, make a JScript compiler.
                    compiler = new JScriptCodeProvider();
                }
                if (ProgrammingLanguage == Language.VisualBasic)
                {//If the language is visual basic, make a vb compiler.
                    compiler = new VBCodeProvider();
                }
                parameters.GenerateExecutable = false;//Duh.
                parameters.GenerateInMemory = true;//Makes compiler generate assembly in memory.
                parameters.IncludeDebugInformation = false;//Debug info increases script size in memory, so we disable it.
                parameters.ReferencedAssemblies.Add("System.dll");//References System.dll, so scripts can access it's namespaces.
                parameters.ReferencedAssemblies.Add("System.Windows.Forms.dll");//WinForms and controls, for the win.
                parameters.CompilerOptions = "/o"; //Tells compiler to optimize code for speed.
            }//Constructor. Settings for code compilation are all here.
        }
        class ScriptThreading
        {
            public static Thread RunScriptAsync(Script ScriptToRun)
            {//Takes a Script object, executes it's member method "Run()" on a new thread. Returns that thread so you can control execution of the script.
                Thread ScriptThread = new Thread(new ThreadStart(ScriptToRun.Run));//Create a thread, ready to run the script's main method.
                ScriptThread.Start();//Start the thread's execution.
                return ScriptThread;//Return the thread so we can access it.
            }
            public static Thread ReadyScriptThread(Script ScriptToRun)
            {
                Thread ScriptThread = new Thread(new ThreadStart(ScriptToRun.Run));
                return ScriptThread;
            }
        }
    }
}

namespace Script
{
    class ScriptClass
    {
        public void ScriptMain()
        {
        //Code here.
        return;
        }
    }
}