using System;
using System.Buffers;
using System.ComponentModel;
using System.Diagnostics;
using System.IO;
using System.IO.Pipes;
using System.Runtime.InteropServices;
using System.Threading.Tasks;

namespace LongPathTest;

public static class Program
{
    public static void Main(string[] args)
    {
        if (args.Length == 0)
        {
            Setup();
            return;
        }

        string? processPath = args[0] switch
        {
            "PInvoke" => GetModuleFileName(),
            "ProcessMainModule" => Process.GetCurrentProcess()?.MainModule?.FileName,
            "ProcessPath" => Environment.ProcessPath,
            _ => throw new ArgumentException($"Unknown action {args[0]}"),
        };
        Console.WriteLine("Path: '{0}'", processPath);
    }

    public static void Setup()
    {
        string basePath = Path.GetDirectoryName(typeof(Program).Assembly.Location)
            ?? throw new Exception("Could not find current dll path");

        string[] filesToCopy = Directory.GetFiles(basePath);

        string dir1 = "\\\\?\\" + Path.Combine(basePath, new string('a', 255));
        string dir2 = Path.Combine(dir1, new string('b', 255));
        try
        {
            Directory.CreateDirectory(dir1);
            Directory.CreateDirectory(dir2);

            string? shortExePath = null;
            string? longExePath = null;
            foreach (string toCopy in filesToCopy)
            {
                string filename = Path.GetFileName(toCopy);
                string destPath = Path.Combine(dir2, filename);

                File.Copy(toCopy, destPath, true);
                if (Path.GetExtension(filename) == ".exe")
                {
                    shortExePath = toCopy;
                    longExePath = destPath;
                }
            }
            Debug.Assert(shortExePath is not null);
            Debug.Assert(longExePath is not null);

            string banner = new string('=', Console.BufferWidth);
            foreach (string scenario in new [] {"PInvoke", "ProcessMainModule", "ProcessPath"})
            {
                foreach (string exePath in new[] { shortExePath, longExePath })
                {
                    (string stdout, string stderr, int rc) = RunProcess(exePath, scenario);
                    Console.WriteLine("{0}\n{1} RC {2}\nSTDOUT:\n{3}\nSTDERR:\n{4}", banner, scenario, rc, stdout, stderr);
                }
            }
        }
        finally
        {
            if (Directory.Exists(dir1))
            {
                Directory.Delete(dir1, true);
            }
        }
    }

    public static (string, string, int) RunProcess(
        ReadOnlySpan<char> executable,
        ReadOnlySpan<char> commandLine)
    {
        using AnonymousPipeServerStream stdoutPipe = new(PipeDirection.In, HandleInheritability.Inheritable);
        using AnonymousPipeServerStream stderrPipe = new(PipeDirection.In, HandleInheritability.Inheritable);

        Kernel32.STARTUPINFOW si = new()
        {
            cb = Marshal.SizeOf<Kernel32.STARTUPINFOW>(),
            dwFlags = Kernel32.STARTF_USESTDHANDLES,
            hStdOutput = stdoutPipe.ClientSafePipeHandle.DangerousGetHandle(),
            hStdError = stderrPipe.ClientSafePipeHandle.DangerousGetHandle(),
        };
        Kernel32.PROCESS_INFORMATION pi = new();

        int commandLineLength = executable.Length + commandLine.Length + 4;
        char[] commandLineBuffer = ArrayPool<char>.Shared.Rent(commandLineLength);
        try
        {
            commandLineBuffer[0] = '"';
            executable.CopyTo(commandLineBuffer.AsSpan(1));
            commandLineBuffer[executable.Length + 1] = '"';
            commandLineBuffer[executable.Length + 2] = ' ';
            commandLine.CopyTo(commandLineBuffer.AsSpan(executable.Length + 3));
            commandLineBuffer[commandLineLength - 1] = '\0';

            unsafe
            {
                fixed (char* executablePtr = executable)
                fixed (char* commandLinePtr = commandLineBuffer)
                {
                    bool res = Kernel32.CreateProcessW(
                        executablePtr,
                        commandLinePtr,
                        nint.Zero,
                        nint.Zero,
                        true,
                        Kernel32.CREATE_UNICODE_ENVIRONMENT,
                        nint.Zero,
                        nint.Zero,
                        ref si,
                        ref pi);
                    if (!res)
                    {
                        throw new Win32Exception();
                    }
                }
            }

            stdoutPipe.DisposeLocalCopyOfClientHandle();
            stderrPipe.DisposeLocalCopyOfClientHandle();

            using StreamReader stdoutReader = new(stdoutPipe);
            using StreamReader stderrReader = new(stderrPipe);
            Task<string> stdoutTask = Task.Run(stdoutReader.ReadToEndAsync);
            Task<string> stderrTask = Task.Run(stderrReader.ReadToEndAsync);

            bool terminated = false;
            int waitRes = Kernel32.WaitForSingleObject(pi.hProcess, 5000);
            if (waitRes == Kernel32.WAIT_TIMEOUT)
            {
                Kernel32.TerminateProcess(pi.hProcess, -1);
                terminated = true;
            }
            else if (waitRes == Kernel32.WAIT_FAILED)
            {
                throw new Win32Exception();
            }

            int rc;
            if (!Kernel32.GetExitCodeProcess(pi.hProcess, out rc))
            {
                throw new Win32Exception();
            }

            string stdout = stdoutTask.GetAwaiter().GetResult();
            string stderr = stderrTask.GetAwaiter().GetResult();
            if (terminated && string.IsNullOrWhiteSpace(stderr))
            {
                stderr = "Timed out waiting for process output";
            }
            return (stdout, stderr, rc);
        }
        finally
        {
            ArrayPool<char>.Shared.Return(commandLineBuffer);
            if (pi.hProcess != nint.Zero)
            {
                Kernel32.CloseHandle(pi.hProcess);
            }
            if (pi.hThread != nint.Zero)
            {
                Kernel32.CloseHandle(pi.hThread);
            }
        }
    }

