NodeConditionsPanel.cpp

Go to the documentation of this file.

/**
 * @file NodeConditionsPanel.cpp
 * @brief Implementation of NodeConditionsPanel (Phase 24.2).
 * @author Olympe Engine
 * @date 2026-03-17
 *
 * C++14 compliant — no std::optional, structured bindings, std::filesystem.
 */
 
#include "NodeConditionsPanel.h"
 
#include <algorithm>
#include <iomanip>
#include <sstream>
#include "../../NodeGraphCore/GlobalTemplateBlackboard.h"
 
// ImGui is only compiled in the full editor build.
#ifndef OLYMPE_HEADLESS
#  include "../../third_party/imgui/imgui.h"
#endif
 
namespace Olympe {
 
// ============================================================================
// Constructor
// ============================================================================
 
NodeConditionsPanel::NodeConditionsPanel(ConditionPresetRegistry& registry)
    : m_registry(registry)
    , m_editModal(registry)
{
}
 
// ============================================================================
// State accessors
// ============================================================================
 
void NodeConditionsPanel::SetConditionRefs(const std::vector<NodeConditionRef>& refs)
{
    m_conditionRefs = refs;
    NormalizeLogicalOps();
 
    // Resize the operand-ref list to stay in sync with conditionRefs.
    // Preserve existing entries where possible; add defaults for new entries.
    if (m_conditionOperandRefs.size() != m_conditionRefs.size())
    {
        m_conditionOperandRefs.resize(m_conditionRefs.size());
        for (size_t i = 0; i < m_conditionOperandRefs.size(); ++i)
            m_conditionOperandRefs[i].conditionIndex = static_cast<int>(i);
    }
 
    m_dirty = false;
}
 
const std::vector<NodeConditionRef>& NodeConditionsPanel::GetConditionRefs() const
{
    return m_conditionRefs;
}
 
void NodeConditionsPanel::SetConditionOperandRefs(const std::vector<ConditionRef>& refs)
{
    m_conditionOperandRefs = refs;
}
 
const std::vector<ConditionRef>& NodeConditionsPanel::GetConditionOperandRefs() const
{
    return m_conditionOperandRefs;
}
 
void NodeConditionsPanel::SetDynamicPins(const std::vector<DynamicDataPin>& pins)
{
    m_dynamicPins = pins;
}
 
// ============================================================================
// Condition management
// ============================================================================
 
void NodeConditionsPanel::AddCondition(const std::string& presetID)
{
    if (presetID.empty())
        return;
 
    LogicalOp op = m_conditionRefs.empty() ? LogicalOp::Start : LogicalOp::And;
    m_conditionRefs.emplace_back(presetID, op);
    NormalizeLogicalOps();
 
    // Add a matching ConditionRef initialized from the preset's default operands.
    ConditionRef cref;
    cref.conditionIndex = static_cast<int>(m_conditionRefs.size()) - 1;
    const ConditionPreset* preset = m_registry.GetPreset(presetID);
    if (preset)
    {
        // Initialize from the preset's left operand
        switch (preset->left.mode)
        {
            case OperandMode::Variable:
                cref.leftOperand.mode = OperandRef::Mode::Variable;
                cref.leftOperand.variableName = preset->left.stringValue;
                break;
            case OperandMode::Pin:
                cref.leftOperand.mode = OperandRef::Mode::Pin;
                break;
            case OperandMode::Const:
            default:
                cref.leftOperand.mode = OperandRef::Mode::Const;
                {
                    std::ostringstream oss;
                    oss << preset->left.constValue;
                    cref.leftOperand.constValue = oss.str();
                }
                break;
        }
        // Initialize operator string
        switch (preset->op)
        {
            case ComparisonOp::Equal:        cref.operatorStr = "=="; break;
            case ComparisonOp::NotEqual:     cref.operatorStr = "!="; break;
            case ComparisonOp::Less:         cref.operatorStr = "<";  break;
            case ComparisonOp::LessEqual:    cref.operatorStr = "<="; break;
            case ComparisonOp::Greater:      cref.operatorStr = ">";  break;
            case ComparisonOp::GreaterEqual: cref.operatorStr = ">="; break;
            default:                         cref.operatorStr = "=="; break;
        }
        // Initialize from the preset's right operand
        switch (preset->right.mode)
        {
            case OperandMode::Variable:
                cref.rightOperand.mode = OperandRef::Mode::Variable;
                cref.rightOperand.variableName = preset->right.stringValue;
                break;
            case OperandMode::Pin:
                cref.rightOperand.mode = OperandRef::Mode::Pin;
                break;
            case OperandMode::Const:
            default:
                cref.rightOperand.mode = OperandRef::Mode::Const;
                {
                    std::ostringstream oss;
                    oss << preset->right.constValue;
                    cref.rightOperand.constValue = oss.str();
                }
                break;
        }
    }
    m_conditionOperandRefs.push_back(cref);
 
    m_dirty = true;
 
    if (OnPresetChanged)
        OnPresetChanged(presetID);
}
 
void NodeConditionsPanel::RemoveCondition(size_t index)
{
    if (index >= m_conditionRefs.size())
        return;
 
    m_conditionRefs.erase(m_conditionRefs.begin() + static_cast<int>(index));
 
    // Keep operand refs in sync
    if (index < m_conditionOperandRefs.size())
    {
        m_conditionOperandRefs.erase(
            m_conditionOperandRefs.begin() + static_cast<int>(index));
    }
    // Re-index remaining operand refs
    for (size_t i = index; i < m_conditionOperandRefs.size(); ++i)
        m_conditionOperandRefs[i].conditionIndex = static_cast<int>(i);
 
    NormalizeLogicalOps();
    m_dirty = true;
}
 
void NodeConditionsPanel::SetLogicalOp(size_t index, LogicalOp op)
{
    if (index >= m_conditionRefs.size())
        return;
 
    // Index 0 is always Start
    m_conditionRefs[index].logicalOp = (index == 0) ? LogicalOp::Start : op;
    m_dirty = true;
}
 
size_t NodeConditionsPanel::GetConditionCount() const
{
    return m_conditionRefs.size();
}
 
// ============================================================================
// Preset deletion handler
// ============================================================================
 
void NodeConditionsPanel::OnPresetDeleted(const std::string& deletedPresetID)
{
    bool changed = false;
    auto it = m_conditionRefs.begin();
    while (it != m_conditionRefs.end())
    {
        if (it->presetID == deletedPresetID)
        {
            it      = m_conditionRefs.erase(it);
            changed = true;
        }
        else
        {
            ++it;
        }
    }
 
    if (changed)
    {
        NormalizeLogicalOps();
        m_dirty = true;
    }
}
 
// ============================================================================
// Validation
// ============================================================================
 
bool NodeConditionsPanel::IsValid() const
{
    return Validate().empty();
}
 
std::vector<std::string> NodeConditionsPanel::Validate() const
{
    std::vector<std::string> errors;
 
    for (size_t i = 0; i < m_conditionRefs.size(); ++i)
    {
        const NodeConditionRef& ref = m_conditionRefs[i];
 
        if (ref.presetID.empty())
        {
            std::ostringstream oss;
            oss << "Condition " << (i + 1) << ": preset ID is empty.";
            errors.push_back(oss.str());
            continue;
        }
 
        if (!m_registry.ValidatePresetID(ref.presetID))
        {
            std::ostringstream oss;
            oss << "Condition " << (i + 1) << ": preset \"" << ref.presetID
                << "\" not found in registry.";
            errors.push_back(oss.str());
        }
    }
 
    return errors;
}
 
// ============================================================================
// Dropdown filter
// ============================================================================
 
void NodeConditionsPanel::SetDropdownFilter(const std::string& filter)
{
    m_dropdownFilter = filter;
}
 
std::vector<ConditionPreset>
NodeConditionsPanel::GetFilteredPresetsForDropdown() const
{
    if (m_dropdownFilter.empty())
    {
        // Return all presets in registry order
        std::vector<ConditionPreset> result;
        for (const auto& id : m_registry.GetAllPresetIDs())
        {
            const ConditionPreset* p = m_registry.GetPreset(id);
            if (p)
                result.push_back(*p);
        }
        return result;
    }
 
    // Filtered by name substring
    std::vector<ConditionPreset> result;
    for (const auto& id : m_registry.FindPresetsByName(m_dropdownFilter))
    {
        const ConditionPreset* p = m_registry.GetPreset(id);
        if (p)
            result.push_back(*p);
    }
    return result;
}
 
// ============================================================================
// Rendering
// ============================================================================
 
void NodeConditionsPanel::Render()
{
#ifndef OLYMPE_HEADLESS
    ImGui::PushID("NodeConditionsPanel");
 
    // Phase 24 UX: Integrate condition editing INLINE (no modal popup)
    // Render collapsible editor section directly in properties panel
    RenderInlineConditionEditor();
 
    ImGui::PopID();
#endif
}
 
void NodeConditionsPanel::RenderInlineConditionEditor()
{
#ifndef OLYMPE_HEADLESS
    // Phase 24 UX Refactor: Replace modal with inline collapsible editor
    ImGui::PushStyleColor(ImGuiCol_Header,        ImVec4(0.0f, 0.7f, 0.4f, 1.0f));
    ImGui::PushStyleColor(ImGuiCol_HeaderHovered, ImVec4(0.0f, 0.8f, 0.5f, 1.0f));
    ImGui::PushStyleColor(ImGuiCol_HeaderActive,  ImVec4(0.0f, 0.6f, 0.3f, 1.0f));
    const bool editorOpen = ImGui::CollapsingHeader(
        "Conditions Editor (Inline)",
        ImGuiTreeNodeFlags_DefaultOpen);
    ImGui::PopStyleColor(3);
 
    if (!editorOpen)
        return;
 
    ImGui::Indent(8.f);
 
    // Conditions list with inline editing
    ImGui::Text("Active Conditions:");
    ImGui::BeginChild("ConditionsList##Inline", ImVec2(0.f, 120.f), true);
 
    // Render each condition with edit controls
    for (size_t i = 0; i < m_conditionRefs.size(); ++i)
    {
        RenderInlineConditionRow(i, m_conditionRefs[i]);
    }
 
    ImGui::EndChild();
    ImGui::Spacing();
 
    // Add condition button + preset picker inline
    RenderInlineAddCondition();
 
    ImGui::Unindent(8.f);
#endif
}
 
void NodeConditionsPanel::RenderInlineConditionRow(size_t index,
                                                    const NodeConditionRef& ref)
{
#ifndef OLYMPE_HEADLESS
    ImGui::PushID(static_cast<int>(index));
 
    // Logical operator dropdown (disabled for first entry)
    if (index == 0)
    {
        ImGui::TextDisabled("     ");
    }
    else
    {
        const char* ops[] = { "And", "Or" };
        int current = (ref.logicalOp == LogicalOp::And) ? 0 : 1;
        ImGui::SetNextItemWidth(60.f);
        if (ImGui::Combo("##op", &current, ops, 2))
        {
            SetLogicalOp(index, (current == 0) ? LogicalOp::And : LogicalOp::Or);
            m_dirty = true;
            if (OnDynamicPinsNeedRegeneration)
                OnDynamicPinsNeedRegeneration();
        }
    }
 
    ImGui::SameLine();
 
    // Condition preset preview — green text
    const ConditionPreset* preset = m_registry.GetPreset(ref.presetID);
    if (preset)
    {
        ImGui::TextColored(ImVec4(0.0f, 1.0f, 0.0f, 1.0f),
                           "[%s] %s", preset->name.c_str(), preset->GetPreview().c_str());
    }
    else
    {
        ImGui::TextColored(ImVec4(1.f, 0.3f, 0.3f, 1.f),
                           "(missing: %s)", ref.presetID.c_str());
    }
 
    ImGui::SameLine();
 
    // Move up button
    if (ImGui::SmallButton("^##up"))
    {
        if (index > 0)
        {
            std::swap(m_conditionRefs[index - 1], m_conditionRefs[index]);
            m_dirty = true;
        }
    }
 
    ImGui::SameLine();
 
    // Move down button
    if (ImGui::SmallButton("v##dn"))
    {
        if (index < m_conditionRefs.size() - 1)
        {
            std::swap(m_conditionRefs[index], m_conditionRefs[index + 1]);
            m_dirty = true;
        }
    }
 
    ImGui::SameLine();
 
    // Delete button
    if (ImGui::SmallButton("X##del"))
    {
        m_conditionRefs.erase(m_conditionRefs.begin() + static_cast<int>(index));
        // Adjust operandRefs if they exist
        if (index < m_conditionOperandRefs.size())
            m_conditionOperandRefs.erase(m_conditionOperandRefs.begin() + static_cast<int>(index));
        m_dirty = true;
        if (OnDynamicPinsNeedRegeneration)
            OnDynamicPinsNeedRegeneration();
    }
 
    ImGui::PopID();
#endif
}
 
void NodeConditionsPanel::RenderInlineAddCondition()
{
#ifndef OLYMPE_HEADLESS
    // Toggle button for preset picker
    if (ImGui::Button("+ Add Condition", ImVec2(-1.f, 24.f)))
        m_pickerOpen = !m_pickerOpen;
 
    if (m_pickerOpen)
    {
        // Search filter
        ImGui::Spacing();
        ImGui::TextDisabled("Search presets:");
        static char filterBuf[256] = {};
        ImGui::InputText("##PresetFilter", filterBuf, sizeof(filterBuf));
 
        // Get filtered preset list from registry
        std::string filter = std::string(filterBuf);
        std::vector<ConditionPreset> filteredPresets = m_registry.GetFilteredPresets(filter);
 
        // Filtered preset list
        ImGui::BeginChild("PresetPickerList##Inline", ImVec2(0.f, 150.f), true);
 
        for (const auto& preset : filteredPresets)
        {
            const std::string label = preset.name + "  " + preset.GetPreview();
            if (ImGui::Selectable(label.c_str()))
            {
                // Add new condition
                LogicalOp op = m_conditionRefs.empty() ? LogicalOp::Start : LogicalOp::And;
                m_conditionRefs.emplace_back(preset.id, op);
                m_dirty = true;
 
                // Clear filter and close picker
                filterBuf[0] = '\0';
                m_pickerOpen = false;
 
                if (OnDynamicPinsNeedRegeneration)
                    OnDynamicPinsNeedRegeneration();
            }
        }
 
        if (filteredPresets.empty())
            ImGui::TextDisabled("No presets found.");
 
        ImGui::EndChild();
    }
#endif
}
 
void NodeConditionsPanel::RenderTitleSection()
{
#ifndef OLYMPE_HEADLESS
    // Blue background (#0066CC equivalent) with white text — matches canvas node
    ImGui::PushStyleColor(ImGuiCol_Header,        ImVec4(0.0f, 0.4f, 0.8f, 1.0f));
    ImGui::PushStyleColor(ImGuiCol_HeaderHovered, ImVec4(0.0f, 0.5f, 0.9f, 1.0f));
    ImGui::PushStyleColor(ImGuiCol_HeaderActive,  ImVec4(0.0f, 0.3f, 0.7f, 1.0f));
    ImGui::PushStyleColor(ImGuiCol_Text,          ImVec4(1.0f, 1.0f, 1.0f, 1.0f));
    const std::string& title = m_nodeName.empty() ? "Node" : m_nodeName;
    ImGui::Selectable(title.c_str(), true, ImGuiSelectableFlags_None, ImVec2(0.f, 28.f));
    ImGui::PopStyleColor(4);
#endif
}
 
void NodeConditionsPanel::RenderExecPinsSection()
{
#ifndef OLYMPE_HEADLESS
    // Static exec pins — never editable from this panel
    const float columnWidth = 120.f;
 
    ImGui::TextDisabled("In");
    ImGui::SameLine(columnWidth);
    ImGui::TextDisabled("Then");
 
    ImGui::TextDisabled("  ");
    ImGui::SameLine(columnWidth);
    ImGui::TextDisabled("Else");
#endif
}
 
void NodeConditionsPanel::RenderConditionsPreview()
{
#ifndef OLYMPE_HEADLESS
    // Green text for condition previews (READ-ONLY)
    const ImVec4 condColor(0.f, 1.f, 0.f, 1.f);
 
    ImGui::TextDisabled("Conditions Preview:");
 
    if (m_conditionRefs.empty())
    {
        ImGui::TextDisabled("  (no conditions)");
    }
    else
    {
        for (size_t i = 0; i < m_conditionRefs.size(); ++i)
        {
            const NodeConditionRef& ref = m_conditionRefs[i];
 
            ImGui::PushID(static_cast<int>(i));
 
            // Format: "[LogicalOp] Condition #N: [preview]"
            std::string linePrefix = "  ";  // Indentation
            if (i > 0)
            {
                if (ref.logicalOp == LogicalOp::And)
                    linePrefix += "And ";
                else if (ref.logicalOp == LogicalOp::Or)
                    linePrefix += "Or  ";
            }
            else
            {
                linePrefix += "If  ";
            }
 
            const ConditionPreset* preset = m_registry.GetPreset(ref.presetID);
            ImGui::PushStyleColor(ImGuiCol_Text, condColor);
 
            // Format: "  If    Condition #1: [mHealth] <= [100.00]"
            // or:     "  And   Condition #2: [mSpeed] == [Pin-in #1]"
            // Phase 24: Build preview from ACTUAL operand data (ConditionRef), not static preset
            // This ensures Pin-mode operands display correctly (e.g., "Pin-in #1" instead of old const value)
            std::string conditionPreview;
            if (preset && i < m_conditionOperandRefs.size())
            {
                const ConditionRef& cref = m_conditionOperandRefs[i];
                std::ostringstream oss;
 
                // Left operand
                oss << "[";
                if (cref.leftOperand.mode == OperandRef::Mode::Variable)
                    oss << cref.leftOperand.variableName;
                else if (cref.leftOperand.mode == OperandRef::Mode::Pin)
                    oss << "Pin-in #" << (i + 1) << "L";
                else
                    oss << cref.leftOperand.constValue;
                oss << "]";
 
                // Operator
                oss << " " << cref.operatorStr << " ";
 
                // Right operand
                oss << "[";
                if (cref.rightOperand.mode == OperandRef::Mode::Variable)
                    oss << cref.rightOperand.variableName;
                else if (cref.rightOperand.mode == OperandRef::Mode::Pin)
                    oss << "Pin-in #" << (i + 1) << "R";
                else
                    oss << cref.rightOperand.constValue;
                oss << "]";
 
                conditionPreview = oss.str();
            }
            else if (preset)
            {
                // Fallback to preset preview if operand data not available
                conditionPreview = preset->GetPreview();
            }
            else
            {
                conditionPreview = "(missing: " + ref.presetID + ")";
            }
 
            ImGui::Text("%sCondition #%zu: %s", linePrefix.c_str(), i + 1, conditionPreview.c_str());
            ImGui::PopStyleColor();
 
            ImGui::PopID();
        }
    }
 
    ImGui::Spacing();
 
    // "Edit Conditions" button — full width — opens the owned modal
    if (ImGui::Button("Edit Conditions", ImVec2(-1.f, 24.f)))
    {
        m_editModalRequested = true;
        // Phase 24: Pass both conditionRefs AND operandRefs to the modal
        m_editModal.Open(m_conditionRefs, m_conditionOperandRefs);
    }
#endif
}
 
void NodeConditionsPanel::RenderConditionList()
{
#ifndef OLYMPE_HEADLESS
    // UI layout constants
    static const float  kOpComboWidth    = 60.f;  ///< Width of the And/Or combo
    static const float  kDeleteBtnWidth  = 22.f;  ///< Width of the [X] delete button
    static const size_t kFilterBufSize   = 256u;  ///< Max filter string length incl. NUL
 
    // Collapsible section header — green tint to match condition colour convention
    ImGui::PushStyleColor(ImGuiCol_Text, ImVec4(0.f, 0.9f, 0.f, 1.f));
    const bool open = ImGui::CollapsingHeader(
        "Structured Conditions (evaluated with implicit AND)",
        ImGuiTreeNodeFlags_DefaultOpen);
    ImGui::PopStyleColor();
 
    if (!open)
        return;
 
    const ImVec4 condColor(0.f, 1.f, 0.f, 1.f);   // green for preview text (unused in list, kept for IDE compat)
    (void)condColor;
 
    // Deferred-deletion index (avoids invalidating the iterator inside the loop)
    size_t deleteIdx = static_cast<size_t>(-1);
 
    for (size_t i = 0; i < m_conditionRefs.size(); ++i)
    {
        NodeConditionRef& ref = m_conditionRefs[i];
        ImGui::PushID(static_cast<int>(i));
 
        // ── Operand editors (left operand | operator | right operand) ─────────
        // Ensure parallel operand-ref list is always in sync
        if (i >= m_conditionOperandRefs.size())
        {
            ConditionRef newCref;
            newCref.conditionIndex = static_cast<int>(i);
            m_conditionOperandRefs.push_back(newCref);
        }
        ConditionRef& cref = m_conditionOperandRefs[i];
 
        // Resolve short pin labels for Pin-mode operands
        std::string leftPinLabel, rightPinLabel;
        for (const auto& pin : m_dynamicPins)
        {
            if (pin.conditionIndex == static_cast<int>(i))
            {
                if (pin.position == OperandPosition::Left)
                    leftPinLabel = pin.GetShortLabel();
                else
                    rightPinLabel = pin.GetShortLabel();
            }
        }
 
        ImGui::PushID("left");
        RenderOperandDropdown(cref, /*isLeft=*/true, leftPinLabel);
        ImGui::PopID();
 
        ImGui::SameLine();
        ImGui::PushID("op");
        RenderOperatorDropdown(cref);
        ImGui::PopID();
 
        ImGui::SameLine();
        ImGui::PushID("right");
        RenderOperandDropdown(cref, /*isLeft=*/false, rightPinLabel);
        ImGui::PopID();
 
        ImGui::SameLine();
        if (i > 0)
        {
            ImGui::SetNextItemWidth(kOpComboWidth);
            const char* opLabel = (ref.logicalOp == LogicalOp::Or) ? "Or" : "And";
            if (ImGui::BeginCombo("##op", opLabel, ImGuiComboFlags_NoArrowButton))
            {
                if (ImGui::Selectable("And", ref.logicalOp == LogicalOp::And))
                {
                    ref.logicalOp = LogicalOp::And;
                    m_dirty = true;
                }
                if (ImGui::Selectable("Or", ref.logicalOp == LogicalOp::Or))
                {
                    ref.logicalOp = LogicalOp::Or;
                    m_dirty = true;
                }
                ImGui::EndCombo();
            }
            ImGui::SameLine();
        }
        else
        {
            // Reserve the same horizontal space as the combo so [X] buttons align
            ImGui::Dummy(ImVec2(kOpComboWidth, 0.f));
            ImGui::SameLine();
        }
 
        // ── Delete button (X) ─────────────────────────────────────────────────
        ImGui::SetNextItemWidth(kDeleteBtnWidth);
        if (ImGui::SmallButton("X"))
            deleteIdx = i;
 
        ImGui::PopID();
    }
 
    // Apply deferred deletion outside the loop to avoid iterator invalidation
    if (deleteIdx != static_cast<size_t>(-1))
        RemoveCondition(deleteIdx);
 
    // ── Empty-list placeholder ────────────────────────────────────────────────
    if (m_conditionRefs.empty())
        ImGui::TextDisabled("(no conditions — click [+ Add Condition] below)");
 
    ImGui::Spacing();
 
    // ── [+ Add Condition] button -> opens preset-selector popup ───────────────
    if (ImGui::Button("[+ Add Condition]", ImVec2(-1.f, 0.f)))
        ImGui::OpenPopup("##AddCondPopup");
 
    if (ImGui::BeginPopup("##AddCondPopup"))
    {
        // Filter input
        char filterBuf[kFilterBufSize] = {};
        {
            const std::string& cur = m_dropdownFilter;
            const size_t copyLen =
                cur.size() < (kFilterBufSize - 1u) ? cur.size() : kFilterBufSize - 1u;
            cur.copy(filterBuf, copyLen);
        }
        if (ImGui::InputText("Filter", filterBuf, kFilterBufSize))
            SetDropdownFilter(filterBuf);
 
        ImGui::Separator();
 
        const auto presets = GetFilteredPresetsForDropdown();
        for (const auto& p : presets)
        {
            const std::string rowLabel = p.name + "  —  " + p.GetPreview();
            if (ImGui::Selectable(rowLabel.c_str()))
            {
                AddCondition(p.id);
                SetDropdownFilter("");
                ImGui::CloseCurrentPopup();
 
                if (OnDynamicPinsNeedRegeneration)
                    OnDynamicPinsNeedRegeneration();
            }
        }
 
        if (presets.empty())
            ImGui::TextDisabled("(no presets in registry)");
 
        ImGui::EndPopup();
    }
#endif
}
 
 
void NodeConditionsPanel::RenderDynamicPinsSection()
{
#ifndef OLYMPE_HEADLESS
    // Yellow color (#FFD700) for dynamic pins
    const ImVec4 pinColor(1.0f, 0.843f, 0.0f, 1.0f);
    for (const auto& pin : m_dynamicPins)
    {
        const std::string displayLabel = pin.GetDisplayLabel();
        ImGui::TextColored(pinColor, "%s", displayLabel.c_str());
 
        // Hover tooltip shows full label
        if (ImGui::IsItemHovered())
        {
            ImGui::SetTooltip("%s", displayLabel.c_str());
        }
    }
#endif
}
 
void NodeConditionsPanel::RenderOperandDropdown(ConditionRef& cref, bool isLeft,
                                                 const std::string& pinLabel)
{
#ifndef OLYMPE_HEADLESS
    OperandRef& op = isLeft ? cref.leftOperand : cref.rightOperand;
 
    // Build unified dropdown: [Pin-in #1] [Pin-in #2] ... [Const] <value> ... Variables (sorted)
    std::vector<std::string> allOptions;
    std::vector<int> optionTypes;  // 0=Variable, 1=Const, 2=Pin
    std::vector<std::string> optionValues;
 
    int currentSelectionIdx = -1;
 
    // ── Add all available pins FIRST ─────────────────────────────────────
    for (const auto& pin : m_dynamicPins)
    {
        if (pin.conditionIndex == cref.conditionIndex)
        {
            if ((isLeft && pin.position == OperandPosition::Left) ||
                (!isLeft && pin.position == OperandPosition::Right))
            {
                // Phase 24: Show just the pin's short label, not duplicated "[Pin-in] Pin-in #N"
                allOptions.push_back(pin.GetShortLabel());
                optionTypes.push_back(2);  // Pin
                optionValues.push_back(pin.id);
 
                if (op.mode == OperandRef::Mode::Pin && op.dynamicPinID == pin.id)
                {
                    currentSelectionIdx = static_cast<int>(allOptions.size() - 1);
                }
            }
        }
    }
 
    // ── Add [Const] option SECOND ────────────────────────────────────────
    {
        std::string constLabel = "[Const] ";
        std::ostringstream oss;
        oss << std::fixed << std::setprecision(3) << std::stod(op.constValue);
        std::string constVal = oss.str();
        // Trim trailing zeros
        size_t dot = constVal.find('.');
        if (dot != std::string::npos)
        {
            size_t last = constVal.find_last_not_of('0');
            if (last != std::string::npos && last > dot)
                constVal = constVal.substr(0, last + 1);
            else if (last == dot)
                constVal = constVal.substr(0, dot);
        }
        constLabel += constVal;
 
        allOptions.push_back(constLabel);
        optionTypes.push_back(1);  // Const
        optionValues.push_back(op.constValue);
 
        if (op.mode == OperandRef::Mode::Const)
        {
            currentSelectionIdx = static_cast<int>(allOptions.size() - 1);
        }
    }
 
    // ── Add all variables (local + global) LAST (sorted alphabetically) ────
    // Separate local and global variables with a visual separator
    int variableStartIdx = static_cast<int>(allOptions.size());
 
    // Add local variables first
    for (const auto& localVar : m_localVariables)
    {
        allOptions.push_back(localVar.Key);
        optionTypes.push_back(0);  // Variable
        optionValues.push_back(localVar.Key);
 
        if (op.mode == OperandRef::Mode::Variable && op.variableName == localVar.Key)
        {
            currentSelectionIdx = static_cast<int>(allOptions.size()) - 1;
        }
    }
 
    // Add separator if we have both local and global variables
    if (!m_localVariables.empty())
    {
        allOptions.push_back("--- Global Variables ---");
        optionTypes.push_back(-1);  // Separator (non-selectable)
        optionValues.push_back("");
    }
 
    // Add global variables
    GlobalTemplateBlackboard& gtb = GlobalTemplateBlackboard::Get();
    const std::vector<GlobalEntryDefinition>& globalVars = gtb.GetAllVariables();
    for (const auto& globalVar : globalVars)
    {
        allOptions.push_back(globalVar.Key);
        optionTypes.push_back(0);  // Variable
        optionValues.push_back(globalVar.Key);
 
        if (op.mode == OperandRef::Mode::Variable && op.variableName == globalVar.Key)
        {
            currentSelectionIdx = static_cast<int>(allOptions.size()) - 1;
        }
    }
 
    ImGui::SetNextItemWidth(120.0f);
    const char* displayText = (currentSelectionIdx >= 0 && currentSelectionIdx < static_cast<int>(allOptions.size()))
                              ? allOptions[currentSelectionIdx].c_str()
                              : "Variable";
 
    if (ImGui::BeginCombo("##operand_dropdown", displayText))
    {
        // Const options
        for (int i = 0; i < static_cast<int>(allOptions.size()); ++i)
        {
            if (optionTypes[i] == -1)
            {
                // Separator (non-selectable)
                ImGui::TextDisabled("%s", allOptions[i].c_str());
                ImGui::Separator();
            }
            else if (optionTypes[i] == 0)
            {
                // Variable option
                bool selected = (i == currentSelectionIdx);
                if (ImGui::Selectable(allOptions[i].c_str(), selected))
                {
                    op.mode = OperandRef::Mode::Variable;
                    op.variableName = allOptions[i];
                    currentSelectionIdx = i;
                    m_dirty = true;
                    if (OnDynamicPinsNeedRegeneration)
                        OnDynamicPinsNeedRegeneration();
                }
            }
            else if (optionTypes[i] == 1 || optionTypes[i] == 2)
            {
                // Const or Pin option
                bool selected = (i == currentSelectionIdx);
                if (ImGui::Selectable(allOptions[i].c_str(), selected))
                {
                    switch (optionTypes[i])
                    {
                        case 1:  // Const
                            op.mode = OperandRef::Mode::Const;
                            op.constValue = optionValues[i];
                            break;
                        case 2:  // Pin
                            op.mode = OperandRef::Mode::Pin;
                            op.dynamicPinID = optionValues[i];
                            break;
                    }
                    currentSelectionIdx = i;
                    m_dirty = true;
                    if (OnDynamicPinsNeedRegeneration)
                        OnDynamicPinsNeedRegeneration();
                }
            }
        }
 
        ImGui::EndCombo();
    }
 
    ImGui::SameLine();
 
    // ── Input field based on current mode ────────────────────────────────
    static const size_t kBufSize = 128u;
    switch (op.mode)
    {
        case OperandRef::Mode::Variable:
        {
            char buf[kBufSize] = {};
            const std::string& cur = op.variableName;
            const size_t copyLen = cur.size() < (kBufSize - 1u) ? cur.size() : kBufSize - 1u;
            cur.copy(buf, copyLen);
            ImGui::SetNextItemWidth(80.f);
            if (ImGui::InputText("##varname", buf, kBufSize))
            {
                op.variableName = buf;
                m_dirty = true;
            }
            break;
        }
        case OperandRef::Mode::Const:
        {
            // Try to parse as double, but show as text in dropdown
            double doubleVal = 0.0;
            try {
                doubleVal = std::stod(op.constValue);
            } catch (...) {
                // Parse failed, keep 0.0
            }
 
            ImGui::SetNextItemWidth(80.f);
            if (ImGui::InputDouble("##constval", &doubleVal, 0.0, 0.0, "%.3f"))
            {
                std::ostringstream oss;
                oss << doubleVal;
                op.constValue = oss.str();
                m_dirty = true;
            }
            break;
        }
        case OperandRef::Mode::Pin:
        {
            // Read-only: show the "Pin-in #N" label
            const std::string display = pinLabel.empty() ? "[Pin-in]" : pinLabel;
            ImGui::SetNextItemWidth(80.f);
            ImGui::TextDisabled("%s", display.c_str());
            break;
        }
        default:
            break;
    }
#endif
}
 
void NodeConditionsPanel::RenderOperatorDropdown(ConditionRef& cref)
{
#ifndef OLYMPE_HEADLESS
    static const char* kOperators[] = { "==", "!=", "<", "<=", ">", ">=" };
    static const int   kNumOps = 6;
 
    int currentOp = 0;
    for (int i = 0; i < kNumOps; ++i)
    {
        if (cref.operatorStr == kOperators[i])
        {
            currentOp = i;
            break;
        }
    }
 
    ImGui::SetNextItemWidth(44.f);
    if (ImGui::BeginCombo("##op2", kOperators[currentOp], ImGuiComboFlags_NoArrowButton))
    {
        for (int i = 0; i < kNumOps; ++i)
        {
            bool selected = (i == currentOp);
            if (ImGui::Selectable(kOperators[i], selected))
            {
                cref.operatorStr = kOperators[i];
                m_dirty = true;
            }
        }
        ImGui::EndCombo();
    }
#endif
}
 
// ============================================================================
// Internal helpers
// ============================================================================
 
void NodeConditionsPanel::NormalizeLogicalOps()
{
    if (!m_conditionRefs.empty())
        m_conditionRefs[0].logicalOp = LogicalOp::Start;
}
 
} // namespace Olympe