main.cpp

#include <cstddef>
#include <cstring>
#include <functional>
#include <filesystem>
#include <string_view>
#include <windows.h>
#include <shellapi.h>
#include <vector>
#include <memory>
#include <iomanip>
#include <sstream>
#include <string>
#include <algorithm>
#include <set>
#include <cmath>
#include <common/version/version.h>
#include <common/config/BuildConfig.h>
#include <common/utils/os-utils.h>
#include <xlog/xlog.h>
#include <xlog/ConsoleAppender.h>
#include <xlog/FileAppender.h>
#include <xlog/Win32Appender.h>
#include <patch_common/MemUtils.h>
#include <patch_common/CallHook.h>
#include <patch_common/FunHook.h>
#include <patch_common/AsmWriter.h>
#include <patch_common/CodeInjection.h>
#include <crash_handler_stub.h>
#include "../game_patch/rf/os/array.h"
#include "exports.h"
#include "resources.h"
#include "mfc_types.h"
#include "vtypes.h"
#include "level.h"
#include "event.h"
#include "mesh.h"
#include "alpine_obj.h"
#include "geometry.h"
#include "textures.h"
#include "meshes.h"

#define LAUNCHER_FILENAME "AlpineFactionLauncher.exe"
HMODULE g_module;
static std::string g_launcher_pathname;
static bool g_is_play_in_multi = false;
static std::string g_red_cmdline;

constexpr size_t max_texture_name_len = 31;

bool g_skip_wnd_set_text = false;

static bool g_is_saving_af_version = true;
static bool g_skip_legacy_level_warning = false;
static int g_current_level_version = -1;

static const auto g_editor_app = reinterpret_cast<std::byte*>(0x006F9DA0);

void *GetMainFrame()
{
    return struct_field_ref<void*>(g_editor_app, 0xC8);
}

void *GetLogDlg()
{
    return struct_field_ref<void*>(GetMainFrame(), 692);
}

HWND GetMainFrameHandle()
{
    auto* main_frame = struct_field_ref<CWnd*>(g_editor_app, 0xC8);
    return WndToHandle(main_frame);
}

bool get_is_saving_af_version()
{
    return g_is_saving_af_version;
}

int get_level_rfl_version()
{
    return g_current_level_version;
}

void set_initial_level_rfl_version()
{
    g_current_level_version = MAXIMUM_RFL_VERSION;
}

void OpenLevel(const char* level_path)
{
    void* doc_manager = *reinterpret_cast<void**>(g_editor_app + 0x80);
    void** doc_manager_vtbl = *reinterpret_cast<void***>(doc_manager);
    using CDocManager_OpenDocumentFile_Ptr = int(__thiscall*)(void* this_, LPCSTR path);
    auto DocManager_OpenDocumentFile = reinterpret_cast<CDocManager_OpenDocumentFile_Ptr>(doc_manager_vtbl[7]);
    DocManager_OpenDocumentFile(doc_manager, level_path);
}

CodeInjection CMainFrame_PreCreateWindow_injection{
    0x0044713C,
    [](auto& regs) {
        auto& cs = addr_as_ref<CREATESTRUCTA>(regs.eax);
        cs.style |= WS_MAXIMIZEBOX|WS_THICKFRAME;
        cs.dwExStyle |= WS_EX_ACCEPTFILES;
    },
};

CodeInjection CEditorApp_InitInstance_additional_file_paths_injection{
    0x0048290D,
    []() {
        meshes_init_paths();
    },
};

CodeInjection CEditorApp_InitInstance_open_level_injection{
    0x00482BF1,
    []() {
        static auto& argv = addr_as_ref<char**>(0x01DBF8E4);
        static auto& argc = addr_as_ref<int>(0x01DBF8E0);
        const char* level_param = nullptr;
        for (int i = 1; i < argc; ++i) {
            xlog::trace("argv[{}] = {}", i, argv[i]);
            std::string_view arg = argv[i];
            if (arg == "-level") {
                ++i;
                if (i < argc) {
                    level_param = argv[i];
                }
            }
        }
        if (level_param) {
            OpenLevel(level_param);
        }
    },
};

// ===== Brush "Is Geoable" support =====

static int compute_geoable_state_from_selected()
{
    auto* level = CDedLevel::Get();
    if (!level) return BST_UNCHECKED;
    auto& props = level->GetAlpineLevelProperties();

    BrushNode* node = level->brush_list;
    if (!node) return BST_UNCHECKED;
    int num_selected = 0;
    int num_geoable = 0;
    do {
        if (node->state == BRUSH_STATE_SELECTED) {
            num_selected++;
            if (std::find(props.geoable_brush_uids.begin(),
                          props.geoable_brush_uids.end(), node->uid)
                != props.geoable_brush_uids.end()) {
                num_geoable++;
            }
        }
        node = node->next;
    } while (node != level->brush_list);

    if (num_selected == 0 || num_geoable == 0) return BST_UNCHECKED;
    if (num_geoable == num_selected) return BST_CHECKED;
    return BST_INDETERMINATE;
}

static void apply_geoable_to_selected_brushes(int new_state)
{
    if (new_state == BST_INDETERMINATE) return;

    auto* level = CDedLevel::Get();
    if (!level) return;
    auto& props = level->GetAlpineLevelProperties();

    BrushNode* node = level->brush_list;
    if (!node) return;
    do {
        if (node->state == BRUSH_STATE_SELECTED) {
            auto it = std::find(props.geoable_brush_uids.begin(),
                                props.geoable_brush_uids.end(), node->uid);
            if (new_state == BST_CHECKED) {
                if (it == props.geoable_brush_uids.end()) {
                    props.geoable_brush_uids.push_back(node->uid);
                }
            } else {
                if (it != props.geoable_brush_uids.end()) {
                    props.geoable_brush_uids.erase(it);
                }
            }
        }
        node = node->next;
    } while (node != level->brush_list);
}

// Returns true if at least one selected brush is a breakable detail brush (is_detail && life != -1)
static bool selection_has_breakable_detail()
{
    auto* level = CDedLevel::Get();
    if (!level) return false;
    BrushNode* node = level->brush_list;
    if (!node) return false;
    do {
        if (node->state == BRUSH_STATE_SELECTED && node->is_detail && node->life != -1)
            return true;
        node = node->next;
    } while (node != level->brush_list);
    return false;
}

// Returns material index for selected breakable brushes, or -1 if mixed
static int compute_material_from_selected()
{
    auto* level = CDedLevel::Get();
    if (!level) return 0;
    auto& props = level->GetAlpineLevelProperties();

    BrushNode* node = level->brush_list;
    if (!node) return 0;
    int result = -2; // not set yet
    do {
        if (node->state == BRUSH_STATE_SELECTED && node->is_detail && node->life != -1) {
            uint8_t mat = 0; // default = Glass
            auto it = std::find(props.breakable_brush_uids.begin(),
                                props.breakable_brush_uids.end(), node->uid);
            if (it != props.breakable_brush_uids.end()) {
                auto idx = std::distance(props.breakable_brush_uids.begin(), it);
                mat = props.breakable_materials[idx] & 0x7F; // mask out flags (bit 7 = no_debris)
            }
            if (result == -2) {
                result = mat;
            } else if (result != mat) {
                return -1; // mixed
            }
        }
        node = node->next;
    } while (node != level->brush_list);
    return (result == -2) ? 0 : result;
}

static void apply_material_to_selected_brushes(uint8_t mat)
{
    auto* level = CDedLevel::Get();
    if (!level) return;
    auto& props = level->GetAlpineLevelProperties();

    BrushNode* node = level->brush_list;
    if (!node) return;
    do {
        if (node->state == BRUSH_STATE_SELECTED && node->is_detail && node->life != -1) {
            auto it = std::find(props.breakable_brush_uids.begin(),
                                props.breakable_brush_uids.end(), node->uid);
            if (mat == 0) {
                // Glass = default, remove from list (also clears no_debris flag)
                if (it != props.breakable_brush_uids.end()) {
                    auto idx = std::distance(props.breakable_brush_uids.begin(), it);
                    props.breakable_brush_uids.erase(it);
                    props.breakable_room_uids.erase(props.breakable_room_uids.begin() + idx);
                    props.breakable_materials.erase(props.breakable_materials.begin() + idx);
                    xlog::info("[Material] brush uid={} set to Glass (removed from list)", node->uid);
                }
            } else {
                // Non-glass: add or update (preserve flags in high bit)
                if (it != props.breakable_brush_uids.end()) {
                    auto idx = std::distance(props.breakable_brush_uids.begin(), it);
                    uint8_t flags = props.breakable_materials[idx] & 0x80;
                    props.breakable_materials[idx] = mat | flags;
                    xlog::info("[Material] brush uid={} updated material to {}", node->uid, mat);
                } else {
                    props.breakable_brush_uids.push_back(node->uid);
                    props.breakable_room_uids.push_back(0); // filled at save time
                    props.breakable_materials.push_back(mat);
                    xlog::info("[Material] brush uid={} added with material {} (total breakable={})",
                        node->uid, mat, props.breakable_brush_uids.size());
                }
            }
        }
        node = node->next;
    } while (node != level->brush_list);
}

