MonitorFrame.cpp

Go to the documentation of this file.

#include "App/MonitorFrame.h"
#include "Panels/ConnectionPanel.h"
#include "Panels/MainPanel.h"
#include "Panels/RightSidePanel.h"
#include "Tabs/MonitorNavigatorTab.h"
#include "Tabs/PropertiesTab.h"
#include "Utils/DPI.h"
#include "Utils/LayoutConstants.h"
#include "Utils/Logger.h"
 
namespace Ember {
namespace Monitor {
 
enum { ID_POLL_TIMER = wxID_HIGHEST + 100, ID_QUIT = wxID_EXIT, ID_ABOUT = wxID_ABOUT };
 
wxBEGIN_EVENT_TABLE(MonitorFrame, wxFrame) EVT_CLOSE(MonitorFrame::OnClose) EVT_MENU(ID_QUIT, MonitorFrame::OnQuit)
    EVT_MENU(ID_ABOUT, MonitorFrame::OnAbout) EVT_TIMER(ID_POLL_TIMER, MonitorFrame::OnPollTimer)
        EVT_SIZE(MonitorFrame::OnFrameResize) wxEND_EVENT_TABLE()
 
            MonitorFrame::MonitorFrame(const wxString &title, const wxPoint &pos, const wxSize &size)
    : wxFrame(nullptr, wxID_ANY, title, pos, size), m_auiManager(nullptr), m_pollTimer(this, ID_POLL_TIMER) {
 
    CreateMenuBar();
    CreateLayout();
    SetupCallbacks();
 
    m_pollTimer.Start(33);
 
    UpdateStatusBar();
}
 
MonitorFrame::~MonitorFrame() {
    m_pollTimer.Stop();
    m_server.Stop();
    if (m_auiManager) {
        m_auiManager->UnInit();
        delete m_auiManager;
    }
}
 
void MonitorFrame::CreateMenuBar() {
    wxMenuBar *menuBar = new wxMenuBar();
 
    wxMenu *fileMenu = new wxMenu();
    fileMenu->Append(ID_QUIT, "E&xit\tAlt-F4", "Quit the application");
    menuBar->Append(fileMenu, "&File");
 
    wxMenu *helpMenu = new wxMenu();
    helpMenu->Append(ID_ABOUT, "&About...", "Show about dialog");
    menuBar->Append(helpMenu, "&Help");
 
    SetMenuBar(menuBar);
}
 
void MonitorFrame::CreateLayout() {
    m_statusBar = CreateStatusBar(3);
    int sbFieldWidth = EmberUI::DPI::Scale(this, EmberUI::Layout::STATUS_BAR_FIELD_WIDTH);
    int widths[] = {-1, sbFieldWidth, sbFieldWidth};
    m_statusBar->SetStatusWidths(3, widths);
 
    m_auiManager = new wxAuiManager(this);
 
    m_connectionPanel = new ConnectionPanel(this, &m_server);
    m_mainPanel = new MainPanel(this);
    m_rightPanel = new RightSidePanel(this);
    m_rightPanel->SetupTabs();
    m_navigatorTab = m_rightPanel->GetNavigatorTab();
    m_propertiesTab = m_rightPanel->GetPropertiesTab();
 
    wxSize cs = GetClientSize();
    m_lastClientSize = cs;
 
    int connWidth = cs.x * 15 / 100;
    int connMinWidth = cs.x * 12 / 100;
    int rightWidth = cs.x * 18 / 100;
    int rightMinWidth = cs.x * 13 / 100;
 
    m_auiManager->AddPane(m_connectionPanel, wxAuiPaneInfo()
                                                 .Name("connection_panel")
                                                 .Caption("Connection")
                                                 .Left()
                                                 .BestSize(wxSize(connWidth, -1))
                                                 .MinSize(wxSize(connMinWidth, -1))
                                                 .Dockable(false)
                                                 .Floatable(false)
                                                 .CloseButton(false)
                                                 .CaptionVisible(false)
                                                 .Resizable(true));
 
    m_auiManager->AddPane(
        m_mainPanel,
        wxAuiPaneInfo().Name("scene_panel").CenterPane().Dockable(false).Floatable(false).CloseButton(false));
 
    m_auiManager->AddPane(m_rightPanel, wxAuiPaneInfo()
                                            .Name("right_panel")
                                            .Caption("Inspector")
                                            .Right()
                                            .BestSize(wxSize(rightWidth, -1))
                                            .MinSize(wxSize(rightMinWidth, -1))
                                            .Dockable(false)
                                            .Floatable(false)
                                            .CloseButton(false)
                                            .CaptionVisible(false)
                                            .Resizable(true));
 
    m_layout.Track("connection_panel", 0.15, 0.12, true);
    m_layout.Track("right_panel", 0.18, 0.13, true);
 
    m_auiManager->Update();
}
 
void MonitorFrame::SetupCallbacks() {
    m_server.SetConnectCallback([this](const std::string &address) { OnClientConnect(address); });
 
    m_server.SetDisconnectCallback([this]() { OnClientDisconnect(); });
 
    m_server.SetMessageCallback([this](const Network::MessageFrame &frame) {
        if (frame.messageType == Ember::Protocol::MessageType_TickUpdate) {
            m_pendingTickUpdate = frame;
            m_hasPendingTickUpdate = true;
        } else {
            OnServerMessage(frame);
        }
    });
 
    // Wire node selection: canvas -> hierarchy + properties
    m_mainPanel->SetNodeSelectionCallback([this](EmberCore::ITreeNode *node) { OnNodeSelected(node); });
 
    // Wire node selection: navigator hierarchy -> canvas + properties
    m_navigatorTab->SetNodeSelectionCallback([this](EmberCore::ITreeNode *node) {
        OnNodeSelected(node);
        if (node) {
            m_mainPanel->GetTreeCanvas()->SetSelectedNode(node);
        }
    });
 
    m_navigatorTab->SetCallbacks({[]() { return true; }, [this]() { RefreshVisualization(); },
                                  [this](EmberCore::ITreeNode *node) {
                                      if (node) {
                                          m_mainPanel->GetTreeCanvas()->CenterOnNode(node);
                                      }
                                  },
                                  nullptr, nullptr});
}
 
void MonitorFrame::OnFrameResize(wxSizeEvent &event) {
    wxSize newSize = GetClientSize();
    if (m_auiManager && m_lastClientSize.x > 0 && m_lastClientSize.y > 0) {
        m_layout.HandleResize(m_auiManager, m_lastClientSize, newSize);
        m_auiManager->Update();
    }
    m_lastClientSize = newSize;
    event.Skip();
}
 
void MonitorFrame::OnClose(wxCloseEvent &event) {
    m_pollTimer.Stop();
    m_server.Stop();
    if (m_auiManager) {
        m_auiManager->UnInit();
        delete m_auiManager;
        m_auiManager = nullptr;
    }
    Destroy();
}
 
void MonitorFrame::OnQuit(wxCommandEvent &event) { Close(true); }
 
void MonitorFrame::OnAbout(wxCommandEvent &event) {
    wxMessageBox("EmberMonitor v1.0\n\nReal-time Behavior Tree Monitoring", "About EmberMonitor",
                 wxOK | wxICON_INFORMATION, this);
}
 
void MonitorFrame::OnPollTimer(wxTimerEvent &event) {
    m_server.Poll();
 
    if (m_hasPendingTickUpdate) {
        HandleTickUpdate(m_pendingTickUpdate);
        m_hasPendingTickUpdate = false;
        m_mainPanel->GetTreeCanvas()->MarkDirty();
        RefreshVisualization();
    }
 
    if (m_stateChanged) {
        UpdateStatusBar();
        m_stateChanged = false;
    }
}
 
void MonitorFrame::OnClientConnect(const std::string &address) {
    LOG_INFO("Monitor", "Client connected: " + address);
    m_connectionState = ConnectionState::Connected;
    m_connectionPanel->UpdateStatus();
    UpdateStatusBar();
}
 
void MonitorFrame::OnClientDisconnect() {
    LOG_INFO("Monitor", "Client disconnected");
    m_currentTree.reset();
    m_stateManager.reset();
    m_currentTreeId.clear();
    m_connectionState = ConnectionState::Idle;
 
    m_mainPanel->ClearTree();
    m_navigatorTab->ClearMonitorTree();
    m_propertiesTab->ClearNode();
 
    m_connectionPanel->UpdateStatus();
    UpdateStatusBar();
}
 
void MonitorFrame::OnServerMessage(const Network::MessageFrame &frame) {
    LOG_TRACE("Monitor", "Message type=" + std::to_string(static_cast<int>(frame.messageType)) +
                             " payload=" + std::to_string(frame.payload.size()) + " bytes");
    switch (frame.messageType) {
    case Ember::Protocol::MessageType_Handshake:
        HandleHandshake(frame);
        break;
    case Ember::Protocol::MessageType_TreeInit:
        HandleTreeInit(frame);
        break;
    case Ember::Protocol::MessageType_TickUpdate:
        HandleTickUpdate(frame);
        break;
    case Ember::Protocol::MessageType_BlackboardUpdate:
        HandleBlackboardUpdate(frame);
        break;
    case Ember::Protocol::MessageType_TreeReset:
        HandleTreeReset(frame);
        break;
    case Ember::Protocol::MessageType_Disconnect:
        HandleDisconnect(frame);
        break;
    default:
        LOG_WARNING("Monitor", "Unknown message type " + std::to_string(static_cast<int>(frame.messageType)));
        break;
    }
}
 
void MonitorFrame::HandleHandshake(const Network::MessageFrame &frame) {
    LOG_INFO("Monitor", "Handshake received (payload=" + std::to_string(frame.payload.size()) + " bytes)");
    if (!Network::FlatBufferCodec::Verify<Ember::Protocol::Handshake>(frame.payload.data(), frame.payload.size())) {
        LOG_ERROR("Monitor", "Handshake verification failed!");
        auto errorFrame = m_codec.BuildError(Ember::Protocol::ErrorCode_InvalidMessage, "Invalid handshake message");
        m_server.Send(errorFrame);
        return;
    }
 
    auto handshake = Network::FlatBufferCodec::GetRoot<Ember::Protocol::Handshake>(frame.payload);
 
    std::string clientName = handshake->client_name() ? handshake->client_name()->str() : "";
    std::string clientId = handshake->client_id() ? handshake->client_id()->str() : "";
    LOG_INFO("Monitor", "Handshake OK: client='" + clientName + "' id='" + clientId + "'");
 
    m_server.SetClientName(clientName.empty() ? clientId : clientName);
 
    auto ackFrame = m_codec.BuildHandshakeAck("1.0.0", "session_" + std::to_string(time(nullptr)), true);
    m_server.Send(ackFrame);
 
    m_connectionState = ConnectionState::AwaitingTree;
    m_connectionPanel->UpdateStatus();
    m_connectionPanel->SetTreeStatus("Receiving tree...");
    UpdateStatusBar();
}
 
void MonitorFrame::HandleTreeInit(const Network::MessageFrame &frame) {
    LOG_INFO("Monitor", "TreeInit received (payload=" + std::to_string(frame.payload.size()) + " bytes)");
    if (!Network::FlatBufferCodec::Verify<Ember::Protocol::TreeInit>(frame.payload.data(), frame.payload.size())) {
        LOG_ERROR("Monitor", "TreeInit verification failed!");
        auto errorFrame = m_codec.BuildError(Ember::Protocol::ErrorCode_InvalidMessage, "Invalid TreeInit message");
        m_server.Send(errorFrame);
        return;
    }
 
    auto treeInit = Network::FlatBufferCodec::GetRoot<Ember::Protocol::TreeInit>(frame.payload);
    LOG_INFO("Monitor",
             "TreeInit: tree_id='" + std::string(treeInit->tree_id() ? treeInit->tree_id()->c_str() : "(null)") +
                 "' tree_name='" + std::string(treeInit->tree_name() ? treeInit->tree_name()->c_str() : "(null)") +
                 "' has_root=" + std::to_string(treeInit->root() != nullptr));
 
    auto result = m_treeBuilder.Build(treeInit);
 
    if (!result.success) {
        LOG_ERROR("Monitor", "TreeBuilder failed: " + result.error);
        auto ackFrame =
            m_codec.BuildTreeInitAck(treeInit->tree_id() ? treeInit->tree_id()->str() : "", false, 0, result.error);
        m_server.Send(ackFrame);
        return;
    }
 
    LOG_INFO("Monitor", "Tree built: " + std::to_string(result.node_count) +
                            " nodes, hasRoot=" + std::to_string(result.tree->HasRootNode()));
 
    m_currentTree = result.tree;
    m_currentTreeId = treeInit->tree_id() ? treeInit->tree_id()->str() : "";
    m_stateManager = std::make_shared<Network::StateManager>(m_currentTree);
    m_stateManager->EnableHistory(1000);
 
    auto adapter = std::make_shared<Network::TCPTreeAdapter>(m_currentTree, m_stateManager);
    m_mainPanel->SetTree(adapter, m_stateManager);
 
    std::map<std::string, std::shared_ptr<EmberCore::BehaviorTree>> treeMap;
    treeMap[m_currentTreeId] = m_currentTree;
    m_navigatorTab->UpdateTreeList(treeMap, m_currentTreeId);
    m_navigatorTab->SetMonitorTree(adapter, m_stateManager, m_currentTreeId);
 
    m_propertiesTab->SetStateManager(m_stateManager);
 
    auto ackFrame = m_codec.BuildTreeInitAck(m_currentTreeId, true, result.node_count);
    m_server.Send(ackFrame);
 
    m_connectionState = ConnectionState::TreeReady;
    m_connectionPanel->SetTreeId(m_currentTreeId);
    m_connectionPanel->UpdateStatus();
    UpdateStatusBar();
    LOG_INFO("Monitor", "Tree visualization set up. State=TreeReady");
}
 
void MonitorFrame::HandleTickUpdate(const Network::MessageFrame &frame) {
    if (!m_stateManager)
        return;
 
    if (!Network::FlatBufferCodec::Verify<Ember::Protocol::TickUpdate>(frame.payload.data(), frame.payload.size()))
        return;
 
    auto tickUpdate = Network::FlatBufferCodec::GetRoot<Ember::Protocol::TickUpdate>(frame.payload);
    m_stateManager->ApplyTickUpdate(tickUpdate);
 
    m_stateChanged = true;
}
 
void MonitorFrame::HandleBlackboardUpdate(const Network::MessageFrame &frame) {
    if (!m_stateManager)
        return;
 
    if (!Network::FlatBufferCodec::Verify<Ember::Protocol::BlackboardUpdate>(frame.payload.data(),
                                                                             frame.payload.size()))
        return;
 
    auto bbUpdate = Network::FlatBufferCodec::GetRoot<Ember::Protocol::BlackboardUpdate>(frame.payload);
    m_stateManager->ApplyBlackboardUpdate(bbUpdate);
}
 
void MonitorFrame::HandleTreeReset(const Network::MessageFrame &frame) {
    if (!m_stateManager)
        return;
 
    m_stateManager->Reset();
    m_stateChanged = true;
}
 
void MonitorFrame::HandleDisconnect(const Network::MessageFrame &frame) { m_server.DisconnectClient(); }
 
void MonitorFrame::OnNodeSelected(EmberCore::ITreeNode *node) {
    if (m_inNodeSelection)
        return;
    m_inNodeSelection = true;
 
    m_propertiesTab->SetSelectedNode(node);
    m_propertiesTab->Refresh();
 
    if (node) {
        m_navigatorTab->SelectNodeById(node->GetId());
    }
 
    m_inNodeSelection = false;
}
 
void MonitorFrame::RefreshVisualization() {
    m_navigatorTab->RefreshStatus();
    m_propertiesTab->Refresh();
}
 
void MonitorFrame::UpdateStatusBar() {
    if (m_server.IsRunning()) {
        m_statusBar->SetStatusText(wxString::Format("Listening on port %d", m_server.GetPort()), 0);
    } else {
        m_statusBar->SetStatusText("Server stopped", 0);
    }
 
    switch (m_connectionState) {
    case ConnectionState::Connected:
        m_statusBar->SetStatusText("Handshaking...", 1);
        break;
    case ConnectionState::AwaitingTree:
        m_statusBar->SetStatusText("Receiving tree...", 1);
        break;
    case ConnectionState::TreeReady:
        if (m_currentTree) {
            m_statusBar->SetStatusText(wxString::Format("Tree: %s (%lu nodes)", m_currentTree->GetName(),
                                                        static_cast<unsigned long>(m_currentTree->GetNodeCount())),
                                       1);
        } else {
            m_statusBar->SetStatusText("Connected", 1);
        }
        break;
    default:
        m_statusBar->SetStatusText("No client", 1);
        break;
    }
 
    if (m_stateManager) {
        m_statusBar->SetStatusText(
            wxString::Format("Tick: %lld", static_cast<long long>(m_stateManager->GetCurrentTick())), 2);
    } else if (m_connectionState == ConnectionState::AwaitingTree) {
        m_statusBar->SetStatusText("Building tree...", 2);
    } else {
        m_statusBar->SetStatusText("No tree", 2);
    }
 
    int tick = m_stateManager ? static_cast<int>(m_stateManager->GetCurrentTick()) : 0;
    m_mainPanel->GetTreeCanvas()->SetConnectionInfo(m_connectionState == ConnectionState::TreeReady, tick);
}
 
} // namespace Monitor
} // namespace Ember