main.cpp

#include <string>
#include <memory>
#include <thread>
#include <atomic>
#include <chrono>
#include <iostream>
#include <functional>

#ifdef _WIN32
    #define NOMINMAX
    #include <windows.h>
#endif

#include <ftxui/component/component.hpp>
#include <ftxui/component/screen_interactive.hpp>
#include <ftxui/dom/elements.hpp>

struct ThreadArgs {
    std::atomic<int> counter{0};
    std::atomic<int> timer_value{0};            // Timer value that increments every 5 seconds
    std::atomic<bool> is_running{true};
    std::atomic<bool> ui_ready{false};
    std::atomic<bool> confirm_exit{false};     // Exit confirmation modal state

    ThreadArgs() = default;
    ThreadArgs(int c, bool r, bool u) : counter(c), is_running(r), ui_ready(u) {}
};

// ============================================================================
// FTXUI thread function — takes ThreadArgs by reference so main and UI share same instance
// ============================================================================
void RunUIThread(ThreadArgs& args) {
    using namespace ftxui;

    auto screen = ScreenInteractive::TerminalOutput();

    // Timer thread: increments timer_value by 1 every 5 seconds, separate from the UI
    std::thread timer_thread([&args]() {
        while (args.is_running.load()) {
            std::this_thread::sleep_for(std::chrono::seconds(5));
            if (!args.is_running.load()) 
                break;
            args.timer_value++;
        }
    });

    auto button = Button("Click me!", [&args]() {
        args.counter++; // atomic safe increment
    });

    auto renderer = Renderer(button, [&args, &button]() {
        // Basic layout
        auto title = text("--- FTXUI Function Separation Example ---") | bold | color(Color::Blue);
        // bold: display text in bold. color(Color::Blue): set text color to blue.

        std::string counter_str = "Button click count: " + std::to_string(args.counter.load());
        auto counter_view = text(counter_str) | color(Color::Green);

        std::string timer_str = "Timer value (5s interval): " + std::to_string(args.timer_value.load());
        auto timer_view = text(timer_str) | color(Color::Yellow);

        auto button_view = align_right(button->Render());

        auto footer = text("Press 'Ctrl + Q' to exit.") | dim;
        // dim: make the text less prominent compared to surrounding UI.

        auto content = vbox({
            title,
            separator(),
            counter_view,
            timer_view,
            button_view,
            separator(),
            footer
        }) | border;

        // If the exit confirmation flag is set, add a simple confirmation box
        if (args.confirm_exit.load()) {
            auto ask_quit_text = text("Do you want to exit?") | bold;
            auto select_text = text("Choice: 'y' or 'n'") | dim;
            auto modal = vbox({
                ask_quit_text,
                select_text
            }) | border | color(Color::Yellow2);

            // Use explicit spacer
            auto ret = vbox({
                content, // existing screen
                text("") | size(HEIGHT, EQUAL, 1), // small spacer
                hcenter(modal) // place modal centered on the screen
            });
            return ret;
        }

        return content;
    });

    auto exit_screen = screen.ExitLoopClosure();

    auto component = CatchEvent(renderer, [&](Event event) {
        // 1) If confirmation modal is already shown: 'y' to exit, 'n' or ESC to cancel
        if (args.confirm_exit.load()) {
            if (event == Event::Character('y') || event == Event::Character('Y')) {
                args.is_running = false;
                exit_screen();
                return true;
            }
            if (event == Event::Character('n') || event == Event::Character('N') || event == Event::Escape) {
                args.confirm_exit = false; // cancel
                return true;
            }
            // Consume all other input while modal is shown so it isn't passed to child widgets
            return true;
        }

        // 2) Normal operation: Show confirmation modal when Ctrl+Q is pressed
        if (event == Event::Special("\x11")) { // Ctrl + Q
            args.confirm_exit = true;
            return true;
        }

        return false;
    });

    args.ui_ready = true;
    screen.Loop(component); // Start UI loop

    // After UI loop ends, clean up timer thread
    args.is_running = false;
    if (timer_thread.joinable()) {
        timer_thread.join();
    }
}

// ============================================================================
// main
// ============================================================================
int main() {
#ifdef _WIN32
    // for non-English characters to display correctly in Windows console
	::SetConsoleOutputCP(CP_UTF8); 
    ::SetConsoleCP(CP_UTF8);
#endif

    // Atomics are now owned by ThreadArgs
    ThreadArgs args; // counter:0, timer_value:0, is_running:true, ui_ready:false

    // Pass ThreadArgs by reference into the thread
    std::thread ui_thread(RunUIThread, std::ref(args));

    while (!args.ui_ready.load()) {
        using namespace std::chrono_literals;
        std::this_thread::sleep_for(100ms);
    }

    while (args.is_running.load()) {
        // Main thread loop (You can add any other logic here if needed)
        using namespace std::chrono_literals;
        std::this_thread::sleep_for(100ms);
    }

    if (ui_thread.joinable()) {
        ui_thread.join(); // Wait for the UI thread to finish before exiting main
    }  

    std::cout << std::endl << "[Info] Program exited successfully." << std::endl;
    std::cout << "Final button click count: " << args.counter.load() << " times" << std::endl;
    std::cout << "Final timer value: " << args.timer_value.load() << std::endl;

    return 0;
}