static void init_material_combo(HWND hdlg)
{
    HWND combo = GetDlgItem(hdlg, IDC_MATERIAL_COMBO);
    HWND label = GetDlgItem(hdlg, IDC_MATERIAL_LABEL);
    if (!combo) return;

    // Reset content
    SendMessageA(combo, CB_RESETCONTENT, 0, 0);
    SendMessageA(combo, CB_ADDSTRING, 0, reinterpret_cast<LPARAM>("Glass"));
    SendMessageA(combo, CB_ADDSTRING, 0, reinterpret_cast<LPARAM>("Rock"));
    SendMessageA(combo, CB_ADDSTRING, 0, reinterpret_cast<LPARAM>("Wood"));
    SendMessageA(combo, CB_ADDSTRING, 0, reinterpret_cast<LPARAM>("Metal"));
    SendMessageA(combo, CB_ADDSTRING, 0, reinterpret_cast<LPARAM>("Cement"));
    SendMessageA(combo, CB_ADDSTRING, 0, reinterpret_cast<LPARAM>("Ice"));

    bool has_breakable = selection_has_breakable_detail();
    EnableWindow(combo, has_breakable ? TRUE : FALSE);
    if (label) EnableWindow(label, has_breakable ? TRUE : FALSE);

    if (has_breakable) {
        int mat = compute_material_from_selected();
        if (mat >= 0) {
            SendMessageA(combo, CB_SETCURSEL, mat, 0);
        } else {
            // Mixed — don't select anything
            SendMessageA(combo, CB_SETCURSEL, static_cast<WPARAM>(-1), 0);
        }
    } else {
        SendMessageA(combo, CB_SETCURSEL, 0, 0); // show Glass as default
    }
}

// ===== Brush "No Debris" support =====

// Returns BST_CHECKED/UNCHECKED/INDETERMINATE for the no_debris flag on selected breakable brushes
static int compute_no_debris_state_from_selected()
{
    auto* level = CDedLevel::Get();
    if (!level) return BST_UNCHECKED;
    auto& props = level->GetAlpineLevelProperties();

    BrushNode* node = level->brush_list;
    if (!node) return BST_UNCHECKED;
    int num_checked = 0;
    int num_applicable = 0;
    do {
        if (node->state == BRUSH_STATE_SELECTED && node->is_detail && node->life != -1) {
            auto it = std::find(props.breakable_brush_uids.begin(),
                                props.breakable_brush_uids.end(), node->uid);
            if (it != props.breakable_brush_uids.end()) {
                auto idx = std::distance(props.breakable_brush_uids.begin(), it);
                uint8_t mat = props.breakable_materials[idx] & 0x7F;
                if (mat > 0) { // non-glass only
                    num_applicable++;
                    if (props.breakable_materials[idx] & 0x80)
                        num_checked++;
                }
            }
        }
        node = node->next;
    } while (node != level->brush_list);

    if (num_applicable == 0) return BST_UNCHECKED;
    if (num_checked == num_applicable) return BST_CHECKED;
    if (num_checked == 0) return BST_UNCHECKED;
    return BST_INDETERMINATE;
}

static void apply_no_debris_to_selected_brushes(int new_state)
{
    if (new_state == BST_INDETERMINATE) return;

    auto* level = CDedLevel::Get();
    if (!level) return;
    auto& props = level->GetAlpineLevelProperties();

    BrushNode* node = level->brush_list;
    if (!node) return;
    do {
        if (node->state == BRUSH_STATE_SELECTED && node->is_detail && node->life != -1) {
            auto it = std::find(props.breakable_brush_uids.begin(),
                                props.breakable_brush_uids.end(), node->uid);
            if (it != props.breakable_brush_uids.end()) {
                auto idx = std::distance(props.breakable_brush_uids.begin(), it);
                if (new_state == BST_CHECKED) {
                    props.breakable_materials[idx] |= 0x80;
                } else {
                    props.breakable_materials[idx] &= 0x7F;
                }
            }
        }
        node = node->next;
    } while (node != level->brush_list);
}

static void init_no_debris_checkbox(HWND hdlg)
{
    HWND ctrl = GetDlgItem(hdlg, IDC_NO_DEBRIS);
    if (!ctrl) return;

    bool has_breakable = selection_has_breakable_detail();
    int mat = has_breakable ? compute_material_from_selected() : 0;
    bool enabled = has_breakable && mat > 0; // non-glass breakable only

    EnableWindow(ctrl, enabled ? TRUE : FALSE);
    if (enabled) {
        CheckDlgButton(hdlg, IDC_NO_DEBRIS, compute_no_debris_state_from_selected());
    } else {
        CheckDlgButton(hdlg, IDC_NO_DEBRIS, BST_UNCHECKED);
    }
}

// Dialog 205 (brush panel) subclass for Is Geoable click handling
static WNDPROC g_brush_panel_orig_wndproc = nullptr;
static HWND g_brush_panel_hwnd = nullptr;

static LRESULT CALLBACK BrushPanelSubclassProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    if (msg == WM_COMMAND && LOWORD(wParam) == IDC_BRUSH_MIRROR) {
        handle_brush_mirror();
        return 0;
    }
    if (msg == WM_COMMAND && LOWORD(wParam) == IDC_BRUSH_CONVERT) {
        handle_brush_convert();
        return 0;
    }
    if (msg == WM_COMMAND && LOWORD(wParam) == IDC_IS_GEOABLE) {
        int state = IsDlgButtonChecked(hwnd, IDC_IS_GEOABLE);
        // Normalize: skip indeterminate state, treat as unchecked
        if (state == BST_INDETERMINATE) {
            state = BST_UNCHECKED;
            CheckDlgButton(hwnd, IDC_IS_GEOABLE, BST_UNCHECKED);
        }
        apply_geoable_to_selected_brushes(state);
        // Auto-check Is Detail when Is Geoable is checked
        if (state == BST_CHECKED && IsDlgButtonChecked(hwnd, 1215) != BST_CHECKED) {
            CheckDlgButton(hwnd, 1215, BST_CHECKED);
            // Trigger stock handler to apply detail flag to selected brushes
            CallWindowProcA(g_brush_panel_orig_wndproc, hwnd, WM_COMMAND,
                           MAKEWPARAM(1215, BN_CLICKED),
                           reinterpret_cast<LPARAM>(GetDlgItem(hwnd, 1215)));
        }
    }
    if (msg == WM_COMMAND && LOWORD(wParam) == IDC_MATERIAL_COMBO && HIWORD(wParam) == CBN_SELCHANGE) {
        int sel = static_cast<int>(SendDlgItemMessageA(hwnd, IDC_MATERIAL_COMBO, CB_GETCURSEL, 0, 0));
        if (sel >= 0) {
            apply_material_to_selected_brushes(static_cast<uint8_t>(sel));
        }
        // Refresh no_debris checkbox enable state when material changes
        init_no_debris_checkbox(hwnd);
    }
    if (msg == WM_COMMAND && LOWORD(wParam) == IDC_NO_DEBRIS) {
        int state = IsDlgButtonChecked(hwnd, IDC_NO_DEBRIS);
        apply_no_debris_to_selected_brushes(state);
    }
    if (msg == WM_COMMAND && LOWORD(wParam) == 1215) {
        // Auto-uncheck Is Geoable when Is Detail is no longer checked
        if (IsDlgButtonChecked(hwnd, 1215) != BST_CHECKED) {
            CheckDlgButton(hwnd, IDC_IS_GEOABLE, BST_UNCHECKED);
            apply_geoable_to_selected_brushes(BST_UNCHECKED);
        }
        // Refresh material combo and no_debris enable state when detail flag changes
        init_material_combo(hwnd);
        init_no_debris_checkbox(hwnd);
    }
    return CallWindowProcA(g_brush_panel_orig_wndproc, hwnd, msg, wParam, lParam);
}

// Dialog 270 (brush properties popup) hook and subclass
static HHOOK g_brush_props_msg_hook = nullptr;
static WNDPROC g_brush_props_orig_wndproc = nullptr;

