using System.Runtime.InteropServices;

class Program
{
    // Атрибут [DllImport] вказує CLR, де знайти функцію
    [DllImport("user32.dll", CharSet = CharSet.Unicode)]
    static extern int MessageBox(
        IntPtr hWnd,          // HWND → IntPtr (handle)
        string lpText,        // LPCWSTR → string (CLR автоматично конвертує)
        string lpCaption,     // LPCWSTR → string
        uint uType            // UINT → uint
    );

    // Константи для uType (з winuser.h)
    const uint MB_OK = 0x00000000;
    const uint MB_ICONINFORMATION = 0x00000040;
    const uint MB_YESNO = 0x00000004;
    const uint MB_ICONQUESTION = 0x00000020;

    static void Main()
    {
        // Виклик виглядає як звичайний C# метод
        int result = MessageBox(
            IntPtr.Zero,                           // Немає батьківського вікна
            "Це виклик нативної Win32 функції!",   // Текст
            "P/Invoke Demo",                       // Заголовок
            MB_OK | MB_ICONINFORMATION             // Кнопка OK + іконка інформації
        );

        Console.WriteLine($"Користувач натиснув кнопку з кодом: {result}");
    }
}

using System.Runtime.InteropServices;

// StructLayout.Sequential — поля у порядку оголошення
// CharSet.Unicode — для сумісності з іншими структурами, що містять рядки
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
struct SYSTEMTIME
{
    public ushort wYear;         // WORD → ushort (2 байти)
    public ushort wMonth;
    public ushort wDayOfWeek;
    public ushort wDay;
    public ushort wHour;
    public ushort wMinute;
    public ushort wSecond;
    public ushort wMilliseconds;
}

class Program
{
    [DllImport("kernel32.dll")]
    static extern void GetSystemTime(out SYSTEMTIME lpSystemTime);

    static void Main()
    {
        SYSTEMTIME st;
        GetSystemTime(out st);

        Console.WriteLine($"UTC Time: {st.wYear:D4}-{st.wMonth:D2}-{st.wDay:D2} " +
                          $"{st.wHour:D2}:{st.wMinute:D2}:{st.wSecond:D2}.{st.wMilliseconds:D3}");
        Console.WriteLine($"Day of week: {(DayOfWeek)st.wDayOfWeek}");
    }
}

using System.Runtime.InteropServices;
using Microsoft.Win32.SafeHandles;

// SafeHandleZeroOrMinusOneIsInvalid — базовий клас для handles,
// де 0 або -1 означають невалідний handle
class SafeFileHandle : SafeHandleZeroOrMinusOneIsInvalid
{
    // Конструктор для створення "порожнього" handle
    public SafeFileHandle() : base(ownsHandle: true) { }

    // Конструктор для обгортання існуючого handle
    public SafeFileHandle(IntPtr handle, bool ownsHandle) : base(ownsHandle)
    {
        SetHandle(handle);
    }

    // Метод звільнення ресурсу — викликається автоматично GC або при Dispose
    protected override bool ReleaseHandle()
    {
        return CloseHandle(handle);
    }

    [DllImport("kernel32.dll", SetLastError = true)]
    private static extern bool CloseHandle(IntPtr handle);
}

