//            Copyright Keysight Technologies 2012-2019
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, you can obtain one at http://mozilla.org/MPL/2.0/.
using System;
using Microsoft.Build.Framework;
using Microsoft.Build.Utilities;
using System.Diagnostics;
using System.IO;
using System.Text.RegularExpressions;

namespace Keysight.OpenTap.Sdk.MSBuild
{
    public static class BuildType
    {
        public const string None = "None";
        public const string Package = "Package";
    }

    public static class InstallType
    {
        public const string None = "None";
        public const string PackageDef = "PackageDef";
    }

    /// <summary>
    /// MSBuild Task to help package plugin. This task is used by the OpenTAP SDK project template
    /// </summary>
    [Serializable]
    public class PackageTask : Task
    {
        [Required]
        public string ConfFile { get; set; }

        [Required]
        public string Dir { get; set; }

        public string Build { get; set; }

        public string Install { get; set; }

        public PackageTask()
        {
            Build = BuildType.Package;
            Install = InstallType.PackageDef;
        }

        void confFileRun(string packagePath)
        {
            ProcessStartInfo info = new ProcessStartInfo(packagePath);
            
            info.Arguments = String.Format("package create \"{0}\" --project-directory \"{1}\" -v", ConfFile, Directory.GetCurrentDirectory());

            switch (Build)
            {
                case BuildType.Package:
                    info.Arguments += " -o \"\""; // Means "make tappackage with the correct name"
                    break;
            }


            switch (Install)
            {
                case InstallType.PackageDef:
                    if (Build != BuildType.Package)
                        info.Arguments += " -o \"\""; // Means "make tappackage with the correct name"

                    info.Arguments += " --install"; // Means "copy files not already present and output package xml to make it appear installed"
                    break;
            }

            info.WorkingDirectory = Dir;
            Log.LogMessage("{0} {1}", packagePath, info.Arguments);
            
            info.WindowStyle = ProcessWindowStyle.Normal;
            info.RedirectStandardError = true;
            info.RedirectStandardOutput = true;
            info.UseShellExecute = false;
            Process p = Process.Start(info);

            // find the output filename from the stdout of the Tap.Package.exe process
            // (we do this in a separate thread in parallel with reading stderr to avoid a potential deadlock)
            string filename = null;
            var task = System.Threading.Tasks.Task.Run(() =>
            {
                // Handle all non-error log messages
                while (!p.StandardOutput.EndOfStream)
                {
                    string line = p.StandardOutput.ReadLine();
                    // Catch the name of the generated file.
                    Regex sucessRegex = new Regex(@"TAP plugin package '(?<filename>[^']+)' containing '(?<name>[^']+)' successfully created.");
                    Match m = sucessRegex.Match(line);
                    if (m.Success)
                    {
                        filename = m.Groups["filename"].Value;
                    }

                    // extract messages of type Warning, Information and Debug. These are messages coming from OpenTAP.
                    Regex msgRegex = new Regex(@":[ ]*(?<source>.*)[ ]*:[ ]*(?<type>Warning|Information|Debug)[ ]*:[ ]*(?<msg>.+)");
                    Match msgMatch = msgRegex.Match(line);
                    if (msgMatch.Success)
                    {
                        string source = msgMatch.Groups["source"].Value;
                        string type = msgMatch.Groups["type"].Value;
                        string message = msgMatch.Groups["msg"].Value;

                        switch(type)
                        {
                            case "Warning":
                                BuildEngine.LogWarningEvent(new BuildWarningEventArgs(source, "", ConfFile, 1, 1, 0, 0, message, "", "tap.exe"));
                                break;
                            case "Information":
                                BuildEngine.LogMessageEvent(new BuildMessageEventArgs(source, "", ConfFile, 1, 1, 0, 0, message, "", "tap.exe", MessageImportance.High));
                                break;
                            case "Debug":
                                Log.LogMessage(source, "1", "", ConfFile, 1, 1, 0, 0, MessageImportance.Normal, message);
                                break;
                        }
                    }
                }
            });

            // Handle all error messages
            while (!p.StandardError.EndOfStream)
            {
                string line = p.StandardError.ReadLine();
                // Match Dotfuscator errors.
                Regex dtofErrorRegex = new Regex(@"(?<path>[^\(]+)\((?<line>[0-9]+),(?<column>[0-9]+)\): error: (?<msg>.+)");
                Match dotfErrorMatch = dtofErrorRegex.Match(line);
                if (dotfErrorMatch.Success)
                {
                    int lineNum = int.Parse(dotfErrorMatch.Groups["line"].Value);
                    int columnNum = int.Parse(dotfErrorMatch.Groups["column"].Value);
                    string message = dotfErrorMatch.Groups["msg"].Value;
                    BuildErrorEventArgs errorEvent = new BuildErrorEventArgs("Xml", "", ConfFile, lineNum, columnNum, 0, 0, message, "", "tap.exe");
                    BuildEngine.LogErrorEvent(errorEvent);
                }
                else
                {
                    // extract messages of type Error.  These are messages coming from OpenTAP.
                    Regex tapErrorRegex = new Regex(@":[ ]*(?<source>.*)[ ]*:[ ]*Error[ ]*:[ ]*(?<msg>.+)");
                    Match tapErrorMatch = tapErrorRegex.Match(line);
                    if (tapErrorMatch.Success)
                    {
                        string source = tapErrorMatch.Groups["source"].Value;
                        string message = tapErrorMatch.Groups["msg"].Value;

                       BuildEngine.LogErrorEvent(new BuildErrorEventArgs(source, "", ConfFile, 1, 1, 0, 0, message, "", "tap.exe"));
                    }
                    else
                        Log.LogError(line);
                }
            }

            task.Wait();
            p.WaitForExit();

            // Make sure we log an error. If Tap.Package did not succeed
            if (p.ExitCode == 0)
            {
                if(!string.IsNullOrEmpty(filename))
                    Log.LogMessage(MessageImportance.High, "Created package '{0}'", Path.Combine(Dir, filename));
                else
                    Log.LogMessage(MessageImportance.High, "Created package in '{0}'", Dir);
            }
            else
                Log.LogError("Error {1} creating package from {0}", ConfFile, p.ExitCode);
        }