static LRESULT CALLBACK BrushPropsSubclassProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    if (msg == WM_COMMAND && LOWORD(wParam) == IDOK) {
        int state = IsDlgButtonChecked(hwnd, IDC_IS_GEOABLE);
        apply_geoable_to_selected_brushes(state);
        // Apply material from combo
        int sel = static_cast<int>(SendDlgItemMessageA(hwnd, IDC_MATERIAL_COMBO, CB_GETCURSEL, 0, 0));
        if (sel >= 0) {
            apply_material_to_selected_brushes(static_cast<uint8_t>(sel));
        }
        // Apply no_debris checkbox
        int nd_state = IsDlgButtonChecked(hwnd, IDC_NO_DEBRIS);
        apply_no_debris_to_selected_brushes(nd_state);
    }
    if (msg == WM_COMMAND && LOWORD(wParam) == IDC_IS_GEOABLE) {
        int state = IsDlgButtonChecked(hwnd, IDC_IS_GEOABLE);
        // Normalize: skip indeterminate state, treat as unchecked
        if (state == BST_INDETERMINATE) {
            state = BST_UNCHECKED;
            CheckDlgButton(hwnd, IDC_IS_GEOABLE, BST_UNCHECKED);
        }
        // Auto-check Is Detail when Is Geoable is checked
        if (state == BST_CHECKED && IsDlgButtonChecked(hwnd, 1215) != BST_CHECKED) {
            CheckDlgButton(hwnd, 1215, BST_CHECKED);
        }
    }
    if (msg == WM_COMMAND && LOWORD(wParam) == IDC_MATERIAL_COMBO && HIWORD(wParam) == CBN_SELCHANGE) {
        // Refresh no_debris checkbox when material changes
        init_no_debris_checkbox(hwnd);
    }
    if (msg == WM_COMMAND && LOWORD(wParam) == 1215) {
        // Auto-uncheck Is Geoable when Is Detail is no longer checked
        if (IsDlgButtonChecked(hwnd, 1215) != BST_CHECKED) {
            CheckDlgButton(hwnd, IDC_IS_GEOABLE, BST_UNCHECKED);
        }
        // Refresh material combo and no_debris enable state when detail flag changes
        init_material_combo(hwnd);
        init_no_debris_checkbox(hwnd);
    }
    if (msg == WM_NCDESTROY) {
        SetWindowLongPtrA(hwnd, GWLP_WNDPROC,
                          reinterpret_cast<LONG_PTR>(g_brush_props_orig_wndproc));
        auto result = CallWindowProcA(g_brush_props_orig_wndproc, hwnd, msg, wParam, lParam);
        g_brush_props_orig_wndproc = nullptr;
        return result;
    }
    return CallWindowProcA(g_brush_props_orig_wndproc, hwnd, msg, wParam, lParam);
}

static LRESULT CALLBACK BrushPropsMsgHookProc(int nCode, WPARAM wParam, LPARAM lParam)
{
    if (nCode == HC_ACTION) {
        auto* msg = reinterpret_cast<CWPRETSTRUCT*>(lParam);
        if (msg->message == WM_INITDIALOG && GetDlgItem(msg->hwnd, IDC_IS_GEOABLE)) {
            int state = compute_geoable_state_from_selected();
            CheckDlgButton(msg->hwnd, IDC_IS_GEOABLE, state);
            init_material_combo(msg->hwnd);
            init_no_debris_checkbox(msg->hwnd);
            g_brush_props_orig_wndproc = reinterpret_cast<WNDPROC>(
                SetWindowLongPtrA(msg->hwnd, GWLP_WNDPROC,
                                  reinterpret_cast<LONG_PTR>(BrushPropsSubclassProc)));
            UnhookWindowsHookEx(g_brush_props_msg_hook);
            g_brush_props_msg_hook = nullptr;
        }
    }
    return CallNextHookEx(g_brush_props_msg_hook, nCode, wParam, lParam);
}

// CWnd::CreateDlg path — used by CDialogBar::Create for toolbar-style dialog bars
CodeInjection CWnd_CreateDlg_injection{
    0x0052F112,
    [](auto& regs) {
        auto& hCurrentResourceHandle = regs.esi;
        auto lpszTemplateName = addr_as_ref<LPCSTR>(regs.esp);
        // - 136: main window top bar (added tool buttons)
        if (lpszTemplateName == MAKEINTRESOURCE(IDD_MAIN_FRAME_TOP_BAR)) {
            hCurrentResourceHandle = reinterpret_cast<int>(g_module);
        }
    },
};

// CFormView::Create path — used for form view panels like the brush mode side panel
// At 0x0052F08D: ESI = hModule, EBX = lpszTemplateName (MAKEINTRESOURCE)
CodeInjection CFormView_Create_injection{
    0x0052F08D,
    [](auto& regs) {
        auto& hCurrentResourceHandle = regs.esi;
        auto lpszTemplateName = static_cast<LPCSTR>(reinterpret_cast<void*>(static_cast<uintptr_t>(regs.ebx)));
        if (lpszTemplateName == MAKEINTRESOURCE(IDD_BRUSH_MODE_PANEL)
            || lpszTemplateName == MAKEINTRESOURCE(IDD_FACE_MODE_PANEL)
            || lpszTemplateName == MAKEINTRESOURCE(IDD_VERTEX_MODE_PANEL)
            || lpszTemplateName == MAKEINTRESOURCE(IDD_GROUP_MODE_PANEL)) {
            hCurrentResourceHandle = reinterpret_cast<int>(g_module);
        }
    },
};

// Post-creation hook for CFormView panels. At 0x0052F0A9 (after CreateDlgIndirect),
// EDI = CWnd*, EBX = template name. CWnd::m_hWnd is at CWnd+0x1C.
// Subclasses group panel immediately after creation.
static LRESULT CALLBACK GroupPanelSubclassProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam);
static void subclass_group_panel_post_create(HWND hwnd);

CodeInjection CFormView_PostCreate_injection{
    0x0052F0A9,
    [](auto& regs) {
        auto lpszTemplateName = static_cast<LPCSTR>(reinterpret_cast<void*>(static_cast<uintptr_t>(regs.ebx)));
        if (lpszTemplateName == MAKEINTRESOURCE(IDD_GROUP_MODE_PANEL)) {
            HWND hwnd = *reinterpret_cast<HWND*>(
                reinterpret_cast<uint8_t*>(static_cast<uintptr_t>(regs.edi)) + 0x1C);
            if (hwnd) {
                subclass_group_panel_post_create(hwnd);
            }
        }
    },
};

CodeInjection CDialog_DoModal_injection{
    0x0052F461,
    [](auto& regs) {
        auto& hCurrentResourceHandle = regs.ebx;
        auto lpszTemplateName = addr_as_ref<LPCSTR>(regs.esp);
        if (lpszTemplateName == MAKEINTRESOURCE(IDD_TRIGGER_PROPERTIES) ||
            lpszTemplateName == MAKEINTRESOURCE(IDD_LEVEL_PROPERTIES) ||
            lpszTemplateName == MAKEINTRESOURCE(IDD_UV_UNWRAP) ||
            lpszTemplateName == MAKEINTRESOURCE(IDD_BRUSH_PROPERTIES) ||
            lpszTemplateName == MAKEINTRESOURCE(IDD_FACE_SPLIT) ||
            lpszTemplateName == MAKEINTRESOURCE(IDD_BRUSH_MIRROR)
        ) {
            hCurrentResourceHandle = reinterpret_cast<int>(g_module);
        }
        if (lpszTemplateName == MAKEINTRESOURCE(IDD_BRUSH_PROPERTIES)) {
            g_brush_props_msg_hook = SetWindowsHookExA(
                WH_CALLWNDPROCRET, BrushPropsMsgHookProc, nullptr, GetCurrentThreadId());
        }
    },
};

HMENU WINAPI LoadMenuA_new(HINSTANCE hInstance, LPCSTR lpMenuName) {
    HMENU result = LoadMenuA(g_module, lpMenuName);
    if (!result) {
        result = LoadMenuA(hInstance, lpMenuName);
    }
    return result;
}

HICON WINAPI LoadIconA_new(HINSTANCE hInstance, LPCSTR lpIconName) {
    HICON result = LoadIconA(g_module, lpIconName);
    if (!result) {
        result = LoadIconA(hInstance, lpIconName);
    }
    return result;
}

HACCEL WINAPI LoadAcceleratorsA_new(HINSTANCE hInstance, LPCSTR lpTableName) {
    HACCEL result = LoadAcceleratorsA(g_module, lpTableName);
    if (!result) {
        result = LoadAcceleratorsA(hInstance, lpTableName);
    }
    return result;
}

CodeInjection CDedLevel_OpenRespawnPointProperties_injection{
    0x00404CB8,
    [](auto& regs) {
        // Fix wrong respawn point reference being used when copying booleans from checkboxes
        regs.esi = regs.ebx;
    },
};

using wnd_set_text_type = int __fastcall(void*, void*, const char*);
extern CallHook<wnd_set_text_type> log_append_wnd_set_text_hook;
int __fastcall log_append_wnd_set_text_new(void* self, void* edx, const char* str)
{
    if (g_skip_wnd_set_text) {
        return std::strlen(str);
    }
    return log_append_wnd_set_text_hook.call_target(self, edx, str);
}
CallHook<wnd_set_text_type> log_append_wnd_set_text_hook{0x004449C6, log_append_wnd_set_text_new};

