cli_args_debugger.cpp

//
// cli_args_debugger.cpp
//
// Build Requirements:
// ------------------
// 1. Visual Studio 2022 (Community Edition or higher)
//    - Install the following workloads:
//         * "Desktop development with C++"
//         * "Universal Windows Platform development"
// 2. Required components:
//    - Windows 10/11 SDK (latest version)
//    - Visual C++ tools for CMake
// 3. DirectX Dependencies:
//    - DirectX SDK (June 2010) for legacy components, or a modern Windows SDK
//
// Additionally: Place the files qrcodegen.hpp and qrcodegen.cpp (from QrCodeGen by Nayuki)
// in the same directory as this file and add them to your project.
// ------------------

#ifndef UNICODE
#define UNICODE
#define _UNICODE
#endif

#include <DirectXMath.h>
#include <algorithm>
#include <array>
#include <atomic>
#include <audioclient.h>
#include <avrt.h> // For AvSetMmThreadCharacteristics
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <ctime>
#include <d2d1.h>
#include <d3d11.h>
#include <d3dcompiler.h>
#include <dwrite.h>
#include <excpt.h> // For SEH exception handling
#include <fstream>
#include <iomanip> // For setw/setfill
#include <knownfolders.h>
#include <mmdeviceapi.h>
#include <mmsystem.h> // For PlaySound
#include <psapi.h>    // For GetProcessMemoryInfo
#include <share.h>    // For _wfsopen share flags
#include <shlobj.h>
#include <sstream>
#include <stdexcept>
#include <string>
#include <thread>
#include <vector>
#include <windows.h>
#include <wrl/client.h>

// Debug memory leak detection
#ifdef _DEBUG
#define _CRTDBG_MAP_ALLOC
#include <crtdbg.h>
#endif

// Safe string functions for buffer overflow prevention
#include <strsafe.h>
#define INITGUID                           // Required by /permissive- for GUID initialization
#include <functiondiscoverykeys_devpkey.h> // For PKEY_Device_FriendlyName
#include <ks.h>                            // For GUID constants
#include <ksmedia.h>                       // For KSDATAFORMAT_SUBTYPE constants
#include <propsys.h>                       // IPropertyStore, PKEY_*
#include <propvarutil.h>                   // PropVariant helpers
#pragma comment(lib, "propsys")            // + linker

// NTSTATUS and RTL_OSVERSIONINFOW are already defined in Windows SDK
// No need to redefine them

// Link with required libraries
#pragma comment(lib, "d2d1")
#pragma comment(lib, "dwrite")
#pragma comment(lib, "d3d11")
#pragma comment(lib, "d3dcompiler")
#pragma comment(lib, "ole32")
#pragma comment(lib, "avrt")
#pragma comment(lib, "user32")  // For window functions
#pragma comment(lib, "shell32") // For SHGetKnownFolderPath
#pragma comment(lib, "gdi32")   // For GDI functions
#pragma comment(lib, "winmm")   // For PlaySound
#pragma comment(lib, "psapi")   // For GetProcessMemoryInfo

// Include QrCodeGen (ensure that qrcodegen.hpp and qrcodegen.cpp are in your project)
#include "qrcodegen.hpp"
using qrcodegen::QrCode;

// Logger lives in log_manager.{hpp,cpp} so multiple translation units (tests,
// seh_wrapper) can link against the same instance.
#include "log_manager.hpp"

// Path/env inspection (executable path, OS version, Wine/Proton, etc.)
#include "path_info.hpp"

// WASAPI microphone capture (owns its own thread, COM objects, and level
// smoothing). See audio_capture.hpp for the public contract.
#include "audio_capture.hpp"

// Use Microsoft::WRL::ComPtr for COM object management
using Microsoft::WRL::ComPtr;

// Helper macro that calls a DirectX function and throws an exception on failure.
#define DX_CALL(expr, msg)                                                                                             \
    do                                                                                                                 \
    {                                                                                                                  \
        auto hr = (expr);                                                                                              \
        if (FAILED(hr))                                                                                                \
            throw std::runtime_error(msg);                                                                             \
    } while (0)

// Helper function: robust conversion from std::wstring to std::string using WideCharToMultiByte (UTF-8)
std::string wstring_to_string(const std::wstring& wstr)
{
    if (wstr.empty())
        return std::string();

    // Use the string length so embedded null characters are preserved
    int size_needed =
        WideCharToMultiByte(CP_UTF8, 0, wstr.c_str(), static_cast<int>(wstr.size()), nullptr, 0, nullptr, nullptr);

    std::string strTo(size_needed, 0);
    WideCharToMultiByte(CP_UTF8, 0, wstr.c_str(), static_cast<int>(wstr.size()), &strTo[0], size_needed, nullptr,
                        nullptr);

    return strTo;
}

#include "cli_args_display.hpp"

constexpr const wchar_t* kWindowClassName = L"CloudStreamingArgsDebuggerClass";
constexpr const wchar_t* kWindowCaption = L"Cloud Streaming Args Debugger";

// Description text for the window
const std::vector<std::wstring> kDescriptionLines = {
    L"Cloud Streaming Args Debugger",
    L"This utility displays all command-line arguments for cloud streaming applications.",
    L"Type 'exit', 'save', 'read', 'logs', 'path', 'sound' or 'memory' and press Enter to execute commands."};

constexpr float kMargin = 20.0f;
constexpr float kLineHeight = 30.0f;

// Structures for 3D rendering
struct SimpleVertex
{
    DirectX::XMFLOAT3 position;
    DirectX::XMFLOAT3 color;
};

struct ConstantBufferData
{
    DirectX::XMMATRIX world_view_projection;
};

class ArgumentDebuggerWindow;
LRESULT CALLBACK WindowProc(HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam);
ArgumentDebuggerWindow* g_app_instance = nullptr;

// External SEH wrapper function (defined in seh_wrapper.cpp)
// Global function for unhandled exception filter - renamed to avoid conflict
LONG WINAPI AppUnhandledExceptionFilter(EXCEPTION_POINTERS* ep)
{
    Log(L"Unhandled SEH exception: code=0x" + std::to_wstring(ep->ExceptionRecord->ExceptionCode));
    return EXCEPTION_EXECUTE_HANDLER;
}

class ArgumentDebuggerWindow
{
  public:
    ArgumentDebuggerWindow() = default;
    ~ArgumentDebuggerWindow()
    {
        Cleanup();
    }

    // Throws on failure.
    void Initialize(HINSTANCE h_instance, int cmd_show, const std::vector<std::wstring>& args);
    int RunMessageLoop();
    void OnCharInput(wchar_t ch);
    void OnDestroy();
    bool is_running() const
    {
        return is_running_;
    }

  private:
    void InitializeWindow(HINSTANCE h_instance, int cmd_show);
    void InitializeDevice();
    void CreateDeviceAndSwapChain(UINT width, UINT height);
    void CreateRenderTargetView();
    void CreateD2DResources();
    void CreateShadersAndGeometry();
    void RenderFrame();
    void Cleanup();
    void UpdateRotation(float delta_time);

