using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential)]
struct SYSTEM_INFO
{
    public ushort wProcessorArchitecture;
    public ushort wReserved;
    public uint dwPageSize;
    public IntPtr lpMinimumApplicationAddress;
    public IntPtr lpMaximumApplicationAddress;
    public IntPtr dwActiveProcessorMask;
    public uint dwNumberOfProcessors;
    public uint dwProcessorType;
    public uint dwAllocationGranularity;
    public ushort wProcessorLevel;
    public ushort wProcessorRevision;
}

// Константи для wProcessorArchitecture
enum ProcessorArchitecture : ushort
{
    Intel = 0,
    MIPS = 1,
    Alpha = 2,
    PowerPC = 3,
    ARM = 5,
    IA64 = 6,
    AMD64 = 9,
    ARM64 = 12,
    Unknown = 0xFFFF
}

static class NativeMethods
{
    [DllImport("kernel32.dll")]
    public static extern void GetSystemInfo(out SYSTEM_INFO lpSystemInfo);

    [DllImport("kernel32.dll", CharSet = CharSet.Unicode)]
    public static extern void GetSystemDirectory(
        StringBuilder lpBuffer, 
        uint uSize
    );

    [DllImport("kernel32.dll", CharSet = CharSet.Unicode)]
    public static extern void GetWindowsDirectory(
        StringBuilder lpBuffer, 
        uint uSize
    );
}

using System.Text;

class SystemInfoHelper
{
    public static void PrintSystemInfo()
    {
        SYSTEM_INFO sysInfo;
        NativeMethods.GetSystemInfo(out sysInfo);

        Console.WriteLine("═══════════════════════════════════════════════");
        Console.WriteLine("           SYSTEM INFORMATION");
        Console.WriteLine("═══════════════════════════════════════════════\n");

        // Архітектура процесора
        var arch = (ProcessorArchitecture)sysInfo.wProcessorArchitecture;
        Console.WriteLine($"Processor Architecture: {arch}");
        
        string archDescription = arch switch
        {
            ProcessorArchitecture.Intel => "x86 (32-bit)",
            ProcessorArchitecture.AMD64 => "x64 (64-bit)",
            ProcessorArchitecture.ARM64 => "ARM64 (64-bit)",
            ProcessorArchitecture.ARM => "ARM (32-bit)",
            _ => "Unknown"
        };
        Console.WriteLine($"  → {archDescription}\n");

        // Кількість процесорів
        Console.WriteLine($"Number of Processors: {sysInfo.dwNumberOfProcessors}");
        Console.WriteLine($"  → Logical cores available to OS\n");

        // Розмір сторінки пам'яті
        Console.WriteLine($"Page Size: {sysInfo.dwPageSize:N0} bytes");
        Console.WriteLine($"  → {sysInfo.dwPageSize / 1024} KB (memory allocation unit)\n");

        // Діапазон адресного простору
        Console.WriteLine($"Application Address Space:");
        Console.WriteLine($"  Min: 0x{sysInfo.lpMinimumApplicationAddress:X16}");
        Console.WriteLine($"  Max: 0x{sysInfo.lpMaximumApplicationAddress:X16}");
        
        long addressSpaceSize = sysInfo.lpMaximumApplicationAddress.ToInt64() - 
                                sysInfo.lpMinimumApplicationAddress.ToInt64();
        Console.WriteLine($"  → {addressSpaceSize / (1024.0 * 1024 * 1024):F1} GB virtual address space\n");

        // Granularity для VirtualAlloc
        Console.WriteLine($"Allocation Granularity: {sysInfo.dwAllocationGranularity:N0} bytes");
        Console.WriteLine($"  → {sysInfo.dwAllocationGranularity / 1024} KB (VirtualAlloc alignment)\n");

        // Системні директорії
        var sysDir = new StringBuilder(260);
        var winDir = new StringBuilder(260);
        NativeMethods.GetSystemDirectory(sysDir, (uint)sysDir.Capacity);
        NativeMethods.GetWindowsDirectory(winDir, (uint)winDir.Capacity);

        Console.WriteLine($"System Directory: {sysDir}");
        Console.WriteLine($"Windows Directory: {winDir}\n");

        // Маска активних процесорів (bitmap)
        Console.WriteLine($"Active Processor Mask: 0x{sysInfo.dwActiveProcessorMask:X}");
        Console.WriteLine($"  → Binary: {Convert.ToString(sysInfo.dwActiveProcessorMask.ToInt64(), 2).PadLeft(64, '0')}");
        
        int activeCores = CountBits(sysInfo.dwActiveProcessorMask.ToInt64());
        Console.WriteLine($"  → {activeCores} cores enabled\n");

        Console.WriteLine("═══════════════════════════════════════════════");
    }

