using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using Scripty.Core;
using Scripty.Core.Output;
using Scripty.Core.ProjectTree;

namespace Scripty
{
    public class Program
    {
        private static int Main(string[] args)
        {
            AppDomain.CurrentDomain.UnhandledException += UnhandledExceptionEvent;
            Program program = new Program();
            return program.Run(args);
        }

        private static void UnhandledExceptionEvent(object sender, UnhandledExceptionEventArgs e)
        {
            // Exit with a error exit code
            Exception exception = e.ExceptionObject as Exception;
            if (exception != null)
            {
                Console.Error.WriteLine(exception.ToString());
            }
            Environment.Exit((int) ExitCode.UnhandledError);
        }

        private readonly Settings _settings = new Settings();

        private int Run(string[] args)
        {
            // Parse the command line if there are args
            if (args.Length > 0)
            {
                try
                {
                    bool hasParseArgsErrors;
                    if (!_settings.ParseArgs(args, out hasParseArgsErrors))
                    {
                        return hasParseArgsErrors ? (int) ExitCode.CommandLineError : (int) ExitCode.Normal;
                    }
                }
                catch (Exception ex)
                {
                    Console.Error.WriteLine(ex.ToString());
                    return (int) ExitCode.CommandLineError;
                }
            }
            else
            {
                // Otherwise the settings should come in over stdin
                _settings.ReadStdin();
            }

            // Attach
            if (_settings.Attach)
            {
                Console.WriteLine("Waiting for a debugger to attach (or press a key to continue)...");
                while (!Debugger.IsAttached && !Console.KeyAvailable)
                {
                    Thread.Sleep(100);
                }
                if (Console.KeyAvailable)
                {
                    Console.ReadKey(true);
                    Console.WriteLine("Key pressed, continuing execution");
                }
                else
                {
                    Console.WriteLine("Debugger attached, continuing execution");
                }
            }

            // Get the script engine
            string solutionFilePath = null;
            string projectFilePath = Path.Combine(Environment.CurrentDirectory, _settings.ProjectFilePath);

            if (_settings.SolutionFilePath != null)
            {
                solutionFilePath = Path.Combine(Environment.CurrentDirectory, _settings.SolutionFilePath);
            }

            ScriptEngine engine = new ScriptEngine(projectFilePath, solutionFilePath, _settings.Properties);

            // Get script files if none were specified
            IReadOnlyList<string> finalScriptFilePaths;
            if (_settings.ScriptFilePaths != null && _settings.ScriptFilePaths.Count > 0)
            {
                finalScriptFilePaths = _settings.ScriptFilePaths;
            }
            else
            {
                // Look for any .csx files in the project
                Console.WriteLine("No script files were specified, scanning project for .csx files");
                List<string> scriptFilePaths = new List<string>();
                PopulateScriptFilePaths(engine.ProjectRoot, scriptFilePaths);
                finalScriptFilePaths = scriptFilePaths;
            }
            
            // Set up tasks for the specified script files
            ConcurrentBag<Task<ScriptResult>> tasks = new ConcurrentBag<Task<ScriptResult>>();
            Parallel.ForEach(finalScriptFilePaths
                .Select(x => Path.Combine(Path.GetDirectoryName(projectFilePath), x))
                .Where(x => !string.IsNullOrEmpty(x))
                .Distinct(),
                x =>
                {
                    if (File.Exists(x))
                    {
                        Console.WriteLine($"Adding task to evaluate {x}");
                        tasks.Add(engine.Evaluate(new ScriptSource(x, File.ReadAllText(x))));
                    }
                });

            // Evaluate all the scripts
            try
            {
                Task.WaitAll(tasks.ToArray());
            }
            catch (AggregateException aggregateException)
            {
                foreach (Exception ex in aggregateException.InnerExceptions)
                {
                    Console.Error.WriteLine(ex.ToString());
                }
            }

            // Iterate over the completed tasks
            foreach (Task<ScriptResult> task in tasks.Where(x => x.Status == TaskStatus.RanToCompletion))
            {
                // Check for any errors
                foreach (ScriptError error in task.Result.Errors)
                {
                    Console.Error.WriteLine($"{error.Message} [{error.Line},{error.Column}]");
                }

                // Output the set of generated files w/ build actions
                foreach (IOutputFileInfo outputFile in task.Result.OutputFiles)
                {
                    Console.WriteLine($"{outputFile.BuildAction}|{outputFile.FilePath}");
                }
            }

            return (int) ExitCode.Normal;
        }

        private void PopulateScriptFilePaths(ProjectNode node, List<string> scriptFilePaths)
        {
            foreach (KeyValuePair<string, ProjectNode> child in node.Children)
            {
                if (Path.GetExtension(child.Key) == ".csx")
                {
                    scriptFilePaths.Add(child.Key);
                }
                PopulateScriptFilePaths(child.Value, scriptFilePaths);
            }
        }
    }
}