        public override bool Execute()
        {
            string packagePath = GetTapExePath();

            if (!File.Exists(packagePath))
            {
                Log.LogError("Cannot find OpenTAP installation. Is the OpenTAP SDK installed?");
                return false;
            }

            if (ConfFile == null)
            {
                Log.LogError("Missing package cofiguration file (ConfFile).");
                return false;
            }

            var be3 = BuildEngine as IBuildEngine3;

            if (be3 != null) be3.Yield();
            try
            {
                confFileRun(packagePath);
            }
            finally
            {
                if (be3 != null) be3.Reacquire();
            }
            return !Log.HasLoggedErrors;
        }

        private string GetTapExePath()
        {
            try
            {
                string installRootDir = Path.GetDirectoryName(this.GetType().Assembly.Location);
                for(int i = 0; i<4;i++)
                {
                    if (File.Exists(Path.Combine(installRootDir,"tap.exe")))
                    {
                        return Path.Combine(installRootDir, "tap.exe");
                    }
                    installRootDir = Path.GetDirectoryName(installRootDir);
                }
            }
            catch
            {
            }
            return null;
        }
        private string formatOutput(string output, bool appendVersionToOutput, string assemblyPath)
        {
            if (appendVersionToOutput == false)
                return output;
            string extension = Path.GetExtension(output);
            string name = Path.GetFileNameWithoutExtension(output);
            string version = FileVersionInfo.GetVersionInfo(assemblyPath).ProductVersion;
            return String.Format("{0}.{1}{2}", name, version, extension);
        }
    }
}