    private static int CountBits(long value)
    {
        int count = 0;
        while (value != 0)
        {
            count += (int)(value & 1);
            value >>= 1;
        }
        return count;
    }
}

class Program
{
    static void Main()
    {
        try
        {
            SystemInfoHelper.PrintSystemInfo();
        }
        catch (Exception ex)
        {
            Console.ForegroundColor = ConsoleColor.Red;
            Console.WriteLine($"Error: {ex.Message}");
            Console.ResetColor();
        }
    }
}

using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential)]
struct RECT
{
    public int Left;
    public int Top;
    public int Right;
    public int Bottom;

    public int Width => Right - Left;
    public int Height => Bottom - Top;

    public override string ToString() => 
        $"({Left}, {Top}) - ({Right}, {Bottom}) [{Width}x{Height}]";
}

[StructLayout(LayoutKind.Sequential)]
struct POINT
{
    public int X;
    public int Y;

    public override string ToString() => $"({X}, {Y})";
}

static class WindowConstants
{
    // ShowWindow commands
    public const int SW_HIDE = 0;
    public const int SW_SHOWNORMAL = 1;
    public const int SW_SHOWMINIMIZED = 2;
    public const int SW_SHOWMAXIMIZED = 3;
    public const int SW_RESTORE = 9;

    // SetWindowPos flags
    public const uint SWP_NOSIZE = 0x0001;
    public const uint SWP_NOMOVE = 0x0002;
    public const uint SWP_NOZORDER = 0x0004;
    public const uint SWP_SHOWWINDOW = 0x0040;

    // Window messages
    public const uint WM_CLOSE = 0x0010;
    public const uint WM_SETTEXT = 0x000C;
}

using System.Runtime.InteropServices;
using System.Text;

static class WindowNativeMethods
{
    [DllImport("user32.dll", CharSet = CharSet.Unicode)]
    public static extern IntPtr FindWindow(string? lpClassName, string? lpWindowName);

    [DllImport("user32.dll", CharSet = CharSet.Unicode)]
    public static extern int GetWindowText(IntPtr hWnd, StringBuilder lpString, int nMaxCount);

    [DllImport("user32.dll")]
    public static extern int GetWindowTextLength(IntPtr hWnd);

    [DllImport("user32.dll")]
    [return: MarshalAs(UnmanagedType.Bool)]
    public static extern bool GetWindowRect(IntPtr hWnd, out RECT lpRect);

    [DllImport("user32.dll")]
    [return: MarshalAs(UnmanagedType.Bool)]
    public static extern bool SetWindowPos(
        IntPtr hWnd,
        IntPtr hWndInsertAfter,
        int X,
        int Y,
        int cx,
        int cy,
        uint uFlags
    );

    [DllImport("user32.dll")]
    [return: MarshalAs(UnmanagedType.Bool)]
    public static extern bool ShowWindow(IntPtr hWnd, int nCmdShow);

    [DllImport("user32.dll")]
    [return: MarshalAs(UnmanagedType.Bool)]
    public static extern bool IsWindowVisible(IntPtr hWnd);

    [DllImport("user32.dll")]
    [return: MarshalAs(UnmanagedType.Bool)]
    public static extern bool IsIconic(IntPtr hWnd); // Мінімізоване

    [DllImport("user32.dll")]
    [return: MarshalAs(UnmanagedType.Bool)]
    public static extern bool IsZoomed(IntPtr hWnd); // Максимізоване

    [DllImport("user32.dll")]
    public static extern IntPtr SendMessage(
        IntPtr hWnd, 
        uint Msg, 
        IntPtr wParam, 
        IntPtr lParam
    );

    [DllImport("user32.dll")]
    [return: MarshalAs(UnmanagedType.Bool)]
    public static extern bool SetForegroundWindow(IntPtr hWnd);

    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
    public delegate bool EnumWindowsProc(IntPtr hWnd, IntPtr lParam);