using group_mode_handle_selection_type = void __fastcall(void* self);
extern FunHook<group_mode_handle_selection_type> group_mode_handle_selection_hook;
void __fastcall group_mode_handle_selection_new(void* self)
{
    g_skip_wnd_set_text = true;
    group_mode_handle_selection_hook.call_target(self);
    g_skip_wnd_set_text = false;
    // TODO: print
    LogDlg_Append(GetLogDlg(), "");
}
FunHook<group_mode_handle_selection_type> group_mode_handle_selection_hook{0x00423460, group_mode_handle_selection_new};

using brush_mode_handle_selection_type = void __fastcall(void* self);
extern FunHook<brush_mode_handle_selection_type> brush_mode_handle_selection_hook;
void __fastcall brush_mode_handle_selection_new(void* self)
{
    g_skip_wnd_set_text = true;
    brush_mode_handle_selection_hook.call_target(self);
    g_skip_wnd_set_text = false;
    LogDlg_Append(GetLogDlg(), "");

    // Update Is Geoable checkbox and material combo in brush panel
    HWND hdlg = WndToHandle(reinterpret_cast<CWnd*>(self));
    if (hdlg && GetDlgItem(hdlg, IDC_IS_GEOABLE)) {
        int state = compute_geoable_state_from_selected();
        CheckDlgButton(hdlg, IDC_IS_GEOABLE, state);
        init_material_combo(hdlg);
        init_no_debris_checkbox(hdlg);
        // Subclass panel for Is Geoable click handling (once per HWND)
        if (hdlg != g_brush_panel_hwnd) {
            if (g_brush_panel_hwnd && g_brush_panel_orig_wndproc) {
                SetWindowLongPtrA(g_brush_panel_hwnd, GWLP_WNDPROC,
                                  reinterpret_cast<LONG_PTR>(g_brush_panel_orig_wndproc));
            }
            g_brush_panel_orig_wndproc = reinterpret_cast<WNDPROC>(
                SetWindowLongPtrA(hdlg, GWLP_WNDPROC,
                                  reinterpret_cast<LONG_PTR>(BrushPanelSubclassProc)));
            g_brush_panel_hwnd = hdlg;
        }
    }
}
FunHook<brush_mode_handle_selection_type> brush_mode_handle_selection_hook{0x0043F430, brush_mode_handle_selection_new};

void __fastcall DedLight_UpdateLevelLight_new(void *this_);
FunHook DedLight_UpdateLevelLight_hook{
    0x00453200,
    DedLight_UpdateLevelLight_new,
};
void __fastcall DedLight_UpdateLevelLight_new(void *this_)
{
    auto& this_is_enabled = struct_field_ref<bool>(this_, 0xD5);
    auto& level_light = struct_field_ref<void*>(this_, 0xD8);
    auto& level_light_is_enabled = struct_field_ref<bool>(level_light, 0x91);
    level_light_is_enabled = this_is_enabled;
    DedLight_UpdateLevelLight_hook.call_target(this_);
}

struct CTextureBrowserDialog;
rf::String * __fastcall CTextureBrowserDialog_GetFolderName(CTextureBrowserDialog *this_, int edx, rf::String *folder_name);
FunHook CTextureBrowserDialog_GetFolderName_hook{
    0x00471260,
    CTextureBrowserDialog_GetFolderName,
};
rf::String * __fastcall CTextureBrowserDialog_GetFolderName(CTextureBrowserDialog *this_, int edx, rf::String *folder_name)
{
    auto& texture_browser_folder_index = addr_as_ref<int>(0x006CA404);
    if (texture_browser_folder_index > 0) {
        return CTextureBrowserDialog_GetFolderName_hook.call_target(this_, edx, folder_name);
    }
    folder_name->buf = nullptr;
    folder_name->max_len = 0;
    return folder_name;
}

CodeInjection CCutscenePropertiesDialog_ct_crash_fix{
    0x00458A84,
    [](auto& regs) {
        void* this_ = regs.esi;
        auto& this_num_shots = struct_field_ref<int>(this_, 0x60);
        this_num_shots = 0;
    },
};

static auto RedrawEditorAfterModification = addr_as_ref<int __cdecl()>(0x00483560);

void* GetLevelFromMainFrame(CWnd* main_frame)
{
    auto* doc = struct_field_ref<void*>(main_frame, 0xD0);
    return &struct_field_ref<int>(doc, 0x60);
}

void CMainFrame_ToggleMaximizeViewport(CMainFrame* this_)
{
    if (g_maximized_viewport == -1) {
        this_->MaximizeActiveViewport();
    } else {
        this_->RestoreAllViewports();
    }
}

void CMainFrame_OpenHelp(CWnd* this_)
{
    ShellExecuteA(WndToHandle(this_), "open", "https://redfactionwiki.com/wiki/RF1_Editing_Main_Page", nullptr, nullptr, SW_SHOW);
}

void CMainFrame_OpenHotkeysHelp(CWnd* this_)
{
    ShellExecuteA(WndToHandle(this_), "open", "https://redfactionwiki.com/wiki/RED_Hotkey_Reference", nullptr, nullptr, SW_SHOW);
}

void CMainFrame_OpenAlpineHelp(CWnd* this_)
{
    ShellExecuteA(WndToHandle(this_), "open", "https://redfactionwiki.com/wiki/Alpine_Level_Design", nullptr, nullptr, SW_SHOW);
}

void CMainFrame_HideAllObjects(CWnd* this_)
{
    AddrCaller{0x0042DCA0}.this_call(GetLevelFromMainFrame(this_));
    RedrawEditorAfterModification();
}

void CMainFrame_ShowAllObjects(CWnd* this_)
{
    AddrCaller{0x0042DDA0}.this_call(GetLevelFromMainFrame(this_));
    RedrawEditorAfterModification();
}

void CMainFrame_HideSelected(CWnd* this_)
{
    AddrCaller{0x0042DBF0}.this_call(GetLevelFromMainFrame(this_));
    RedrawEditorAfterModification();
}

void CMainFrame_SelectObjectByUid(CWnd* this_)
{
    AddrCaller{0x0042E720}.this_call(GetLevelFromMainFrame(this_));
    RedrawEditorAfterModification();
}

void CMainFrame_InvertSelection(CWnd* this_)
{
    AddrCaller{0x0042E890}.this_call(GetLevelFromMainFrame(this_));
    RedrawEditorAfterModification();
}

static char* patch_cmdline_if_multi(char* original)
{
    if (!original) {
        return original;
    }

    if (!g_is_play_in_multi) {
        return original;
    }

    g_red_cmdline.assign(original);

    constexpr const char needle[] = "-level ";
    auto pos = g_red_cmdline.find(needle);
    if (pos != std::string::npos) {
        // already has -levelm (defensive)
        if (g_red_cmdline.compare(pos, 8, "-levelm ") != 0) {
            // insert m before the space
            g_red_cmdline.insert(pos + 6, "m");
        }
    }

    return g_red_cmdline.data();
}

CodeInjection CMainFrame_OnPlayLevel_injection{
    0x00447B32,
    [](auto& regs) {
        char* original = regs.edx;
        auto* patched = patch_cmdline_if_multi(original);
        regs.edx = reinterpret_cast<uintptr_t>(patched);
    },
};

CodeInjection CMainFrame_OnPlayLevelFromCameraCmd_injection{
    0x00448024,
    [](auto& regs) {
        char* original = regs.edx;
        auto* patched = patch_cmdline_if_multi(original);
        regs.edx = reinterpret_cast<uintptr_t>(patched);
    },
};

void CMainFrame_PlayMulti(CWnd* this_)
{
    g_is_play_in_multi = true;
    AddrCaller{0x004478B0}.this_call<int>(this_); // CMainFrame_OnPlayLevel
    g_is_play_in_multi = false;
}

void CMainFrame_PlayMultiFromCamera(CWnd* this_)
{
    g_is_play_in_multi = true;
    AddrCaller{0x00447B90}.this_call<int>(this_); // CMainFrame_OnPlayLevelFromCameraCmd
    g_is_play_in_multi = false;
}

void CMainFrame_BackLink([[maybe_unused]] CWnd* this_)
{
    DedLevel_DoBackLink();
    RedrawEditorAfterModification();
}

// Clip tool fix: replace buggy single-pass Cohen-Sutherland with proper slab intersection
// ====================
// Stock FUN_004c9af0 fails on diagonal clip lines because it only clips one endpoint
// against one boundary per axis without iterating. This causes the clip tool to silently
// skip brushes when the clip plane is sufficiently diagonal.

