BasaltMeter/BasaltPresenter/Presenter/command_client.cpp

#include "command_client.hpp"
#include <basalt/char_types.hpp>
#include <stdexcept>

namespace Basalt::Presenter {

    CommandClient::CommandClient() : m_PipeOperator(BSTEXT("ed0e3f1f-d214-4880-9562-640bce15e72e")), m_Status(ClientStatus::Ready) {}

    CommandClient::~CommandClient() {}

    HandshakePayload CommandClient::WaitHandshake() {
        if (m_Status != ClientStatus::Ready) {
            throw std::runtime_error("unexcpected client status");
        }

        // Wait for handshake request from Trainer (code 0x61)
        ProtocolCode request_code;
        m_PipeOperator.Read(&request_code, sizeof(request_code));
        if (request_code != ProtocolCode::HANDSHAKE_REQUEST) {
            throw std::runtime_error("unexpcted handshake code");
        }
        // Accept payload
        HandshakePayload handshake_payload;
        m_PipeOperator.Read(&handshake_payload, sizeof(HandshakePayload));

        // Send handshake response (code 0x62) back to Trainer
        ProtocolCode response_code = ProtocolCode::HANDSHAKE_RESPONSE;
        m_PipeOperator.Write(&response_code, sizeof(response_code));

        // Set status and return
        m_Status = ClientStatus::Running;
        return handshake_payload;
    }

    bool CommandClient::Tick(bool actively_stop) {
        if (m_Status != ClientStatus::Running) {
            throw std::runtime_error("unexcpected client status");
        }

        // If actively stop, send actively stop code to Trainer first
        if (actively_stop) {
            ProtocolCode sent_code = ProtocolCode::STOP_REQUEST;
            m_PipeOperator.Write(&sent_code, sizeof(sent_code));
        }

        // Send data ready code to Trainer
        ProtocolCode sent_code = ProtocolCode::DATA_READY;
        m_PipeOperator.Write(&sent_code, sizeof(sent_code));

        // Process the response from Trainer
        while (true) {
            ProtocolCode recv_code;
            m_PipeOperator.Read(&recv_code, sizeof(recv_code));

            switch (recv_code) {
                case ProtocolCode::DATA_RECEIVED:
                    // Normal response, continue processing
                    return false; // Not stopping
                case Basalt::Presenter::ProtocolCode::STOP:
                    // Trainer wants to stop
                    m_Status = ClientStatus::Stop;
                    return true; // Should stop
                default:
                    throw std::runtime_error("unexpected code when running");
            }
        }
    }

} // namespace Basalt::Presenter