OpenScript.cpp

// OpenScript 1.5 - A simple script creator and editor
// This code is designed to be compiled with a C++17 compliant compiler and linked against the Windows API libraries.
// It provides basic text editing functionalities including file operations, find/replace, word wrap, font selection, and printing.
// Copyright (C) 2026 R.J. Dohnert
// This program is free software licensed under the BSD-3 Clause
// You can redistribute it and/or modify it under the terms of the BSD-3 Clause.

#include <windows.h>
#include <commdlg.h>
#include <string>
#include <algorithm>
#include <cwctype>
#include <shellapi.h>
#include <richedit.h>

#ifndef IDI_APP_ICON
#define IDI_APP_ICON 101
#endif

// Link essential Windows libraries (especially helpful for MSVC/VS Code)
#pragma comment(lib, "user32.lib")
#pragma comment(lib, "gdi32.lib")
#pragma comment(lib, "comdlg32.lib")
// Shell functions (icon extraction)
#pragma comment(lib, "shell32.lib")

// Define Resources and Menu IDs
#define IDC_EDIT          1
#define IDC_LINE_NUMBERS  2
#define IDM_FILE_NEW      1001
#define IDM_FILE_OPEN     1002
#define IDM_FILE_SAVE     1003
#define IDM_FILE_SAVE_AS  1004
#define IDM_FILE_PRINT    1005
#define IDM_FILE_EXIT     1006
#define IDM_EDIT_FIND     1007
#define IDM_EDIT_REPLACE  1008
#define IDM_EDIT_LINE_NUMBERS 1012
#define IDM_HELP_ABOUT    1011
#define IDM_VIEW_SHOW_TERMINAL 1013
#define IDM_INSERT_CMD_IF       1014
#define IDM_INSERT_CMD_FOR      1015
#define IDM_INSERT_CMD_ECHO     1016
#define IDM_INSERT_CMD_POWERSHELL_FOREACH 1017
#define IDM_INSERT_VAR_ERRORLEVEL 1018
#define IDM_INSERT_VAR_BATCH_SCRIPT_DIR 1019
#define IDM_INSERT_VAR_PS_SCRIPT_ROOT 1020
#define IDM_INSERT_VAR_PS_PATH 1021
#define IDM_INSERT_CMD_CD       1022
#define IDM_INSERT_CMD_DIR      1023
#define IDM_INSERT_CMD_COPY     1024
#define IDM_INSERT_CMD_DEL      1025
#define IDM_INSERT_CMD_SET      1026
#define IDM_INSERT_CMD_PAUSE    1027
#define WM_APP_PROCESS_TERMINATED (WM_APP + 1)

// Common UI constants
static const int PRINT_MARGIN = 100;

// Global variables for window states
HWND hwndEdit = NULL;
HWND hwndLineNumbers = NULL;
HFONT hFont = NULL;
HWND hwndFindDlg = NULL;
UINT uFindReplaceMsg = 0;
FINDREPLACEW fr;
wchar_t szFindWhat[256] = L"";
wchar_t szReplaceWith[256] = L"";
wchar_t szFileName[MAX_PATH] = L"";
wchar_t szSettingsPath[MAX_PATH] = L"";
bool bWordWrap = true;
bool bShowLineNumbers = false;
bool bIsModified = false;
HICON hAppIcon = NULL;
HICON hAppIconSmall = NULL;
HMODULE g_hMsftEdit = NULL;
bool g_isApplyingHighlight = false;
HANDLE g_hWatchedProcess = NULL;
HANDLE g_hProcessExitWait = NULL;

// Subclass procedure and line number sync state
WNDPROC g_OriginalEditProc = NULL;
int g_prevLineCount = -1;

void CleanupProcessWatch() {
    if (g_hProcessExitWait) {
        UnregisterWaitEx(g_hProcessExitWait, INVALID_HANDLE_VALUE);
        g_hProcessExitWait = NULL;
    }
    if (g_hWatchedProcess) {
        CloseHandle(g_hWatchedProcess);
        g_hWatchedProcess = NULL;
    }
}

VOID CALLBACK OnWatchedProcessExit(PVOID context, BOOLEAN) {
    HWND hwnd = (HWND)context;
    if (hwnd) {
        PostMessageW(hwnd, WM_APP_PROCESS_TERMINATED, 0, 0);
    }
}

enum class ScriptLang {
    None,
    Batch,
    Shell,
    PowerShell
};

bool IsWordChar(wchar_t ch) {
    return (std::iswalnum(ch) != 0) || ch == L'_' || ch == L'-';
}

bool IsKeyword(const std::wstring& token, const wchar_t* const* keywords, int count) {
    for (int i = 0; i < count; ++i) {
        if (token == keywords[i]) {
            return true;
        }
    }
    return false;
}

ScriptLang DetectScriptLanguage() {
    if (wcslen(szFileName) == 0) return ScriptLang::None;

    const wchar_t* dot = wcsrchr(szFileName, L'.');
    if (!dot || dot[1] == L'\0') return ScriptLang::None;

    std::wstring ext(dot + 1);
    std::transform(ext.begin(), ext.end(), ext.begin(), ::towlower);

    if (ext == L"cmd" || ext == L"bat") return ScriptLang::Batch;
    if (ext == L"sh" || ext == L"ksh") return ScriptLang::Shell;
    if (ext == L"ps1") return ScriptLang::PowerShell;
    return ScriptLang::None;
}

void ApplyColorRange(int start, int end, COLORREF color) {
    if (end <= start) return;

    CHARRANGE cr = { start, end };
    SendMessageW(hwndEdit, EM_EXSETSEL, 0, (LPARAM)&cr);

    CHARFORMAT2W cf;
    ZeroMemory(&cf, sizeof(cf));
    cf.cbSize = sizeof(cf);
    cf.dwMask = CFM_COLOR;
    cf.crTextColor = color;
    SendMessageW(hwndEdit, EM_SETCHARFORMAT, SCF_SELECTION, (LPARAM)&cf);
}

