using System;
using System.Collections.Generic;
using System.Diagnostics;
using Microsoft.Build.Framework;
using Microsoft.Build.Utilities;

namespace Cosmos.Build.MSBuild
{
    public enum WriteType
    {
        Warning,
        Error,
        Message, // only issued on console
        Info
    }

    public class LogInfo
    {
        /// <summary>
        /// Specifies if warning, error, info or message.
        /// </summary>
        public WriteType logType;

        /// <summary>
        /// Description of the type (can be null).
        /// </summary>
        public string subcategory;

        /// <summary>
        /// Message, Warning or Error code (can be null)
        /// </summary>
        public string code;

        /// <summary>
        /// The help keyword for the host IDE (can be null).
        /// </summary>
        public string helpKeyword;

        /// <summary>
        /// The path to the file causing the message (can be null).
        /// </summary>
        public string file;

        /// <summary>
        /// The line in the file causing the message (set to zero if not available).
        /// </summary>
        public int lineNumber;

        /// <summary>
        /// The column in the file causing the message (set to zero if not available).
        /// </summary>
        public int columnNumber;

        /// <summary>
        /// The last line of a range of lines in the file causing the message (set to zero if not available).
        /// </summary>
        public int endLineNumber;

        /// <summary>
        /// The last column of a range of columns in the file causing the message (set to zero if not available).
        /// </summary>
        public int endColumnNumber;

        /// <summary>
        /// Importance of the message. (default is High)
        /// </summary>
        public MessageImportance importance;

        /// <summary>
        /// The message string.
        /// </summary>
        public string message;

        /// <summary>
        /// Optional arguments for formatting the message string.
        /// </summary>
        public object[] messageArgs;//TODO check if null is allowed, if yes document it here
    }
    
    public abstract class BaseToolTask : Task
    {
        public static bool ExecuteTool(string workingDir, string filename, string arguments, string name, Action<string> errorReceived, Action<string> outputReceived)
        {
            var xProcessStartInfo = new ProcessStartInfo();
            xProcessStartInfo.WorkingDirectory = workingDir;
            xProcessStartInfo.FileName = filename;
            xProcessStartInfo.Arguments = arguments;
            xProcessStartInfo.UseShellExecute = false;
            xProcessStartInfo.RedirectStandardOutput = true;
            xProcessStartInfo.RedirectStandardError = true;
            xProcessStartInfo.CreateNoWindow = true;

            outputReceived(string.Format("Executing command line \"{0}\" {1}", filename, arguments));
            outputReceived(string.Format("Working directory = '{0}'", workingDir));

            using (var xProcess = new Process())
            {
                xProcess.ErrorDataReceived += delegate (object sender, DataReceivedEventArgs e)
                {
                    if (e.Data != null)
                    {
                        errorReceived(e.Data);
                    }
                };
                xProcess.OutputDataReceived += delegate (object sender, DataReceivedEventArgs e)
                {
                    if (e.Data != null)
                    {
                        outputReceived(e.Data);
                    }
                };
                xProcess.StartInfo = xProcessStartInfo;
                xProcess.Start();
                xProcess.BeginErrorReadLine();
                xProcess.BeginOutputReadLine();
                xProcess.WaitForExit(15 * 60 * 1000); // wait 15 minutes
                if (!xProcess.HasExited)
                {
                    xProcess.Kill();
                    errorReceived(String.Format("{0} timed out.", name));
                    return false;
                }
                else
                {
                    if (xProcess.ExitCode != 0)
                    {
                        errorReceived(String.Format("Error occurred while invoking {0}.", name));
                        return false;
                    }
                }
                return true;
            }
        }

        protected bool ExecuteTool(string workingDir, string filename, string arguments, string name)
        {
            var xResult = ExecuteTool(workingDir, filename, arguments, name, s => mErrors.Add(s), s => mOutput.Add(s));

            LogInfo logContent;
            for (int xIndex = 0; xIndex < mErrors.Count; xIndex++)
            {
                var xError = mErrors[xIndex];
                if (ExtendLineError(xResult, xError, out logContent))
                {
                    Logs(logContent);
                }
            }

            for (int xIndex = 0; xIndex < mOutput.Count; xIndex++)
            {
                var xOutput = mOutput[xIndex];
                if (ExtendLineOutput(xResult, xOutput, out logContent))
                {
                    Logs(logContent);
                }
            }

            return xResult;
        }

        private List<string> mErrors = new List<string>();
        private List<string> mOutput = new List<string>();

        public virtual bool ExtendLineError(bool hasErrored, string errorMessage, out LogInfo log)
        {
            log = new LogInfo();
            log.logType = WriteType.Error;
            log.message = errorMessage;
            if (!hasErrored)
                return false;
            return true;
        }

        public virtual bool ExtendLineOutput(bool hasErrored, string errorMessage, out LogInfo log)
        {
            log = new LogInfo();
            log.logType = WriteType.Info;
            log.message = errorMessage;
            return true;
        }

        public void Logs(LogInfo logInfo)// string message, string category, string filename, string lineNumber = 0, string columnNumber = 0)
        {
            switch (logInfo.logType)
            {
                case WriteType.Warning:
                    //Log.LogWarning(category, string.Empty, string.Empty, filename, lineNumber, columnNumber, lineNumber, columnNumber, message);
                    Log.LogWarning(logInfo.subcategory, logInfo.code, logInfo.helpKeyword, logInfo.file, logInfo.lineNumber, logInfo.columnNumber, logInfo.endLineNumber, logInfo.endColumnNumber, logInfo.message, logInfo.messageArgs);
                    break;
                case WriteType.Message:
                    Log.LogMessage(logInfo.subcategory, logInfo.code, logInfo.helpKeyword, logInfo.file, logInfo.lineNumber, logInfo.columnNumber, logInfo.endLineNumber, logInfo.endColumnNumber, logInfo.message, logInfo.messageArgs);
                    break;
                case WriteType.Info:
                    // changed IDEBuildLogger.cs for this behavior of add to ErrorList Messages
                    Log.LogMessage(logInfo.subcategory, logInfo.code, logInfo.helpKeyword, logInfo.file, logInfo.lineNumber, logInfo.columnNumber, logInfo.endLineNumber, logInfo.endColumnNumber, logInfo.importance, logInfo.message, logInfo.messageArgs);
                    break;
                case WriteType.Error:
                default:
                    if (UseConsoleForLog)
                    {
                        LogError(logInfo.message, logInfo.messageArgs);
                    }
                    else
                    {
                        Log.LogError(logInfo.subcategory, logInfo.code, logInfo.helpKeyword, logInfo.file, logInfo.lineNumber, logInfo.columnNumber, logInfo.endLineNumber, logInfo.endColumnNumber, logInfo.message ?? "", logInfo.messageArgs);
                    }
                    break;
            }
        }

        protected void LogError(string message, params object[] args)
        {
            if (UseConsoleForLog)
            {
                if (message == null)
                {
                    return;
                }
                Console.WriteLine("Error: " + String.Format(message, args));
            }
            else
            {
                Log.LogError(message, args);
            }
        }

        public bool UseConsoleForLog { get; set; }
    }
}