    // RenderFrame is split into small section methods. RenderFrame itself just
    // orchestrates the sequence; each helper owns one visible region of the UI.
    void UpdateFrameTiming();
    void RenderCube(const D3D11_VIEWPORT& vp);
    void RenderTextHud(const D2D1_SIZE_F& size, float& y_pos);
    void RenderLoadedDataPanel(const D2D1_SIZE_F& size);
    void RenderPathsPanel(const D2D1_SIZE_F& size);
    void RenderInputPrompt(const D2D1_SIZE_F& size);
    void RenderQrBitmap(const D2D1_SIZE_F& size);
    void RenderVolumeMeter(const D2D1_SIZE_F& size);
    // Returns false if the D2D device was lost and has been recreated; in that
    // case the caller should skip Present and move on to the next frame.
    bool EndOverlay();
    void PresentFrame();

  private:
    // Update QR code – here we add the FPS synchronization logic.
    void UpdateQrCode(ULONGLONG current_time);

    // Methods for file operations (saving/loading data)
    void SaveData();
    void ReadData();

    // Helper to load entire log file into loaded_data_
    void ShowLogs();

    // Helper to calculate and cache path information once
    void CalculatePathInfo();

    // Play telephone-like beeps for 1 minute
    void PlayTelephoneBeeps();

    // Show memory usage statistics
    void ShowMemoryStats();

    HWND window_handle_ = nullptr;
    bool is_running_ = true;
    ULONGLONG last_time_ = 0;
    float rotation_angle_ = 0.0f;
    std::wstring user_input_;
    std::vector<std::wstring> args_;

    // New variables for displaying command status and loaded data:
    std::wstring command_status_;
    std::wstring loaded_data_;
    std::wstring loaded_data_title_; // Title for the loaded data section
    bool show_paths_ = false;        // Flag to control file paths display
    bool show_logs_ = false;         // Flag to control logs display

    // Cached path information to avoid expensive system calls every frame
    std::vector<std::pair<std::wstring, std::wstring>> cached_path_items_;

    // Variables for FPS and QR code
    float current_fps_ = 0.0f;
    // Adding a variable for "synchronized" FPS,
    // which will be the same as what is shown in the QR code.
    int synced_fps_ = 0;

    ULONGLONG last_qr_update_time_ = 0;
    ComPtr<ID2D1Bitmap> qr_bitmap_;

    // Direct2D and DirectWrite objects
    ComPtr<ID2D1Factory> d2d_factory_;
    ComPtr<ID2D1RenderTarget> d2d_render_target_;
    ComPtr<IDWriteFactory> dwrite_factory_;
    ComPtr<IDWriteTextFormat> text_format_;
    ComPtr<IDWriteTextFormat> small_text_format_; // Smaller font for logs
    ComPtr<IDWriteTextFormat> data_text_format_;  // Medium font for loaded data

    // D2D Brushes - created once and reused
    ComPtr<ID2D1SolidColorBrush> white_brush_;
    ComPtr<ID2D1SolidColorBrush> green_brush_;
    ComPtr<ID2D1SolidColorBrush> yellow_brush_;

    // Direct3D objects
    ComPtr<ID3D11Device> d3d_device_;
    ComPtr<ID3D11DeviceContext> immediate_context_;
    ComPtr<IDXGISwapChain> swap_chain_;
    ComPtr<ID3D11RenderTargetView> d3d_render_target_view_;

    // Shader and geometry objects
    ComPtr<ID3D11Buffer> vertex_buffer_;
    ComPtr<ID3D11Buffer> index_buffer_;
    ComPtr<ID3D11Buffer> constant_buffer_;
    ComPtr<ID3D11InputLayout> vertex_layout_;
    ComPtr<ID3D11VertexShader> vertex_shader_;
    ComPtr<ID3D11PixelShader> pixel_shader_;

    // WASAPI
    AudioCapture audio_capture_; // Owns the WASAPI pipeline and capture thread
};

#ifndef EXCLUDE_MAIN
int WINAPI wWinMain(HINSTANCE h_instance, HINSTANCE, PWSTR, int cmd_show)
{
#ifdef _DEBUG
    // Enable memory leak detection in debug builds
    _CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);
    // Break on allocation number (uncomment to debug specific leak)
    // _CrtSetBreakAlloc(123);
#endif

    try
    {
        // Initialize COM once at the start - STA is the safest option for UI thread and D2D
        DX_CALL(CoInitializeEx(nullptr, COINIT_APARTMENTTHREADED), "COM initialization failed");

        InitLogger();
        Log(L"Application start");
        Log(L"wWinMain: entered");

        // Set unhandled exception filter using a regular function
        SetUnhandledExceptionFilter(AppUnhandledExceptionFilter);

        int argc = 0;
        LPWSTR* argv = CommandLineToArgvW(GetCommandLineW(), &argc);
        std::vector<std::wstring> args;
        if (argv != nullptr)
        {
            for (int i = 1; i < argc; ++i)
            {
                args.push_back(argv[i]);
            }
            LocalFree(argv);
        }

        ArgumentDebuggerWindow debugger_app;
        g_app_instance = &debugger_app;

        debugger_app.Initialize(h_instance, cmd_show, args);

        int exit_code = debugger_app.RunMessageLoop();
        g_app_instance = nullptr;

        Log(L"Application exit, code = " + std::to_wstring(exit_code));
        Log(L"wWinMain: leaving, exitCode=" + std::to_wstring(exit_code));

        CloseLogger();
        CoUninitialize();
        return exit_code;
    }
    catch (const std::exception& ex)
    {
        std::wstring wstr(ex.what(), ex.what() + strlen(ex.what()));
        Log(L"Unhandled C++ exception");
        Log(L"FATAL: " + wstr);

        CloseLogger();

        MessageBoxA(nullptr, ex.what(), "Initialization Error", MB_OK | MB_ICONERROR);
        return -1;
    }
}
#endif // EXCLUDE_MAIN

void ArgumentDebuggerWindow::Initialize(HINSTANCE h_instance, int cmd_show, const std::vector<std::wstring>& args)
{
    args_ = args;
    InitializeWindow(h_instance, cmd_show);
    InitializeDevice();
}

int ArgumentDebuggerWindow::RunMessageLoop()
{
    Log(L"RunMessageLoop: started");
    MSG msg = {};
    last_time_ = GetTickCount64();

    while (is_running_)
    {
        bool hadMsg = false;
        while (PeekMessage(&msg, nullptr, 0, 0, PM_REMOVE))
        {
            hadMsg = true;
            if (msg.message == WM_QUIT)
            {
                Log(L"WM_QUIT received, wParam=" + std::to_wstring(msg.wParam));
                is_running_ = false;
                break;
            }
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }

        if (!hadMsg)
        {
            // Log only once every 10 seconds to avoid bloating the log file
            static ULONGLONG t0 = GetTickCount64();
            ULONGLONG now = GetTickCount64();
            if (now - t0 > 10000)
            {
                Log(L"RunMessageLoop: idle");
                t0 = now;
            }
        }

        // Frame rate limiting - target 60 FPS
        static ULONGLONG lastFrameTime = 0;
        ULONGLONG currentFrameTime = GetTickCount64();
        const ULONGLONG targetFrameTime = 16; // ~60 FPS (1000ms / 60 = 16.67ms)

        if (currentFrameTime - lastFrameTime < targetFrameTime)
        {
            // Sleep to maintain target frame rate
            DWORD sleepTime = static_cast<DWORD>(targetFrameTime - (currentFrameTime - lastFrameTime));
            if (sleepTime > 0 && sleepTime < targetFrameTime)
            {
                Sleep(sleepTime);
            }
        }
        lastFrameTime = GetTickCount64();

        try
        {
            RenderFrame();
        }
        catch (const std::exception& ex)
        {
            // Safe string conversion with bounds checking
            size_t msgLen = strnlen_s(ex.what(), 1024); // Limit to 1KB
            std::wstring wideMsg;
            if (msgLen > 0)
            {
                wideMsg = std::wstring(ex.what(), ex.what() + msgLen);
            }
            Log(L"Render error: " + wideMsg);
            MessageBoxA(window_handle_, ex.what(), "Render error", MB_ICONERROR);
            PostQuitMessage(1);
            break;
        }
        catch (...)
        {
            Log(L"Unknown exception in render loop - terminating");
            MessageBoxW(window_handle_, L"Unknown error occurred", L"Error", MB_ICONERROR);
            PostQuitMessage(1);
            break;
        }
    }

    Log(L"RunMessageLoop: finished");
    return static_cast<int>(msg.wParam);
}