void ApplySyntaxHighlighting() {
    if (!hwndEdit || g_isApplyingHighlight) return;

    ScriptLang lang = DetectScriptLanguage();
    if (lang == ScriptLang::None) return;

    int len = GetWindowTextLengthW(hwndEdit);
    if (len <= 0 || len > 200000) return;

    std::wstring text;
    text.resize(len + 1);
    int copied = GetWindowTextW(hwndEdit, &text[0], len + 1);
    text.resize(copied);

    static const wchar_t* batchKeywords[] = {
        L"if", L"else", L"for", L"in", L"do", L"goto", L"call", L"set", L"setlocal", L"endlocal",
        L"echo", L"pause", L"shift", L"exit", L"not", L"exist", L"defined", L"errorlevel", L"choice", L"timeout",
        L"enabledelayedexpansion", L"disabledelayedexpansion", L"equ", L"neq", L"lss", L"leq", L"gtr", L"geq",
        L"cmdextversion", L"verify", L"assoc", L"attrib", L"break", L"cd", L"chdir", L"cls", L"color", L"copy",
        L"date", L"del", L"erase", L"dir", L"ftype", L"md", L"mkdir", L"mklink", L"move", L"path",
        L"popd", L"prompt", L"pushd", L"rd", L"rmdir", L"ren", L"rename", L"start", L"title", L"type",
        L"ver", L"vol", L"where", L"setx"
    };
    static const wchar_t* shellKeywords[] = {
        L"if", L"then", L"else", L"elif", L"fi", L"for", L"while", L"do", L"done", L"case", L"esac",
        L"function", L"in", L"select", L"until", L"break", L"continue", L"return", L"exit", L"local", L"export",
        L"readonly", L"typeset", L"declare", L"integer", L"float", L"alias", L"unalias", L"unset", L"source",
        L"exec", L"eval", L"trap", L"times", L"umask", L"wait", L"shift", L"getopts", L"set", L"test",
        L"true", L"false", L"coproc", L"time", L"let", L"printf", L"read", L"mapfile", L"array", L"typeset"
    };
    static const wchar_t* psKeywords[] = {
        L"if", L"else", L"elseif", L"switch", L"for", L"foreach", L"while", L"do", L"until", L"function",
        L"filter", L"param", L"begin", L"process", L"end", L"return", L"break", L"continue", L"trap", L"throw",
        L"try", L"catch", L"finally", L"in", L"data", L"dynamicparam", L"class", L"enum", L"hidden", L"using",
        L"workflow", L"parallel", L"sequence", L"configuration", L"from", L"define", L"var", L"exit", L"default"
    };
    static const wchar_t* psCmdlets[] = {
        L"get-item", L"set-item", L"new-item", L"remove-item", L"clear-item", L"copy-item", L"move-item", L"rename-item",
        L"get-childitem", L"resolve-path", L"convert-path", L"join-path", L"split-path", L"test-path", L"new-psdrive", L"remove-psdrive",
        L"get-content", L"set-content", L"add-content", L"clear-content", L"get-location", L"set-location", L"push-location", L"pop-location",
        L"get-acl", L"set-acl", L"get-service", L"start-service", L"stop-service", L"restart-service", L"suspend-service", L"resume-service",
        L"new-service", L"set-service", L"get-process", L"start-process", L"stop-process", L"wait-process", L"debug-process",
        L"get-command", L"get-help", L"get-member", L"select-object", L"where-object", L"forEach-object", L"measure-object",
        L"sort-object", L"group-object", L"compare-object", L"tee-object", L"new-object", L"add-member", L"get-variable", L"set-variable",
        L"clear-variable", L"remove-variable", L"get-alias", L"set-alias", L"new-alias", L"export-alias", L"import-alias",
        L"get-date", L"set-date", L"get-random", L"get-unique", L"write-output", L"write-host", L"write-warning", L"write-error",
        L"write-verbose", L"write-debug", L"write-information", L"write-progress", L"read-host", L"out-host", L"out-file", L"out-string",
        L"out-null", L"out-gridview", L"format-table", L"format-list", L"format-wide", L"format-custom", L"convertto-json", L"convertfrom-json",
        L"convertto-csv", L"convertfrom-csv", L"export-csv", L"import-csv", L"convertto-xml", L"select-string", L"start-sleep", L"start-job",
        L"stop-job", L"wait-job", L"receive-job", L"get-job", L"remove-job", L"invoke-command", L"invoke-expression", L"invoke-item",
        L"get-history", L"add-history", L"clear-history", L"get-event", L"new-event", L"remove-event", L"get-eventsubscriber",
        L"register-objectevent", L"unregister-event", L"get-psprovider", L"get-psdrive", L"get-module", L"import-module", L"remove-module",
        L"new-module", L"find-module", L"install-module", L"update-module", L"save-module", L"publish-module", L"get-package", L"find-package",
        L"install-package", L"uninstall-package", L"save-package", L"get-credential", L"get-culture", L"get-uiculture", L"get-timezone",
        L"set-timezone", L"get-winuserlanguageList", L"set-winuserlanguageList", L"new-timespan", L"get-filehash", L"get-authenticodesignature",
        L"set-authenticodesignature", L"expand-archive", L"compress-archive", L"get-computerinfo", L"get-hotfix", L"get-ciminstance",
        L"new-cimsession", L"remove-cimsession", L"get-wmiobject", L"invoke-webrequest", L"invoke-restmethod", L"new-webserviceproxy",
        L"enter-pssession", L"exit-pssession", L"new-pssession", L"remove-pssession", L"get-pssession", L"test-connection", L"get-netipaddress",
        L"get-netadapter", L"get-dnsclientserveraddress", L"get-scheduledtask", L"register-scheduledtask", L"unregister-scheduledtask",
        L"start-transcript", L"stop-transcript", L"set-executionpolicy", L"get-executionpolicy", L"about", L"help"
    };

    const wchar_t* const* keywords = NULL;
    int keywordCount = 0;
    const wchar_t* const* cmdlets = NULL;
    int cmdletCount = 0;
    if (lang == ScriptLang::Batch) {
        keywords = batchKeywords;
        keywordCount = (int)(sizeof(batchKeywords) / sizeof(batchKeywords[0]));
    } else if (lang == ScriptLang::Shell) {
        keywords = shellKeywords;
        keywordCount = (int)(sizeof(shellKeywords) / sizeof(shellKeywords[0]));
    } else {
        keywords = psKeywords;
        keywordCount = (int)(sizeof(psKeywords) / sizeof(psKeywords[0]));
        cmdlets = psCmdlets;
        cmdletCount = (int)(sizeof(psCmdlets) / sizeof(psCmdlets[0]));
    }

    const COLORREF defaultColor = RGB(0, 0, 0);
    const COLORREF keywordColor = RGB(0, 0, 180);
    const COLORREF cmdletColor = RGB(121, 94, 38);
    const COLORREF stringColor = RGB(163, 21, 21);
    const COLORREF commentColor = RGB(0, 128, 0);

    g_isApplyingHighlight = true;
    SendMessageW(hwndEdit, WM_SETREDRAW, FALSE, 0);

    CHARRANGE savedSel;
    SendMessageW(hwndEdit, EM_EXGETSEL, 0, (LPARAM)&savedSel);

    ApplyColorRange(0, copied, defaultColor);

    const int n = copied;
    int i = 0;
    while (i < n) {
        bool lineStart = (i == 0 || text[i - 1] == L'\n');

        if (lineStart && lang == ScriptLang::Batch) {
            int j = i;
            while (j < n && (text[j] == L' ' || text[j] == L'\t')) j++;

            if (j + 1 < n && text[j] == L':' && text[j + 1] == L':') {
                int k = j;
                while (k < n && text[k] != L'\n') k++;
                ApplyColorRange(j, k, commentColor);
                i = k;
                continue;
            }

            if (j + 2 < n) {
                wchar_t c0 = (wchar_t)towlower(text[j]);
                wchar_t c1 = (wchar_t)towlower(text[j + 1]);
                wchar_t c2 = (wchar_t)towlower(text[j + 2]);
                if (c0 == L'r' && c1 == L'e' && c2 == L'm') {
                    wchar_t next = (j + 3 < n) ? text[j + 3] : L'\n';
                    if (next == L' ' || next == L'\t' || next == L'\r' || next == L'\n') {
                        int k = j;
                        while (k < n && text[k] != L'\n') k++;
                        ApplyColorRange(j, k, commentColor);
                        i = k;
                        continue;
                    }
                }
            }
        }

        if ((lang == ScriptLang::Shell || lang == ScriptLang::PowerShell) && text[i] == L'#') {
            int k = i;
            while (k < n && text[k] != L'\n') k++;
            ApplyColorRange(i, k, commentColor);
            i = k;
            continue;
        }

        bool isStringStart = false;
        wchar_t quote = L'\0';
        if (lang == ScriptLang::Batch) {
            isStringStart = (text[i] == L'"');
            quote = L'"';
        } else {
            isStringStart = (text[i] == L'"' || text[i] == L'\'');
            quote = text[i];
        }

        if (isStringStart) {
            int k = i + 1;
            while (k < n) {
                if (text[k] == quote) {
                    k++;
                    break;
                }
                if (text[k] == L'\\' && k + 1 < n) {
                    k += 2;
                    continue;
                }
                k++;
            }
            ApplyColorRange(i, k, stringColor);
            i = k;
            continue;
        }

        if (IsWordChar(text[i])) {
            int start = i;
            while (i < n && IsWordChar(text[i])) i++;

            std::wstring token = text.substr(start, i - start);
            std::transform(token.begin(), token.end(), token.begin(), ::towlower);
            if (IsKeyword(token, keywords, keywordCount)) {
                ApplyColorRange(start, i, keywordColor);
            } else if (lang == ScriptLang::PowerShell && cmdlets && IsKeyword(token, cmdlets, cmdletCount)) {
                ApplyColorRange(start, i, cmdletColor);
            }
            continue;
        }

        i++;
    }

    SendMessageW(hwndEdit, EM_EXSETSEL, 0, (LPARAM)&savedSel);
    SendMessageW(hwndEdit, WM_SETREDRAW, TRUE, 0);
    InvalidateRect(hwndEdit, NULL, TRUE);
    g_isApplyingHighlight = false;
}