static bool __cdecl line_aabb_intersect(
    const Vector3* bbox_min, const Vector3* bbox_max,
    const Vector3* p0, const Vector3* p1,
    Vector3* intersection_out)
{
    // Slab (Liang-Barsky) line-AABB intersection
    float dir[3] = {p1->x - p0->x, p1->y - p0->y, p1->z - p0->z};
    const float* origin = &p0->x;
    const float* bmin = &bbox_min->x;
    const float* bmax = &bbox_max->x;

    float t_enter = 0.0f;
    float t_exit = 1.0f;

    for (int i = 0; i < 3; i++) {
        if (std::abs(dir[i]) < 1e-12f) {
            // Line is parallel to this slab — check if origin is inside
            if (origin[i] < bmin[i] || origin[i] > bmax[i])
                return false;
        }
        else {
            float inv_dir = 1.0f / dir[i];
            float t0 = (bmin[i] - origin[i]) * inv_dir;
            float t1 = (bmax[i] - origin[i]) * inv_dir;
            if (t0 > t1) { float tmp = t0; t0 = t1; t1 = tmp; }
            if (t0 > t_enter) t_enter = t0;
            if (t1 < t_exit) t_exit = t1;
            if (t_enter > t_exit)
                return false;
        }
    }

    // Clamp to line segment [0, 1]
    if (t_enter > 1.0f || t_exit < 0.0f)
        return false;

    float t = (t_enter >= 0.0f) ? t_enter : 0.0f;
    intersection_out->x = p0->x + dir[0] * t;
    intersection_out->y = p0->y + dir[1] * t;
    intersection_out->z = p0->z + dir[2] * t;
    return true;
}

FunHook<bool __cdecl(const Vector3*, const Vector3*, const Vector3*, const Vector3*, Vector3*)>
    line_aabb_intersect_hook{0x004c9af0, line_aabb_intersect};

// Fix crash when moving/rotating/undoing decal objects (DED_DECAL, type 0x12).
// FUN_0042a460 case 0x12 calls FUN_0044e9a0 which dereferences the sub-object pointer at +0xA4
// without a null check. The sub-object is created by FUN_00494390, which returns NULL if the
// decal count exceeds 127 or allocation fails. Moving/rotating/undoing such a decal crashes
// in FUN_00494400 when it dereferences NULL+0x34 etc.
static void __fastcall object_rotation_update_new(void* self, int /*edx*/, void* param);
FunHook<decltype(object_rotation_update_new)> object_rotation_update_hook{
    0x0044e9a0, object_rotation_update_new};
static void __fastcall object_rotation_update_new(void* self, int /*edx*/, void* param)
{
    auto* sub_obj = *reinterpret_cast<void**>(static_cast<std::byte*>(self) + 0xA4);
    if (!sub_obj) {
        WARN_ONCE("Skipping rotation update for object with null sub-object at +0xA4");
        return;
    }
    object_rotation_update_hook.call_target(self, 0, param);
}

// Face mode panel (dialog 178) subclass
static WNDPROC g_face_panel_orig_wndproc = nullptr;
static HWND g_face_panel_hwnd = nullptr;

static LRESULT CALLBACK FacePanelSubclassProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    if (msg == WM_COMMAND) {
        WORD id = LOWORD(wParam);
        if (id == IDC_FACE_DELETE) { handle_face_delete(); return 0; }
        if (id == IDC_FACE_DELETE_EXT) { handle_face_delete_ext(); return 0; }
        if (id == IDC_FACE_SPLIT) { handle_face_split(); return 0; }
        if (id == IDC_FACE_FLIP_NORMAL) { handle_face_flip_normal(); return 0; }
    }
    return CallWindowProcA(g_face_panel_orig_wndproc, hwnd, msg, wParam, lParam);
}

// Subclass the face mode panel when it becomes active.
// Called from CWnd_CreateDlg_injection when dialog 178 is created.
static void subclass_face_panel(HWND hdlg)
{
    if (hdlg == g_face_panel_hwnd) return; // already subclassed
    if (g_face_panel_hwnd && g_face_panel_orig_wndproc) {
        SetWindowLongPtrA(g_face_panel_hwnd, GWLP_WNDPROC,
                          reinterpret_cast<LONG_PTR>(g_face_panel_orig_wndproc));
    }
    g_face_panel_orig_wndproc = reinterpret_cast<WNDPROC>(
        SetWindowLongPtrA(hdlg, GWLP_WNDPROC,
                          reinterpret_cast<LONG_PTR>(FacePanelSubclassProc)));
    g_face_panel_hwnd = hdlg;
}

// Vertex mode panel subclass — handles Delete and Bridge button clicks.
static WNDPROC g_vertex_panel_orig_wndproc = nullptr;
static HWND g_vertex_panel_hwnd = nullptr;

static LRESULT CALLBACK VertexPanelSubclassProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    if (msg == WM_COMMAND) {
        WORD id = LOWORD(wParam);
        if (id == IDC_VERTEX_DELETE) { handle_vertex_delete(); return 0; }
        if (id == IDC_VERTEX_CAP) { handle_vertex_bridge(); return 0; }
    }
    return CallWindowProcA(g_vertex_panel_orig_wndproc, hwnd, msg, wParam, lParam);
}

static void subclass_vertex_panel(HWND hdlg)
{
    if (hdlg == g_vertex_panel_hwnd) return;
    if (g_vertex_panel_hwnd && g_vertex_panel_orig_wndproc) {
        SetWindowLongPtrA(g_vertex_panel_hwnd, GWLP_WNDPROC,
                          reinterpret_cast<LONG_PTR>(g_vertex_panel_orig_wndproc));
    }
    g_vertex_panel_orig_wndproc = reinterpret_cast<WNDPROC>(
        SetWindowLongPtrA(hdlg, GWLP_WNDPROC,
                          reinterpret_cast<LONG_PTR>(VertexPanelSubclassProc)));
    g_vertex_panel_hwnd = hdlg;
}

// Group mode panel subclass — handles Mirror button click.
static WNDPROC g_group_panel_orig_wndproc = nullptr;
static HWND g_group_panel_hwnd = nullptr;

static void subclass_group_panel(HWND hdlg)
{
    // Check if already subclassed (current WndProc is ours)
    auto current = reinterpret_cast<WNDPROC>(GetWindowLongPtrA(hdlg, GWLP_WNDPROC));
    if (current == GroupPanelSubclassProc) return;
    g_group_panel_orig_wndproc = reinterpret_cast<WNDPROC>(
        SetWindowLongPtrA(hdlg, GWLP_WNDPROC,
                          reinterpret_cast<LONG_PTR>(GroupPanelSubclassProc)));
    g_group_panel_hwnd = hdlg;
}

// Called from CFormView_PostCreate_injection when dialog 231 is created
static void subclass_group_panel_post_create(HWND hwnd)
{
    subclass_group_panel(hwnd);
}

static LRESULT CALLBACK GroupPanelSubclassProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    if (msg == WM_COMMAND) {
        WORD id = LOWORD(wParam);
        if (id == IDC_GROUP_MIRROR) {
            handle_group_mirror();
            return 0;
        }
    }
    return CallWindowProcA(g_group_panel_orig_wndproc, hwnd, msg, wParam, lParam);
}

// Inject after the CALL to CDedLevel::SetEditMode in the mode combobox handler
// (FUN_004496d0 at 0x004496f9). When face/vertex/group mode is entered, find and subclass
// the panel CFormView to handle our custom button clicks.

struct FindPanelsCtx { HWND face_panel; HWND vertex_panel; HWND group_panel; };

static BOOL CALLBACK EnumChildFindPanelsProc(HWND hwnd, LPARAM lParam)
{
    auto* c = reinterpret_cast<FindPanelsCtx*>(lParam);
    int id = GetDlgCtrlID(hwnd);
    if (id == IDC_FACE_DELETE) c->face_panel = GetParent(hwnd);
    if (id == IDC_VERTEX_DELETE) c->vertex_panel = GetParent(hwnd);
    if (id == IDC_GROUP_MIRROR) c->group_panel = GetParent(hwnd);
    return (c->face_panel && c->vertex_panel && c->group_panel) ? FALSE : TRUE;
}

CodeInjection face_panel_subclass_injection{
    0x004496f9,
    [](BaseCodeInjection::Regs& regs) {
        HWND main_hwnd = *reinterpret_cast<HWND*>(
            reinterpret_cast<uint8_t*>(static_cast<uintptr_t>(regs.esi)) + 0x1C);
        if (!main_hwnd) return;
        FindPanelsCtx ctx{nullptr, nullptr, nullptr};
        EnumChildWindows(main_hwnd, EnumChildFindPanelsProc, reinterpret_cast<LPARAM>(&ctx));
        if (ctx.face_panel) subclass_face_panel(ctx.face_panel);
        if (ctx.vertex_panel) subclass_vertex_panel(ctx.vertex_panel);
        if (ctx.group_panel) subclass_group_panel(ctx.group_panel);
    },
    true, // needs_trampoline
};


