using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
using System.IO;
using System.Windows.Forms;
using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.Emit;

namespace AppBasicIDE
{
    public class ScriptEngine
    {
        private Dictionary<string, Assembly> _compiledScripts = new Dictionary<string, Assembly>();
        private ControlManager _controlManager;

        public ScriptEngine(ControlManager controlManager = null)
        {
            _controlManager = controlManager;
        }

        public void SetControlManager(ControlManager controlManager)
        {
            _controlManager = controlManager;
        }

        public bool CompileScript(string scriptId, string code, out string error)
        {
            error = null;

            try
            {
                // 生成控件访问代码
                var controlAccessCode = GenerateControlAccessCode();

                // 包装代码到一个类中，包含控件访问功能
                var wrappedCode = $@"
using System;
using System.Windows.Forms;
using System.Drawing;

public class ScriptClass
{{
    private System.Collections.Generic.Dictionary<string, Control> _controls;

    public void SetControls(System.Collections.Generic.Dictionary<string, Control> controls)
    {{
        _controls = controls;
    }}

    {controlAccessCode}

    public void Execute(Control sender, EventArgs e)
    {{
        {code}
    }}
}}";

                var syntaxTree = CSharpSyntaxTree.ParseText(wrappedCode);

                // 获取所有必要的引用程序集
                var references = GetMetadataReferences();

                var compilation = CSharpCompilation.Create(
                    assemblyName: $"Script_{scriptId}_{Guid.NewGuid():N}",
                    syntaxTrees: new[] { syntaxTree },
                    references: references,
                    options: new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary));

                using (var ms = new MemoryStream())
                {
                    EmitResult result = compilation.Emit(ms);

                    if (!result.Success)
                    {
                        var failures = result.Diagnostics.Where(diagnostic =>
                            diagnostic.IsWarningAsError ||
                            diagnostic.Severity == DiagnosticSeverity.Error);

                        error = string.Join("\n", failures.Select(f => f.GetMessage()));
                        return false;
                    }

                    ms.Seek(0, SeekOrigin.Begin);
                    var assembly = Assembly.Load(ms.ToArray());
                    _compiledScripts[scriptId] = assembly;

                    return true;
                }
            }
            catch (Exception ex)
            {
                error = ex.Message;
                return false;
            }
        }