// Keyboard input handling: added support for "save", "read" and "logs" commands
void ArgumentDebuggerWindow::OnCharInput(wchar_t ch)
{
    if (ch == VK_RETURN)
    {
        if (_wcsicmp(user_input_.c_str(), L"exit") == 0)
        {
            Log(L"Command: exit");
            PostQuitMessage(0);
            is_running_ = false;
        }
        else if (_wcsicmp(user_input_.c_str(), L"save") == 0)
        {
            Log(L"Command: save");
            SaveData();
        }
        else if (_wcsicmp(user_input_.c_str(), L"read") == 0)
        {
            Log(L"Command: read");
            ReadData();
            if (!loaded_data_.empty())
            {
                loaded_data_title_ = L"Save File Contents:";
                show_logs_ = true; // Show the data when read succeeds
            }
        }
        else if (_wcsicmp(user_input_.c_str(), L"logs") == 0)
        {
            Log(L"Command: logs");
            show_logs_ = !show_logs_;
            if (show_logs_)
            {
                ShowLogs();
                loaded_data_title_ = L"Log File Contents:";
                command_status_ = L"Logs enabled.";
            }
            else
            {
                loaded_data_.clear();
                loaded_data_title_.clear();
                command_status_ = L"Logs disabled.";
            }
        }
        else if (_wcsicmp(user_input_.c_str(), L"path") == 0)
        {
            Log(L"Command: path");
            show_paths_ = !show_paths_;
            if (show_paths_)
            {
                // Calculate path information once when enabling
                CalculatePathInfo();
                command_status_ = L"File paths enabled.";
            }
            else
            {
                // Clear cached data when disabling
                cached_path_items_.clear();
                command_status_ = L"File paths disabled.";
            }
        }
        else if (_wcsicmp(user_input_.c_str(), L"sound") == 0)
        {
            Log(L"Command: sound");
            command_status_ = L"Playing low-frequency beeps (300Hz) for 1 minute...";
            PlayTelephoneBeeps();
        }
        else if (_wcsicmp(user_input_.c_str(), L"memory") == 0)
        {
            Log(L"Command: memory");
            ShowMemoryStats();
        }
        else
        {
            command_status_ = L"Unknown command.";
        }
        user_input_.clear();
    }
    else if (ch == VK_BACK)
    {
        if (!user_input_.empty())
            user_input_.pop_back();
    }
    else
    {
        user_input_ += ch;
    }
}

void ArgumentDebuggerWindow::OnDestroy()
{
    Log(L"Window destroy event");

    is_running_ = false;
    audio_capture_.Stop();
    Cleanup();
    PostQuitMessage(0);
}

void ArgumentDebuggerWindow::InitializeWindow(HINSTANCE h_instance, int /*cmd_show*/)
{
    Log(L"InitializeWindow: registering class");
    // Register and create the window.
    WNDCLASS wc = {};
    wc.lpfnWndProc = WindowProc;
    wc.hInstance = h_instance;
    wc.lpszClassName = kWindowClassName;
    wc.hCursor = LoadCursor(nullptr, IDC_ARROW);

    if (!RegisterClass(&wc))
        throw std::runtime_error("Failed to register window class.");

    int screen_width = GetSystemMetrics(SM_CXSCREEN);
    int screen_height = GetSystemMetrics(SM_CYSCREEN);

    window_handle_ = CreateWindowEx(WS_EX_TOPMOST, kWindowClassName, kWindowCaption, WS_POPUP, 0, 0, screen_width,
                                    screen_height, nullptr, nullptr, h_instance, nullptr);

    if (!window_handle_)
        throw std::runtime_error("Failed to create window.");

    Log(L"InitializeWindow: HWND=" + std::to_wstring(reinterpret_cast<uintptr_t>(window_handle_)));

    ShowWindow(window_handle_, SW_SHOWMAXIMIZED);
}

void ArgumentDebuggerWindow::InitializeDevice()
{
    RECT rc;
    GetClientRect(window_handle_, &rc);
    UINT width = rc.right - rc.left;
    UINT height = rc.bottom - rc.top;

    CreateDeviceAndSwapChain(width, height);
    CreateRenderTargetView();
    CreateD2DResources();
    CreateShadersAndGeometry();
    audio_capture_.Initialize();
}

void ArgumentDebuggerWindow::CreateDeviceAndSwapChain(UINT width, UINT height)
{
    DXGI_SWAP_CHAIN_DESC sd = {};
    sd.BufferCount = 1;
    sd.BufferDesc.Width = width;
    sd.BufferDesc.Height = height;
    sd.BufferDesc.Format = DXGI_FORMAT_B8G8R8A8_UNORM;
    sd.BufferDesc.RefreshRate.Numerator = 60;
    sd.BufferDesc.RefreshRate.Denominator = 1;
    sd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT | DXGI_USAGE_SHARED;
    sd.OutputWindow = window_handle_;
    sd.SampleDesc.Count = 1;
    sd.Windowed = TRUE;
    sd.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;

    // Enable debug layer for better diagnostics in debug builds
#ifdef _DEBUG
    UINT create_flags = D3D11_CREATE_DEVICE_BGRA_SUPPORT | D3D11_CREATE_DEVICE_DEBUG;
#else
    UINT create_flags = D3D11_CREATE_DEVICE_BGRA_SUPPORT;
#endif

    DX_CALL(D3D11CreateDeviceAndSwapChain(nullptr, D3D_DRIVER_TYPE_HARDWARE, nullptr, create_flags, nullptr, 0,
                                          D3D11_SDK_VERSION, &sd, swap_chain_.GetAddressOf(),
                                          d3d_device_.GetAddressOf(), nullptr, immediate_context_.GetAddressOf()),
            "Failed to create Direct3D device and swap chain.");
}

void ArgumentDebuggerWindow::CreateRenderTargetView()
{
    ComPtr<ID3D11Texture2D> back_buffer;
    DX_CALL(swap_chain_->GetBuffer(0, __uuidof(ID3D11Texture2D), reinterpret_cast<void**>(back_buffer.GetAddressOf())),
            "Failed to get back buffer.");
    DX_CALL(d3d_device_->CreateRenderTargetView(back_buffer.Get(), nullptr, d3d_render_target_view_.GetAddressOf()),
            "Failed to create render target view.");
}