BOOL __fastcall CMainFrame_OnCmdMsg(CWnd* this_, int, UINT nID, int nCode, void* pExtra, void* pHandlerInfo)
{
    constexpr int CN_COMMAND = 0;

    if (nCode == CN_COMMAND) {
        std::function<void()> handler;
        switch (nID) {
            case ID_WIKI_EDITING_MAIN_PAGE:
                handler = std::bind(CMainFrame_OpenHelp, this_);
                break;
            case ID_WIKI_HOTKEYS:
                handler = std::bind(CMainFrame_OpenHotkeysHelp, this_);
                break;
            case ID_WIKI_ALPINE_HELP:
                handler = std::bind(CMainFrame_OpenAlpineHelp, this_);
                break;
            case ID_HIDE_ALL_OBJECTS:
                handler = std::bind(CMainFrame_HideAllObjects, this_);
                break;
            case ID_SHOW_ALL_OBJECTS:
                handler = std::bind(CMainFrame_ShowAllObjects, this_);
                break;
            case ID_HIDE_SELECTED:
                handler = std::bind(CMainFrame_HideSelected, this_);
                break;
            case ID_SELECT_OBJECTS:
                handler = [this_]() {
                    auto* level = reinterpret_cast<CDedLevel*>(GetLevelFromMainFrame(this_));
                    if (level) alpine_select_objects(level);
                };
                break;
            case ID_HIDE_OBJECTS:
                handler = [this_]() {
                    auto* level = reinterpret_cast<CDedLevel*>(GetLevelFromMainFrame(this_));
                    if (level) alpine_hide_objects(level);
                };
                break;
            case ID_SELECT_OBJECT_BY_UID:
                handler = std::bind(CMainFrame_SelectObjectByUid, this_);
                break;
            case ID_INVERT_SELECTION:
                handler = std::bind(CMainFrame_InvertSelection, this_);
                break;
            case ID_PLAY_MULTI:
                handler = std::bind(CMainFrame_PlayMulti, this_);
                break;
            case ID_PLAY_MULTI_CAMERA:
                handler = std::bind(CMainFrame_PlayMultiFromCamera, this_);
                break;
            case ID_BACK_LINK:
                handler = std::bind(CMainFrame_BackLink, this_);
                break;
            case IDC_FACE_DELETE:
                handler = handle_face_delete;
                break;
            case IDC_FACE_DELETE_EXT:
                handler = handle_face_delete_ext;
                break;
            case IDC_FACE_SPLIT:
                handler = handle_face_split;
                break;
            case IDC_FACE_FLIP_NORMAL:
                handler = handle_face_flip_normal;
                break;
            case IDC_BRUSH_MIRROR:
                handler = handle_brush_mirror;
                break;
            case IDC_BRUSH_CONVERT:
                handler = handle_brush_convert;
                break;
            case IDC_VERTEX_DELETE:
                handler = handle_vertex_delete;
                break;
            case IDC_VERTEX_CAP:
                handler = handle_vertex_bridge;
                break;
            case IDC_GROUP_MIRROR:
                handler = handle_group_mirror;
                break;
            case ID_RELOAD_MESHES:
                handler = reload_custom_meshes;
                break;
            case ID_RELOAD_TEXTURES:
                handler = reload_custom_textures;
                break;
            case ID_TOGGLE_MAXIMIZE_VIEWPORT:
                handler = std::bind(CMainFrame_ToggleMaximizeViewport, reinterpret_cast<CMainFrame*>(this_));
                break;
        }

        if (handler) {
            // Tell MFC that this command has a handler so it does not disable menu item
            if (pHandlerInfo) {
                // It seems handler info is not used but it's better to initialize it just in case
                ZeroMemory(pHandlerInfo, 8);
            }
            else {
                // Run the handler
                handler();
            }
            return TRUE;
        }
    }
    return AddrCaller{0x00540C5B}.this_call<BOOL>(this_, nID, nCode, pExtra, pHandlerInfo);
}

void InitLogging()
{
    CreateDirectoryA("logs", nullptr);
    xlog::LoggerConfig::get()
        .add_appender<xlog::FileAppender>("logs/AlpineEditor.log", false)
        .add_appender<xlog::ConsoleAppender>()
        .add_appender<xlog::Win32Appender>();
    xlog::info("Alpine Faction Editor log started.");
}

void InitCrashHandler()
{
    char current_dir[MAX_PATH] = ".";
    GetCurrentDirectoryA(std::size(current_dir), current_dir);

    CrashHandlerConfig config;
    config.this_module_handle = g_module;
    std::snprintf(config.log_file, std::size(config.log_file), "%s\\logs\\AlpineEditor.log", current_dir);
    std::snprintf(config.output_dir, std::size(config.output_dir), "%s\\logs", current_dir);
    std::snprintf(config.app_name, std::size(config.app_name), "AlpineEditor");
    config.add_known_module("RED");
    config.add_known_module("AlpineEditor");

    CrashHandlerStubInstall(config);
}

void ApplyGraphicsPatches();
void ApplyTriggerPatches();
void ApplyLevelPatches();
void ApplyEventsPatches();
void ApplyTexturesPatches();
void ApplyLightmapPatches();

void LoadAlpineEditorPackfile()
{
    static auto& vpackfile_add = addr_as_ref<int __cdecl(const char *name, const char *dir)>(0x004CA930);
    static auto& root_path = addr_as_ref<char[256]>(0x0158CA10);

    auto af_dir = get_module_dir(g_module);
    std::string old_root_path = root_path;
    std::strncpy(root_path, af_dir.c_str(), sizeof(root_path) - 1);
    if (!vpackfile_add("alpinefaction.vpp", nullptr)) {
        xlog::error("Failed to load alpinefaction.vpp from {}", af_dir);
    }
    std::strncpy(root_path, old_root_path.c_str(), sizeof(root_path) - 1);
}

CodeInjection vpackfile_init_injection{
    0x004CA533,
    []() {
        LoadAlpineEditorPackfile();
    },
};

CodeInjection CMainFrame_OnPlayLevelCmd_skip_level_dir_injection{
    0x004479AD,
    [](auto& regs) {
        char* level_pathname = regs.eax;
        regs.eax = std::strrchr(level_pathname, '\\') + 1;
    },
};

CodeInjection CMainFrame_OnPlayLevelFromCameraCmd_skip_level_dir_injection{
    0x00447CF2,
    [](auto& regs) {
        char* level_pathname = regs.eax;
        regs.eax = std::strrchr(level_pathname, '\\') + 1;
    },
};

CodeInjection CDedLevel_CloneObject_injection{
    0x004135B9,
    [](auto& regs) {
        void* that = regs.ecx;
        int type = regs.eax;
        void* obj = regs.edi;
        if (type == 0xC) {
            // clone cutscene path node
            regs.eax = AddrCaller{0x00413C70}.this_call<void*>(that, obj);
            regs.eip = 0x004135CF;
        }
        else if (type == static_cast<int>(DedObjectType::DED_MESH)) {
            // Safety net: if CloneObject is called for mesh (shouldn't normally happen
            // since mesh_paste_skip_stock handles it), create clone WITHOUT adding to
            // mesh_objects to avoid double-cloning.
            auto* source = static_cast<DedMesh*>(reinterpret_cast<DedObject*>(obj));
            xlog::info("[Mesh] CloneObject called (safety): source={:p} uid={} type=0x{:x}",
                static_cast<void*>(source), source->uid, type);
            auto* clone = CloneMeshObject(source, false);
            regs.eax = reinterpret_cast<uintptr_t>(static_cast<DedObject*>(clone));
            regs.eip = 0x004135CF;
        }
    },
};

// Copy geoable and breakable material alpine properties from old_uid to new_uid.
// Used when a brush is duplicated or pasted with a new UID.
static void copy_alpine_brush_props(int old_uid, int new_uid)
{
    auto* level = CDedLevel::Get();
    if (!level) return;
    auto& props = level->GetAlpineLevelProperties();

    // Copy geoable property
    if (std::find(props.geoable_brush_uids.begin(),
                  props.geoable_brush_uids.end(), old_uid)
        != props.geoable_brush_uids.end()) {
        props.geoable_brush_uids.push_back(new_uid);
    }

    // Copy breakable material property
    auto bit = std::find(props.breakable_brush_uids.begin(),
                         props.breakable_brush_uids.end(), old_uid);
    if (bit != props.breakable_brush_uids.end()) {
        auto idx = std::distance(props.breakable_brush_uids.begin(), bit);
        props.breakable_brush_uids.push_back(new_uid);
        props.breakable_room_uids.push_back(0); // filled at save time
        props.breakable_materials.push_back(props.breakable_materials[idx]);
    }
}

