using System.Diagnostics;

namespace CMM.Library.Helpers;

internal class ConsoleHelper
{
    const string cmdFileName = "cmd.exe";
    private static Process CreatProcess(string fileName) =>
        new Process()
        {
            StartInfo = new ProcessStartInfo
            {
                FileName = fileName,
                UseShellExecute = false,
                RedirectStandardInput = true,
                RedirectStandardOutput = true,
                RedirectStandardError = true,
                CreateNoWindow = true,
            }
        };

    public static async Task<string> ExecuteCommand(string command, int timeoutMs = 5000)
    {
        Process p = new Process();
        p.StartInfo.UseShellExecute = false;
        p.StartInfo.CreateNoWindow = true;
        p.StartInfo.RedirectStandardOutput = true;
        p.StartInfo.FileName = command;
        p.Start();

        var readTask = p.StandardOutput.ReadToEndAsync();
        var completedTask = await Task.WhenAny(readTask, Task.Delay(timeoutMs));

        if (completedTask != readTask)
        {
            // Timeout - kill the process
            try { p.Kill(true); } catch { }
            return string.Empty;
        }

        return await readTask;
    }

    /// <summary>
    /// Execute an exe directly with arguments (no cmd.exe or batch file wrapper)
    /// </summary>
    public static async Task<(string Output, int ExitCode)> ExecuteExeAsync(string exePath, string arguments, int timeoutMs = 5000)
    {
        var p = new Process
        {
            StartInfo = new ProcessStartInfo
            {
                FileName = exePath,
                Arguments = arguments,
                UseShellExecute = false,
                CreateNoWindow = true,
                RedirectStandardOutput = true,
                RedirectStandardError = true
            }
        };

        p.Start();

        var readTask = Task.Run(async () =>
        {
            var output = await p.StandardOutput.ReadToEndAsync();
            await p.WaitForExitAsync();
            return (output, p.ExitCode);
        });

        var completedTask = await Task.WhenAny(readTask, Task.Delay(timeoutMs));

        if (completedTask != readTask)
        {
            try { p.Kill(true); } catch { }
            return (string.Empty, -1);
        }

        var result = await readTask;
        p.Close();
        return result;
    }

    public static async Task<string> CmdCommandAsync(params string[] cmds) =>
        await CommandAsync(cmdFileName, cmds);

    public static string CmdCommand(params string[] cmds) =>
        Command(cmdFileName, cmds);

    public static async Task<string> CommandAsync(string fileName, params string[] cmds)
    {
        return await CommandAsync(fileName, 5000, cmds);
    }

    public static async Task<string> CommandAsync(string fileName, int timeoutMs, params string[] cmds)
    {
        var p = CreatProcess(fileName);
        p.Start();
        foreach (var cmd in cmds)
        {
            p.StandardInput.WriteLine(cmd);
        }
        p.StandardInput.WriteLine("exit");

        var readTask = Task.Run(async () =>
        {
            var result = await p.StandardOutput.ReadToEndAsync();
            var error = await p.StandardError.ReadToEndAsync();
            if (!string.IsNullOrWhiteSpace(error))
                result = result + "\r\n<Error Message>:\r\n" + error;
            return result;
        });

        var completedTask = await Task.WhenAny(readTask, Task.Delay(timeoutMs));

        if (completedTask != readTask)
        {
            // Timeout - kill the process
            try { p.Kill(true); } catch { }
            return string.Empty;
        }

        var output = await readTask;
        p.Close();
        Debug.WriteLine(output);
        return output;
    }

    public static string Command(string fileName, params string[] cmds)
    {
        var p = CreatProcess(fileName);
        p.Start();
        foreach (var cmd in cmds)
        {
            p.StandardInput.WriteLine(cmd);
        }
        p.StandardInput.WriteLine("exit");
        var result = p.StandardOutput.ReadToEnd();
        var error = p.StandardError.ReadToEnd();
        if (!string.IsNullOrWhiteSpace(error))
            result = result + "\r\n<Error Message>:\r\n" + error;
        p.WaitForExit();
        p.Close();
        Debug.WriteLine(result);
        return result;
    }
}