void ArgumentDebuggerWindow::CreateD2DResources()
{
    // Create the Direct2D factory.
    DX_CALL(D2D1CreateFactory(D2D1_FACTORY_TYPE_SINGLE_THREADED, D2D1_FACTORY_OPTIONS{}, d2d_factory_.GetAddressOf()),
            "Failed to create Direct2D factory.");

    // Get the DXGI surface from the swap chain.
    ComPtr<IDXGISurface> dxgi_surface;
    DX_CALL(swap_chain_->GetBuffer(0, IID_PPV_ARGS(&dxgi_surface)), "Failed to get DXGI surface.");

    D2D1_RENDER_TARGET_PROPERTIES props = D2D1::RenderTargetProperties(
        D2D1_RENDER_TARGET_TYPE_DEFAULT, D2D1::PixelFormat(DXGI_FORMAT_UNKNOWN, D2D1_ALPHA_MODE_PREMULTIPLIED), 0, 0);
    DX_CALL(d2d_factory_->CreateDxgiSurfaceRenderTarget(dxgi_surface.Get(), &props, d2d_render_target_.GetAddressOf()),
            "Failed to create Direct2D render target.");

    // Create the DirectWrite factory and text format.
    DX_CALL(DWriteCreateFactory(DWRITE_FACTORY_TYPE_SHARED, __uuidof(IDWriteFactory),
                                reinterpret_cast<IUnknown**>(dwrite_factory_.GetAddressOf())),
            "Failed to create DirectWrite factory.");
    DX_CALL(dwrite_factory_->CreateTextFormat(L"Arial", nullptr, DWRITE_FONT_WEIGHT_NORMAL, DWRITE_FONT_STYLE_NORMAL,
                                              DWRITE_FONT_STRETCH_NORMAL, 24.0f, L"en-us", text_format_.GetAddressOf()),
            "Failed to create text format.");
    text_format_->SetTextAlignment(DWRITE_TEXT_ALIGNMENT_LEADING);
    text_format_->SetParagraphAlignment(DWRITE_PARAGRAPH_ALIGNMENT_NEAR);

    // Create a smaller text format for logs (half the size of the regular text)
    DX_CALL(dwrite_factory_->CreateTextFormat(L"Consolas", nullptr, // Using monospaced font for logs
                                              DWRITE_FONT_WEIGHT_NORMAL, DWRITE_FONT_STYLE_NORMAL,
                                              DWRITE_FONT_STRETCH_NORMAL,
                                              12.0f, // Half the size of the regular font
                                              L"en-us", small_text_format_.GetAddressOf()),
            "Failed to create small text format.");
    // Set text alignment properties
    small_text_format_->SetParagraphAlignment(DWRITE_PARAGRAPH_ALIGNMENT_NEAR);
    small_text_format_->SetWordWrapping(DWRITE_WORD_WRAPPING_WRAP);
    // Use trailing alignment for device name text to align to the right
    small_text_format_->SetTextAlignment(DWRITE_TEXT_ALIGNMENT_TRAILING);

    // Create a medium text format for loaded data (double the size of small font)
    DX_CALL(dwrite_factory_->CreateTextFormat(L"Consolas", nullptr, // Using monospaced font for data
                                              DWRITE_FONT_WEIGHT_NORMAL, DWRITE_FONT_STYLE_NORMAL,
                                              DWRITE_FONT_STRETCH_NORMAL,
                                              24.0f, // Double the size of small_text_format_
                                              L"en-us", data_text_format_.GetAddressOf()),
            "Failed to create data text format.");
    data_text_format_->SetParagraphAlignment(DWRITE_PARAGRAPH_ALIGNMENT_NEAR);
    data_text_format_->SetWordWrapping(DWRITE_WORD_WRAPPING_WRAP);
    data_text_format_->SetTextAlignment(DWRITE_TEXT_ALIGNMENT_LEADING);

    // Create brushes once during initialization
    DX_CALL(d2d_render_target_->CreateSolidColorBrush(D2D1::ColorF(D2D1::ColorF::White), white_brush_.GetAddressOf()),
            "Failed to create white brush.");
    DX_CALL(d2d_render_target_->CreateSolidColorBrush(D2D1::ColorF(D2D1::ColorF::Green), green_brush_.GetAddressOf()),
            "Failed to create green brush.");
    DX_CALL(d2d_render_target_->CreateSolidColorBrush(D2D1::ColorF(D2D1::ColorF::Yellow), yellow_brush_.GetAddressOf()),
            "Failed to create yellow brush.");
}