// Hook in BrushList_clone_selected (0x00412c27) at 0x00412c91, right after the new UID
// is stored in the clone. EDI = source BrushNode*, ESI = cloned BrushNode* (with new UID).
CodeInjection brush_clone_copy_alpine_props_injection{
    0x00412c91,
    [](auto& regs) {
        auto* source = reinterpret_cast<BrushNode*>(static_cast<void*>(regs.edi));
        auto* clone  = reinterpret_cast<BrushNode*>(static_cast<void*>(regs.esi));
        copy_alpine_brush_props(source->uid, clone->uid);
    },
};

// Hook BrushNode_clone_from (0x0044d620) to propagate source UID through copy/paste.
// BrushNode_clone_from copies is_detail, life, state etc. but intentionally does NOT copy uid.
// In the copy-to-clipboard path (caller 0x0041301f): we store the source brush's uid in the
// clipboard clone so it carries the original identity.
// In the paste-from-clipboard path (caller 0x0041325c): we capture the clipboard clone's uid
// (set during copy) so we can copy alpine properties after the new uid is assigned.
static int g_paste_source_uid = -1;

CodeInjection brush_clone_from_alpine_hook{
    0x0044d620,
    [](auto& regs) {
        auto* stack = reinterpret_cast<uint32_t*>(static_cast<uintptr_t>(regs.esp));
        uint32_t ret_addr = stack[0];
        auto* source = reinterpret_cast<BrushNode*>(stack[1]);
        auto* clone = reinterpret_cast<BrushNode*>(static_cast<void*>(regs.ecx));

        if (ret_addr == 0x0041301f) {
            // Copy to clipboard: store source uid in clipboard clone.
            // This runs BEFORE clone_from executes. clone_from won't touch uid, so our
            // write persists. The clipboard clone will carry the original brush's uid.
            clone->uid = source->uid;
        }
        else if (ret_addr == 0x0041325c) {
            // Paste from clipboard: source is the clipboard clone (uid set above).
            // Save it so the post-insert hook can copy alpine properties.
            g_paste_source_uid = source->uid;
        }
    },
};

// After FUN_00414650 inserts the pasted brush and assigns a new UID (0x00413266).
// ESI = paste clone with its new UID. Copy alpine properties from the original source.
CodeInjection brush_paste_apply_alpine_props{
    0x00413266,
    [](auto& regs) {
        if (g_paste_source_uid > 0) {
            auto* paste_clone = reinterpret_cast<BrushNode*>(static_cast<void*>(regs.esi));
            copy_alpine_brush_props(g_paste_source_uid, paste_clone->uid);
            g_paste_source_uid = -1;
        }
    },
};

CodeInjection CDedEvent_Copy_injection{
    0x0045146D,
    [](auto& regs) {
        void* src_event = regs.edi;
        void* dst_event = regs.esi;
        // copy bool2 field
        struct_field_ref<bool>(dst_event, 0xB1) = struct_field_ref<bool>(src_event, 0xB1);
    },
};

CodeInjection texture_name_buffer_overflow_injection1{
    0x00445297,
    [](auto &regs) {
        const char *filename = regs.esi;
        if (std::strlen(filename) > max_texture_name_len) {
            LogDlg_Append(GetLogDlg(), "Texture name too long: %s\n", filename);
            regs.eip = 0x00445273;
        }
    },
};

CodeInjection texture_name_buffer_overflow_injection2{
    0x004703EC,
    [](auto &regs) {
        const char *filename = regs.ebp;
        if (std::strlen(filename) > max_texture_name_len) {
            LogDlg_Append(GetLogDlg(), "Texture name too long: %s\n", filename);
            regs.eip = 0x0047047F;
        }
    },
};

CodeInjection LoadSaveLevel_patch{
    0x0041CD20,
    [](auto& regs) {
        int* version = reinterpret_cast<int*>(regs.esi + 0x54);
        *version = MAXIMUM_RFL_VERSION; // set rfl version saved to file
        regs.eip = 0x0041CD27; // skip version being set to 200 by original code
        g_current_level_version = *version;
    }
};

INT_PTR CALLBACK DialogLegacyLevel(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    switch (uMsg) {
    case WM_INITDIALOG:
        SetDlgItemTextA(hwndDlg, IDC_LEVEL_PROMPT_MESSAGE, (LPCSTR)lParam);
        return TRUE;

    case WM_COMMAND:
        switch (LOWORD(wParam)) {
        case IDLEVELLINK: // If the link button is clicked
            ShellExecuteA(NULL, "open", "https://www.redfactionwiki.com/wiki/Alpine_Level_Design", NULL, NULL,
                          SW_SHOWNORMAL);
            return TRUE;

        case IDOK: // OK button
        case IDCANCEL:
            EndDialog(hwndDlg, LOWORD(wParam));
            return TRUE;
        }
        break;
    }
    return FALSE;
}

void ShowLegacyLevelDialog(int current_version, int new_version) {
    std::string message =
        std::format("This level file was constructed using an older version of RED.\n\n"
                    "The version of this level file is {}.\n\n"
                    "Due to new Alpine Faction features and capabilities that are not available in older client versions, "
                    "Alpine RED saves levels with version {}.\n\n"
                    "If you resave this file, it will be converted to an Alpine Level with version {}, "
                    "and it will no longer be playable on non-Alpine legacy client versions.\n\n"
                    "To learn more about Alpine Levels, click below to visit the Red Faction Wiki.",
                    current_version, new_version, new_version);

    DialogBoxParamA(
        ((HINSTANCE) & __ImageBase),
        MAKEINTRESOURCEA(IDD_ALPINE_LEVEL_POPUP),
        GetActiveWindow(),
        DialogLegacyLevel,
        reinterpret_cast<LPARAM>(message.c_str())
    );
}

CodeInjection LoadSaveLevel_patch2{
    0x0041CDAA,
    [](auto& regs) {
        int* version = regs.edi;
        g_current_level_version = *version;

        if (*version < 300 && !g_skip_legacy_level_warning) {
            xlog::info("Displaying legacy level warning dialog");
            ShowLegacyLevelDialog(*version, MAXIMUM_RFL_VERSION);
        }
    }
};

// disable splash screen if editor is launched with -level switch, fixes splash screen issue with version popup
CodeInjection disable_splash_screen_on_load_level {
    0x00482672,
    [](auto& regs) {
        static auto& argv = addr_as_ref<char**>(0x01DBF8E4);
        static auto& argc = addr_as_ref<int>(0x01DBF8E0);
        for (int i = 1; i < argc; ++i) {
            std::string_view arg = argv[i];

            // skip legacy level warning dialog
            if (arg == "-skiplegacywarning") {
                g_skip_legacy_level_warning = true;
            }

            // skip past the splash screen if loading a level directly
            // this fixes unintuitive behaviour when the splash screen and legacy level warning both show up at the same time
            if (arg == "-level") {
                ++i;
                if (i < argc) {
                    regs.eip = 0x0048268E;
                }
            }
        }
    }
};

void apply_af_level_editor_changes()
{
    // Use new version for saved rfls
    LoadSaveLevel_patch.install();
    LoadSaveLevel_patch2.install();
    disable_splash_screen_on_load_level.install();

    // Raise maximum apply map pixels/m value to 8192 (default 256)
    AsmWriter(0x00476FCD).push(0x2000);

    // Write version 300 to saved group files, instead of 200 (default)
    // Fixes issue loading events with orientation values (in event.cpp DedEvent__exchange_patch)
    // Note: Doesn't need to be updated when MAXIMUM_RFL_VERSION is incremented
    AsmWriter(0x0041D0AF).push(0x12C);
    AsmWriter(0x0041D0BC).push(0x12C);

    // Allow linking to multiplayer respawn points
    AsmWriter(0x004698C7).nop(2);

    // Remove legacy geometry maximums from build output window
    static char new_faces_string[] = "Faces: %d\n";                                  // Replace "Faces: %d/%d\n"
    static char new_face_vertices_string[] = "Face Vertices: %d\n";                  // Replace "Face Vertices: %d/%d\n"
    static char new_vertices_string[] = "Vertices: %d\n";                            // Replace "Vertices: %d/%d\n"
    AsmWriter(0x0043A4A3).push(reinterpret_cast<int32_t>(new_faces_string));         // faces
    AsmWriter(0x0043A4C7).push(reinterpret_cast<int32_t>(new_face_vertices_string)); // face verts
    AsmWriter(0x0043A4EB).push(reinterpret_cast<int32_t>(new_vertices_string));      // verts

    // Remove "You must rebuild geometry before leaving group mode"
    AsmWriter(0x0042645E).jmp(0x00426486);
    AsmWriter(0x004263D1).jmp(0x004263F9);
    AsmWriter(0x0042637A).jmp(0x004263A2);
    AsmWriter(0x0042631C).jmp(0x00426344);
    AsmWriter(0x004262E2).jmp(0x0042630A);

    // Remove "You must rebuild geometry before texturing brushes"
    AsmWriter{0x0042642E}.jmp(0x00426456);

    // Stop adding faces to "fix ps2 tiling" when the surface UVs tile a lot
    AsmWriter{0x0043A081}.jmp(0x0043A0E9);
    AsmWriter{0x0043A0EF}.nop(3);
}

