#pragma once

#ifdef RORO_DEBUG

#include <freertos/FreeRTOS.h>
#include <freertos/semphr.h>

#include <deque>
#include <functional>
#include <string>

#include "service.h"
#include "services/storage_service.h"
#include "services/wifi_service.h"
#include "ui/canvas.h"

class NetworkClient;

namespace roro {

// Debug Builds only (ADR 0004): the console over Wi-Fi, on TCP 2323 while Wi-Fi is Connected. A
// client sends the debug token as its first line, then gets the recent console backlog, every new
// console line, and runs the same commands as the serial port. One client at a time.
//
// The socket lives on this Service's own task; commands are handed to the main loop (takeCommand),
// which runs them where touching Apps and Services is safe. Their output reaches the client
// through the console ring like everything else.
class DebugConsole : public Service {
   public:
    static constexpr uint16_t kPort = 2323;

    DebugConsole(WifiService& wifi, StorageService& storage);
    // The off-screen frame the UI composes into: `screenshot` sends it as it stands.
    void setFrame(Canvas& frame) { frame_ = &frame; }
    const char* name() const override { return "debug"; }
    void start() override;

    // The next command line a client sent, for the main loop to run.
    bool takeCommand(std::string& line);
    bool clientConnected() const { return connected_; }

   private:
    static void taskEntry(void* self);
    void listen();
    void serve(::NetworkClient& client);
    bool authenticate(::NetworkClient& client);
    // Binary commands, answered on this task: true if `line` was one.
    bool binaryCommand(::NetworkClient& client, const std::string& line);
    // Runs `job` on the storage task (where card access is safe) and waits for it. False if the
    // card isn't mounted, in which case the storage task never runs it.
    bool onStorage(std::function<void()> job);
    void get(::NetworkClient& client, const std::string& path);
    void put(::NetworkClient& client, const std::string& args);
    void screenshot(::NetworkClient& client);

    WifiService& wifi_;
    StorageService& storage_;
    Canvas* frame_ = nullptr;
    TaskHandle_t task_ = nullptr;
    SemaphoreHandle_t lock_;
    std::deque<std::string> commands_;
    volatile bool connected_ = false;
};

}  // namespace roro

#endif