void ArgumentDebuggerWindow::CreateShadersAndGeometry()
{
    // Vertex shader source code.
    constexpr const char vs_src[] = "cbuffer ConstantBuffer : register(b0) {"
                                    "    matrix WorldViewProjection;"
                                    "};"
                                    "struct VS_INPUT { float3 Pos : POSITION; float3 Color : COLOR; };"
                                    "struct PS_INPUT { float4 Pos : SV_POSITION; float3 Color : COLOR; };"
                                    "PS_INPUT VSMain(VS_INPUT input) {"
                                    "    PS_INPUT output;"
                                    "    output.Pos = mul(float4(input.Pos, 1.0f), WorldViewProjection);"
                                    "    output.Color = input.Color;"
                                    "    return output;"
                                    "}";

    // Pixel shader source code.
    constexpr const char ps_src[] = "struct PS_INPUT { float4 Pos : SV_POSITION; float3 Color : COLOR; };"
                                    "float4 PSMain(PS_INPUT input) : SV_Target {"
                                    "    return float4(input.Color, 1.0f);"
                                    "}";

    ComPtr<ID3DBlob> vs_blob, ps_blob, error_blob;
    DX_CALL(D3DCompile(vs_src, sizeof(vs_src) - 1, nullptr, nullptr, nullptr, "VSMain", "vs_4_0", 0, 0,
                       vs_blob.GetAddressOf(), error_blob.GetAddressOf()),
            "Failed to compile vertex shader.");
    DX_CALL(D3DCompile(ps_src, sizeof(ps_src) - 1, nullptr, nullptr, nullptr, "PSMain", "ps_4_0", 0, 0,
                       ps_blob.GetAddressOf(), error_blob.GetAddressOf()),
            "Failed to compile pixel shader.");

    DX_CALL(d3d_device_->CreateVertexShader(vs_blob->GetBufferPointer(), vs_blob->GetBufferSize(), nullptr,
                                            vertex_shader_.GetAddressOf()),
            "Failed to create vertex shader.");
    DX_CALL(d3d_device_->CreatePixelShader(ps_blob->GetBufferPointer(), ps_blob->GetBufferSize(), nullptr,
                                           pixel_shader_.GetAddressOf()),
            "Failed to create pixel shader.");

    // Define input layout.
    std::array<D3D11_INPUT_ELEMENT_DESC, 2> layout_desc = {
        {{"POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0},
         {"COLOR", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 12, D3D11_INPUT_PER_VERTEX_DATA, 0}}};
    DX_CALL(d3d_device_->CreateInputLayout(layout_desc.data(), static_cast<UINT>(layout_desc.size()),
                                           vs_blob->GetBufferPointer(), vs_blob->GetBufferSize(),
                                           vertex_layout_.GetAddressOf()),
            "Failed to create input layout.");
    immediate_context_->IASetInputLayout(vertex_layout_.Get());

    // Define vertices (cube).
    std::array<SimpleVertex, 8> vertices = {
        {// Front face
         {DirectX::XMFLOAT3(-1.0f, 1.0f, -1.0f), DirectX::XMFLOAT3(1.0f, 0.0f, 0.0f)},
         {DirectX::XMFLOAT3(1.0f, 1.0f, -1.0f), DirectX::XMFLOAT3(0.0f, 1.0f, 0.0f)},
         {DirectX::XMFLOAT3(1.0f, -1.0f, -1.0f), DirectX::XMFLOAT3(0.0f, 0.0f, 1.0f)},
         {DirectX::XMFLOAT3(-1.0f, -1.0f, -1.0f), DirectX::XMFLOAT3(1.0f, 1.0f, 0.0f)},
         // Back face
         {DirectX::XMFLOAT3(-1.0f, 1.0f, 1.0f), DirectX::XMFLOAT3(1.0f, 0.0f, 1.0f)},
         {DirectX::XMFLOAT3(1.0f, 1.0f, 1.0f), DirectX::XMFLOAT3(0.0f, 1.0f, 1.0f)},
         {DirectX::XMFLOAT3(1.0f, -1.0f, 1.0f), DirectX::XMFLOAT3(1.0f, 1.0f, 1.0f)},
         {DirectX::XMFLOAT3(-1.0f, -1.0f, 1.0f), DirectX::XMFLOAT3(0.0f, 0.0f, 0.0f)}}};

    // Create vertex buffer.
    D3D11_BUFFER_DESC bd = {};
    bd.Usage = D3D11_USAGE_DEFAULT;
    bd.ByteWidth = static_cast<UINT>(sizeof(SimpleVertex) * vertices.size());
    bd.BindFlags = D3D11_BIND_VERTEX_BUFFER;
    D3D11_SUBRESOURCE_DATA init_data = {};
    init_data.pSysMem = vertices.data();
    DX_CALL(d3d_device_->CreateBuffer(&bd, &init_data, vertex_buffer_.GetAddressOf()),
            "Failed to create vertex buffer.");

    // Define indices.
    std::array<WORD, 36> indices = {
        {0, 1, 2, 2, 3, 0, 4, 7, 6, 6, 5, 4, 4, 0, 3, 3, 7, 4, 1, 5, 6, 6, 2, 1, 4, 5, 1, 1, 0, 4, 3, 2, 6, 6, 7, 3}};
    bd.Usage = D3D11_USAGE_DEFAULT;
    bd.ByteWidth = static_cast<UINT>(sizeof(WORD) * indices.size());
    bd.BindFlags = D3D11_BIND_INDEX_BUFFER;
    init_data.pSysMem = indices.data();
    DX_CALL(d3d_device_->CreateBuffer(&bd, &init_data, index_buffer_.GetAddressOf()), "Failed to create index buffer.");

    // Create constant buffer.
    bd.Usage = D3D11_USAGE_DEFAULT;
    bd.ByteWidth = sizeof(ConstantBufferData);
    bd.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
    bd.CPUAccessFlags = 0;
    DX_CALL(d3d_device_->CreateBuffer(&bd, nullptr, constant_buffer_.GetAddressOf()),
            "Failed to create constant buffer.");
}

void ArgumentDebuggerWindow::UpdateQrCode(ULONGLONG current_time)
{
    // Update the QR code no more than once every 5 seconds.
    if (current_time - last_qr_update_time_ < 5000)
        return;
    last_qr_update_time_ = current_time;

    time_t unix_time = time(nullptr);
    // Get the integer value of FPS.
    int fps_for_qr = static_cast<int>(current_fps_);

    // Save this value for synchronized file output.
    synced_fps_ = fps_for_qr;

    // Create the string for the QR code
    std::ostringstream oss;
    oss << "t=" << unix_time << ";f=" << fps_for_qr;
    if (!args_.empty())
    {
        oss << ";args=";
        for (const auto& arg : args_)
        {
            oss << wstring_to_string(arg) << " ";
        }
    }
    std::string qr_data = oss.str();

    // Generate the QR code (error correction level MEDIUM).
    QrCode qr = QrCode::encodeText(qr_data.c_str(), QrCode::Ecc::MEDIUM);
    int qr_modules = qr.getSize();
    constexpr int pixel_size = 375; // final size 375x375
    float scale = static_cast<float>(pixel_size) / qr_modules;
    std::vector<uint32_t> pixels(pixel_size * pixel_size, 0xffffffff); // white background

    for (int y = 0; y < pixel_size; y++)
    {
        for (int x = 0; x < pixel_size; x++)
        {
            int module_x = static_cast<int>(x / scale);
            int module_y = static_cast<int>(y / scale);
            if (module_x < qr_modules && module_y < qr_modules)
            {
                if (qr.getModule(module_x, module_y))
                    pixels[y * pixel_size + x] = 0xff000000; // black pixel
            }
        }
    }

    D2D1_BITMAP_PROPERTIES bitmapProperties = {};
    bitmapProperties.pixelFormat.format = DXGI_FORMAT_B8G8R8A8_UNORM;
    bitmapProperties.pixelFormat.alphaMode = D2D1_ALPHA_MODE_PREMULTIPLIED;
    bitmapProperties.dpiX = 96.0f;
    bitmapProperties.dpiY = 96.0f;

    qr_bitmap_.Reset();
    DX_CALL(d2d_render_target_->CreateBitmap(D2D1::SizeU(pixel_size, pixel_size), pixels.data(),
                                             pixel_size * sizeof(uint32_t), &bitmapProperties,
                                             qr_bitmap_.GetAddressOf()),
            "Failed to create QR code bitmap.");
}

void ArgumentDebuggerWindow::RenderFrame()
{
    UpdateFrameTiming();

    RECT rc;
    GetClientRect(window_handle_, &rc);
    D3D11_VIEWPORT vp{};
    vp.Width = static_cast<float>(rc.right - rc.left);
    vp.Height = static_cast<float>(rc.bottom - rc.top);
    vp.MaxDepth = 1.0f;
    RenderCube(vp);

    d2d_render_target_->BeginDraw();
    UpdateQrCode(GetTickCount64());

    const D2D1_SIZE_F size = d2d_render_target_->GetSize();
    float y_pos = kMargin;
    RenderTextHud(size, y_pos);
    RenderLoadedDataPanel(size);
    RenderPathsPanel(size);
    RenderInputPrompt(size);
    RenderQrBitmap(size);
    RenderVolumeMeter(size);

    if (!EndOverlay()) // device lost → D2D resources already recreated
        return;

    PresentFrame();
}

void ArgumentDebuggerWindow::UpdateFrameTiming()
{
    ULONGLONG current_time = GetTickCount64();
    float delta_time = (current_time - last_time_) / 1000.0f;
    last_time_ = current_time;
    current_fps_ = (delta_time > 0.0f) ? (1.0f / delta_time) : 0.0f;
    UpdateRotation(delta_time);
}

void ArgumentDebuggerWindow::RenderCube(const D3D11_VIEWPORT& vp)
{
    FLOAT clear_color[4] = {0.0f, 0.0f, 0.0f, 1.0f};
    immediate_context_->ClearRenderTargetView(d3d_render_target_view_.Get(), clear_color);
    immediate_context_->OMSetRenderTargets(1, d3d_render_target_view_.GetAddressOf(), nullptr);
    immediate_context_->RSSetViewports(1, &vp);

    UINT stride = sizeof(SimpleVertex);
    UINT offset = 0;
    immediate_context_->IASetVertexBuffers(0, 1, vertex_buffer_.GetAddressOf(), &stride, &offset);
    immediate_context_->IASetIndexBuffer(index_buffer_.Get(), DXGI_FORMAT_R16_UINT, 0);
    immediate_context_->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);

    using namespace DirectX;
    XMMATRIX world = XMMatrixRotationY(rotation_angle_);
    XMVECTOR eye = XMVectorSet(0.0f, 2.0f, -5.0f, 0.0f);
    XMVECTOR at = XMVectorSet(0.0f, 0.0f, 0.0f, 0.0f);
    XMVECTOR up = XMVectorSet(0.0f, 1.0f, 0.0f, 0.0f);
    XMMATRIX view = XMMatrixLookAtLH(eye, at, up);
    XMMATRIX proj = XMMatrixPerspectiveFovLH(XM_PIDIV4, vp.Width / vp.Height, 0.01f, 100.0f);

    ConstantBufferData cb_data;
    cb_data.world_view_projection = XMMatrixTranspose(world * view * proj);
    immediate_context_->UpdateSubresource(constant_buffer_.Get(), 0, nullptr, &cb_data, 0, 0);

    immediate_context_->VSSetShader(vertex_shader_.Get(), nullptr, 0);
    immediate_context_->VSSetConstantBuffers(0, 1, constant_buffer_.GetAddressOf());
    immediate_context_->PSSetShader(pixel_shader_.Get(), nullptr, 0);
    immediate_context_->DrawIndexed(36, 0, 0);
}

