// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.

using System.Diagnostics;
using System.Globalization;
using System.Reflection;
using Newtonsoft.Json.Linq;
using Windows.Win32;

namespace System.Windows.Forms.IntegrationTests.Common;

public static class TestHelpers
{
    /// <summary>
    ///  Gets the current config
    /// </summary>
    private static string Config
    {
        get
        {
#if DEBUG
            return "Debug";
#else
            return "Release";
#endif
        }
    }

    /// <summary>
    ///  Should always match the TargetFramework in the .csproj
    /// </summary>
    private static string TargetFramework
    {
        get
        {
            var frameworkAttribute = (Runtime.Versioning.TargetFrameworkAttribute)Assembly.GetExecutingAssembly()
                .GetCustomAttributes(typeof(Runtime.Versioning.TargetFrameworkAttribute), false)
                .SingleOrDefault();

            string[] extractedTokens = frameworkAttribute.FrameworkName.Split("=v"); // "NetCoreApp, Version=v7.0"

            return $"net{extractedTokens[1]}";
        }
    }

    /// <summary>
    ///  Get the output exe path for a specified project.
    ///  Throws an exception if the path does not exist
    /// </summary>
    /// <param name="projectName">The name of the project</param>
    /// <returns>The exe path</returns>
    public static string GetExePath(string projectName)
    {
        if (string.IsNullOrEmpty(projectName))
            throw new ArgumentNullException(nameof(projectName));

        string repoRoot = GetRepoRoot();
        string exePath = Path.Join(
            repoRoot,
            $"artifacts\\bin\\{projectName}\\{Config}\\{TargetFramework}\\{projectName}.exe");

        if (!File.Exists(exePath))
            throw new FileNotFoundException("File does not exist", exePath);

        return exePath;
    }

    /// <summary>
    ///  Start a process with the specified path.
    ///  Also searches for a local .dotnet folder and adds it to the path.
    ///  If a local folder is not found, searches for a machine-wide install that matches
    ///  the version specified in the global.json.
    /// </summary>
    /// <param name="path">The path to the file to execute</param>
    /// <param name="setCwd">Set the current working directory to the process path</param>
    /// <returns>The new Process</returns>
    public static Process StartProcess(string path, bool setCwd = false)
    {
        if (string.IsNullOrEmpty(path))
            throw new ArgumentNullException(nameof(path));

        if (!File.Exists(path))
            throw new FileNotFoundException("File does not exist", path);

        ProcessStartInfo startInfo = new()
        {
            FileName = path
        };
        if (setCwd)
        {
            startInfo.WorkingDirectory = Path.GetDirectoryName(path);
        }

        return StartProcess(startInfo);
    }

    /// <summary>
    ///  Start a process with the specified start info.
    ///  Also searches for a local .dotnet folder and adds it to the path.
    ///  If a local folder is not found, searches for a machine-wide install that matches
    ///  the version specified in the global.json.
    /// </summary>
    /// <param name="startInfo">The start info</param>
    /// <returns>The new Process</returns>
    public static Process StartProcess(ProcessStartInfo startInfo)
    {
        string dotnetPath = GetDotNetPath();
        if (!Directory.Exists(dotnetPath))
            throw new DirectoryNotFoundException($"{dotnetPath} directory cannot be found.");

        Process process = new();

        // Set the dotnet_root for the exe being launched
        // This allows the exe to look for runtime dependencies (like the shared framework (NetCore.App))
        // outside of the normal machine-wide install location (program files\dotnet)
        startInfo.EnvironmentVariables["DOTNET_ROOT"] = dotnetPath;
        process.StartInfo = startInfo;

        process.Start();
        process.WaitForExit(500);
        return process;
    }

    /// <summary>
    ///  End the process.
    /// </summary>
    /// <returns>The process ExitCode</returns>
    public static int EndProcess(Process process, int timeout = Timeout.Infinite)
    {
        try
        {
            process.Kill();
        }
        catch (Exception)
        {
        }

        process.WaitForExit(timeout);
        return process.ExitCode;
    }