    [DllImport("user32.dll")]
    [return: MarshalAs(UnmanagedType.Bool)]
    public static extern bool EnumWindows(EnumWindowsProc lpEnumFunc, IntPtr lParam);
}

using System.Text;

class WindowWrapper
{
    public IntPtr Handle { get; }

    public WindowWrapper(IntPtr handle)
    {
        if (handle == IntPtr.Zero)
            throw new ArgumentException("Invalid window handle", nameof(handle));
        
        Handle = handle;
    }

    public string GetTitle()
    {
        int length = WindowNativeMethods.GetWindowTextLength(Handle);
        if (length == 0)
            return string.Empty;

        var sb = new StringBuilder(length + 1);
        WindowNativeMethods.GetWindowText(Handle, sb, sb.Capacity);
        return sb.ToString();
    }

    public void SetTitle(string title)
    {
        IntPtr titlePtr = Marshal.StringToHGlobalUni(title);
        try
        {
            WindowNativeMethods.SendMessage(
                Handle, 
                WindowConstants.WM_SETTEXT, 
                IntPtr.Zero, 
                titlePtr
            );
        }
        finally
        {
            Marshal.FreeHGlobal(titlePtr);
        }
    }

    public RECT GetBounds()
    {
        if (!WindowNativeMethods.GetWindowRect(Handle, out RECT rect))
            throw new InvalidOperationException("Failed to get window bounds");
        
        return rect;
    }

    public void SetBounds(int x, int y, int width, int height)
    {
        WindowNativeMethods.SetWindowPos(
            Handle,
            IntPtr.Zero,
            x, y, width, height,
            WindowConstants.SWP_NOZORDER | WindowConstants.SWP_SHOWWINDOW
        );
    }

    public void MoveTo(int x, int y)
    {
        WindowNativeMethods.SetWindowPos(
            Handle,
            IntPtr.Zero,
            x, y, 0, 0,
            WindowConstants.SWP_NOSIZE | WindowConstants.SWP_NOZORDER
        );
    }

    public void Resize(int width, int height)
    {
        WindowNativeMethods.SetWindowPos(
            Handle,
            IntPtr.Zero,
            0, 0, width, height,
            WindowConstants.SWP_NOMOVE | WindowConstants.SWP_NOZORDER
        );
    }

    public void Show() => 
        WindowNativeMethods.ShowWindow(Handle, WindowConstants.SW_SHOWNORMAL);

    public void Hide() => 
        WindowNativeMethods.ShowWindow(Handle, WindowConstants.SW_HIDE);

    public void Minimize() => 
        WindowNativeMethods.ShowWindow(Handle, WindowConstants.SW_SHOWMINIMIZED);

    public void Maximize() => 
        WindowNativeMethods.ShowWindow(Handle, WindowConstants.SW_SHOWMAXIMIZED);

    public void Restore() => 
        WindowNativeMethods.ShowWindow(Handle, WindowConstants.SW_RESTORE);

    public void BringToFront() => 
        WindowNativeMethods.SetForegroundWindow(Handle);

    public void Close() => 
        WindowNativeMethods.SendMessage(Handle, WindowConstants.WM_CLOSE, IntPtr.Zero, IntPtr.Zero);

    public bool IsVisible => 
        WindowNativeMethods.IsWindowVisible(Handle);

    public bool IsMinimized => 
        WindowNativeMethods.IsIconic(Handle);

    public bool IsMaximized => 
        WindowNativeMethods.IsZoomed(Handle);

    public string GetState()
    {
        if (!IsVisible) return "Hidden";
        if (IsMinimized) return "Minimized";
        if (IsMaximized) return "Maximized";
        return "Normal";
    }
}

class WindowManager
{
    public static WindowWrapper? FindByTitle(string title)
    {
        IntPtr handle = WindowNativeMethods.FindWindow(null, title);
        return handle != IntPtr.Zero ? new WindowWrapper(handle) : null;
    }

    public static WindowWrapper? FindByTitleContains(string partialTitle)
    {
        WindowWrapper? found = null;

        WindowNativeMethods.EnumWindows((hWnd, lParam) =>
        {
            if (!WindowNativeMethods.IsWindowVisible(hWnd))
                return true;

            var window = new WindowWrapper(hWnd);
            string title = window.GetTitle();

            if (title.Contains(partialTitle, StringComparison.OrdinalIgnoreCase))
            {
                found = window;
                return false; // Зупинити перебір
            }

            return true;
        }, IntPtr.Zero);

        return found;
    }

