//---------------------------------------------------------------------------------------------------------------------------------------------------
// <copyright file="CSharpCompiler.cs" company="DarkWynter Studios">
//     Copyright (C)2007 DarkWynter Studios.  All rights reserved.
// </copyright>
//---------------------------------------------------------------------------------------------------------------------------------------------------
// {Contact : darkwynter.com for licensing information
//---------------------------------------------------------------------------------------------------------------------------------------------------




namespace DarkWynter.Engine.Compiler
{
    #region Using Statements
    using System;
    using System.Collections.Generic;
    using System.Text;
    using System.CodeDom;
    using System.CodeDom.Compiler;
    using System.Runtime.CompilerServices;
    using System.Reflection;
    using Microsoft.CSharp;
    using System.Security;
    using System.Security.Permissions;
    using System.IO; 
    #endregion
    /// <summary>
    /// Creates a CSharpCompiler for use in game
    /// </summary>
    public class CSharpCompiler
    {

        public static object Execute(string source,
                                     string className,
                                     string functionName,
                                     object[] parameters)
        {

            CompilerResults compilerResults = CompileCode(source);

            if (compilerResults.Errors.Count > 0)
            {
                throw new Exception("Not a valid assembly");
            }
            return Execute(compilerResults.CompiledAssembly, className, functionName, parameters);
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="a"></param>
        /// <param name="parameters"></param>
        /// <param name="callingObject"></param>
        /// <returns></returns>
        public static object Execute(Assembly a,
                                    // string className,
                                   //  string functionName,
                                     object[] parameters,
                                     ref object callingObject)
        {
            object obj = null;

        
                Type type = a.GetType();
                foreach (Type tempType in a.GetTypes())
                {
                    type = tempType;

                    try
                    {
                        foreach (MethodInfo info in type.GetMethods())
                        {
                            Array tempArray = info.GetParameters();
                            if (info.GetParameters().Length == 0)
                            {
                                if (obj == null)
                                {
                                    obj = Activator.CreateInstance(type);
                                    info.Invoke(obj, null);
                                }
                            }

                        }
                    }
                    catch (Exception e)
                    {
                        Console.WriteLine(e.Message);
                    }
                }
            
            return obj;
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="assembly"></param>
        /// <param name="className"></param>
        /// <param name="functionName"></param>
        /// <param name="parameters"></param>
        /// <returns></returns>
        public static object Execute(Assembly assembly, string className, string functionName, object[] parameters)
        {
            object o = null;
            return Execute(assembly,  parameters, ref o);
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="source"></param>
        /// <returns></returns>
        public static CompilerResults CompileCode(String source)
        {

            CodeDomProvider provider = new CSharpCodeProvider();


            // Set Compile parameters
            CompilerParameters compilerParameters = new CompilerParameters();
            compilerParameters.GenerateExecutable = false;
            compilerParameters.GenerateInMemory = true;
            compilerParameters.IncludeDebugInformation = false;




            //// Create CodeDom Source-Tree
            //ICodeGenerator cg = provider.CreateGenerator();
            
            //// Create Namespace
            //CodeNamespace cnamespace = new CodeNamespace("Microsoft.Samples");
            //cnamespace.Imports.Add (new CodeNamespaceImport ("System") );
            
            //// Create a DataType
            //CodeTypeDeclaration co = new CodeTypeDeclaration (typeName +"List");
            //co.IsClass = true;
            //cnamespace.Types.Add (co);

            //// Generate Source Code
            //cg.GenerateCodeFromNamespace(cnamespace, w, null);




            // Add an assembly reference.
            Assembly executingAssembly = Assembly.GetExecutingAssembly();


            Assembly entryAssembly = Assembly.GetEntryAssembly();

            foreach (AssemblyName assemblyName in
                            executingAssembly.GetReferencedAssemblies())
            {
                //if (assemblyName.Name == "DWApplication" || assemblyName.Name == "DWGame" || assemblyName.Name == "DWEngine" || assemblyName.Name == "DWStream")
                //{
                compilerParameters.ReferencedAssemblies.Add(assemblyName.Name + ".dll");
                //}
            }

            compilerParameters.ReferencedAssemblies.Add("DWEngine.dll");
            compilerParameters.ReferencedAssemblies.Add("DWGame.dll");
            compilerParameters.ReferencedAssemblies.Add("DWContent.dll");
            compilerParameters.ReferencedAssemblies.Add("DWApplication.dll");

            // compilerParameters.ReferencedAssemblies.Add("DarkWynterGame" + ".dll");

            // Set the level at which the compiler 
            // should start displaying warnings.
            compilerParameters.WarningLevel = 3;

            // Set whether to treat all warnings as errors.
            compilerParameters.TreatWarningsAsErrors = false;


            // Set compiler argument to optimize output.
            compilerParameters.CompilerOptions = "/optimize";


            // Invoke compilation.
            CompilerResults compilerResults = provider.CompileAssemblyFromSource(
                                        compilerParameters, new string[] { source });

            return compilerResults;
            //}

        }



    }
}