void InitializeSettingsPath() {
    if (GetModuleFileNameW(NULL, szSettingsPath, MAX_PATH) == 0) {
        wcscpy_s(szSettingsPath, L"openscript.ini");
        return;
    }

    wchar_t* lastSlash = wcsrchr(szSettingsPath, L'\\');
    if (lastSlash) {
        *(lastSlash + 1) = L'\0';
        wcscat_s(szSettingsPath, L"openscript.ini");
    } else {
        wcscpy_s(szSettingsPath, L"openscript.ini");
    }
}

void LoadAppSettings() {
    bShowLineNumbers = GetPrivateProfileIntW(L"View", L"LineNumbers", 0, szSettingsPath) != 0;
}

void SaveAppSettings() {
    WritePrivateProfileStringW(L"View", L"LineNumbers", bShowLineNumbers ? L"1" : L"0", szSettingsPath);
}

int GetLineNumberGutterWidth(HWND hwndParent) {
    int lineCount = (int)SendMessageW(hwndEdit, EM_GETLINECOUNT, 0, 0);
    if (lineCount < 1) lineCount = 1;

    int digits = 1;
    int temp = lineCount;
    while (temp >= 10) {
        temp /= 10;
        digits++;
    }

    HDC hdc = GetDC(hwndParent);
    HFONT hOldFont = NULL;
    if (hFont) {
        hOldFont = (HFONT)SelectObject(hdc, hFont);
    }

    TEXTMETRICW tm;
    GetTextMetricsW(hdc, &tm);

    if (hOldFont) {
        SelectObject(hdc, hOldFont);
    }
    ReleaseDC(hwndParent, hdc);

    return 12 + (digits * tm.tmAveCharWidth) + 8;
}

void LayoutEditorControls(HWND hwndParent) {
    RECT rect;
    GetClientRect(hwndParent, &rect);

    if (bShowLineNumbers && hwndLineNumbers) {
        int gutterWidth = GetLineNumberGutterWidth(hwndParent);
        MoveWindow(hwndLineNumbers, 0, 0, gutterWidth, rect.bottom, TRUE);
        ShowWindow(hwndLineNumbers, SW_SHOW);
        MoveWindow(hwndEdit, gutterWidth, 0, rect.right - gutterWidth, rect.bottom, TRUE);
    } else {
        if (hwndLineNumbers) {
            ShowWindow(hwndLineNumbers, SW_HIDE);
        }
        MoveWindow(hwndEdit, 0, 0, rect.right, rect.bottom, TRUE);
    }
}

void SyncLineNumberScroll() {
    if (!bShowLineNumbers || !hwndLineNumbers || !hwndEdit) return;

    int firstMain = (int)SendMessageW(hwndEdit, EM_GETFIRSTVISIBLELINE, 0, 0);
    int firstNums = (int)SendMessageW(hwndLineNumbers, EM_GETFIRSTVISIBLELINE, 0, 0);
    int delta = firstMain - firstNums;
    if (delta != 0) {
        SendMessageW(hwndLineNumbers, EM_LINESCROLL, 0, delta);
    }
}

LRESULT CALLBACK EditSubclassProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam) {
    if (!g_OriginalEditProc) {
        return DefWindowProcW(hwnd, message, wParam, lParam);
    }

    LRESULT res = CallWindowProcW(g_OriginalEditProc, hwnd, message, wParam, lParam);
    
    // Sync line number scrolling after relevant messages are processed
    if (message == WM_VSCROLL || message == WM_MOUSEWHEEL || 
        message == WM_KEYDOWN || message == WM_KEYUP || 
        message == WM_LBUTTONDOWN || message == WM_LBUTTONUP || 
        message == WM_MOUSEMOVE) {
        SyncLineNumberScroll();
    }
    
    return res;
}

void UpdateLineNumbers(HWND hwndParent) {
    if (!hwndLineNumbers || !hwndEdit) return;

    int textLen = GetWindowTextLengthW(hwndEdit);
    std::wstring text;
    if (textLen > 0) {
        text.resize(textLen + 1);
        int copied = GetWindowTextW(hwndEdit, &text[0], textLen + 1);
        text.resize(copied);
    }

    int lineCount = (int)SendMessageW(hwndEdit, EM_GETLINECOUNT, 0, 0);
    if (lineCount < 1) lineCount = 1;

    std::wstring numbers;
    numbers.reserve(lineCount * 6);
    
    int currentLogicalLine = 1;
    wchar_t lineNum[32];

    for (int i = 0; i < lineCount; ++i) {
        int charIndex = (int)SendMessageW(hwndEdit, EM_LINEINDEX, i, 0);
        bool isNewLogicalLine = false;

        if (charIndex == 0) {
            isNewLogicalLine = true;
        } else if (charIndex > 0 && charIndex <= (int)text.length()) {
            if (text[charIndex - 1] == L'\n') {
                isNewLogicalLine = true;
            }
        }

        if (isNewLogicalLine) {
            swprintf_s(lineNum, L"%d\r\n", currentLogicalLine);
            numbers += lineNum;
            currentLogicalLine++;
        } else {
            numbers += L"\r\n";
        }
    }

    int currentLen = GetWindowTextLengthW(hwndLineNumbers);
    std::wstring currentNumbers;
    if (currentLen > 0) {
        currentNumbers.resize(currentLen + 1);
        int copied = GetWindowTextW(hwndLineNumbers, &currentNumbers[0], currentLen + 1);
        currentNumbers.resize(copied);
    }

    if (numbers != currentNumbers) {
        SetWindowTextW(hwndLineNumbers, numbers.c_str());
        LayoutEditorControls(hwndParent);
    }

    SyncLineNumberScroll();
}

// Conversion helper: UTF-8 standard string to Wide UTF-16
std::wstring Utf8ToWstring(const std::string& str) {
    if (str.empty()) return L"";
    int size_needed = MultiByteToWideChar(CP_UTF8, 0, &str[0], (int)str.size(), NULL, 0);
    std::wstring wstrTo(size_needed, 0);
    MultiByteToWideChar(CP_UTF8, 0, &str[0], (int)str.size(), &wstrTo[0], size_needed);
    return wstrTo;
}

// Conversion helper: Wide UTF-16 to UTF-8 standard string
std::string WstringToUtf8(const std::wstring& wstr) {
    if (wstr.empty()) return "";
    int size_needed = WideCharToMultiByte(CP_UTF8, 0, &wstr[0], (int)wstr.size(), NULL, 0, NULL, NULL);
    std::string strTo(size_needed, 0);
    WideCharToMultiByte(CP_UTF8, 0, &wstr[0], (int)wstr.size(), &strTo[0], size_needed, NULL, NULL);
    return strTo;
}

// Update the application's title bar based on current open file
void UpdateWindowTitle(HWND hwnd) {
    std::wstring title = L"OpenScript 1.5";
    std::wstring prefix = bIsModified ? L"*" : L"";
    if (wcslen(szFileName) > 0) {
        wchar_t* p = wcsrchr(szFileName, L'\\');
        if (p) {
            title = prefix + (p + 1) + L" - " + title;
        } else {
            title = prefix + szFileName + L" - " + title;
        }
    } else {
        title = prefix + L"Untitled - " + title;
    }
    SetWindowTextW(hwnd, title.c_str());
}