class Program
{
    [DllImport("kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
    static extern SafeFileHandle CreateFile(
        string lpFileName,
        uint dwDesiredAccess,
        uint dwShareMode,
        IntPtr lpSecurityAttributes,
        uint dwCreationDisposition,
        uint dwFlagsAndAttributes,
        IntPtr hTemplateFile
    );

    const uint GENERIC_READ = 0x80000000;
    const uint OPEN_EXISTING = 3;

    static void Main()
    {
        // using гарантує виклик Dispose, навіть при exception
        using SafeFileHandle handle = CreateFile(
            "test.txt",
            GENERIC_READ,
            0,
            IntPtr.Zero,
            OPEN_EXISTING,
            0,
            IntPtr.Zero
        );

        if (handle.IsInvalid)
        {
            throw new Win32Exception(Marshal.GetLastWin32Error());
        }

        Console.WriteLine("Файл відкрито успішно!");
        // handle автоматично закриється при виході з using
    }
}

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

class Program
{
    // Делегат, що відповідає сигнатурі WNDENUMPROC
    [UnmanagedFunctionPointer(CallingConvention.StdCall)]
    delegate bool EnumWindowsProc(IntPtr hWnd, IntPtr lParam);

    [DllImport("user32.dll")]
    static extern bool EnumWindows(EnumWindowsProc lpEnumFunc, IntPtr lParam);

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

    [DllImport("user32.dll")]
    static extern bool IsWindowVisible(IntPtr hWnd);

    static void Main()
    {
        var windows = new List<(IntPtr Handle, string Title)>();

        // Callback функція — буде викликана для кожного вікна
        bool EnumWindowCallback(IntPtr hWnd, IntPtr lParam)
        {
            // Фільтруємо тільки видимі вікна
            if (!IsWindowVisible(hWnd))
                return true; // true = продовжити перебір

            var title = new StringBuilder(256);
            int length = GetWindowText(hWnd, title, title.Capacity);

            if (length > 0)
            {
                windows.Add((hWnd, title.ToString()));
            }

            return true; // Продовжити перебір
        }

        // Передаємо делегат у native функцію
        EnumWindows(EnumWindowCallback, IntPtr.Zero);

        Console.WriteLine($"Знайдено {windows.Count} видимих вікон:\n");
        foreach (var (handle, title) in windows.Take(10))
        {
            Console.WriteLine($"[0x{handle:X8}] {title}");
        }
    }
}

using System;
using System.Runtime.InteropServices;

internal static class NativeMethods
{
    // Прапорці доступу до процесу
    public const uint PROCESS_VM_READ = 0x0010;
    public const uint PROCESS_VM_WRITE = 0x0020;
    public const uint PROCESS_VM_OPERATION = 0x0008;

    // Відкриття дескриптора процесу
    [DllImport("kernel32.dll", SetLastError = true)]
    public static extern IntPtr OpenProcess(
        uint dwDesiredAccess,
        [MarshalAs(UnmanagedType.Bool)] bool bInheritHandle,
        int dwProcessId
    );

    // Читання віртуальної пам'яті
    [DllImport("kernel32.dll", SetLastError = true)]
    [return: MarshalAs(UnmanagedType.Bool)]
    public static extern bool ReadProcessMemory(
        IntPtr hProcess,
        IntPtr lpBaseAddress,
        [Out] byte[] lpBuffer,
        int nSize,
        out IntPtr lpNumberOfBytesRead
    );

    // Запис у віртуальну пам'ять
    [DllImport("kernel32.dll", SetLastError = true)]
    [return: MarshalAs(UnmanagedType.Bool)]
    public static extern bool WriteProcessMemory(
        IntPtr hProcess,
        IntPtr lpBaseAddress,
        byte[] lpBuffer,
        int nSize,
        out IntPtr lpNumberOfBytesWritten
    );

    // Закриття дескриптора
    [DllImport("kernel32.dll", SetLastError = true)]
    [return: MarshalAs(UnmanagedType.Bool)]
    public static extern bool CloseHandle(IntPtr hObject);
}

using System;
using System.ComponentModel;
using System.Diagnostics;
using System.Runtime.InteropServices;

public class MemoryManager : IDisposable
{
    private readonly IntPtr _processHandle;
    public IntPtr BaseAddress { get; }

    public MemoryManager(string processName)
    {
        // Шукаємо запущений процес
        Process[] processes = Process.GetProcessesByName(processName);
        if (processes.Length == 0)
        {
            throw new Exception($"Процес {processName}.exe не знайдено! Переконайтеся, що гра запущена.");
        }

        Process targetProcess = processes[0];
        BaseAddress = targetProcess.MainModule.BaseAddress;

        // Запитуємо права на читання, запис та віртуальні операції
        uint accessFlags = NativeMethods.PROCESS_VM_READ | 
                            NativeMethods.PROCESS_VM_WRITE | 
                            NativeMethods.PROCESS_VM_OPERATION;

        _processHandle = NativeMethods.OpenProcess(accessFlags, false, targetProcess.Id);

        if (_processHandle == IntPtr.Zero)
        {
            int errorCode = Marshal.GetLastWin32Error();
            throw new Win32Exception(errorCode, "Не вдалося відкрити процес для маніпуляцій з пам'яттю.");
        }
    }

    // Читання примітивного значення типу T
    public T Read<T>(IntPtr address) where T : struct
    {
        int size = Marshal.SizeOf<T>();
        byte[] buffer = new byte[size];

        if (!NativeMethods.ReadProcessMemory(_processHandle, address, buffer, size, out _))
        {
            int errorCode = Marshal.GetLastWin32Error();
            throw new Win32Exception(errorCode, $"Помилка читання пам'яті за адресою 0x{address.ToInt64():X}");
        }

        // Перетворюємо байти у структуру T
        GCHandle handle = GCHandle.Alloc(buffer, GCHandleType.Pinned);
        try
        {
            return Marshal.PtrToStructure<T>(handle.AddrOfPinnedObject());
        }
        finally
        {
            handle.Free();
        }
    }

    // Запис примітивного значення типу T
    public void Write<T>(IntPtr address, T value) where T : struct
    {
        int size = Marshal.SizeOf<T>();
        byte[] buffer = new byte[size];

        // Записуємо структуру T у масив байтів
        GCHandle handle = GCHandle.Alloc(value, GCHandleType.Pinned);
        try
        {
            Marshal.Copy(handle.AddrOfPinnedObject(), buffer, 0, size);
        }
        finally
        {
            handle.Free();
        }

        if (!NativeMethods.WriteProcessMemory(_processHandle, address, buffer, size, out _))
        {
            int errorCode = Marshal.GetLastWin32Error();
            throw new Win32Exception(errorCode, $"Помилка запису в пам'ять за адресою 0x{address.ToInt64():X}");
        }
    }

    // Розіменування ланцюжка покажчиків (Pointer Chain)
    // Наприклад: BaseAddress + Offset1 -> Address1 + Offset2 -> Address2 + Offset3 -> Final Address
    public IntPtr ResolvePointerChain(IntPtr basePtr, int[] offsets)
    {
        IntPtr currentAddress = basePtr;

        // Перебираємо всі зміщення, крім останнього
        for (int i = 0; i < offsets.Length - 1; i++)
        {
            // Для 32-бітної гри зчитуємо 4 байти покажчика (Int32/IntPtr)
            int pointerValue = Read<int>(currentAddress + offsets[i]);
            currentAddress = (IntPtr)pointerValue;
        }

        // Додаємо останнє зміщення для отримання фінальної фізичної адреси
        return currentAddress + offsets[offsets.Length - 1];
    }

    public void Dispose()
    {
        if (_processHandle != IntPtr.Zero)
        {
            NativeMethods.CloseHandle(_processHandle);
        }
        GC.SuppressFinalize(this);
    }

    ~MemoryManager()
    {
        Dispose();
    }
}

using System;
using System.Threading;

class Program
{
    // === КОНСТАНТИ ТА ЗМІЩЕННЯ ДЛЯ ASSAULTCUBE ===
    // (Ви можете змінити їх залежно від версії гри)
    
    // Версія 1.2.0.2:
    private const int PLAYER_BASE_OFFSET_V12 = 0x10F4F4;
    private const int HEALTH_OFFSET_V12 = 0xF8;
    private const int ARMOR_OFFSET_V12 = 0xFC;
    private const int RIFLE_AMMO_OFFSET_V12 = 0x150;

    // Версія 1.3.0.2 (новіша):
    private const int PLAYER_BASE_OFFSET_V13 = 0x17E0A8;
    private const int HEALTH_OFFSET_V13 = 0xEC;
    private const int ARMOR_OFFSET_V13 = 0xF0;
    private const int RIFLE_AMMO_OFFSET_V13 = 0x140;

    static void Main()
    {
        Console.OutputEncoding = System.Text.Encoding.UTF8;
        Console.Title = "AssaultCube C# Trainer - Навчальний проект";

        Console.ForegroundColor = ConsoleColor.Cyan;
        Console.WriteLine("====================================================");
        Console.WriteLine("        ASSAULTCUBE C# WINAPI MEMORY TRAINER        ");
        Console.WriteLine("====================================================");
        Console.ResetColor();

        try
        {
            // Ініціалізуємо менеджер пам'яті для гри
            using var memory = new MemoryManager("ac_client");
            Console.WriteLine($"[+] Успішно підключено до ac_client.exe!");
            Console.WriteLine($"[+] Базова адреса модуля: 0x{memory.BaseAddress.ToInt64():X}\n");

            // Вибір версії гри для застосування коректних зміщень
            Console.WriteLine("Оберіть версію AssaultCube:");
            Console.WriteLine("1. Версія 1.2.0.2");
            Console.WriteLine("2. Версія 1.3.0.2 (або новіша)");
            Console.Write("Ваш вибір (1 або 2): ");
            
            string choice = Console.ReadLine();
            int playerBaseOffset = choice == "1" ? PLAYER_BASE_OFFSET_V12 : PLAYER_BASE_OFFSET_V13;
            int healthOffset = choice == "1" ? HEALTH_OFFSET_V12 : HEALTH_OFFSET_V13;
            int armorOffset = choice == "1" ? ARMOR_OFFSET_V12 : ARMOR_OFFSET_V13;
            int rifleAmmoOffset = choice == "1" ? RIFLE_AMMO_OFFSET_V12 : RIFLE_AMMO_OFFSET_V13;

            // Визначаємо ланцюжки зміщень
            IntPtr localPlayerPtr = memory.BaseAddress + playerBaseOffset;

            // Здоров'я: PlayerPtr -> [PlayerPtr] + healthOffset
            int[] healthChain = new int[] { 0x0, healthOffset };
            // Набої автомата: PlayerPtr -> [PlayerPtr] + rifleAmmoOffset
            int[] ammoChain = new int[] { 0x0, rifleAmmoOffset };
            // Броня: PlayerPtr -> [PlayerPtr] + armorOffset
            int[] armorChain = new int[] { 0x0, armorOffset };

            bool isGodMode = false;
            bool isInfAmmo = false;

            // Запускаємо фоновий потік для "заморожування" значень (Freezing Values)
            var workerThread = new Thread(() =>
            {
                while (true)
                {
                    try
                    {
                        if (isGodMode)
                        {
                            IntPtr healthAddress = memory.ResolvePointerChain(localPlayerPtr, healthChain);
                            memory.Write<int>(healthAddress, 9999);
                            
                            IntPtr armorAddress = memory.ResolvePointerChain(localPlayerPtr, armorChain);
                            memory.Write<int>(armorAddress, 9999);
                        }

                        if (isInfAmmo)
                        {
                            IntPtr ammoAddress = memory.ResolvePointerChain(localPlayerPtr, ammoChain);
                            memory.Write<int>(ammoAddress, 1337);
                        }
                    }
                    catch
                    {
                        // Якщо гра закрилася під час роботи потоку
                        break;
                    }
                    Thread.Sleep(10); // Невелике очікування, щоб не перевантажувати процесор
                }
            }) { IsBackground = true };
            
            workerThread.Start();

            // Основний цикл CLI меню
            while (true)
            {
                Console.Clear();
                Console.ForegroundColor = ConsoleColor.Cyan;
                Console.WriteLine("====================================================");
                Console.WriteLine("            ASSAULTCUBE TRAINER INTERFACE           ");
                Console.WriteLine("====================================================");
                Console.ResetColor();

                try
                {
                    // Отримуємо актуальні адреси в купі
                    IntPtr healthAddress = memory.ResolvePointerChain(localPlayerPtr, healthChain);
                    IntPtr ammoAddress = memory.ResolvePointerChain(localPlayerPtr, ammoChain);

                    // Зчитуємо поточні показники з пам'яті гри
                    int currentHealth = memory.Read<int>(healthAddress);
                    int currentAmmo = memory.Read<int>(ammoAddress);

                    Console.WriteLine($"[Дані з пам'яті гри]");
                    Console.WriteLine($"Адреса структури гравця: 0x{healthAddress.ToInt64() - healthOffset:X}");
                    Console.WriteLine($"Поточне здоров'я:        {currentHealth}");
                    Console.WriteLine($"Набої в автоматі:        {currentAmmo}\n");

                    Console.WriteLine("[Функції трейнера]");
                    
                    Console.Write("1. [");
                    WriteState(isGodMode);
                    Console.WriteLine("] God Mode + Infinite Armor (Заморожування на 9999)");

                    Console.Write("2. [");
                    WriteState(isInfAmmo);
                    Console.WriteLine("] Infinite Rifle Ammo (Заморожування на 1337)");

                    Console.WriteLine("3. Миттєво встановити здоров'я на 500");
                    Console.WriteLine("4. Миттєво встановити набої на 500");
                    Console.WriteLine("5. Вихід");
                    Console.Write("\nОберіть дію (1-5): ");

                    char menuKey = Console.ReadKey(true).KeyChar;

                    if (menuKey == '1')
                    {
                        isGodMode = !isGodMode;
                    }
                    else if (menuKey == '2')
                    {
                        isInfAmmo = !isInfAmmo;
                    }
                    else if (menuKey == '3')
                    {
                        memory.Write<int>(healthAddress, 500);
                        Console.WriteLine("\n[+] Здоров'я змінено на 500!");
                        Thread.Sleep(500);
                    }
                    else if (menuKey == '4')
                    {
                        memory.Write<int>(ammoAddress, 500);
                        Console.WriteLine("\n[+] Набої автомата змінено на 500!");
                        Thread.Sleep(500);
                    }
                    else if (menuKey == '5')
                    {
                        Console.WriteLine("\n[-] Вихід з трейнера. Дескриптор процесу закрито.");
                        break;
                    }
                }
                catch (Win32Exception)
                {
                    Console.ForegroundColor = ConsoleColor.Red;
                    Console.WriteLine("\n[Помилка] Не вдалося зчитати пам'ять. Можливо, ви в полі зору меню, померли, або гра перезавантажила рівень.");
                    Console.ResetColor();
                    Console.WriteLine("Спробуйте увійти в раунд та натиснути будь-яку клавішу для повтору...");
                    Console.ReadKey(true);
                }
            }
        }
        catch (Exception ex)
        {
            Console.ForegroundColor = ConsoleColor.Red;
            Console.WriteLine($"\n[Помилка ініціалізації]: {ex.Message}");
            Console.ResetColor();
            Console.WriteLine("Натисніть будь-яку клавішу для виходу...");
            Console.ReadKey(true);
        }
    }

    private static void WriteState(bool state)
    {
        if (state)
        {
            Console.ForegroundColor = ConsoleColor.Green;
            Console.Write("УВІМКНЕНО");
        }
        else
        {
            Console.ForegroundColor = ConsoleColor.DarkGray;
            Console.Write("ВИМКНЕНО");
        }
        Console.ResetColor();
    }
}