    /// <summary>
    ///  Get the path where dotnet is installed
    /// </summary>
    /// <returns>The full path of the folder containing the dotnet.exe</returns>
    private static string GetDotNetPath()
    {
        string dotNetPath;

        // walk the dir tree up, looking for a .dotnet folder
        try
        {
            dotNetPath = RelativePathBackwardsUntilFind(".dotnet");
        }
        catch (DirectoryNotFoundException)
        {
            // If there is no private install, check for a machine-wide install
            dotNetPath = GetGlobalDotNetPath();
        }

        return dotNetPath;
    }

    /// <summary>
    ///  Get the path of the globally installed dotnet that matches the version specified in the global.json
    ///
    ///  The file looks something like this:
    ///
    ///  {
    ///  "tools": {
    ///  "dotnet": "3.0.100-preview5-011568"
    ///  },
    ///
    ///  All we care about is the dotnet entry under tools
    /// </summary>
    /// <returns>
    ///  The path to the globally installed dotnet that matches the version specified in the global.json.
    /// </returns>
    private static string GetGlobalDotNetPath()
    {
        // find the repo root
        string repoRoot = GetRepoRoot();

        // make sure there's a global.json
        string jsonFile = Path.Join(repoRoot, "global.json");
        if (!File.Exists(jsonFile))
            throw new FileNotFoundException("global.json does not exist");

        // parse the file into a json object
        string jsonContents = File.ReadAllText(jsonFile);
        JObject jsonObject = JObject.Parse(jsonContents);

        string dotnetVersion;
        try
        {
            // check if tools:dotnet is specified
            dotnetVersion = jsonObject["tools"]["dotnet"].ToString();
        }
        catch
        {
            // no version was found, so we're done
            throw new InvalidOperationException("global.json does not contain a tools:dotnet version");
        }

        // Check to see if the matching version is installed
        // The default install location is C:\Program Files\dotnet\sdk
        string defaultSdkRoot = @"C:\Program Files\dotnet\sdk";
        string sdkPath = Path.Join(defaultSdkRoot, dotnetVersion);
        if (!Directory.Exists(sdkPath))
            throw new DirectoryNotFoundException($"dotnet sdk {dotnetVersion} is not installed globally");

        // if we get here, there was a match
        return sdkPath;
    }

    /// <summary>
    ///  Get the full path to the root of the repository
    /// </summary>
    /// <returns>The repo root</returns>
    private static string GetRepoRoot()
    {
        string gitPath = RelativePathBackwardsUntilFind(".git");
        string repoRoot = Directory.GetParent(gitPath).FullName;
        return repoRoot;
    }

    /// <summary>
    ///  Looks backwards form the current executing directory until it finds a sibling directory seek,
    ///  then returns the full path of that sibling.
    /// </summary>
    /// <param name="seek">The sibling directory to look for</param>
    /// <returns>
    ///  The full path of the first sibling directory by the current executing directory, away from the root.
    /// </returns>
    private static string RelativePathBackwardsUntilFind(string seek)
    {
        if (string.IsNullOrEmpty(seek))
        {
            throw new ArgumentNullException(nameof(seek));
        }

        Uri codeBaseUrl = new(Assembly.GetExecutingAssembly().Location);
        string codeBasePath = Uri.UnescapeDataString(codeBaseUrl.AbsolutePath);
        string currentDirectory = Path.GetDirectoryName(codeBasePath);
        string root = Directory.GetDirectoryRoot(currentDirectory);
        while (!currentDirectory.Equals(root, StringComparison.CurrentCultureIgnoreCase))
        {
            if (Directory.GetDirectories(currentDirectory, seek, SearchOption.TopDirectoryOnly).Length == 1)
            {
                string ret = Path.Join(currentDirectory, seek);
                return ret;
            }

            currentDirectory = Directory.GetParent(currentDirectory).FullName;
        }

        throw new DirectoryNotFoundException($"No {seek} folder was found among siblings of subfolders of {codeBasePath}.");
    }