void LoadFile(HWND hwnd, const wchar_t* filePath) {
    wchar_t szFullPath[MAX_PATH];
    DWORD retval = GetFullPathNameW(filePath, MAX_PATH, szFullPath, NULL);
    const wchar_t* targetPath = (retval > 0 && retval < MAX_PATH) ? szFullPath : filePath;

    HANDLE hFile = CreateFileW(targetPath, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
    if (hFile != INVALID_HANDLE_VALUE) {
        DWORD dwSize = GetFileSize(hFile, NULL);
        if (dwSize != INVALID_FILE_SIZE) {
            // Safeguard against opening files larger than 20MB
            if (dwSize > 20 * 1024 * 1024) {
                MessageBoxW(hwnd, L"File is too large to open in OpenScript (limit is 20 MB).", L"Error", MB_OK | MB_ICONERROR);
                CloseHandle(hFile);
                return;
            }

            std::string buffer(dwSize, '\0');
            DWORD dwRead;
            if (ReadFile(hFile, &buffer[0], dwSize, &dwRead, NULL)) {
                buffer.resize(dwRead);
                
                // Strip UTF-8 BOM if present (\xEF\xBB\xBF)
                if (buffer.size() >= 3 && 
                    (unsigned char)buffer[0] == 0xEF && 
                    (unsigned char)buffer[1] == 0xBB && 
                    (unsigned char)buffer[2] == 0xBF) {
                    buffer.erase(0, 3);
                }

                std::wstring wtext = Utf8ToWstring(buffer);
                SetWindowTextW(hwndEdit, wtext.c_str());
                wcscpy_s(szFileName, targetPath);
                bIsModified = false;
                g_prevLineCount = -1; // Reset gutter line count cache to force update
                UpdateWindowTitle(hwnd);
                ApplySyntaxHighlighting();
            } else {
                MessageBoxW(hwnd, L"Failed to read file.", L"Error", MB_OK | MB_ICONERROR);
            }
        } else {
            MessageBoxW(hwnd, L"Failed to get file size.", L"Error", MB_OK | MB_ICONERROR);
        }
        CloseHandle(hFile);
    } else {
        MessageBoxW(hwnd, L"Failed to open file.", L"Error", MB_OK | MB_ICONERROR);
    }
}

// Dialog helper to open standard files
void DoFileOpen(HWND hwnd) {
    OPENFILENAMEW ofn;
    ZeroMemory(&ofn, sizeof(ofn));
    ofn.lStructSize = sizeof(ofn);
    ofn.hwndOwner = hwnd;
    ofn.lpstrFilter =
        L"Script Files (*.ksh;*.cmd;*.bat;*.sh;*.ps1)\0*.ksh;*.cmd;*.bat;*.sh;*.ps1\0"
        L"Text Files (*.txt)\0*.txt\0"
        L"All Files (*.*)\0*.*\0";
    ofn.lpstrFile = szFileName;
    ofn.nMaxFile = MAX_PATH;
    ofn.Flags = OFN_EXPLORER | OFN_FILEMUSTEXIST | OFN_HIDEREADONLY;
    ofn.lpstrDefExt = L"txt";

    if (GetOpenFileNameW(&ofn)) {
        LoadFile(hwnd, szFileName);
    }
}

// Dialog helper to save standard files. Returns true if saved, false if cancelled/failed.
bool DoFileSave(HWND hwnd, bool bSaveAs) {
    if (bSaveAs || wcslen(szFileName) == 0) {
        OPENFILENAMEW ofn;
        ZeroMemory(&ofn, sizeof(ofn));
        ofn.lStructSize = sizeof(ofn);
        ofn.hwndOwner = hwnd;
        ofn.lpstrFilter =
            L"Script Files (*.ksh;*.cmd;*.bat;*.sh;*.ps1)\0*.ksh;*.cmd;*.bat;*.sh;*.ps1\0"
            L"Text Files (*.txt)\0*.txt\0"
            L"All Files (*.*)\0*.*\0";
        ofn.lpstrFile = szFileName;
        ofn.nMaxFile = MAX_PATH;
        ofn.Flags = OFN_EXPLORER | OFN_PATHMUSTEXIST | OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT;
        ofn.lpstrDefExt = L"txt";

        if (!GetSaveFileNameW(&ofn)) {
            return false;
        }
    }

    int len = GetWindowTextLengthW(hwndEdit);
    std::wstring wtext;
    if (len > 0) {
        wtext.resize(len + 1);
        int copied = GetWindowTextW(hwndEdit, &wtext[0], len + 1);
        wtext.resize(copied);
    }

    std::string text = WstringToUtf8(wtext);

    HANDLE hFile = CreateFileW(szFileName, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
    if (hFile != INVALID_HANDLE_VALUE) {
        DWORD dwWritten;
        BOOL bSuccess = WriteFile(hFile, text.c_str(), (DWORD)text.size(), &dwWritten, NULL);
        CloseHandle(hFile);
        if (bSuccess) {
            bIsModified = false;
            UpdateWindowTitle(hwnd);
            return true;
        } else {
            MessageBoxW(hwnd, L"Failed to write to file.", L"Error", MB_OK | MB_ICONERROR);
        }
    } else {
        MessageBoxW(hwnd, L"Failed to create file.", L"Error", MB_OK | MB_ICONERROR);
    }
    return false;
}

// Perform simple case-sensitive or insensitive text searches
void DoFindText(LPFINDREPLACEW lpfr) {
    int len = GetWindowTextLengthW(hwndEdit);
    std::wstring text;
    if (len > 0) {
        text.resize(len + 1);
        int copied = GetWindowTextW(hwndEdit, &text[0], len + 1);
        text.resize(copied);
    }

    DWORD startSel, endSel;
    SendMessageW(hwndEdit, EM_GETSEL, (WPARAM)&startSel, (LPARAM)&endSel);

    std::wstring searchStr(lpfr->lpstrFindWhat);
    if (searchStr.empty()) return;

    size_t startPos = 0;
    bool bDown = (lpfr->Flags & FR_DOWN) != 0;
    bool bMatchCase = (lpfr->Flags & FR_MATCHCASE) != 0;

    std::wstring textToSearch = text;
    std::wstring query = searchStr;
    if (!bMatchCase) {
        std::transform(textToSearch.begin(), textToSearch.end(), textToSearch.begin(), ::towlower);
        std::transform(query.begin(), query.end(), query.begin(), ::towlower);
    }

    size_t foundPos = std::wstring::npos;
    if (bDown) {
        startPos = (startSel == endSel) ? startSel : endSel;
        if (startPos < textToSearch.length()) {
            foundPos = textToSearch.find(query, startPos);
        }
    } else {
        startPos = startSel;
        if (startPos > 0) {
            foundPos = textToSearch.rfind(query, startPos - 1);
        }
    }

    if (foundPos != std::wstring::npos) {
        SendMessageW(hwndEdit, EM_SETSEL, foundPos, foundPos + query.length());
        SendMessageW(hwndEdit, EM_SCROLLCARET, 0, 0);
        SetFocus(hwndEdit);
    } else {
        MessageBoxW(lpfr->hwndOwner, L"Cannot find text.", L"Find", MB_OK | MB_ICONINFORMATION);
    }
}

// Find and replace text at current selection
void DoReplaceText(LPFINDREPLACEW lpfr) {
    DWORD startSel, endSel;
    SendMessageW(hwndEdit, EM_GETSEL, (WPARAM)&startSel, (LPARAM)&endSel);

    int len = GetWindowTextLengthW(hwndEdit);
    std::wstring text;
    if (len > 0) {
        text.resize(len + 1);
        int copied = GetWindowTextW(hwndEdit, &text[0], len + 1);
        text.resize(copied);
    }

    std::wstring searchStr(lpfr->lpstrFindWhat);
    std::wstring replaceStr(lpfr->lpstrReplaceWith);
    bool bMatchCase = (lpfr->Flags & FR_MATCHCASE) != 0;

    if (startSel != endSel && endSel <= text.length()) {
        std::wstring selText = text.substr(startSel, endSel - startSel);
        std::wstring matchText = selText;
        std::wstring query = searchStr;
        if (!bMatchCase) {
            std::transform(matchText.begin(), matchText.end(), matchText.begin(), ::towlower);
            std::transform(query.begin(), query.end(), query.begin(), ::towlower);
        }

        if (matchText == query) {
            SendMessageW(hwndEdit, EM_REPLACESEL, TRUE, (LPARAM)replaceStr.c_str());
        }
    }
    DoFindText(lpfr);
}

// Global find and replace all matches
void DoReplaceAllText(LPFINDREPLACEW lpfr) {
    int len = GetWindowTextLengthW(hwndEdit);
    std::wstring text;
    if (len > 0) {
        text.resize(len + 1);
        int copied = GetWindowTextW(hwndEdit, &text[0], len + 1);
        text.resize(copied);
    }

    std::wstring searchStr(lpfr->lpstrFindWhat);
    std::wstring replaceStr(lpfr->lpstrReplaceWith);
    if (searchStr.empty()) return;

    bool bMatchCase = (lpfr->Flags & FR_MATCHCASE) != 0;

    std::wstring textToSearch = text;
    std::wstring query = searchStr;
    if (!bMatchCase) {
        std::transform(textToSearch.begin(), textToSearch.end(), textToSearch.begin(), ::towlower);
        std::transform(query.begin(), query.end(), query.begin(), ::towlower);
    }

    std::wstring newText;
    size_t currentPos = 0;
    size_t foundPos = textToSearch.find(query, currentPos);
    int replaceCount = 0;

    while (foundPos != std::wstring::npos) {
        newText += text.substr(currentPos, foundPos - currentPos);
        newText += replaceStr;
        currentPos = foundPos + query.length();
        foundPos = textToSearch.find(query, currentPos);
        replaceCount++;
    }
    newText += text.substr(currentPos);

    if (replaceCount > 0) {
        SetWindowTextW(hwndEdit, newText.c_str());
        bIsModified = true;
        wchar_t msg[128];
        swprintf_s(msg, L"Replaced %d occurrences.", replaceCount);
        MessageBoxW(lpfr->hwndOwner, msg, L"Replace All", MB_OK | MB_ICONINFORMATION);
    } else {
        MessageBoxW(lpfr->hwndOwner, L"Cannot find text to replace.", L"Replace All", MB_OK | MB_ICONINFORMATION);
    }
}

// Instantiate Modeless Find Dialog
void ShowFindDialog(HWND hwnd) {
    if (hwndFindDlg) {
        SetFocus(hwndFindDlg);
        return;
    }
    ZeroMemory(&fr, sizeof(fr));
    fr.lStructSize = sizeof(fr);
    fr.hwndOwner = hwnd;
    fr.lpstrFindWhat = szFindWhat;
    fr.wFindWhatLen = sizeof(szFindWhat) / sizeof(wchar_t);
    fr.Flags = FR_DOWN;
    hwndFindDlg = FindTextW(&fr);
}

// Instantiate Modeless Replace Dialog
void ShowReplaceDialog(HWND hwnd) {
    if (hwndFindDlg) {
        SetFocus(hwndFindDlg);
        return;
    }
    ZeroMemory(&fr, sizeof(fr));
    fr.lStructSize = sizeof(fr);
    fr.hwndOwner = hwnd;
    fr.lpstrFindWhat = szFindWhat;
    fr.wFindWhatLen = sizeof(szFindWhat) / sizeof(wchar_t);
    fr.lpstrReplaceWith = szReplaceWith;
    fr.wReplaceWithLen = sizeof(szReplaceWith) / sizeof(wchar_t);
    fr.Flags = FR_DOWN;
    hwndFindDlg = ReplaceTextW(&fr);
}

// Print text using Windows GDI, adjusting for high-DPI printer metrics and margins
void DoFilePrint(HWND hwnd) {
    PRINTDLGW pd;
    ZeroMemory(&pd, sizeof(pd));
    pd.lStructSize = sizeof(pd);
    pd.hwndOwner = hwnd;
    pd.Flags = PD_RETURNDC | PD_NOPAGENUMS | PD_NOSELECTION;

    if (PrintDlgW(&pd)) {
        DOCINFOW di = { sizeof(DOCINFOW), L"Text Editor Print Output" };
        if (StartDocW(pd.hDC, &di) > 0) {
            StartPage(pd.hDC);

            LOGFONTW lf;
            if (hFont == NULL || GetObjectW(hFont, sizeof(LOGFONTW), &lf) == 0) {
                // Fall back to a default GUI font if the editor font is unavailable
                GetObjectW(GetStockObject(DEFAULT_GUI_FONT), sizeof(LOGFONTW), &lf);
            }

            HDC hScreenDC = GetDC(NULL);
            int screenY = GetDeviceCaps(hScreenDC, LOGPIXELSY);
            int printY = GetDeviceCaps(pd.hDC, LOGPIXELSY);
            ReleaseDC(NULL, hScreenDC);

            // Scale screen-font sizes to printer units
            lf.lfHeight = MulDiv(lf.lfHeight, printY, screenY);
            lf.lfWidth = 0;

            HFONT hPrintFont = CreateFontIndirectW(&lf);
            HFONT hOldFont = NULL;
            if (hPrintFont) {
                hOldFont = (HFONT)SelectObject(pd.hDC, hPrintFont);
            }

            TEXTMETRICW tm;
            GetTextMetricsW(pd.hDC, &tm);
            int lineHeight = tm.tmHeight + tm.tmExternalLeading;

            int pageHeight = GetDeviceCaps(pd.hDC, VERTRES);
            int pageWidth = GetDeviceCaps(pd.hDC, HORZRES);
            int y = PRINT_MARGIN; // Top margin offset

            int len = GetWindowTextLengthW(hwndEdit);
            std::wstring text;
            if (len > 0) {
                text.resize(len + 1);
                int copied = GetWindowTextW(hwndEdit, &text[0], len + 1);
                text.resize(copied);
            }

            std::wstring line;
            size_t start = 0;
            size_t end = 0;
            while ((end = text.find(L'\n', start)) != std::wstring::npos) {
                line = text.substr(start, end - start);
                if (!line.empty() && line.back() == L'\r') {
                    line.pop_back();
                }

                if (line.empty()) {
                    y += lineHeight;
                    if (y > pageHeight - PRINT_MARGIN) {
                        EndPage(pd.hDC);
                        StartPage(pd.hDC);
                        y = PRINT_MARGIN;
                    }
                } else {
                    RECT rect = { PRINT_MARGIN, y, pageWidth - PRINT_MARGIN, pageHeight - PRINT_MARGIN };
                    int heightUsed = DrawTextW(pd.hDC, line.c_str(), (int)line.length(), &rect, DT_WORDBREAK | DT_CALCRECT);

                    if (y + heightUsed > pageHeight - PRINT_MARGIN) {
                        EndPage(pd.hDC);
                        StartPage(pd.hDC);
                        y = PRINT_MARGIN;
                        rect.top = y;
                        rect.bottom = pageHeight - PRINT_MARGIN;
                        heightUsed = DrawTextW(pd.hDC, line.c_str(), (int)line.length(), &rect, DT_WORDBREAK | DT_CALCRECT);
                    }

                    DrawTextW(pd.hDC, line.c_str(), (int)line.length(), &rect, DT_WORDBREAK);
                    y += heightUsed;
                }
                start = end + 1;
            }

            if (start < text.length()) {
                line = text.substr(start);
                if (!line.empty()) {
                    RECT rect = { PRINT_MARGIN, y, pageWidth - PRINT_MARGIN, pageHeight - PRINT_MARGIN };
                    int heightUsed = DrawTextW(pd.hDC, line.c_str(), (int)line.length(), &rect, DT_WORDBREAK | DT_CALCRECT);

                    if (y + heightUsed > pageHeight - PRINT_MARGIN) {
                        EndPage(pd.hDC);
                        StartPage(pd.hDC);
                        y = PRINT_MARGIN;
                        rect.top = y;
                        rect.bottom = pageHeight - PRINT_MARGIN;
                        heightUsed = DrawTextW(pd.hDC, line.c_str(), (int)line.length(), &rect, DT_WORDBREAK | DT_CALCRECT);
                    }
                    DrawTextW(pd.hDC, line.c_str(), (int)line.length(), &rect, DT_WORDBREAK);
                }
            }

            EndPage(pd.hDC);
            EndDoc(pd.hDC);

            if (hOldFont) SelectObject(pd.hDC, hOldFont);
            if (hPrintFont) DeleteObject(hPrintFont);
        }
        DeleteDC(pd.hDC);
    }
    if (pd.hDevMode != NULL) GlobalFree(pd.hDevMode);
    if (pd.hDevNames != NULL) GlobalFree(pd.hDevNames);
}

void ShowTestingTerminal(HWND hwnd) {
    wchar_t workingDir[MAX_PATH] = {0};

    if (wcslen(szFileName) > 0) {
        wcscpy_s(workingDir, szFileName);
        wchar_t* slash = wcsrchr(workingDir, L'\\');
        if (slash) {
            *slash = L'\0';
        }
    }

    if (workingDir[0] == L'\0') {
        if (GetModuleFileNameW(NULL, workingDir, MAX_PATH) > 0) {
            wchar_t* slash = wcsrchr(workingDir, L'\\');
            if (slash) {
                *slash = L'\0';
            }
        }
    }

    wchar_t cmdLine[] =
        L"cmd.exe /K title OpenScript Test Terminal && "
        L"echo Terminal ready for script testing. && "
        L"echo Use this window to run .cmd, .bat, .ps1, .sh, or .ksh files.";

    STARTUPINFOW si;
    PROCESS_INFORMATION pi;
    ZeroMemory(&si, sizeof(si));
    ZeroMemory(&pi, sizeof(pi));
    si.cb = sizeof(si);

    BOOL created = CreateProcessW(
        NULL,
        cmdLine,
        NULL,
        NULL,
        FALSE,
        CREATE_NEW_CONSOLE,
        NULL,
        workingDir[0] ? workingDir : NULL,
        &si,
        &pi
    );

    if (!created) {
        MessageBoxW(hwnd, L"Failed to open test terminal.", L"Terminal", MB_OK | MB_ICONERROR);
        return;
    }

    CleanupProcessWatch();

    CloseHandle(pi.hThread);
    g_hWatchedProcess = pi.hProcess;

    if (!RegisterWaitForSingleObject(
        &g_hProcessExitWait,
        g_hWatchedProcess,
        OnWatchedProcessExit,
        hwnd,
        INFINITE,
        WT_EXECUTEONLYONCE
    )) {
        CleanupProcessWatch();
        MessageBoxW(hwnd, L"Unable to monitor terminal process.", L"Terminal", MB_OK | MB_ICONERROR);
    }
}

void InsertTextAtCaret(const wchar_t* text) {
    if (!hwndEdit || !text) return;
    SendMessageW(hwndEdit, EM_REPLACESEL, TRUE, (LPARAM)text);
    SetFocus(hwndEdit);
}

// Window Event Dispatcher
LRESULT CALLBACK WndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam) {
    if (message == uFindReplaceMsg && uFindReplaceMsg != 0) {
        LPFINDREPLACEW lpfr = (LPFINDREPLACEW)lParam;
        if (lpfr->Flags & FR_DIALOGTERM) {
            hwndFindDlg = NULL;
            return 0;
        }
        if (lpfr->Flags & FR_FINDNEXT) {
            DoFindText(lpfr);
        }
        if (lpfr->Flags & FR_REPLACE) {
            DoReplaceText(lpfr);
        }
        if (lpfr->Flags & FR_REPLACEALL) {
            DoReplaceAllText(lpfr);
        }
        return 0;
    }

    switch (message) {
    case WM_APP_PROCESS_TERMINATED:
        DestroyWindow(hwnd);
        return 0;
    case WM_CREATE: {
        RECT rect;
        GetClientRect(hwnd, &rect);

        if (!g_hMsftEdit) {
            g_hMsftEdit = LoadLibraryW(L"Msftedit.dll");
        }

        DWORD style = WS_CHILD | WS_VISIBLE | WS_VSCROLL | ES_MULTILINE | ES_WANTRETURN;
        if (bWordWrap) {
            style |= ES_AUTOVSCROLL;
        } else {
            style |= ES_AUTOHSCROLL | ES_AUTOVSCROLL | WS_HSCROLL;
        }

        hwndEdit = CreateWindowExW(
            WS_EX_CLIENTEDGE, MSFTEDIT_CLASS, L"", style,
            0, 0, rect.right, rect.bottom, hwnd,
            (HMENU)IDC_EDIT, ((LPCREATESTRUCT)lParam)->hInstance, NULL
        );

        hwndLineNumbers = CreateWindowExW(
            WS_EX_CLIENTEDGE, L"EDIT", L"1\r\n", WS_CHILD | WS_VISIBLE |
            ES_MULTILINE | ES_AUTOVSCROLL | ES_READONLY | ES_RIGHT,
            0, 0, 50, rect.bottom, hwnd,
            (HMENU)IDC_LINE_NUMBERS, ((LPCREATESTRUCT)lParam)->hInstance, NULL
        );

        // Subclass the edit control
        g_OriginalEditProc = (WNDPROC)SetWindowLongPtrW(hwndEdit, GWLP_WNDPROC, (LONG_PTR)EditSubclassProc);

        // Remove the default text limits
        SendMessageW(hwndEdit, EM_EXLIMITTEXT, 0, 0);
        SendMessageW(hwndLineNumbers, EM_LIMITTEXT, 0, 0);

        LOGFONTW lf;
        GetObjectW(GetStockObject(DEFAULT_GUI_FONT), sizeof(LOGFONTW), &lf);
        wcscpy_s(lf.lfFaceName, L"Consolas");
        lf.lfHeight = -16;
        hFont = CreateFontIndirectW(&lf);
        SendMessageW(hwndEdit, WM_SETFONT, (WPARAM)hFont, TRUE);
        SendMessageW(hwndLineNumbers, WM_SETFONT, (WPARAM)hFont, TRUE);

        // Programmatically generate application Menus
        HMENU hMenuBar = CreateMenu();

        HMENU hFile = CreatePopupMenu();
        AppendMenuW(hFile, MF_STRING, IDM_FILE_NEW, L"&New");
        AppendMenuW(hFile, MF_STRING, IDM_FILE_OPEN, L"&Open...");
        AppendMenuW(hFile, MF_STRING, IDM_FILE_SAVE, L"&Save");
        AppendMenuW(hFile, MF_STRING, IDM_FILE_SAVE_AS, L"Save &As...");
        AppendMenuW(hFile, MF_SEPARATOR, 0, NULL);
        AppendMenuW(hFile, MF_STRING, IDM_FILE_PRINT, L"&Print...");
        AppendMenuW(hFile, MF_SEPARATOR, 0, NULL);
        AppendMenuW(hFile, MF_STRING, IDM_FILE_EXIT, L"E&xit");

        HMENU hEdit = CreatePopupMenu();
        AppendMenuW(hEdit, MF_STRING, IDM_EDIT_FIND, L"&Find...");
        AppendMenuW(hEdit, MF_STRING, IDM_EDIT_REPLACE, L"&Replace...");
        AppendMenuW(hEdit, MF_SEPARATOR, 0, NULL);
        AppendMenuW(hEdit, bShowLineNumbers ? MF_CHECKED : MF_UNCHECKED, IDM_EDIT_LINE_NUMBERS, L"&Line Numbers");

        HMENU hView = CreatePopupMenu();
        AppendMenuW(hView, MF_STRING, IDM_VIEW_SHOW_TERMINAL, L"Show &Terminal");

        HMENU hInsert = CreatePopupMenu();
        HMENU hInsertCommands = CreatePopupMenu();
        HMENU hInsertVariables = CreatePopupMenu();

        AppendMenuW(hInsertCommands, MF_STRING, IDM_INSERT_CMD_ECHO, L"echo");
        AppendMenuW(hInsertCommands, MF_STRING, IDM_INSERT_CMD_CD, L"cd");
        AppendMenuW(hInsertCommands, MF_STRING, IDM_INSERT_CMD_DIR, L"dir");
        AppendMenuW(hInsertCommands, MF_STRING, IDM_INSERT_CMD_COPY, L"copy");
        AppendMenuW(hInsertCommands, MF_STRING, IDM_INSERT_CMD_DEL, L"del");
        AppendMenuW(hInsertCommands, MF_STRING, IDM_INSERT_CMD_SET, L"set");
        AppendMenuW(hInsertCommands, MF_STRING, IDM_INSERT_CMD_PAUSE, L"pause");
        AppendMenuW(hInsertCommands, MF_SEPARATOR, 0, NULL);
        AppendMenuW(hInsertCommands, MF_STRING, IDM_INSERT_CMD_IF, L"Batch IF block");
        AppendMenuW(hInsertCommands, MF_STRING, IDM_INSERT_CMD_FOR, L"Batch FOR loop");
        AppendMenuW(hInsertCommands, MF_STRING, IDM_INSERT_CMD_POWERSHELL_FOREACH, L"PowerShell foreach loop");

        AppendMenuW(hInsertVariables, MF_STRING, IDM_INSERT_VAR_ERRORLEVEL, L"%ERRORLEVEL%");
        AppendMenuW(hInsertVariables, MF_STRING, IDM_INSERT_VAR_BATCH_SCRIPT_DIR, L"%~dp0");
        AppendMenuW(hInsertVariables, MF_STRING, IDM_INSERT_VAR_PS_SCRIPT_ROOT, L"$PSScriptRoot");
        AppendMenuW(hInsertVariables, MF_STRING, IDM_INSERT_VAR_PS_PATH, L"$env:PATH");

        AppendMenuW(hInsert, MF_POPUP, (UINT_PTR)hInsertCommands, L"Commands");
        AppendMenuW(hInsert, MF_POPUP, (UINT_PTR)hInsertVariables, L"Variables");

        HMENU hHelp = CreatePopupMenu();
        AppendMenuW(hHelp, MF_STRING, IDM_HELP_ABOUT, L"&About OpenScript");

        AppendMenuW(hMenuBar, MF_POPUP, (UINT_PTR)hFile, L"&File");
        AppendMenuW(hMenuBar, MF_POPUP, (UINT_PTR)hEdit, L"&Edit");
        AppendMenuW(hMenuBar, MF_POPUP, (UINT_PTR)hView, L"&View");
        AppendMenuW(hMenuBar, MF_POPUP, (UINT_PTR)hInsert, L"&Insert");
        AppendMenuW(hMenuBar, MF_POPUP, (UINT_PTR)hHelp, L"&Help");

        SetMenu(hwnd, hMenuBar);
        LayoutEditorControls(hwnd);
        UpdateLineNumbers(hwnd);
        UpdateWindowTitle(hwnd);
        break;
    }
    case WM_SIZE: {
        LayoutEditorControls(hwnd);
        break;
    }
    case WM_SETFOCUS: {
        SetFocus(hwndEdit);
        break;
    }
    case WM_COMMAND: {
        if (LOWORD(wParam) == IDC_LINE_NUMBERS) {
            if (HIWORD(wParam) == EN_SETFOCUS) {
                SetFocus(hwndEdit);
                break;
            }
        }
        if (LOWORD(wParam) == IDC_EDIT) {
            if (HIWORD(wParam) == EN_CHANGE) {
                if (!bIsModified) {
                    bIsModified = true;
                    UpdateWindowTitle(hwnd);
                }
                UpdateLineNumbers(hwnd);
                ApplySyntaxHighlighting();
                break;
            }
            if (HIWORD(wParam) == EN_VSCROLL) {
                SyncLineNumberScroll();
                break;
            }
        }
        switch (LOWORD(wParam)) {
        case IDM_FILE_NEW:
            if (bIsModified) {
                int res = MessageBoxW(hwnd, L"Do you want to save changes?", L"Text Editor", MB_YESNOCANCEL | MB_ICONQUESTION);
                if (res == IDYES) {
                    if (!DoFileSave(hwnd, false)) break;
                }
                else if (res == IDCANCEL) break;
            }
            SetWindowTextW(hwndEdit, L"");
            szFileName[0] = L'\0';
            bIsModified = false;
            g_prevLineCount = -1; // Reset line count cache
            UpdateWindowTitle(hwnd);
            ApplySyntaxHighlighting();
            break;
        case IDM_FILE_OPEN:
            if (bIsModified) {
                int res = MessageBoxW(hwnd, L"Do you want to save changes?", L"Text Editor", MB_YESNOCANCEL | MB_ICONQUESTION);
                if (res == IDYES) {
                    if (!DoFileSave(hwnd, false)) break;
                }
                else if (res == IDCANCEL) break;
            }
            DoFileOpen(hwnd);
            break;
        case IDM_FILE_SAVE:
            DoFileSave(hwnd, false);
            break;
        case IDM_FILE_SAVE_AS:
            DoFileSave(hwnd, true);
            break;
        case IDM_FILE_PRINT:
            DoFilePrint(hwnd);
            break;
        case IDM_FILE_EXIT:
            PostMessageW(hwnd, WM_CLOSE, 0, 0);
            break;
        case IDM_EDIT_FIND:
            ShowFindDialog(hwnd);
            break;
        case IDM_EDIT_REPLACE:
            ShowReplaceDialog(hwnd);
            break;
        case IDM_EDIT_LINE_NUMBERS: {
            bShowLineNumbers = !bShowLineNumbers;
            HMENU hMenuBar = GetMenu(hwnd);
            HMENU hEditMenu = GetSubMenu(hMenuBar, 1);
            CheckMenuItem(hEditMenu, IDM_EDIT_LINE_NUMBERS, bShowLineNumbers ? MF_CHECKED : MF_UNCHECKED);
            LayoutEditorControls(hwnd);
            UpdateLineNumbers(hwnd);
            SaveAppSettings();
            break;
        }
        case IDM_VIEW_SHOW_TERMINAL:
            ShowTestingTerminal(hwnd);
            break;
        case IDM_INSERT_CMD_IF:
            InsertTextAtCaret(L"if exist \"file.txt\" (\r\n    echo Found\r\n) else (\r\n    echo Missing\r\n)\r\n");
            break;
        case IDM_INSERT_CMD_FOR:
            InsertTextAtCaret(L"for %%i in (*.txt) do (\r\n    echo %%i\r\n)\r\n");
            break;
        case IDM_INSERT_CMD_ECHO:
            InsertTextAtCaret(L"echo Hello, World!\r\n");
            break;
        case IDM_INSERT_CMD_CD:
            InsertTextAtCaret(L"cd C:\\Users\r\n");
            break;
        case IDM_INSERT_CMD_DIR:
            InsertTextAtCaret(L"dir\r\n");
            break;
        case IDM_INSERT_CMD_COPY:
            InsertTextAtCaret(L"copy file1.txt file2.txt\r\n");
            break;
        case IDM_INSERT_CMD_DEL:
            InsertTextAtCaret(L"del file.txt\r\n");
            break;
        case IDM_INSERT_CMD_SET:
            InsertTextAtCaret(L"set PATH\r\n");
            break;
        case IDM_INSERT_CMD_PAUSE:
            InsertTextAtCaret(L"pause\r\n");
            break;
        case IDM_INSERT_CMD_POWERSHELL_FOREACH:
            InsertTextAtCaret(L"foreach ($item in $items) {\r\n    Write-Host $item\r\n}\r\n");
            break;
        case IDM_INSERT_VAR_ERRORLEVEL:
            InsertTextAtCaret(L"%ERRORLEVEL%");
            break;
        case IDM_INSERT_VAR_BATCH_SCRIPT_DIR:
            InsertTextAtCaret(L"%~dp0");
            break;
        case IDM_INSERT_VAR_PS_SCRIPT_ROOT:
            InsertTextAtCaret(L"$PSScriptRoot");
            break;
        case IDM_INSERT_VAR_PS_PATH:
            InsertTextAtCaret(L"$env:PATH");
            break;
        case IDM_HELP_ABOUT:
            MessageBoxW(
                hwnd,
                L"OpenScript 1.5\n\n"
                L"Copyright (C) 2026 R.J. Dohnert\n"
                L"Licensed under BSD-3 Clause license",
                L"About OpenScript",
                MB_OK | MB_ICONINFORMATION
            );
            break;
        }
        break;
    }
    case WM_CLOSE: {
        if (bIsModified) {
            int res = MessageBoxW(hwnd, L"Do you want to save changes?", L"Text Editor", MB_YESNOCANCEL | MB_ICONQUESTION);
            if (res == IDYES) {
                if (DoFileSave(hwnd, false)) {
                    DestroyWindow(hwnd);
                }
            } else if (res == IDNO) {
                DestroyWindow(hwnd);
            }
        } else {
            DestroyWindow(hwnd);
        }
        break;
    }
    case WM_DESTROY:
        CleanupProcessWatch();
        SaveAppSettings();
        if (hFont) DeleteObject(hFont);
        if (hAppIcon) DestroyIcon(hAppIcon);
        if (hAppIconSmall) DestroyIcon(hAppIconSmall);
        if (g_hMsftEdit) FreeLibrary(g_hMsftEdit);
        PostQuitMessage(0);
        break;
    default:
        return DefWindowProcW(hwnd, message, wParam, lParam);
    }
    return 0;
}

// Windows Main Entry point
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE, LPSTR, int nCmdShow) {
    InitializeSettingsPath();
    LoadAppSettings();

    WNDCLASSEXW wc;
    ZeroMemory(&wc, sizeof(wc));
    wc.cbSize = sizeof(WNDCLASSEXW);
    wc.style = CS_HREDRAW | CS_VREDRAW;
    wc.lpfnWndProc = WndProc;
    wc.hInstance = hInstance;
    wc.hCursor = LoadCursorW(NULL, (LPCWSTR)IDC_ARROW);
    wc.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
    wc.lpszClassName = L"SimpleTextEditorClass";

    // Prefer script-icon.ico located beside the executable.
    wchar_t modulePath[MAX_PATH] = {0};
    std::wstring iconPath = L"script-icon.ico";
    if (GetModuleFileNameW(NULL, modulePath, MAX_PATH) > 0) {
        wchar_t* lastSlash = wcsrchr(modulePath, L'\\');
        if (lastSlash) {
            *(lastSlash + 1) = L'\0';
            iconPath = std::wstring(modulePath) + L"script-icon.ico";
        }
    }

    hAppIcon = (HICON)LoadImageW(
        NULL,
        iconPath.c_str(),
        IMAGE_ICON,
        GetSystemMetrics(SM_CXICON),
        GetSystemMetrics(SM_CYICON),
        LR_LOADFROMFILE
    );
    hAppIconSmall = (HICON)LoadImageW(
        NULL,
        iconPath.c_str(),
        IMAGE_ICON,
        GetSystemMetrics(SM_CXSMICON),
        GetSystemMetrics(SM_CYSMICON),
        LR_LOADFROMFILE
    );

    // Fallback to icon embedded in application resources.
    if (!hAppIcon || !hAppIconSmall) {
        if (!hAppIcon) {
            hAppIcon = (HICON)LoadImageW(
                hInstance,
                MAKEINTRESOURCEW(IDI_APP_ICON),
                IMAGE_ICON,
                GetSystemMetrics(SM_CXICON),
                GetSystemMetrics(SM_CYICON),
                0
            );
        }
        if (!hAppIconSmall) {
            hAppIconSmall = (HICON)LoadImageW(
                hInstance,
                MAKEINTRESOURCEW(IDI_APP_ICON),
                IMAGE_ICON,
                GetSystemMetrics(SM_CXSMICON),
                GetSystemMetrics(SM_CYSMICON),
                0
            );
        }
    }

    // Try to extract the Notepad icon from the system directory
    if (!hAppIcon || !hAppIconSmall) {
        wchar_t sysDir[MAX_PATH] = {0};
        if (GetSystemDirectoryW(sysDir, MAX_PATH)) {
            std::wstring notepadPath = std::wstring(sysDir) + L"\\notepad.exe";
            ExtractIconExW(notepadPath.c_str(), 0, &hAppIcon, &hAppIconSmall, 1);
        }
    }
    // Fallback to default application icon if extraction failed
    wc.hIcon = hAppIcon ? hAppIcon : LoadIconW(NULL, (LPCWSTR)IDI_APPLICATION);
    wc.hIconSm = hAppIconSmall ? hAppIconSmall : LoadIconW(NULL, (LPCWSTR)IDI_APPLICATION);

    if (!RegisterClassExW(&wc)) {
        MessageBoxW(NULL, L"Window Registration Failed!", L"Error!", MB_ICONEXCLAMATION | MB_OK);
        return 0;
    }

    uFindReplaceMsg = RegisterWindowMessageW(FINDMSGSTRINGW);

    HWND hwnd = CreateWindowExW(
        0,
        L"SimpleTextEditorClass",
        L"OpenScript 1.5 - Simple Script Editor",
        WS_OVERLAPPEDWINDOW,
        CW_USEDEFAULT, CW_USEDEFAULT, 800, 600,
        NULL, NULL, hInstance, NULL
    );

    if (hwnd == NULL) {
        MessageBoxW(NULL, L"Window Creation Failed!", L"Error!", MB_ICONEXCLAMATION | MB_OK);
        return 0;
    }

    int argc = 0;
    LPWSTR* argv = CommandLineToArgvW(GetCommandLineW(), &argc);
    if (argv && argc > 1) {
        // Try to reconstruct the path in case Windows passed a path with spaces split across arguments
        std::wstring combinedPath = argv[1];
        for (int i = 2; i < argc; ++i) {
            combinedPath += L" ";
            combinedPath += argv[i];
        }

        DWORD attribs = GetFileAttributesW(combinedPath.c_str());
        if (attribs != INVALID_FILE_ATTRIBUTES && !(attribs & FILE_ATTRIBUTE_DIRECTORY)) {
            LoadFile(hwnd, combinedPath.c_str());
        } else {
            // Fallback to argv[1] directly
            LoadFile(hwnd, argv[1]);
        }
    }
    if (argv) {
        LocalFree(argv);
    }

    ShowWindow(hwnd, nCmdShow);
    UpdateWindow(hwnd);

    MSG msg;
    while (GetMessageW(&msg, NULL, 0, 0) > 0) {
        if (hwndFindDlg == NULL || !IsDialogMessageW(hwndFindDlg, &msg)) {
            TranslateMessage(&msg);
            DispatchMessageW(&msg);
        }
    }
    return (int)msg.wParam;
}