void ArgumentDebuggerWindow::RenderTextHud(const D2D1_SIZE_F& size, float& y_pos)
{
    for (const auto& line : kDescriptionLines)
    {
        D2D1_RECT_F rect = D2D1::RectF(kMargin, y_pos, size.width - kMargin, y_pos + kLineHeight);
        d2d_render_target_->DrawText(line.c_str(), static_cast<UINT32>(line.size()), text_format_.Get(), rect,
                                     white_brush_.Get());
        y_pos += kLineHeight;
    }
    y_pos += kLineHeight;

    std::wstring cli_text = BuildCliHeaderText(args_);
    D2D1_RECT_F header_rect = D2D1::RectF(kMargin, y_pos, size.width - kMargin, y_pos + kLineHeight);
    d2d_render_target_->DrawText(cli_text.c_str(), static_cast<UINT32>(cli_text.size()), text_format_.Get(),
                                 header_rect, green_brush_.Get());
    y_pos += kLineHeight;

    if (!args_.empty())
    {
        std::wstring formatted_args = BuildCliArgsText(args_);
        D2D1_RECT_F args_rect = D2D1::RectF(kMargin, y_pos, size.width - kMargin, size.height - 200.0f);
        d2d_render_target_->DrawText(formatted_args.c_str(), static_cast<UINT32>(formatted_args.size()),
                                     text_format_.Get(), args_rect, green_brush_.Get());
        y_pos += kLineHeight;
    }

    y_pos += 10.0f;
    D2D1_RECT_F status_rect = D2D1::RectF(kMargin, size.height - 220.0f, size.width - kMargin, size.height - 190.0f);
    d2d_render_target_->DrawText(command_status_.c_str(), static_cast<UINT32>(command_status_.size()),
                                 text_format_.Get(), status_rect, white_brush_.Get());
}

void ArgumentDebuggerWindow::RenderLoadedDataPanel(const D2D1_SIZE_F& size)
{
    if (!show_logs_ || loaded_data_.empty())
        return;

    D2D1_RECT_F data_rect = D2D1::RectF(size.width - 750.0f, kMargin, size.width - kMargin, kMargin + 380.0f);
    d2d_render_target_->DrawText(loaded_data_.c_str(), static_cast<UINT32>(loaded_data_.size()),
                                 data_text_format_.Get(), data_rect, green_brush_.Get());

    if (!loaded_data_title_.empty())
    {
        D2D1_RECT_F title_rect = D2D1::RectF(size.width - 750.0f, kMargin - 30.0f, size.width - kMargin, kMargin);
        d2d_render_target_->DrawText(loaded_data_title_.c_str(), static_cast<UINT32>(loaded_data_title_.size()),
                                     text_format_.Get(), title_rect, yellow_brush_.Get());
    }
}

void ArgumentDebuggerWindow::RenderPathsPanel(const D2D1_SIZE_F& size)
{
    if (!show_paths_ || cached_path_items_.empty())
        return;

    constexpr float pathWidth = 400.0f;
    constexpr float pathLineHeight = 25.0f;
    const float pathEndX = size.width - kMargin;
    const float pathStartX = pathEndX - pathWidth;
    float currentY = size.height * 0.3f;

    for (const auto& item : cached_path_items_)
    {
        std::wstring fullLine = item.first + item.second;
        D2D1_RECT_F rect = D2D1::RectF(pathStartX, currentY, pathEndX, currentY + pathLineHeight);
        d2d_render_target_->DrawText(fullLine.c_str(), static_cast<UINT32>(fullLine.size()), small_text_format_.Get(),
                                     rect, white_brush_.Get());
        currentY += pathLineHeight;
    }
}

void ArgumentDebuggerWindow::RenderInputPrompt(const D2D1_SIZE_F& size)
{
    const std::wstring exit_prompt =
        L"Type 'exit', 'save', 'read', 'logs', 'path', 'sound' or 'memory' and press Enter:";
    D2D1_RECT_F exit_prompt_rect =
        D2D1::RectF(kMargin, size.height - 100.0f, size.width - kMargin, size.height - 70.0f);
    d2d_render_target_->DrawText(exit_prompt.c_str(), static_cast<UINT32>(exit_prompt.size()), text_format_.Get(),
                                 exit_prompt_rect, yellow_brush_.Get());

    D2D1_RECT_F user_input_rect = D2D1::RectF(kMargin, size.height - 60.0f, size.width - kMargin, size.height - 30.0f);
    d2d_render_target_->DrawText(user_input_.c_str(), static_cast<UINT32>(user_input_.size()), text_format_.Get(),
                                 user_input_rect, green_brush_.Get());
}

void ArgumentDebuggerWindow::RenderQrBitmap(const D2D1_SIZE_F& size)
{
    if (!qr_bitmap_)
        return;
    constexpr int qr_size = 375;
    constexpr float qr_margin = 60.0f;
    const float qr_x = qr_margin;
    const float qr_y = size.height - qr_size - qr_margin - 100.0f - (size.height * 0.2f);
    d2d_render_target_->DrawBitmap(qr_bitmap_.Get(), D2D1::RectF(qr_x, qr_y, qr_x + qr_size, qr_y + qr_size));
}