    public static string GetModuleFileName()
    {
        int bufferLength = 260;
        char[] pool = ArrayPool<char>.Shared.Rent(bufferLength);
        try {
            while (true)
            {
                unsafe
                {
                    fixed (char* poolPtr = pool)
                    {
                        int res = Kernel32.GetModuleFileNameW(nint.Zero, poolPtr, bufferLength);
                        if (res < bufferLength)
                        {
                            return new string(pool.AsSpan(0, res));
                        }
                        else if (res == bufferLength)
                        {
                            bufferLength += 260;
                            ArrayPool<char>.Shared.Return(pool);
                            pool = ArrayPool<char>.Shared.Rent(bufferLength);
                        }
                        else
                        {
                            throw new Win32Exception();
                        }
                    }
                }
            }
        }
        finally
        {
            ArrayPool<char>.Shared.Return(pool);
        }
    }
}

internal static partial class Kernel32
{
    public const int CREATE_UNICODE_ENVIRONMENT = 0x00000400;
    public const int STARTF_USESTDHANDLES = 0x00000100;
    public const int WAIT_TIMEOUT = 0x00000102;
    public const int WAIT_FAILED = unchecked((int)0xFFFFFFFF);

    [StructLayout(LayoutKind.Sequential)]
    public struct PROCESS_INFORMATION
    {
        public nint hProcess;
        public nint hThread;
        public int dwProcessId;
        public int dwThreadId;
    }

    [StructLayout(LayoutKind.Sequential)]
    public struct STARTUPINFOW
    {
        public int cb;
        public nint lpReserved;
        public nint lpDesktop;
        public nint lpTitle;
        public int dwX;
        public int dwY;
        public int dwXSize;
        public int dwYSize;
        public int dwXCountChars;
        public int dwYCountChars;
        public int dwFileAttribute;
        public int dwFlags;
        public short wShowWindow;
        public short cbReserved2;
        public nint lpReserved2;
        public nint hStdInput;
        public nint hStdOutput;
        public nint hStdError;
    }

    [LibraryImport("kernel32.dll")]
    [return: MarshalAs(UnmanagedType.Bool)]
    public static partial bool CloseHandle(
        nint hObject);

    [LibraryImport("kernel32.dll", SetLastError = true)]
    [return: MarshalAs(UnmanagedType.Bool)]
    public static unsafe partial bool CreateProcessW(
        char* lpApplicationName,
        char* lpCommandLine,
        nint lpProcessAttributes,
        nint lpThreadAttributes,
        [MarshalAs(UnmanagedType.Bool)] bool bInheritHandles,
        int dwCreationFlags,
        nint lpEnvironment,
        nint lpCurrentDirectory,
        ref STARTUPINFOW lpStartupInfo,
        ref PROCESS_INFORMATION lpProcessInformation);

    [LibraryImport("kernel32.dll", SetLastError = true)]
    public static unsafe partial int GetModuleFileNameW(
        nint hModule,
        void* lpFilename,
        int nSize);

    [LibraryImport("kernel32.dll", SetLastError = true)]
    [return: MarshalAs(UnmanagedType.Bool)]
    public static partial bool GetExitCodeProcess(
        nint hProcess,
        out int lpExitCode);

    [LibraryImport("kernel32.dll", SetLastError = true)]
    [return: MarshalAs(UnmanagedType.Bool)]
    public static partial bool TerminateProcess(
        nint hProcess,
        int uExitCode);

    [LibraryImport("kernel32.dll", SetLastError = true)]
    public static partial int WaitForSingleObject(
        nint hHandle,
        int dwMilliseconds);
}