using Microsoft.CodeAnalysis.CSharp.Scripting;
using Microsoft.CodeAnalysis.Scripting;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;
using Tango.Core;
using Tango.Core.IO;
using Tango.Scripting.Core;
using System.IO;

namespace Tango.Scripting.Basic
{
    public class Project : ExtendedObject
    {
        public String Name { get; set; }

        public ApartmentState ApartmentState { get; set; }

        public ObservableCollection<ReferenceAssembly> ReferenceAssemblies { get; set; }

        [JsonIgnore]
        public ObservableCollection<Assembly> ReferenceAssembliesLoaded { get; set; }

        public ObservableCollection<Script> Scripts { get; set; }

        public ObservableCollection<IScriptSource> AdditionalScripts
        {
            get
            {
                return Scripts.Where(x => !x.IsEntryPoint).Cast<IScriptSource>().ToObservableCollection();
            }
        }

        public Project()
        {
            ApartmentState = ApartmentState.MTA;

            ReferenceAssemblies = new ObservableCollection<ReferenceAssembly>();
            ReferenceAssemblies.CollectionChanged += ReferenceAssemblies_CollectionChanged;

            ReferenceAssembliesLoaded = new ObservableCollection<Assembly>();
            Scripts = new ObservableCollection<Script>();
            Scripts.CollectionChanged += (x, e) => { RaisePropertyChanged(nameof(AdditionalScripts)); };
        }

        private void ReferenceAssemblies_CollectionChanged(object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e)
        {
            LoadReferenceAssemblies();
        }

        private void LoadReferenceAssemblies()
        {
            ReferenceAssembliesLoaded.Clear();

            foreach (var type in ReferenceAssemblies)
            {
                ReferenceAssembliesLoaded.Add(type.FromType.Assembly);
            }
        }

        public static Project New(String name, String code)
        {
            Project p = new Project();

            p.Name = name;

            p.ReferenceAssemblies.Add(new ReferenceAssembly() { FromType = typeof(String) });
            p.ReferenceAssemblies.Add(new ReferenceAssembly() { FromType = typeof(Enumerable) });
            p.ReferenceAssemblies.Add(new ReferenceAssembly() { FromType = typeof(Form) });
            p.ReferenceAssemblies.Add(new ReferenceAssembly() { FromType = typeof(Project) });

            p.Scripts.Add(new Script()
            {
                Name = "main.csx",
                IsEntryPoint = true,
                Code = code,
            });

            return p;
        }

        public Task<CompilationResult> Compile()
        {
            return Task.Factory.StartNew<CompilationResult>(() =>
            {
                var result = new CompilationResult();
                var tempFolder = TemporaryManager.CreateFolder(Name);
                result.TemporaryProjectPath = tempFolder;

                String mainScriptCode = String.Empty;

                foreach (var script in Scripts)
                {
                    String code = script.Code;
                    String codeFile = Path.Combine(tempFolder, script.Name);

                    String loadingString = String.Empty;

                    foreach (var file in Scripts.Where(x => !x.IsEntryPoint && script != x).Select(x => Path.Combine(tempFolder, x.Name)))
                    {
                        loadingString = $"#load \"{file}\"\n";
                    }

                    code = loadingString + code;

                    if (!script.IsEntryPoint)
                    {


                        //foreach (var match in Regex.Matches(code, "#load \".+\"").OfType<Match>())
                        //{
                        //    String line = match.ToString();
                        //    var pathMatch = Regex.Match(line, "(?<=\")(.*?)(?=\")");
                        //    if (pathMatch.Success)
                        //    {
                        //        String path = pathMatch.ToString();

                        //        if (!System.IO.Path.IsPathRooted(path))
                        //        {
                        //            StringBuilder builder = new StringBuilder(code);
                        //            builder.Insert(match.Index + pathMatch.Index, System.IO.Path.GetFullPath(tempFolder + "\\"));
                        //            code = builder.ToString();
                        //        }
                        //    }
                        //}



                        File.WriteAllText(codeFile, code);
                    }
                    else
                    {
                        code += Environment.NewLine + Environment.NewLine + "return new Program().OnExecute(GlobalContext);";
                        mainScriptCode = code;
                    }
                }

                var scriptOptions = ScriptOptions.Default.WithReferences(ReferenceAssembliesLoaded);

                var s = CSharpScript.Create<object>(mainScriptCode, scriptOptions, typeof(GlobalObject));
                result.Script = s;

                var compileResults = s.Compile();

                foreach (var error in compileResults.Where(x => x.Severity == Microsoft.CodeAnalysis.DiagnosticSeverity.Error || x.Severity == Microsoft.CodeAnalysis.DiagnosticSeverity.Warning))
                {
                    CompilationError cError = new CompilationError();
                    cError.File = System.IO.Path.GetFileName(error.Location.SourceTree.FilePath);
                    cError.Message = error.GetMessage();
                    cError.Severity = error.Severity;
                    var line = error.Location.GetMappedLineSpan();
                    cError.Line = line.StartLinePosition.Line + 1;
                    cError.Column = line.StartLinePosition.Character + 1;
                    cError.Length = line.EndLinePosition.Character - line.StartLinePosition.Character;
                    result.Errors.Add(cError);
                }

                return result;
            });
        }

        public async Task<ProjectSession> Run(IContext context)
        {
            var result = await Compile();

            if (result.Errors.Count > 0)
            {
                throw new InvalidOperationException("There were compilation errors.");
            }

            Thread scriptThread = null;
            ProjectSession session = null;

            session = new ProjectSession(this, () =>
            {
                scriptThread.Abort();
            });

            scriptThread = new Thread(() =>
            {
                try
                {
                    var runResult = result.Script.RunAsync(globals: new GlobalObject() { GlobalContext = context }).Result;
                    session.Completed(runResult.ReturnValue);
                }
                catch (ThreadAbortException)
                {

                }
                catch (Exception ex)
                {
                    session.Failed(ex.InnerException);
                }
            });

            scriptThread.SetApartmentState(ApartmentState);
            scriptThread.IsBackground = true;
            scriptThread.Start();

            return session;
        }
    }
}