void ArgumentDebuggerWindow::RenderVolumeMeter(const D2D1_SIZE_F& size)
{
    if (!audio_capture_.IsAvailable())
    {
        std::wstring no_mic = L"No microphone detected";
        D2D1_RECT_F r =
            D2D1::RectF(size.width - 300.f, size.height - 50.f, size.width - kMargin, size.height - kMargin);
        d2d_render_target_->DrawText(no_mic.c_str(), static_cast<UINT32>(no_mic.size()), text_format_.Get(), r,
                                     yellow_brush_.Get());
        return;
    }

    const float level = audio_capture_.Level();

    constexpr float bar_w = 30.0f;
    constexpr float bar_h = 150.0f;
    constexpr float spacing = 15.0f;
    const float total_width = bar_w * 2 + spacing;
    const float x0 = size.width - kMargin - total_width;
    const float y0 = size.height - kMargin - bar_h;

    const std::wstring& dev_name = audio_capture_.Name();
    const std::wstring dev_title = L"Mic: " + (dev_name.empty() ? L"<unknown>" : dev_name);

    constexpr float devAreaWidth = 200.0f;
    constexpr float devAreaHeight = 2 * kLineHeight;
    constexpr float marginBottom = 5.0f;
    const float devRight = size.width - kMargin;
    const float devLeft = devRight - devAreaWidth;
    const float devBottom = y0;
    const float devTop = devBottom - devAreaHeight - marginBottom;

    d2d_render_target_->DrawText(dev_title.c_str(), static_cast<UINT32>(dev_title.size()), small_text_format_.Get(),
                                 D2D1::RectF(devLeft, devTop, devRight, devBottom), white_brush_.Get());

    // Left channel bar.
    const float left_filled = bar_h * level;
    d2d_render_target_->DrawRectangle(D2D1::RectF(x0, y0, x0 + bar_w, y0 + bar_h), white_brush_.Get(), 2.0f);
    d2d_render_target_->FillRectangle(D2D1::RectF(x0, y0 + (bar_h - left_filled), x0 + bar_w, y0 + bar_h),
                                      green_brush_.Get());

    // Right channel bar — slight variation for visual distinction from mono.
    const float right_level = level * 0.9f;
    const float right_filled = bar_h * right_level;
    const float right_x = x0 + bar_w + spacing;
    d2d_render_target_->DrawRectangle(D2D1::RectF(right_x, y0, right_x + bar_w, y0 + bar_h), white_brush_.Get(), 2.0f);
    d2d_render_target_->FillRectangle(D2D1::RectF(right_x, y0 + (bar_h - right_filled), right_x + bar_w, y0 + bar_h),
                                      green_brush_.Get());

    const std::wstring left_label = L"L";
    const std::wstring right_label = L"R";
    d2d_render_target_->DrawText(left_label.c_str(), static_cast<UINT32>(left_label.size()), text_format_.Get(),
                                 D2D1::RectF(x0, y0 - 30.0f, x0 + bar_w, y0), yellow_brush_.Get());
    d2d_render_target_->DrawText(right_label.c_str(), static_cast<UINT32>(right_label.size()), text_format_.Get(),
                                 D2D1::RectF(right_x, y0 - 30.0f, right_x + bar_w, y0), yellow_brush_.Get());
}

bool ArgumentDebuggerWindow::EndOverlay()
{
    HRESULT hr = d2d_render_target_->EndDraw();
    if (hr == D2DERR_RECREATE_TARGET)
    {
        Log(L"Device lost detected, recreating D2D resources");
        white_brush_.Reset();
        green_brush_.Reset();
        yellow_brush_.Reset();
        data_text_format_.Reset();
        CreateD2DResources();
        return false;
    }
    if (FAILED(hr))
        throw std::runtime_error("Failed to end Direct2D draw.");
    return true;
}

void ArgumentDebuggerWindow::PresentFrame()
{
    static ULONGLONG lastFpsLogTime = 0;
    ULONGLONG currentTime = GetTickCount64();
    if (currentTime - lastFpsLogTime > 5000)
    {
        Log(L"RenderFrame: Present FPS=" + std::to_wstring(static_cast<int>(current_fps_)));
        lastFpsLogTime = currentTime;
    }

    // Skip VSync under Wine/Proton — blocking Present on Wine can starve the
    // whole message loop, producing reported FPS in the single digits.
    HMODULE hNtdll = GetModuleHandleW(L"ntdll.dll");
    const bool isWine = hNtdll && GetProcAddress(hNtdll, "wine_get_version");
    const UINT syncInterval = isWine ? 0 : 1;

    HRESULT hr = swap_chain_->Present(syncInterval, 0);
    if (hr == DXGI_ERROR_DEVICE_REMOVED || hr == DXGI_ERROR_DEVICE_RESET)
    {
        Log(L"Device removed/reset detected, recreating all graphics resources");
        CreateDeviceAndSwapChain(static_cast<UINT>(d2d_render_target_->GetSize().width),
                                 static_cast<UINT>(d2d_render_target_->GetSize().height));
        CreateRenderTargetView();
        CreateD2DResources();
        CreateShadersAndGeometry();
        return;
    }
    if (FAILED(hr))
        throw std::runtime_error("Failed to present frame.");
}

void ArgumentDebuggerWindow::UpdateRotation(float delta_time)
{
    rotation_angle_ += delta_time * DirectX::XM_PIDIV4 / 2.0f;
}

// Audio capture (WASAPI pipeline, thread, SEH wrapper) lives in

void ArgumentDebuggerWindow::Cleanup()
{
    Log(L"Cleanup started");

    // The audio pipeline is owned by `audio_capture_` and released either by
    // its Stop() in OnDestroy or by its destructor.

    // Reset all graphics ComPtr objects to automatically release resources.
    vertex_shader_.Reset();
    pixel_shader_.Reset();
    vertex_layout_.Reset();
    constant_buffer_.Reset();
    vertex_buffer_.Reset();
    index_buffer_.Reset();
    d3d_render_target_view_.Reset();
    swap_chain_.Reset();
    immediate_context_.Reset();
    d3d_device_.Reset();
    text_format_.Reset();
    small_text_format_.Reset(); // Release the small text format
    data_text_format_.Reset();  // Release the data text format
    dwrite_factory_.Reset();
    d2d_render_target_.Reset();
    d2d_factory_.Reset();
    qr_bitmap_.Reset();
    white_brush_.Reset();
    green_brush_.Reset();
    yellow_brush_.Reset();

    Log(L"Cleanup finished");
}

// Helper to load entire log file into loaded_data_ (showing only the last 100 lines)
void ArgumentDebuggerWindow::ShowLogs()
{
    loaded_data_.clear();

    // File is already open for writing, so use _wfsopen with _SH_DENYNO flag
    // to explicitly allow both reading and writing from different handles
    FILE* log_file = _wfsopen(g_logPath.c_str(), L"r, ccs=UTF-16LE", _SH_DENYNO);
    if (!log_file)
    {
        command_status_ = L"Log file not found.";
        return;
    }

    // Ensure all pending writes are flushed to the file before reading
    fflush(g_log_file);

    // Skip BOM if present
    wint_t first_char = fgetwc(log_file);
    if (first_char != 0xFEFF)
    {
        // Not a BOM, rewind to start of file
        fseek(log_file, 0, SEEK_SET);
    }

    // Read all lines from the file first into a circular buffer of last 100 lines
    const size_t maxLines = 100;
    std::vector<std::wstring> lastLines;
    lastLines.reserve(maxLines);

    wchar_t buffer[1024];
    while (fgetws(buffer, 1024, log_file))
    {
        if (lastLines.size() >= maxLines)
        {
            // Remove oldest line at the beginning
            lastLines.erase(lastLines.begin());
        }
        // Add new line at the end
        lastLines.push_back(buffer);
    }

    // Now build the output string with only the last 100 lines
    loaded_data_ = L"... (showing last " + std::to_wstring(lastLines.size()) + L" lines)\n\n";
    for (const auto& line : lastLines)
    {
        loaded_data_ += line;
    }

    fclose(log_file);
    command_status_ = L"Log file loaded (last 100 lines).";
}