extern "C" DWORD AF_DLL_EXPORT Init([[maybe_unused]] void* unused)
{
    InitLogging();
    InitCrashHandler();

    // Apply AF-specific changes only if legacy mode isn't active
    if (get_is_saving_af_version()) {
        apply_af_level_editor_changes();
    }

    // Change command for Play Level action to use AF launcher
    g_launcher_pathname = get_module_dir(g_module) + LAUNCHER_FILENAME;
    using namespace asm_regs;
    AsmWriter(0x00447B32, 0x00447B39).mov(eax, g_launcher_pathname.c_str());
    AsmWriter(0x00448024, 0x0044802B).mov(eax, g_launcher_pathname.c_str());
    CMainFrame_OnPlayLevelCmd_skip_level_dir_injection.install();
    CMainFrame_OnPlayLevelFromCameraCmd_skip_level_dir_injection.install();

    // Change -level command to -levelm for play in multi buttons
    CMainFrame_OnPlayLevel_injection.install();
    CMainFrame_OnPlayLevelFromCameraCmd_injection.install();

    // Add additional file paths for V3M loading
    CEditorApp_InitInstance_additional_file_paths_injection.install();

    // Add handling for "-level" command line argument
    CEditorApp_InitInstance_open_level_injection.install();

    // Change main frame style flags to allow dropping files
    CMainFrame_PreCreateWindow_injection.install();

    // Increase memory size of log view buffer (500 lines * 64 characters)
    write_mem<int32_t>(0x0044489C + 1, 32000);

    // Optimize object selection logging
    log_append_wnd_set_text_hook.install();
    brush_mode_handle_selection_hook.install();
    group_mode_handle_selection_hook.install();

    // Replace some editor resources
    CWnd_CreateDlg_injection.install();
    CFormView_Create_injection.install();
    CFormView_PostCreate_injection.install();
    CDialog_DoModal_injection.install();
    write_mem_ptr(0x0055456C, &LoadMenuA_new);
    write_mem_ptr(0x005544FC, &LoadIconA_new);
    write_mem_ptr(0x005543AC, &LoadAcceleratorsA_new);

    // Remove "Packfile saved successfully!" message
    AsmWriter{0x0044CCA3, 0x0044CCB3}.nop();

    // Fix changing properties of multiple respawn points
    CDedLevel_OpenRespawnPointProperties_injection.install();

    // Apply patches defined in other files
    ApplyGraphicsPatches();
    ApplyTriggerPatches();
    ApplyLevelPatches();
    ApplyEventsPatches();
    ApplyAlpineObjectPatches();
    ApplyTexturesPatches();
    ApplyLightmapPatches();

    // Browse for .v3m files instead of .v3d
    static char mesh_ext_filter[] = "Mesh (*.v3m)|*.v3m|All Files (*.*)|*.*||";
    write_mem_ptr(0x0044243E + 1, mesh_ext_filter);
    write_mem_ptr(0x00462490 + 1, mesh_ext_filter);
    write_mem_ptr(0x0044244F + 1, ".v3m");
    write_mem_ptr(0x004624A9 + 1, ".v3m");
    write_mem_ptr(0x0044244A + 1, "RFBrush.v3m");

    // Fix rendering of VBM textures from user_maps/textures
    write_mem_ptr(0x004828C2 + 1, ".tga .vbm");

    // Fix lights sometimes not working
    DedLight_UpdateLevelLight_hook.install();

    // Fix crash when selecting decal texture from 'All' folder
    CTextureBrowserDialog_GetFolderName_hook.install();

    // No longer require "-sound" argument to enable sound support
    AsmWriter{0x00482BC4}.nop(2);

    // Fix random crash when opening cutscene properties
    CCutscenePropertiesDialog_ct_crash_fix.install();

    // Load alpinefaction.vpp
    vpackfile_init_injection.install();

    // Add maps_af.txt to the collection of files scanned for default textures in order to add more textures from the
    // base game to the texture browser
    // Especially add Rck_DefaultP.tga to default textures to fix error when packing a level containing a particle
    // emitter with default properties
    static const char* maps_files_names[] = {
        "maps.txt",
        "maps1.txt",
        "maps2.txt",
        "maps3.txt",
        "maps4.txt",
        "maps_af.txt",
        nullptr,
    };
    write_mem_ptr(0x0041B813 + 1, maps_files_names);
    write_mem_ptr(0x0041B824 + 1, maps_files_names);

    // Fix path node connections sometimes being rendered incorrectly
    // For some reason editor code uses copies of radius and position fields in some situation and those copies
    // are sometimes uninitialized
    write_mem<u8>(0x004190EB, asm_opcodes::jmp_rel_short);
    write_mem<u8>(0x0041924A, asm_opcodes::jmp_rel_short);

    // Support additional commands
    write_mem_ptr(0x00556574, &CMainFrame_OnCmdMsg);

    // Fix F4 key (Maximize active viewport) for screens larger than 1024x768
    constexpr int max_size = 0x7FFF;
    write_mem<int>(0x0044770D + 1, max_size); // 1 cx
    write_mem<int>(0x0044771D + 1, max_size); // 1 cy
    write_mem<int>(0x00447750 + 1, -max_size); // 2 add cx
    write_mem<int>(0x004477E1 + 2, -max_size); // 4 add cx
    write_mem<int>(0x00447797 + 1, max_size); // 3 cx
    write_mem<int>(0x00447761 + 1, max_size); // 3 cy
    write_mem<int>(0x004477A0 + 2, -max_size); // 3 lea
    write_mem<int>(0x004477EE + 2, -max_size); // 4 lea

    // Fix editor crash when building geometry after lightmap resolution for a face was set to Undefined
    write_mem<i8>(0x00402DFA + 1, 0);

    // Allow more decals before displaying a warning message about too many decals in the level
    write_mem<i8>(0x0041E2A9 + 2, 127);
    write_mem<i8>(0x0041E2BA + 2, 127);
    write_mem_ptr(0x0041E2C6 + 1, "There are more than 127 decals in the level! It can result in a crash for older game clients.");

    // Fix copying cutscene path node
    CDedLevel_CloneObject_injection.install();

    // Copy geoable/breakable properties when duplicating or pasting brushes
    brush_clone_copy_alpine_props_injection.install();
    brush_clone_from_alpine_hook.install();
    brush_paste_apply_alpine_props.install();

    // Fix copying bool2 field in events
    CDedEvent_Copy_injection.install();

    // Remove uid limit (50k) by removing cmp and jge instructions in FindBiggestUid function
    AsmWriter{0x004844AC, 0x004844B3}.nop();

    // Ignore textures with filename longer than 31 characters to avoid buffer overflow errors
    texture_name_buffer_overflow_injection1.install();
    texture_name_buffer_overflow_injection2.install();

    // Increase face limit in g_boolean_find_all_pairs
    static void *found_faces_a[0x10000];
    static void *found_faces_b[0x10000];
    write_mem_ptr(0x004A7290+3, found_faces_a);
    write_mem_ptr(0x004A7158+1, found_faces_a);
    write_mem_ptr(0x004A72E5+4, found_faces_a);
    write_mem_ptr(0x004A717D+1, found_faces_b);
    write_mem_ptr(0x004A71A6+1, found_faces_b);
    write_mem_ptr(0x004A72A2+3, found_faces_b);
    write_mem_ptr(0x004A72F9+1, found_faces_b);

    // Display geometry limits according to pools sizes
    //write_mem<std::uint32_t>(0x0043A49D + 1, 30000);
    //write_mem<std::uint32_t>(0x0043A4C1 + 1, 150000);
    //write_mem<std::uint32_t>(0x0043A4E5 + 1, 50000);

    // Disable red background if geometry limits are crossed
    AsmWriter{0x0043A528, 0x0043A546}.nop();

    // Fix clip tool sometimes doing nothing on diagonal clip lines
    line_aabb_intersect_hook.install();

    // Fix crash when rotating objects with null sub-object pointer at +0xA4
    object_rotation_update_hook.install();

    // Subclass face mode panel for Delete/Delete Ext./Split button handling
    face_panel_subclass_injection.install();

    return 1; // success
}

extern "C" void subhook_unk_opcode_handler(uint8_t* opcode)
{
    xlog::error("SubHook unknown opcode 0x{:x} at {}", *opcode, static_cast<void*>(opcode));
}

BOOL WINAPI DllMain(HINSTANCE instance, [[maybe_unused]] DWORD reason, [[maybe_unused]] LPVOID reserved)
{
    g_module = (HMODULE)instance;
    DisableThreadLibraryCalls(instance);
    return TRUE;
}