    /// <summary>
    ///  Presses Enter on the given process if it can be made the foreground process
    /// </summary>
    /// <param name="process">The process to send the Enter key to</param>
    /// <returns>Whether or not the Enter key was pressed on the process</returns>
    /// <seealso cref="SendKeysToProcess(Process, string, bool)"/>
    public static bool SendEnterKeyToProcess(Process process, bool switchToMainWindow = true)
    {
        return SendKeysToProcess(process, "~", switchToMainWindow);
    }

    /// <summary>
    ///  Presses Tab on the given process if it can be made the foreground process
    /// </summary>
    /// <param name="process">The process to send the Tab key to</param>
    /// <returns>Whether or not the Tab key was pressed on the process</returns>
    /// <seealso cref="SendKeysToProcess(Process, string, bool)"/>
    public static bool SendTabKeyToProcess(Process process, bool switchToMainWindow = true)
    {
        return SendKeysToProcess(process, "{TAB}", switchToMainWindow);
    }

    /// <summary>
    ///  Presses Backspace on the given process if it can be made the foreground process
    /// </summary>
    /// <param name="process">The process to send the Backspace key to</param>
    /// <returns>Whether or not the Backspace key was pressed on the process</returns>
    /// <seealso cref="SendKeysToProcess(Process, string, bool)"/>
    public static bool SendBackspaceKeyToProcess(Process process, bool switchToMainWindow = true)
    {
        return SendKeysToProcess(process, "{BACKSPACE}", switchToMainWindow);
    }

    /// <summary>
    ///  Presses Right on the given process if it can be made the foreground process
    /// </summary>
    /// <param name="process">The process to send the Right key to</param>
    /// <returns>Whether or not the Right key was pressed on the process</returns>
    /// <seealso cref="SendKeysToProcess(Process, string, bool)"/>
    public static bool SendRightArrowKeyToProcess(Process process, bool switchToMainWindow = true)
    {
        return SendKeysToProcess(process, "{RIGHT}", switchToMainWindow);
    }

    /// <summary>
    ///  Presses Down on the given process if it can be made the foreground process
    /// </summary>
    /// <param name="process">The process to send the Down key to</param>
    /// <returns>Whether or not the Down key was pressed on the process</returns>
    /// <seealso cref="SendKeysToProcess(Process, string, bool)"/>
    public static bool SendDownArrowKeyToProcess(Process process, bool switchToMainWindow = true)
    {
        return SendKeysToProcess(process, "{DOWN}", switchToMainWindow);
    }

    /// <summary>
    ///  Presses Left on the given process if it can be made the foreground process
    /// </summary>
    /// <param name="process">The process to send the Left key to</param>
    /// <returns>Whether or not the Left key was pressed on the process</returns>
    /// <seealso cref="SendKeysToProcess(Process, string, bool)"/>
    public static bool SendLeftArrowKeyToProcess(Process process, bool switchToMainWindow = true)
    {
        return SendKeysToProcess(process, "{LEFT}", switchToMainWindow);
    }

    /// <summary>
    ///  Presses Up on the given process if it can be made the foreground process
    /// </summary>
    /// <param name="process">The process to send the Up key to</param>
    /// <returns>Whether or not the Up key was pressed on the process</returns>
    /// <seealso cref="SendKeysToProcess(Process, string, bool)"/>
    public static bool SendUpArrowKeyToProcess(Process process, bool switchToMainWindow = true)
    {
        return SendKeysToProcess(process, "{UP}");
    }

    /// <summary>
    ///  Presses Alt plus chosen letter on the given process if it can be made the foreground process
    /// </summary>
    /// <param name="process">The process to send the Alt and key to</param>
    /// <param name="letter">Letter in addition to Alt to send to process.</param>
    /// <returns>Whether or not the Up key was pressed on the process</returns>
    /// <seealso cref="SendKeysToProcess(Process, string, bool)"/>
    public static bool SendAltKeyToProcess(Process process, char letter, bool switchToMainWindow = true)
    {
        return SendKeysToProcess(process, $"%{{{letter}}}", switchToMainWindow);
    }