    public static List<WindowWrapper> GetAllVisibleWindows()
    {
        var windows = new List<WindowWrapper>();

        WindowNativeMethods.EnumWindows((hWnd, lParam) =>
        {
            if (WindowNativeMethods.IsWindowVisible(hWnd))
            {
                var window = new WindowWrapper(hWnd);
                string title = window.GetTitle();
                
                if (!string.IsNullOrWhiteSpace(title))
                    windows.Add(window);
            }

            return true;
        }, IntPtr.Zero);

        return windows;
    }
}

class Program
{
    static void Main(string[] args)
    {
        Console.OutputEncoding = System.Text.Encoding.UTF8;

        if (args.Length == 0)
        {
            ShowHelp();
            return;
        }

        try
        {
            string command = args[0].ToLower();

            switch (command)
            {
                case "list":
                    ListWindows();
                    break;

                case "find":
                    if (args.Length < 2)
                    {
                        Console.WriteLine("Usage: find <title>");
                        return;
                    }
                    FindWindow(args[1]);
                    break;

                case "move":
                    if (args.Length < 4)
                    {
                        Console.WriteLine("Usage: move <title> <x> <y>");
                        return;
                    }
                    MoveWindow(args[1], int.Parse(args[2]), int.Parse(args[3]));
                    break;

                case "resize":
                    if (args.Length < 4)
                    {
                        Console.WriteLine("Usage: resize <title> <width> <height>");
                        return;
                    }
                    ResizeWindow(args[1], int.Parse(args[2]), int.Parse(args[3]));
                    break;

                default:
                    Console.WriteLine($"Unknown command: {command}");
                    ShowHelp();
                    break;
            }
        }
        catch (Exception ex)
        {
            Console.ForegroundColor = ConsoleColor.Red;
            Console.WriteLine($"Error: {ex.Message}");
            Console.ResetColor();
        }
    }

    static void ShowHelp()
    {
        Console.WriteLine("Window Automation Tool");
        Console.WriteLine("======================\n");
        Console.WriteLine("Commands:");
        Console.WriteLine("  list                          - List all visible windows");
        Console.WriteLine("  find <title>                  - Find window by title");
        Console.WriteLine("  move <title> <x> <y>          - Move window to position");
        Console.WriteLine("  resize <title> <w> <h>        - Resize window");
    }

    static void ListWindows()
    {
        var windows = WindowManager.GetAllVisibleWindows();
        
        Console.WriteLine($"Found {windows.Count} visible windows:\n");
        Console.WriteLine($"{"Handle",-12} {"State",-12} {"Bounds",-30} {"Title"}");
        Console.WriteLine(new string('─', 100));

        foreach (var window in windows.Take(20))
        {
            try
            {
                var bounds = window.GetBounds();
                Console.WriteLine(
                    $"0x{window.Handle:X8}  " +
                    $"{window.GetState(),-12} " +
                    $"{bounds.Width}x{bounds.Height} at ({bounds.Left},{bounds.Top})".PadRight(30) +
                    $"{window.GetTitle()}"
                );
            }
            catch { }
        }
    }

    static void FindWindow(string title)
    {
        var window = WindowManager.FindByTitleContains(title);
        
        if (window == null)
        {
            Console.WriteLine($"Window not found: {title}");
            return;
        }

        Console.WriteLine($"Found window:");
        Console.WriteLine($"  Handle: 0x{window.Handle:X8}");
        Console.WriteLine($"  Title: {window.GetTitle()}");
        Console.WriteLine($"  State: {window.GetState()}");
        Console.WriteLine($"  Bounds: {window.GetBounds()}");
    }

    static void MoveWindow(string title, int x, int y)
    {
        var window = WindowManager.FindByTitleContains(title);
        if (window == null)
        {
            Console.WriteLine($"Window not found: {title}");
            return;
        }

        window.MoveTo(x, y);
        Console.WriteLine($"✓ Moved '{window.GetTitle()}' to ({x}, {y})");
    }

    static void ResizeWindow(string title, int width, int height)
    {
        var window = WindowManager.FindByTitleContains(title);
        if (window == null)
        {
            Console.WriteLine($"Window not found: {title}");
            return;
        }

        window.Resize(width, height);
        Console.WriteLine($"✓ Resized '{window.GetTitle()}' to {width}x{height}");
    }
}