cardboy/Firmware/main/include/app_system.hpp

#pragma once

#include "app_framework.hpp"

#include <cstdint>
#include <memory>
#include <string>
#include <vector>

class AppSystem {
public:
    explicit AppSystem(AppContext context);

    void registerApp(std::unique_ptr<IAppFactory> factory);
    bool startApp(const std::string& name);
    bool startAppByIndex(std::size_t index);

    void run();

    [[nodiscard]] std::size_t appCount() const { return factories.size(); }
    [[nodiscard]] const IAppFactory* factoryAt(std::size_t index) const;
    [[nodiscard]] std::size_t indexOfFactory(const IAppFactory* factory) const;
    [[nodiscard]] std::size_t currentFactoryIndex() const { return activeIndex; }

    [[nodiscard]] const IApp* currentApp() const { return current.get(); }
    [[nodiscard]] const IAppFactory* currentFactory() const { return activeFactory; }

private:
    template<typename FramebufferT, typename InputT, typename ClockT>
    friend struct BasicAppContext;

    struct TimerRecord {
        AppTimerHandle id          = kInvalidAppTimer;
        std::uint32_t  generation  = 0;
        std::uint32_t  due_ms      = 0;
        std::uint32_t  interval_ms = 0;
        bool           repeat      = false;
        bool           active      = false;
    };

    AppTimerHandle scheduleTimer(uint32_t delay_ms, bool repeat);
    void           cancelTimer(AppTimerHandle handle);
    void           cancelAllTimers();

    void dispatchEvent(const AppEvent& event);

    void processDueTimers(std::uint32_t now, std::vector<AppEvent>& outEvents);
    std::uint32_t nextTimerDueMs(std::uint32_t now) const;
    void          clearTimersForCurrentApp();
    TimerRecord*  findTimer(AppTimerHandle handle);
    bool          handlePendingSwitchRequest();

    AppContext                       context;
    std::vector<std::unique_ptr<IAppFactory>> factories;
    std::unique_ptr<IApp>                    current;
    IAppFactory*                             activeFactory = nullptr;
    std::size_t                               activeIndex   = static_cast<std::size_t>(-1);
    std::vector<TimerRecord>                 timers;
    AppTimerHandle                           nextTimerId      = 1;
    std::uint32_t                            currentGeneration = 0;
    InputState                               lastInputState{};
};

template<typename FramebufferT, typename InputT, typename ClockT>
AppTimerHandle BasicAppContext<FramebufferT, InputT, ClockT>::scheduleTimerInternal(uint32_t delay_ms, bool repeat) {
    return system ? system->scheduleTimer(delay_ms, repeat) : kInvalidAppTimer;
}

template<typename FramebufferT, typename InputT, typename ClockT>
void BasicAppContext<FramebufferT, InputT, ClockT>::cancelTimerInternal(AppTimerHandle handle) {
    if (system)
        system->cancelTimer(handle);
}

template<typename FramebufferT, typename InputT, typename ClockT>
void BasicAppContext<FramebufferT, InputT, ClockT>::cancelAllTimersInternal() {
    if (system)
        system->cancelAllTimers();
}