        private string GenerateControlAccessCode()
        {
            if (_controlManager == null) return "";

            var sb = new StringBuilder();

            // 生成每个控件的访问属性
            foreach (var controlName in _controlManager.GetAllControlNames())
            {
                var designControl = _controlManager.FindControlByName(controlName);
                if (designControl?.InnerControl != null)
                {
                    var controlType = designControl.InnerControl.GetType().Name;
                    sb.AppendLine($@"
    public {controlType} {controlName}
    {{
        get 
        {{ 
            if (_controls != null && _controls.ContainsKey(""{controlName}""))
                return _controls[""{controlName}""] as {controlType};
            return null;
        }}
    }}");
                }
            }

            // 添加通用的查找方法
            sb.AppendLine(@"
    public Control FindControl(string name)
    {
        if (_controls != null && _controls.ContainsKey(name))
            return _controls[name];
        return null;
    }

    public T FindControl<T>(string name) where T : Control
    {
        return FindControl(name) as T;
    }");

            return sb.ToString();
        }

        private MetadataReference[] GetMetadataReferences()
        {
            var references = new List<MetadataReference>();
            var addedAssemblies = new HashSet<string>();

            try
            {
                // 核心程序集列表
                var coreAssemblies = new[]
                {
            typeof(object),                           // System.Private.CoreLib
            typeof(Console),                          // System.Console
            typeof(Control),                          // System.Windows.Forms
            typeof(MessageBox),                       // System.Windows.Forms
            typeof(System.Drawing.Color),             // System.Drawing
            typeof(System.Drawing.Point),             // System.Drawing.Primitives
            typeof(Dictionary<,>),                    // System.Collections
            typeof(Enumerable),                       // System.Linq
            typeof(System.ComponentModel.Component),  // System.ComponentModel.Primitives
            typeof(System.ComponentModel.TypeConverter), // System.ComponentModel.TypeConverter
            typeof(Encoding),                         // System.Text.Encoding.Extensions
            typeof(System.Text.RegularExpressions.Regex) // System.Text.RegularExpressions
        };

                // 添加核心程序集
                foreach (var type in coreAssemblies)
                {
                    try
                    {
                        var location = type.Assembly.Location;
                        if (!string.IsNullOrEmpty(location) && File.Exists(location) && !addedAssemblies.Contains(location))
                        {
                            references.Add(MetadataReference.CreateFromFile(location));
                            addedAssemblies.Add(location);
                        }
                    }
                    catch { }
                }

                // 添加当前程序集
                var currentAssembly = Assembly.GetExecutingAssembly();
                if (!string.IsNullOrEmpty(currentAssembly.Location) && !addedAssemblies.Contains(currentAssembly.Location))
                {
                    references.Add(MetadataReference.CreateFromFile(currentAssembly.Location));
                    addedAssemblies.Add(currentAssembly.Location);
                }

                // 尝试通过名称加载必要的程序集
                var requiredAssemblyNames = new[]
                {
            "System.Runtime",
            "System.Private.CoreLib",
            "mscorlib",
            "System.ComponentModel.Primitives",
            "System.ComponentModel.TypeConverter",
            "System.ComponentModel",
            "System.Drawing.Primitives",
            "System.Collections",
            "System.Collections.Concurrent",
            "System.Text.Encoding.Extensions",
            "System.Text.RegularExpressions",
            "netstandard"
        };

                foreach (var assemblyName in requiredAssemblyNames)
                {
                    try
                    {
                        var assembly = Assembly.Load(assemblyName);
                        var location = assembly.Location;
                        if (!string.IsNullOrEmpty(location) && File.Exists(location) && !addedAssemblies.Contains(location))
                        {
                            references.Add(MetadataReference.CreateFromFile(location));
                            addedAssemblies.Add(location);
                        }
                    }
                    catch { }
                }

                // 从当前 AppDomain 加载的程序集中查找
                foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies())
                {
                    try
                    {
                        if (!assembly.IsDynamic &&
                            !string.IsNullOrEmpty(assembly.Location) &&
                            File.Exists(assembly.Location) &&
                            !addedAssemblies.Contains(assembly.Location))
                        {
                            var name = assembly.GetName().Name;
                            if (name.StartsWith("System.") ||
                                name.StartsWith("Microsoft.") ||
                                name.Equals("mscorlib") ||
                                name.Equals("netstandard"))
                            {
                                references.Add(MetadataReference.CreateFromFile(assembly.Location));
                                addedAssemblies.Add(assembly.Location);
                            }
                        }
                    }
                    catch { }
                }

                Console.WriteLine($"Added {references.Count} assembly references for script compilation.");

            }
            catch (Exception ex)
            {
                Console.WriteLine($"Error getting metadata references: {ex.Message}");

                // 最小引用集作为后备
                references.Clear();
                addedAssemblies.Clear();

                var fallbackAssemblies = new[]
                {
            typeof(object).Assembly.Location,
            typeof(Control).Assembly.Location,
            typeof(MessageBox).Assembly.Location
        };

                foreach (var location in fallbackAssemblies)
                {
                    if (!string.IsNullOrEmpty(location) && File.Exists(location))
                    {
                        references.Add(MetadataReference.CreateFromFile(location));
                    }
                }
            }

            return references.ToArray();
        }

        public void ExecuteScript(string scriptId, Control sender, EventArgs e)
        {
            if (_compiledScripts.TryGetValue(scriptId, out var assembly))
            {
                try
                {
                    var type = assembly.GetType("ScriptClass");
                    if (type == null)
                    {
                        MessageBox.Show("无法找到脚本类", "错误", MessageBoxButtons.OK, MessageBoxIcon.Error);
                        return;
                    }

                    var instance = Activator.CreateInstance(type);

                    // 设置控件字典
                    if (_controlManager != null)
                    {
                        var controlDict = new Dictionary<string, Control>();
                        foreach (var kvp in _controlManager.ControlsByName)
                        {
                            controlDict[kvp.Key] = kvp.Value.InnerControl;
                        }

                        var setControlsMethod = type.GetMethod("SetControls");
                        setControlsMethod?.Invoke(instance, new object[] { controlDict });
                    }

                    var method = type.GetMethod("Execute");
                    if (method == null)
                    {
                        MessageBox.Show("无法找到Execute方法", "错误", MessageBoxButtons.OK, MessageBoxIcon.Error);
                        return;
                    }

                    method.Invoke(instance, new object[] { sender, e });
                }
                catch (Exception ex)
                {
                    MessageBox.Show($"脚本执行错误: {ex.Message}\n\n详细信息:\n{ex.StackTrace}",
                        "错误", MessageBoxButtons.OK, MessageBoxIcon.Error);
                }
            }
            else
            {
                MessageBox.Show($"未找到脚本: {scriptId}", "错误", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }

        // 清理编译缓存的方法
        public void ClearCompiledScripts()
        {
            _compiledScripts.Clear();
        }

        // 获取所有已编译脚本的ID
        public IEnumerable<string> GetCompiledScriptIds()
        {
            return _compiledScripts.Keys;
        }

        // 测试编译功能
        public bool TestCompilation(out string error)
        {
            var testCode = @"MessageBox.Show(""Test compilation successful!"");";
            return CompileScript("test", testCode, out error);
        }
    }
}