    /// <summary>
    ///  Presses Tab any number of times on the given process if it can be made the foreground process
    /// </summary>
    /// <param name="process">The process to send the Tab key(s) to</param>
    /// <param name="times">The number of times to press tab in a row</param>
    /// <returns>Whether or not the Tab key(s) were pressed on the process</returns>
    /// <seealso cref="SendKeysToProcess(Process, string, bool)"/>
    public static bool SendTabKeysToProcess(Process process, MainFormControlsTabOrder times, bool switchToMainWindow = true)
    {
        return SendTabKeysToProcess(process, (int)times, switchToMainWindow);
    }

    public static bool SendTabKeysToProcess(Process process, int times, bool switchToMainWindow = true)
    {
        if (times == 0)
        {
            return true;
        }

        string keys = string.Empty;
        for (uint i = 0; i < times; i++)
        {
            keys += "{TAB}";
        }

        return SendKeysToProcess(process, keys, switchToMainWindow);
    }

    /// <summary>
    ///  Bring the specified form to the foreground
    /// </summary>
    /// <param name="form">The form</param>
    public static void BringToForeground(this Form form)
    {
        ArgumentNullException.ThrowIfNull(form);

        form.WindowState = FormWindowState.Minimized;
        form.Show();
        form.WindowState = FormWindowState.Normal;
    }

    /// <summary>
    ///  Set the culture for the current thread
    /// </summary>
    /// <param name="culture">The culture</param>
    public static void SetCulture(this Thread thread, string culture)
    {
        if (string.IsNullOrEmpty(culture))
            throw new ArgumentNullException(nameof(culture));

        CultureInfo cultureInfo = new(culture);
        Thread.CurrentThread.CurrentCulture = cultureInfo;
        Thread.CurrentThread.CurrentUICulture = cultureInfo;
    }

    /// <summary>
    ///  Presses the given keys on the given process, then waits 200ms
    /// </summary>
    /// <param name="process">The process to send the key(s) to</param>
    /// <param name="keys">The key(s) to send to the process</param>
    /// <exception cref="ArgumentException">
    ///  <paramref name="process"/> is <see langword="null"/> or has exited or <paramref name="keys"/>
    ///  is <see langword="null"/> or empty.
    /// </exception>
    /// <returns>Whether or not the key(s) were pressed on the process</returns>
    /// <seealso cref="Process.MainWindowHandle"/>
    /// <seealso cref="PInvoke.SetForegroundWindow{T}(T)"/>
    /// <seealso cref="PInvokeCore.GetForegroundWindow()"/>
    /// <seealso cref="SendKeys.SendWait(string)"/>
    /// <seealso cref="Thread.Sleep(int)"/>
    internal static bool SendKeysToProcess(Process process, string keys, bool switchToMainWindow = true)
    {
        if (process is null)
        {
            throw new ArgumentException($"{nameof(process)} must not be null.");
        }

        if (process.HasExited)
        {
            throw new ArgumentException($"{nameof(process)} must not have exited.");
        }

        if (string.IsNullOrEmpty(keys))
        {
            throw new ArgumentException($"{nameof(keys)} must not be null or empty.");
        }

        HWND mainWindowHandle = (HWND)process.MainWindowHandle;

        if (switchToMainWindow)
        {
            PInvoke.SetForegroundWindow(mainWindowHandle);
        }

        HWND foregroundWindow = PInvokeCore.GetForegroundWindow();

        string windowTitle = PInvokeCore.GetWindowText(foregroundWindow);

        if (PInvokeCore.GetWindowThreadProcessId(foregroundWindow, out uint processId) == 0 ||
            processId != process.Id)
        {
            Debug.WriteLine($"ForegroundWindow doesn't belong the test process! The current window is {windowTitle}.");
        }

        if ((switchToMainWindow && mainWindowHandle.Equals(foregroundWindow)) ||
            (!switchToMainWindow && foregroundWindow != IntPtr.Zero))
        {
            SendKeys.SendWait(keys);

            Thread.Sleep(200);

            return true;
        }
        else
        {
            Debug.Assert(true, $"Given process could not be made to be the ForegroundWindow. The current window is {windowTitle}.");

            return false;
        }
    }
}