// Method for saving data (timestamp and FPS) to %APPDATA%\CloudStreamingArgsDebugger\saved_data.txt
void ArgumentDebuggerWindow::SaveData()
{
    PWSTR appdata_path = nullptr;
    HRESULT hr = SHGetKnownFolderPath(FOLDERID_RoamingAppData, 0, nullptr, &appdata_path);
    if (SUCCEEDED(hr))
    {
        std::wstring folder_path = appdata_path;
        CoTaskMemFree(appdata_path);
        folder_path += L"\\CloudStreamingArgsDebugger";
        // Create the directory if it does not exist yet.
        if (!CreateDirectoryW(folder_path.c_str(), nullptr))
        {
            DWORD err = GetLastError();
            if (err != ERROR_ALREADY_EXISTS)
            {
                command_status_ = L"Error creating directory.";
                Log(L"SaveData: Error creating directory, code = " + std::to_wstring(err));
                return;
            }
        }
        std::wstring file_path = folder_path + L"\\saved_data.txt";
        FILE* file = nullptr;
        // Open the file for writing
        if (_wfopen_s(&file, file_path.c_str(), L"w, ccs=UTF-8") == 0 && file)
        {
            time_t timestamp = time(nullptr);
            // Write synced_fps_ so it matches the QR code value
            fwprintf(file, L"Timestamp: %lld\nFPS: %d\n", static_cast<long long>(timestamp), synced_fps_);
            fclose(file);
            command_status_ = L"Data saved successfully.";
            Log(L"SaveData: Data saved successfully to " + file_path);
        }
        else
        {
            command_status_ = L"Error opening file for writing.";
            Log(L"SaveData: Error opening file for writing: " + file_path);
        }
    }
    else
    {
        command_status_ = L"Error retrieving AppData path.";
        Log(L"SaveData: Error retrieving AppData path, hr = " + std::to_wstring(hr));
    }
}

// Method for loading data from %APPDATA%\CloudStreamingArgsDebugger\saved_data.txt
void ArgumentDebuggerWindow::ReadData()
{
    PWSTR appdata_path = nullptr;
    HRESULT hr = SHGetKnownFolderPath(FOLDERID_RoamingAppData, 0, nullptr, &appdata_path);
    if (SUCCEEDED(hr))
    {
        std::wstring folder_path = appdata_path;
        CoTaskMemFree(appdata_path);
        folder_path += L"\\CloudStreamingArgsDebugger";
        std::wstring file_path = folder_path + L"\\saved_data.txt";
        FILE* file = nullptr;
        if (_wfopen_s(&file, file_path.c_str(), L"r, ccs=UTF-8") == 0 && file)
        {
            wchar_t buffer[256];
            loaded_data_.clear();
            // Read file contents line by line.
            while (fgetws(buffer, 256, file))
            {
                loaded_data_ += buffer;
            }
            fclose(file);
            command_status_ = L"Data loaded successfully.";
            Log(L"ReadData: Data loaded successfully from " + file_path);
        }
        else
        {
            command_status_ = L"File not found.";
            loaded_data_.clear();
            Log(L"ReadData: File not found: " + file_path);
        }
    }
    else
    {
        command_status_ = L"Error retrieving AppData path.";
        Log(L"ReadData: Error retrieving AppData path, hr = " + std::to_wstring(hr));
    }
}

// Helper method to calculate and cache path information once
void ArgumentDebuggerWindow::CalculatePathInfo()
{
    cached_path_items_ = path_info::Collect();
}

void ArgumentDebuggerWindow::PlayTelephoneBeeps() // Name kept for compatibility
{
    // Create a separate thread to play beeps so UI doesn't freeze
    std::thread beepThread(
        []()
        {
            // Low-frequency continuous beep pattern
            const int beepFrequency = 300;   // 300Hz - lower tone
            const int beepDuration = 2000;   // 2 seconds beep
            const int pauseDuration = 2000;  // 2 seconds pause
            const int totalDuration = 60000; // 1 minute total

            DWORD startTime = GetTickCount();

            while (GetTickCount() - startTime < totalDuration)
            {
                // Single long beep
                Beep(beepFrequency, beepDuration);

                // Pause
                Sleep(pauseDuration);
            }
        });

    // Detach thread so it runs independently
    beepThread.detach();
}

void ArgumentDebuggerWindow::ShowMemoryStats()
{
    try
    {
        PROCESS_MEMORY_COUNTERS_EX pmc;
        if (GetProcessMemoryInfo(GetCurrentProcess(), (PROCESS_MEMORY_COUNTERS*)&pmc, sizeof(pmc)))
        {
            // Format memory statistics
            std::wstring stats;
            stats += L"=== MEMORY STATISTICS ===\n";
            stats += L"Working Set (RAM): " + std::to_wstring(pmc.WorkingSetSize / 1024 / 1024) + L" MB\n";
            stats += L"Peak Working Set: " + std::to_wstring(pmc.PeakWorkingSetSize / 1024 / 1024) + L" MB\n";
            stats += L"Private Bytes: " + std::to_wstring(pmc.PrivateUsage / 1024 / 1024) + L" MB\n";
            stats += L"Virtual Memory: " + std::to_wstring(pmc.PagefileUsage / 1024 / 1024) + L" MB\n";
            stats += L"Peak Virtual: " + std::to_wstring(pmc.PeakPagefileUsage / 1024 / 1024) + L" MB\n";

            // Get system memory info
            MEMORYSTATUSEX memInfo;
            memInfo.dwLength = sizeof(MEMORYSTATUSEX);
            if (GlobalMemoryStatusEx(&memInfo))
            {
                stats += L"\n=== SYSTEM MEMORY ===\n";
                stats += L"Total RAM: " + std::to_wstring(memInfo.ullTotalPhys / 1024 / 1024) + L" MB\n";
                stats += L"Available RAM: " + std::to_wstring(memInfo.ullAvailPhys / 1024 / 1024) + L" MB\n";
                stats += L"Memory Load: " + std::to_wstring(memInfo.dwMemoryLoad) + L"%\n";
            }

            // Add runtime information
            ULONGLONG uptime = GetTickCount64();
            stats += L"\n=== RUNTIME ===\n";
            stats += L"Uptime: " + std::to_wstring(uptime / 1000) + L" seconds\n";

            // Store in loaded_data_ to display on screen
            loaded_data_ = stats;
            loaded_data_title_ = L"Memory Statistics:";
            show_logs_ = true;

            command_status_ = L"Memory statistics displayed.";
            Log(L"Memory stats: WorkingSet=" + std::to_wstring(pmc.WorkingSetSize / 1024 / 1024) + L"MB");
        }
        else
        {
            command_status_ = L"Failed to get memory statistics.";
            Log(L"Failed to get process memory info");
        }
    }
    catch (...)
    {
        command_status_ = L"Error getting memory statistics.";
        Log(L"Exception in ShowMemoryStats");
    }
}

LRESULT CALLBACK WindowProc(HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam)
{
    switch (message)
    {
    case WM_CREATE:
        Log(L"WM_CREATE");
        break;
    case WM_CHAR:
        Log(L"WM_CHAR: \"" + std::wstring(1, static_cast<wchar_t>(wparam)) + L"\"");
        if (g_app_instance && g_app_instance->is_running())
            g_app_instance->OnCharInput(static_cast<wchar_t>(wparam));
        break;
    case WM_DESTROY:
        Log(L"WM_DESTROY");
        if (g_app_instance)
            g_app_instance->OnDestroy();
        return 0;
    default:
        return DefWindowProc(hwnd, message, wparam, lparam);
    }
    return 0;
}