OrcaSlicer/src/slic3r/GUI/AMSDryControl.cpp

#include "AMSDryControl.hpp"
#include "slic3r/GUI/DeviceCore/DevFilaSystem.h"
#include "GUI_App.hpp"
#include "slic3r/Utils/NetworkAgent.hpp"
#include "I18N.hpp"

#include "slic3r/GUI/DeviceCore/DevExtruderSystem.h"

#include "slic3r/GUI/DeviceCore/DevManager.h"

#include "slic3r/GUI/MsgDialog.hpp"

#include "slic3r/GUI/Widgets/AnimaController.hpp"
#include "slic3r/GUI/Widgets/Label.hpp"
#include "slic3r/GUI/Widgets/ComboBox.hpp"
#include "slic3r/GUI/Widgets/ProgressBar.hpp"
#include "slic3r/GUI/DeviceCore/DevUtilBackend.h"

#include "libslic3r/PresetBundle.hpp"
#include "libslic3r/Preset.hpp"

#include <algorithm>
#include <boost/log/trivial.hpp>
#include <string>
#include "slic3r/GUI/DeviceCore/DevDefs.h"
#include <wx/string.h>
#include <wx/event.h>
#include <wx/panel.h>
#include <wx/colour.h>
#include "slic3r/GUI/Widgets/StateColor.hpp"
#include <wx/gdicmn.h>
#include "libslic3r/Exception.hpp"
#include <wx/dcclient.h>
#include "slic3r/GUI/GUI_Utils.hpp"
#include <wx/toplevel.h>
#include <wx/scrolwin.h>
#include "slic3r/GUI/Widgets/AMSItem.hpp"
#include <wx/chartype.h>
#include "slic3r/GUI/Widgets/Button.hpp"
#include <utility>
#include <chrono>
#include <optional>
#include <wx/timer.h>
#include "libslic3r/Utils.hpp"
#include <unordered_set>
#include <vector>
#include <set>
#include <sstream>
#include <ios>
#include <iomanip>
#include "slic3r/GUI/DeviceCore/DevConfigUtil.h"
#include <limits>
#include <memory>

namespace Slic3r { namespace GUI {

const int AMS_DRY_STATUS_IMAGE_SIZE = 96;

static std::string get_humidity_level_img_path(int humidity_percent)
{
    const int num_levels = 5;
    int hum_level;

    if (humidity_percent <= 100 / num_levels) {
        hum_level = 5;
    } else if (humidity_percent <= 100 / num_levels * 2) {
        hum_level = 4;
    } else if (humidity_percent <= 100 / num_levels * 3) {
        hum_level = 3;
    } else if (humidity_percent <= 100 / num_levels * 4) {
        hum_level = 2;
    } else {
        hum_level = 1;
    }

    if (wxGetApp().dark_mode()) {
        return "hum_level" + std::to_string(hum_level) + "_no_num_dark"; // Orca: use the dark-mode humidity glyph in dark mode
    } else {
        return "hum_level" + std::to_string(hum_level) + "_no_num_light";
    }

}

static std::string get_dry_status_img_path(DevAmsType type, DevAms::DryStatus status, DevAms::DrySubStatus sub_status)
{
    std::string img_name = "dev_ams_dry_ctr_";
    switch (type) {
        case DevAmsType::N3S:
            img_name += "n3s";
            break;
        case DevAmsType::N3F:
            img_name += "n3f";
            break;
        default:
            return "";
    }

    img_name += "_";
    switch (status) {
        case DevAms::DryStatus::Error:
            img_name += "error";
            return img_name;
    }

    switch (sub_status) {
        case DevAms::DrySubStatus::Heating:
            img_name += "heating";
            return img_name;
        case DevAms::DrySubStatus::Dehumidify:
            img_name += "dehumidifying";
            return img_name;
    }

    return "";
}

FilamentItemPanel::FilamentItemPanel(wxWindow* parent, const wxString& text, const std::string& icon_name, wxWindowID id)
    : wxPanel(parent, id)
    , m_icon_name(icon_name)
{
    SetBackgroundColour(wxColour("#F0F0F1")); // Orca: light-gray panel scheme (#F0F0F1 replaces REF #F7F7F7)
    SetMinSize(wxSize(FromDIP(64), FromDIP(106))); // Width: 64, Height: 106
    SetSize(wxSize(FromDIP(64), FromDIP(106)));    // Fixed size

    // Create sizer for vertical layout
    wxBoxSizer* sizer = new wxBoxSizer(wxVERTICAL);

    // Top section with text - moved to be closer to center
    wxBoxSizer* top_sizer = new wxBoxSizer(wxVERTICAL);
    top_sizer->AddStretchSpacer(5);

    m_text_label = new Label(this, text);
    m_text_label->SetForegroundColour(StateColor::darkModeColorFor(wxColour(*wxBLACK)));
    m_text_label->SetBackgroundColour(StateColor::darkModeColorFor(wxColour("#F0F0F1")));
    m_text_label->SetFont(Label::Body_12);
    m_text_label->Wrap(FromDIP(40));
    top_sizer->Add(m_text_label, 0, wxALIGN_CENTER_HORIZONTAL);

    top_sizer->AddStretchSpacer(1); // Increased bottom spacer to push text down
    sizer->Add(top_sizer, 1, wxEXPAND);

    // Bottom section with icon - vertically centered in bottom half
    wxBoxSizer* bottom_sizer = new wxBoxSizer(wxVERTICAL);
    bottom_sizer->AddStretchSpacer(1);

    m_icon_bitmap = new wxStaticBitmap(this, wxID_ANY, wxNullBitmap);
    m_icon_bitmap->SetBackgroundColour(StateColor::darkModeColorFor(wxColour("#F0F0F1")));
    m_icon_bitmap->SetMinSize(wxSize(FromDIP(24), FromDIP(24)));
    m_icon_bitmap->SetMaxSize(wxSize(FromDIP(24), FromDIP(24)));
    bottom_sizer->Add(m_icon_bitmap, 0, wxALIGN_CENTER_HORIZONTAL);

    bottom_sizer->AddStretchSpacer(1);
    sizer->Add(bottom_sizer, 1, wxEXPAND);

    SetSizer(sizer);

    // Bind events
    Bind(wxEVT_PAINT, &FilamentItemPanel::OnPaint, this);
    Bind(wxEVT_SIZE, &FilamentItemPanel::OnSize, this);

    SetIcon(icon_name);
    wxGetApp().UpdateDarkUI(this);
}

void FilamentItemPanel::SetText(const wxString& text)
{
    m_text_label->SetLabel(text);
    Layout();
}

void FilamentItemPanel::SetIcon(const std::string& icon_name)
{
    m_icon_name = icon_name;
    if (!icon_name.empty()) {
        try {
            m_icon = ScalableBitmap(this, icon_name, 20);
            m_icon.msw_rescale();
            m_icon_bitmap->SetBitmap(m_icon.bmp());
        } catch (Exception&) {
            BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ": failed to load filament icon";
            m_icon_bitmap->SetBitmap(wxNullBitmap);
        }
    } else {
        m_icon_bitmap->SetBitmap(wxNullBitmap);
    }
    m_icon_bitmap->Refresh();
}

void FilamentItemPanel::msw_rescale()
{
    if (m_icon_bitmap && !m_icon_name.empty()) {
        m_icon.msw_rescale();
        m_icon_bitmap->SetBitmap(m_icon.bmp());
        m_icon_bitmap->Refresh();
    }
    Layout();
}

void FilamentItemPanel::OnPaint(wxPaintEvent& event)
{
    wxPaintDC dc(this);
    wxSize size = GetSize();

    // bool is_dark_mode = wxGetApp().dark_mode();
    wxColour backgroundColor = StateColor::darkModeColorFor(wxColour("#F0F0F1"));
    wxColour borderColor = StateColor::darkModeColorFor(wxColour("#DBDBDB"));

    // Draw white background rectangle with rounded corners inside the thick vertical lines
    dc.SetBrush(wxBrush(backgroundColor));
    dc.SetPen(wxPen(backgroundColor));
    dc.DrawRectangle(FromDIP(6), FromDIP(12), size.GetWidth() - FromDIP(12), size.GetHeight() - 2 * FromDIP(12));

    // Draw much thicker vertical rounded rectangles on left and right (3 times thicker)
    dc.SetBrush(wxBrush(wxColour(borderColor)));
    dc.SetPen(wxPen(wxColour(borderColor)));
    dc.DrawRoundedRectangle(FromDIP(0), FromDIP(0), FromDIP(6), size.GetHeight(), FromDIP(6)); // Left rounded rectangle
    dc.DrawRoundedRectangle(size.GetWidth() - FromDIP(6), FromDIP(0), FromDIP(6), size.GetHeight(), FromDIP(6)); // Right rounded rectangle

    // Draw thin horizontal rounded rectangles on top and bottom (moved closer to center by half the distance)
    dc.SetBrush(wxBrush(wxColour(borderColor)));
    dc.SetPen(wxPen(wxColour(borderColor)));
    dc.DrawRoundedRectangle(FromDIP(6), FromDIP(12), size.GetWidth() - FromDIP(12), FromDIP(3), FromDIP(1)); // Top rounded rectangle
    dc.DrawRoundedRectangle(FromDIP(6), size.GetHeight() - FromDIP(13), size.GetWidth() - FromDIP(12), FromDIP(3), FromDIP(1)); // Bottom rounded rectangle
}

void FilamentItemPanel::OnSize(wxSizeEvent& event)
{
    Refresh();
    event.Skip();
}

// class AMSFilamentPanel

AMSFilamentPanel::AMSFilamentPanel(wxWindow* parent, const wxString& ams_name, wxWindowID id)
    : wxPanel(parent, id)
{
    SetBackgroundColour(wxColour("#DBDBDB"));

    wxBoxSizer* main_sizer = new wxBoxSizer(wxVERTICAL);

    // Filament items section
    m_filament_container = new wxPanel(this);
    m_filament_container->SetBackgroundColour(wxColour("#F0F0F1"));
    m_filament_sizer = new wxBoxSizer(wxHORIZONTAL);
    m_filament_container->SetSizer(m_filament_sizer);

    // AMS name section
    m_ams_name_label = new Label(this, ams_name);
    m_ams_name_label->SetForegroundColour(wxColour("#858585"));
    m_ams_name_label->SetFont(Label::Body_14);
    m_ams_name_label->SetBackgroundColour(wxColour("#DBDBDB"));

    main_sizer->Add(m_filament_container, 1, wxEXPAND | wxALL, 0);
    main_sizer->Add(m_ams_name_label, 0, wxALIGN_LEFT | wxALL, FromDIP(5));

    SetSizer(main_sizer);
    wxGetApp().UpdateDarkUI(this);
}

void AMSFilamentPanel::AddFilamentItem(FilamentItemPanel* panel)
{
    if (panel) {
        panel->Reparent(m_filament_container);
        m_filament_sizer->Add(panel, 0, wxALL, FromDIP(5));
        m_filament_items.push_back(panel);
        Layout();
    }
}

void AMSFilamentPanel::AddFilamentItem(const wxString& text, const std::string& icon_name)
{
    FilamentItemPanel* item = new FilamentItemPanel(m_filament_container, text, icon_name);
    m_filament_items.push_back(item);
    m_filament_sizer->Add(item, 0, wxALL, FromDIP(5));
    Layout();
}

void AMSFilamentPanel::SetAmsName(const wxString& ams_name)
{
    m_ams_name_label->SetLabel(ams_name);
    Layout();
}

void AMSFilamentPanel::Clear()
{
    m_filament_sizer->Clear(true);
    m_filament_items.clear();
}

void AMSFilamentPanel::msw_rescale()
{
    for (auto item : m_filament_items) {
        item->msw_rescale();
    }
    Layout();
}


AMSDryCtrWin::AMSDryCtrWin(wxWindow *parent)
    :DPIDialog(parent, wxID_ANY, _L("AMS Dryness Control"), wxDefaultPosition, wxDefaultSize, wxCAPTION | wxCLOSE_BOX)
{
    create();
}

AMSDryCtrWin::~AMSDryCtrWin()
{
    if (m_progress_timer) {
        delete m_progress_timer;
    }
}


wxScrolledWindow* AMSDryCtrWin::create_preview_scrolled_window(wxWindow* parent)
{
    wxScrolledWindow* panel = new wxScrolledWindow(parent, wxID_ANY);
    panel->SetScrollRate(10, 0);
    panel->SetSize(AMS_ITEMS_PANEL_SIZE);
    panel->SetMinSize(AMS_ITEMS_PANEL_SIZE);
    panel->SetBackgroundColour(AMS_CONTROL_DEF_BLOCK_BK_COLOUR);

    return panel;
}

wxBoxSizer* AMSDryCtrWin::create_humidity_status_section(wxPanel* parent)
{
    wxBoxSizer* image_sizer = new wxBoxSizer(wxVERTICAL);

    m_humidity_img = new wxStaticBitmap(parent, wxID_ANY, wxNullBitmap);
    image_sizer->Add(m_humidity_img, 1, wxALIGN_CENTER_HORIZONTAL, 0);

    m_humidity_img->SetBitmap(wxNullBitmap);

    // Create a horizontal sizer for description and icon
    wxBoxSizer* desc_sizer = new wxBoxSizer(wxHORIZONTAL);

    m_image_description_icon = new wxStaticBitmap(parent, wxID_ANY, wxNullBitmap);
    m_image_description_icon->SetBackgroundColour(*wxWHITE);
    m_image_description_icon->SetMinSize(wxSize(FromDIP(20), FromDIP(20)));
    m_image_description_icon->SetMaxSize(wxSize(FromDIP(20), FromDIP(20)));
    m_image_description_icon->Show(false);
    desc_sizer->Add(m_image_description_icon, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, FromDIP(5));

    m_image_description = new Label(parent, _L("Idle"));
    m_image_description->SetFont(Label::Head_14);
    m_image_description->SetForegroundColour(*wxBLACK);
    m_image_description->SetBackgroundColour(*wxWHITE);
    desc_sizer->Add(m_image_description, 0, wxALIGN_CENTER_VERTICAL);

    image_sizer->Add(desc_sizer, 0, wxALIGN_CENTER | wxALL, FromDIP(5));

    return image_sizer;
}

wxBoxSizer* AMSDryCtrWin::create_description_item(wxPanel* parent, const wxString& title, Label*& dataLabel)
{
    wxBoxSizer* item_sizer = new wxBoxSizer(wxVERTICAL);

    Label* titleLabel = new Label(parent, title);
    titleLabel->SetForegroundColour(*wxBLACK);
    titleLabel->SetFont(Label::Body_16);

    dataLabel = new Label(parent, wxT("--"));
    dataLabel->SetForegroundColour(*wxBLACK);
    dataLabel->SetFont(Label::Body_14);

    item_sizer->AddStretchSpacer();
    item_sizer->Add(titleLabel, 0, wxALIGN_CENTER | wxALL, FromDIP(2));
    item_sizer->Add(dataLabel, 0, wxALIGN_CENTER | wxALL, FromDIP(2));
    item_sizer->AddStretchSpacer();

    return item_sizer;
}

wxBoxSizer* AMSDryCtrWin::create_status_descriptions_section(wxPanel* parent)
{
    wxBoxSizer* desc_sizer = new wxBoxSizer(wxHORIZONTAL);

    wxBoxSizer* hum_desc_sizer = create_description_item(parent, _L("Humidity"), m_humidity_data_label);
    desc_sizer->Add(hum_desc_sizer, 1, wxEXPAND, FromDIP(1));

    wxStaticLine* vert_separator = new wxStaticLine(parent, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxLI_VERTICAL);
    desc_sizer->Add(vert_separator, 0, wxEXPAND | wxLEFT | wxRIGHT, FromDIP(5));

    wxBoxSizer* temp_desc_sizer = create_description_item(parent, _L("Temperature"), m_temperature_data_label);
    desc_sizer->Add(temp_desc_sizer, 1, wxEXPAND, FromDIP(1));

    m_time_descrition_container = new wxBoxSizer(wxHORIZONTAL);
    wxStaticLine* vert_separator2 = new wxStaticLine(parent, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxLI_VERTICAL);
    m_time_descrition_container->Add(vert_separator2, 0, wxEXPAND | wxLEFT | wxRIGHT, FromDIP(5));

    wxBoxSizer* time_desc_sizer = create_description_item(parent, _L("Left Time"), m_time_data_label);
    m_time_descrition_container->Add(time_desc_sizer, 1, wxEXPAND, FromDIP(1));

    desc_sizer->Add(m_time_descrition_container, 1, wxEXPAND, 0);
    // m_time_descrition_container->Show(false);

    return desc_sizer;
}

wxBoxSizer* AMSDryCtrWin::create_left_panel(wxPanel* parent)
{
    wxBoxSizer* left_sizer = new wxBoxSizer(wxVERTICAL);

    wxBoxSizer* image_section = create_humidity_status_section(parent);
    left_sizer->Add(image_section, 1, wxEXPAND | wxALL, FromDIP(5));

    wxBoxSizer* descriptions_section = create_status_descriptions_section(parent);
    left_sizer->Add(descriptions_section, 0, wxEXPAND | wxALL, FromDIP(20));

    return left_sizer;
}

Button* AMSDryCtrWin::create_button(wxPanel* parent, const wxString& title,
    const wxColour& background_color, const wxColour& border_color, const wxColour& text_color)
{
    Button* button = new Button(parent, title);

    // Create state colors for background
    StateColor bg_color(
        std::pair<wxColour, int>(AMS_CONTROL_DISABLE_COLOUR, StateColor::Disabled),
        std::pair<wxColour, int>(background_color.ChangeLightness(80), StateColor::Pressed),
        std::pair<wxColour, int>(background_color.ChangeLightness(120), StateColor::Hovered),
        std::pair<wxColour, int>(background_color, StateColor::Normal)
    );

    // Create state colors for border
    StateColor bd_color(
        std::pair<wxColour, int>(AMS_CONTROL_WHITE_COLOUR, StateColor::Disabled),
        std::pair<wxColour, int>(border_color, StateColor::Enabled)
    );

    button->SetBackgroundColor(bg_color);
    button->SetBorderColor(bd_color);
    button->SetTextColor(text_color);
    button->SetFont(Label::Body_14);

    // Auto-size button based on text content with padding
    wxSize best_size = button->GetBestSize();
    int padding_width = FromDIP(4);
    int padding_height = FromDIP(2);
    wxSize final_size(best_size.GetWidth() + padding_width, best_size.GetHeight() + padding_height);
    button->SetMinSize(final_size);

    return button;
}

wxBoxSizer* AMSDryCtrWin::create_normal_state_panel(wxPanel* parent)
{
    wxBoxSizer* normal_state_sizer = new wxBoxSizer(wxVERTICAL);

    Label* description_label = new Label(parent, _L("Filament Drying Settings"));
    description_label->SetForegroundColour(*wxBLACK);
    description_label->SetFont(Label::Head_14);
    normal_state_sizer->Add(description_label, 0, wxALL, FromDIP(5));

    // Part 2: ComboBox for material selection
    wxBoxSizer* combo_sizer = new wxBoxSizer(wxHORIZONTAL);
    m_trays_combo = new ComboBox(parent, wxID_ANY, wxEmptyString, wxDefaultPosition, wxSize(-1, FromDIP(26)), 0, nullptr, wxCB_READONLY);
    m_trays_combo->SetFont(Label::Body_14);

    combo_sizer->Add(m_trays_combo, 1, wxEXPAND);
    normal_state_sizer->Add(combo_sizer, 0, wxEXPAND | wxALL, FromDIP(5));

    m_trays_combo->Bind(wxEVT_COMBOBOX, &AMSDryCtrWin::OnFilamentSelectionChanged, this);

    // part 3 time and temperature
    // Temperature part
    wxBoxSizer* temp_sizer = new wxBoxSizer(wxHORIZONTAL);
    m_temperature_input = new wxTextCtrl(parent, wxID_ANY, "", wxDefaultPosition, wxSize(FromDIP(80), -1));
    m_temperature_input->SetMaxLength(3); // Limit to 3 digits

    m_temperature_input->Bind(wxEVT_CHAR, [](wxKeyEvent& event) {
        int keycode = event.GetKeyCode();
        if (keycode >= '0' && keycode <= '9') {
            event.Skip();
        } else if (keycode == WXK_BACK || keycode == WXK_DELETE || keycode == WXK_LEFT || keycode == WXK_RIGHT) {
            event.Skip();
        }
    });

    m_temperature_input->Bind(wxEVT_TEXT, [this](wxCommandEvent&) {
        m_next_button->Disable();
        m_start_button->Disable();
    });

    m_temperature_input->SetBackgroundColour(StateColor::darkModeColorFor(*wxWHITE));
    m_temperature_input->SetForegroundColour(StateColor::darkModeColorFor(*wxBLACK));

    Label* temp_unit_label = new Label(parent, wxString::FromUTF8(u8"\u2103" /* °C */));
    temp_unit_label->SetForegroundColour(*wxBLACK);
    temp_sizer->Add(m_temperature_input, 1, wxRIGHT, FromDIP(1));
    temp_sizer->Add(temp_unit_label, 0, wxALIGN_CENTER_VERTICAL);

    // Time part
    wxBoxSizer* time_sizer = new wxBoxSizer(wxHORIZONTAL);
    m_time_input = new wxTextCtrl(parent, wxID_ANY, "", wxDefaultPosition, wxSize(FromDIP(100), -1));
    m_time_input->SetMaxLength(3); // Limit to 3 digits

    m_time_input->Bind(wxEVT_CHAR, [](wxKeyEvent& event) {
        int keycode = event.GetKeyCode();
        if (keycode >= '0' && keycode <= '9') {
            event.Skip();
        } else if (keycode == WXK_BACK || keycode == WXK_DELETE || keycode == WXK_LEFT || keycode == WXK_RIGHT) {
            event.Skip();
        }
    });

    m_time_input->Bind(wxEVT_TEXT, [this](wxCommandEvent&) {
        m_next_button->Disable();
        m_start_button->Disable();
    });

    m_time_input->SetBackgroundColour(StateColor::darkModeColorFor(*wxWHITE));
    m_time_input->SetForegroundColour(StateColor::darkModeColorFor(*wxBLACK));

    Label* time_unit_label = new Label(parent, _L_CONTEXT("H", "Hours unit"));
    time_unit_label->SetForegroundColour(*wxBLACK);
    time_sizer->Add(m_time_input, 1, wxRIGHT, FromDIP(1));
    time_sizer->Add(time_unit_label, 0, wxALIGN_CENTER_VERTICAL);

    wxBoxSizer* input_sizer = new wxBoxSizer(wxHORIZONTAL);
    input_sizer->Add(temp_sizer, 1, wxRIGHT, FromDIP(10));
    input_sizer->Add(time_sizer, 1, 0);
    normal_state_sizer->Add(input_sizer, 0, wxEXPAND | wxALL, FromDIP(5));

    // Part 4: Abnormal description/message area
    m_normal_description = new Label(parent, "");
    m_normal_description->SetForegroundColour(wxColour("#F09A17"));
    m_normal_description->SetFont(Label::Body_12);
    normal_state_sizer->Add(m_normal_description, 0, wxALL, FromDIP(5));

    // Part 5: Start button
    m_next_button = create_button(
        parent,
        _L("Start"),
        AMS_CONTROL_BRAND_COLOUR,  // Background color - green
        AMS_CONTROL_BRAND_COLOUR,  // Border color - green
        wxColour("#FFFFFE")        // Text color - white
    );

    m_next_button->Bind(wxEVT_COMMAND_BUTTON_CLICKED, [this](wxCommandEvent& event) {
        m_main_simplebook->SetSelection(1);
    });

    normal_state_sizer->Add(m_next_button, 0, wxALL, FromDIP(5));
    m_next_button->Disable();

    m_stop_button = create_button(
        parent,
        _L("Stop"),
        wxColour(255, 0, 0),       // Background color - red
        wxColour(255, 0, 0),       // Border color - red
        wxColour("#FFFFFE")        // Text color - white
    );

    m_stop_button->Bind(wxEVT_COMMAND_BUTTON_CLICKED, [this](wxCommandEvent& event) {
        auto fila_system = get_fila_system();
        if (!fila_system) {
            BOOST_LOG_TRIVIAL(info) << "AMSDryCtrWin::start_sending_drying_command: Invalid FilaSystem Pointer";
            return;
        }

        fila_system->CtrlAmsStopDrying(std::stoi(m_ams_info.m_ams_id));
        // Temporarily show stopping state, then restore after 2 seconds
        if (m_stop_button) {
            m_stop_button->SetLabel(_L("Stopping"));
            update_button_size(m_stop_button);  // Adjust button size for longer text
            m_stop_button->Disable();
            m_stop_button->Layout();
            m_stop_button->GetParent()->Layout();  // Relayout parent container
            m_stop_button->Refresh();

            m_stop_button_restore_deadline.reset();
            m_stop_button_restore_deadline = std::chrono::steady_clock::now() + std::chrono::seconds(2);
        }
    });

    m_stop_button->Show(false);
    normal_state_sizer->Add(m_stop_button, 0, wxALL, FromDIP(5));

    return normal_state_sizer;
}

wxBoxSizer* AMSDryCtrWin::create_cannot_dry_panel(wxPanel* parent)
{
    wxBoxSizer* abnormal_sizer = new wxBoxSizer(wxVERTICAL);

    Label* description_label = new Label(parent, _L("Unable to dry temporarily due to ..."));
    description_label->SetForegroundColour(*wxBLACK);
    description_label->SetFont(Label::Head_16);
    description_label->Wrap(FromDIP(300));
    abnormal_sizer->Add(description_label, 0, wxALIGN_CENTER_VERTICAL, FromDIP(10));

    // Add a description label for the abnormal state
    m_cannot_dry_description_label = new Label(parent, (""));
    m_cannot_dry_description_label->SetForegroundColour(*wxBLACK);
    m_cannot_dry_description_label->SetFont(Label::Body_14);
    m_cannot_dry_description_label->Wrap(FromDIP(250)); // Wrap text to fit within panel

    abnormal_sizer->Add(m_cannot_dry_description_label, 0, wxALIGN_CENTER_VERTICAL, FromDIP(10));

    // Unload button shown only when ConsumableAtAmsOutlet reason is active
    m_unload_button = create_button(
        parent,
        _L("Unload"),
        AMS_CONTROL_BRAND_COLOUR,       // Background color - light gray
        AMS_CONTROL_BRAND_COLOUR,       // Border color - gray
        *wxWHITE                   // Text color - white
    );

    m_unload_button->Bind(wxEVT_COMMAND_BUTTON_CLICKED, [this](wxCommandEvent& event) {
        auto fila_system = get_fila_system();
        if (!fila_system) {
            BOOST_LOG_TRIVIAL(info) << "AMSDryCtrWin::unload_button: Invalid FilaSystem Pointer";
            return;
        }

        MachineObject* obj = fila_system->GetOwner();
        if (!obj) {
            BOOST_LOG_TRIVIAL(info) << "AMSDryCtrWin::unload_button: Invalid MachineObject Pointer";
            return;
        }

        obj->command_ams_change_filament(false, m_ams_info.m_ams_id, "255");

        m_unload_button->Disable();
        m_unload_button_restore_deadline.reset();
        m_unload_button_restore_deadline = std::chrono::steady_clock::now() + std::chrono::seconds(5);
    });

    m_unload_button->Show(false);
    abnormal_sizer->Add(m_unload_button, 0, wxALL, FromDIP(5));

    return abnormal_sizer;
}

wxBoxSizer* AMSDryCtrWin::create_drying_error_panel(wxPanel* parent)
{
    wxBoxSizer* err_sizer = new wxBoxSizer(wxVERTICAL);
    Label* description_label = new Label(parent, _L("Drying Error"));
    description_label->SetForegroundColour(*wxRED);
    description_label->SetFont(Label::Body_14); // Wrap text to fit within panel
    err_sizer->Add(description_label, 0, wxALIGN_CENTER_VERTICAL, FromDIP(10));

    Label* additional_description_label = new Label(parent, _L("Please check the Assistant for troubleshooting"));
    additional_description_label->SetForegroundColour(*wxBLACK);
    additional_description_label->SetFont(Label::Body_14); // Wrap text to fit within panel
    err_sizer->Add(additional_description_label, 0, wxALIGN_CENTER_VERTICAL, FromDIP(10));

    return err_sizer;
}

wxBoxSizer* AMSDryCtrWin::create_right_panel(wxPanel* parent)
{
    wxBoxSizer* right_sizer = new wxBoxSizer(wxHORIZONTAL);

    m_normal_state_sizer = create_normal_state_panel(parent);
    m_cannot_dry_sizer = create_cannot_dry_panel(parent);
    m_dry_error_sizer = create_drying_error_panel(parent);

    right_sizer->Add(m_normal_state_sizer, 1, wxEXPAND);
    right_sizer->Add(m_cannot_dry_sizer, 1, wxEXPAND);

    m_cannot_dry_sizer->Show(false);
    m_dry_error_sizer->Show(false);

    return right_sizer;
}

wxBoxSizer* AMSDryCtrWin::create_main_content_section(wxPanel* parent)
{
    wxBoxSizer* content_sizer = new wxBoxSizer(wxHORIZONTAL);

    wxBoxSizer* left_panel = create_left_panel(parent);
    content_sizer->Add(left_panel, 2, wxALIGN_CENTER_VERTICAL | wxALL, FromDIP(5));
    left_panel->SetMinSize(wxSize(FromDIP(250), -1));

    wxBoxSizer* right_panel = create_right_panel(parent);
    content_sizer->Add(right_panel, 1, wxALIGN_CENTER_VERTICAL | wxALL, FromDIP(5));
    right_panel->SetMinSize(wxSize(FromDIP(250), -1));

    return content_sizer;
}

wxBoxSizer* AMSDryCtrWin::create_main_page_sizer(wxPanel* parent)
{
    wxBoxSizer* main_sizer = new wxBoxSizer(wxVERTICAL);

    wxBoxSizer* content_section = create_main_content_section(parent);
    main_sizer->Add(content_section, 1, wxEXPAND | wxALL, FromDIP(5));

    return main_sizer;
}

wxBoxSizer* AMSDryCtrWin::create_guide_info_filament(wxPanel* parent)
{
    wxBoxSizer* filament_section = new wxBoxSizer(wxHORIZONTAL);

    m_ams_filament_panel = new AMSFilamentPanel(parent, "");

    filament_section->Add(m_ams_filament_panel, 0, wxEXPAND | wxALL | wxALIGN_CENTER_HORIZONTAL, FromDIP(5));

    return filament_section;
}

wxBoxSizer* AMSDryCtrWin::create_guide_info_section(wxPanel* parent)
{
    wxBoxSizer* info_section = new wxBoxSizer(wxVERTICAL);

    // Part 1: Title
    m_guide_title_label = new Label(parent, _L("Please remove and store the filament (as shown)."));
    m_guide_title_label->SetForegroundColour(*wxBLACK);
    m_guide_title_label->SetFont(Label::Head_18);
    info_section->Add(m_guide_title_label, 0, wxEXPAND | wxALL, FromDIP(5));

    // Part 2: Description
    m_guide_description_label = new Label(parent, _L("The AMS can rotate the filament which is properly stored, providing better drying results."));
    m_guide_description_label->SetForegroundColour(*wxBLACK);
    m_guide_description_label->SetFont(Label::Body_14);
    m_guide_description_label->Wrap(FromDIP(300)); // Wrap text to fit within panel
    info_section->Add(m_guide_description_label, 0, wxEXPAND | wxALL, FromDIP(5));

    // Part 3: filament panel
    wxBoxSizer* fila_section = create_guide_info_filament(parent);
    info_section->Add(fila_section, 0, wxEXPAND | wxALL, FromDIP(5));

    // Part 4: Circular toggle with description
    wxBoxSizer* toggle_section = new wxBoxSizer(wxHORIZONTAL);

    m_rotate_spool_toggle = new wxCheckBox(parent, wxID_ANY, "");
    m_rotate_spool_toggle->SetValue(false);

    m_rotate_spool_toggle->Bind(wxEVT_CHECKBOX, [](wxCommandEvent& event) {
        bool is_checked = event.IsChecked();
        // Add toggle behavior logic here
    });

    toggle_section->Add(m_rotate_spool_toggle, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, FromDIP(10));

    // Toggle description
    Label* toggle_description = new Label(parent, _L("Rotate spool when drying"), LB_AUTO_WRAP);
    toggle_description->SetForegroundColour(*wxBLACK);
    toggle_description->SetFont(Label::Body_12);
    toggle_section->Add(toggle_description, 1, wxALIGN_CENTER_VERTICAL | wxEXPAND, 0);

    info_section->Add(toggle_section, 0, wxEXPAND | wxALL, FromDIP(5));

    return info_section;
}

wxBoxSizer* AMSDryCtrWin::create_guide_right_section(wxPanel* parent)
{
    wxBoxSizer* right_section = new wxBoxSizer(wxVERTICAL);

    // Upper part: Image section
    m_image_placeholder = new wxStaticBitmap(parent, wxID_ANY, wxNullBitmap);
    m_guide_image = ScalableBitmap(parent, "dev_ams_dry_ctr_filament_in_chamber", 256);
    m_image_placeholder->SetBitmap(m_guide_image.bmp());

    wxBoxSizer* image_container = new wxBoxSizer(wxHORIZONTAL);
    image_container->AddStretchSpacer(1);
    image_container->Add(m_image_placeholder, 0, wxALL, FromDIP(5));

    right_section->Add(image_container, 0, wxEXPAND | wxALL, FromDIP(5));

    wxBoxSizer* buttons_container = new wxBoxSizer(wxHORIZONTAL);
    buttons_container->AddStretchSpacer(1);

    m_back_button = create_button(
        parent,
        wxString::FromUTF8(_u8L_CONTEXT(L_CONTEXT("Back", "amsdrying"), "amsdrying")),
        wxColour("#F8F8F8"),       // Background color - light gray
        wxColour("#D0D0D0"),       // Border color - gray
        *wxBLACK                   // Text color - black
    );

    m_back_button->Bind(wxEVT_COMMAND_BUTTON_CLICKED, [this](wxCommandEvent& event) {
        m_main_simplebook->SetSelection(0);
    });

    buttons_container->Add(m_back_button, 0, wxALL, FromDIP(5));

    m_start_button = create_button(
        parent,
        _L("Start"),
        AMS_CONTROL_BRAND_COLOUR,  // Background color - green
        AMS_CONTROL_BRAND_COLOUR,  // Border color - green
        wxColour("#FFFFFE")        // Text color - white
    );

    m_start_button->Bind(wxEVT_COMMAND_BUTTON_CLICKED, [this](wxCommandEvent& event) {
        m_main_simplebook->SetSelection(2);
        m_progress_gauge->SetValue(0);

        m_progress_timer->Start(70);
        m_progress_value = 0;
        start_sending_drying_command();
    });

    buttons_container->Add(m_start_button, 0, wxALL, FromDIP(5));

    right_section->Add(buttons_container, 0, wxEXPAND | wxALL, FromDIP(5));

    return right_section;
}

wxBoxSizer* AMSDryCtrWin::create_guide_page_sizer(wxPanel* parent)
{
    wxBoxSizer* guide_sizer = new wxBoxSizer(wxHORIZONTAL);

    wxBoxSizer* info_section = create_guide_info_section(parent);
    guide_sizer->Add(info_section, 1, wxEXPAND | wxALL, FromDIP(10));

    wxBoxSizer* right_section = create_guide_right_section(parent);
    guide_sizer->Add(right_section, 0, wxEXPAND | wxALL, FromDIP(10));

    return guide_sizer;
}

void AMSDryCtrWin::start_sending_drying_command()
{
    auto fila_system = get_fila_system();
    if (!fila_system) {
        BOOST_LOG_TRIVIAL(info) << "AMSDryCtrWin::start_sending_drying_command: Invalid FilaSystem Pointer";
        return;
    }

    if (m_temperature_input->GetValue().IsEmpty() || m_time_input->GetValue().IsEmpty()) {
        // Show error message to user
        BOOST_LOG_TRIVIAL(info) << "AMSDryCtrWin::start_sending_drying_command: Time or temperature is empty";
        return;
    }

    long temperature, time;
    if (!m_temperature_input->GetValue().ToLong(&temperature) ||
        !m_time_input->GetValue().ToLong(&time)) {
        BOOST_LOG_TRIVIAL(info) << "AMSDryCtrWin::start_sending_drying_command: Failed to convert temperature or time";
        return;
    }

    int tray_index;
    tray_index = m_trays_combo->GetSelection();
    if (m_tray_ids.empty() || tray_index < 0 || tray_index >= m_tray_ids.size()) {
        BOOST_LOG_TRIVIAL(warning) << "AMSDryCtrWin::start_sending_drying_command: Invalid tray_index " << tray_index
                                   << ", m_tray_ids.size=" << m_tray_ids.size();
        return;
    }

    int cooling_temp = 50;
    std::optional<DevFilamentDryingPreset> preset = DevUtilBackend::GetFilamentDryingPreset(m_tray_ids[tray_index].filament_id);
    if (preset.has_value()) {
        cooling_temp = static_cast<int>(preset.value().filament_dev_drying_softening_temperature);
    }

    fila_system->CtrlAmsStartDryingHour(std::stoi(m_ams_info.m_ams_id), m_tray_ids[tray_index].filament_type,
        temperature, time, m_rotate_spool_toggle->GetValue(), cooling_temp, false);

    m_dry_setting.m_filament_names[m_ams_info.m_ams_id] = m_tray_ids[tray_index].filament_name;
    m_dry_setting.m_filament_type[m_ams_info.m_ams_id] = m_tray_ids[tray_index].filament_type;
    m_dry_setting.m_dry_temp[m_ams_info.m_ams_id] = temperature;
    m_dry_setting.m_dry_time[m_ams_info.m_ams_id] = time;
}

void AMSDryCtrWin::OnProgressTimer(wxTimerEvent& event)
{
    m_progress_value += 1;

    if (m_progress_value <= 100)
        m_progress_gauge->SetValue(m_progress_value);

    if (m_progress_value == 1) { // First tick, reset message index
        m_progress_message_index = 0;
        if (!m_progress_text.empty()) {
            m_progress_title->SetLabel(m_progress_text[0]);
        }
    }
    else if (m_progress_value % 15 == 0) { // Approximately every second
        m_progress_message_index++;
        if (m_progress_message_index < m_progress_text.size()) {
            m_progress_title->SetLabel(m_progress_text[m_progress_message_index]);
            m_progress_title->Refresh();
        }
    }

    if (m_progress_value >= 100 && !is_dry_ctr_idle()) {
        m_progress_value = 0;
        m_progress_timer->Stop();
        m_main_simplebook->SetSelection(0);
    }
}

void AMSDryCtrWin::restore_stop_button_if_deadline_passed()
{
    if (m_stop_button_restore_deadline.has_value()) {
        if (std::chrono::steady_clock::now() >= m_stop_button_restore_deadline.value()) {
            if (m_stop_button) {
                m_stop_button->SetLabel(_L("Stop"));
                update_button_size(m_stop_button);  // Adjust button size back to original
                m_stop_button->Enable();
                m_stop_button->Layout();
                m_stop_button->GetParent()->Layout();
                m_stop_button->Refresh();
            }
            m_stop_button_restore_deadline.reset();
        }
    }
}

void AMSDryCtrWin::restore_unload_button_if_deadline_passed()
{
    if (m_unload_button_restore_deadline.has_value()) {
        if (std::chrono::steady_clock::now() >= m_unload_button_restore_deadline.value()) {
            if (m_unload_button) {
                m_unload_button->Enable();
            }
            m_unload_button_restore_deadline.reset();
        }
    }
}

void AMSDryCtrWin::update_button_size(Button* button)
{
    if (!button) return;

    // Reset MinSize first to avoid accumulation of size
    button->SetMinSize(wxSize(-1, -1));

    // Recalculate button size based on current text and DPI settings
    wxSize best_size = button->GetBestSize();
    int padding_width = FromDIP(4);
    int padding_height = FromDIP(2);
    wxSize final_size(best_size.GetWidth() + padding_width, best_size.GetHeight() + padding_height);
    button->SetMinSize(final_size);
}

void AMSDryCtrWin::OnShow(wxShowEvent& event)
{
    if (event.IsShown()) {
        wxGetApp().UpdateDlgDarkUI(this);
        msw_rescale();
    }
    event.Skip();
}

void AMSDryCtrWin::OnClose(wxCloseEvent& event)
{
    if (m_progress_timer && m_progress_timer->IsRunning()) {
        m_progress_timer->Stop();
    }

    if (m_progress_gauge) {
        m_progress_gauge->SetValue(0);
    }

    m_progress_value = 0;
    m_progress_message_index = 0;

    if (m_main_simplebook) {
        m_main_simplebook->SetSelection(0);
    }

    if (m_progress_title && !m_progress_text.empty()) {
        m_progress_title->SetLabel(m_progress_text[0]);
    }

    // Clean up and restore stop button state
    if (m_stop_button) {
        m_stop_button->SetLabel(_L("Stop"));
        update_button_size(m_stop_button);  // Adjust button size back to original
        m_stop_button->Enable();
        m_stop_button->Layout();
        m_stop_button->GetParent()->Layout();
        m_stop_button->Refresh();
    }
    m_stop_button_restore_deadline.reset();

    // Clean up unload button state
    if (m_unload_button) {
        m_unload_button->Enable();
    }
    m_unload_button_restore_deadline.reset();

    event.Skip();
}

wxBoxSizer* AMSDryCtrWin::create_progress_page_sizer(wxPanel* parent)
{
    wxBoxSizer* progress_sizer = new wxBoxSizer(wxVERTICAL);

    m_progress_title = new Label(parent, m_progress_text[0]);
    m_progress_title->SetForegroundColour(*wxBLACK);
    m_progress_title->SetFont(Label::Body_16);

    progress_sizer->Add(0, 0, 1, wxEXPAND, 0); // Spacer
    progress_sizer->Add(m_progress_title, 0, wxALIGN_CENTER | wxALL, FromDIP(30));

    m_progress_gauge = new ProgressBar(parent, wxID_ANY, 100, wxDefaultPosition, wxSize(FromDIP(300), FromDIP(8)));
    m_progress_gauge->SetValue(0);
    m_progress_gauge->SetHeight(FromDIP(8));

    progress_sizer->Add(m_progress_gauge, 0, wxALIGN_CENTER | wxALL, FromDIP(10));
    progress_sizer->Add(0, 0, 1, wxEXPAND, 0);

    return progress_sizer;
}

void AMSDryCtrWin::create()
{
    // set title icon
    SetBackgroundColour(StateColor::darkModeColorFor(*wxWHITE));
    this->SetDoubleBuffered(true);
    std::string icon_path = (boost::format("%1%/images/OrcaSlicerTitle.ico") % resources_dir()).str(); // Orca: app title icon
    SetIcon(wxIcon(encode_path(icon_path.c_str()), wxBITMAP_TYPE_ICO));

    SetSize(wxSize(FromDIP(700), FromDIP(500)));
    SetMinSize(wxSize(FromDIP(700), FromDIP(500)));
    SetMaxSize(wxSize(FromDIP(700), FromDIP(500)));

    m_main_simplebook = new wxSimplebook(this, wxID_ANY, wxDefaultPosition, wxDefaultSize);

    // Create main page
    m_original_page = new wxPanel(m_main_simplebook, wxID_ANY);
    m_original_page->SetBackgroundColour(*wxWHITE);
    wxBoxSizer* main_sizer = create_main_page_sizer(m_original_page);
    m_original_page->SetSizer(main_sizer);

    m_main_simplebook->AddPage(m_original_page, "Main Page");

    m_guide_page = new wxPanel(m_main_simplebook, wxID_ANY);
    m_guide_page->SetBackgroundColour(*wxWHITE);
    wxBoxSizer* guide_sizer = create_guide_page_sizer(m_guide_page);
    m_guide_page->SetSizer(guide_sizer);
    m_main_simplebook->AddPage(m_guide_page, "Guide Page");

    // Create progress page
    m_progress_page = new wxPanel(m_main_simplebook, wxID_ANY);
    m_progress_page->SetBackgroundColour(*wxWHITE);
    wxBoxSizer* progress_sizer = create_progress_page_sizer(m_progress_page);
    m_progress_page->SetSizer(progress_sizer);
    m_main_simplebook->AddPage(m_progress_page, "Progress Page");

    m_progress_timer = new wxTimer(this, wxID_ANY);
    Bind(wxEVT_TIMER, &AMSDryCtrWin::OnProgressTimer, this, m_progress_timer->GetId());

    Bind(wxEVT_CLOSE_WINDOW, &AMSDryCtrWin::OnClose, this);

    wxBoxSizer* top_level_sizer = new wxBoxSizer(wxVERTICAL);
    top_level_sizer->Add(m_main_simplebook, 1, wxEXPAND | wxALL, FromDIP(10));

    Bind(wxEVT_SHOW, &AMSDryCtrWin::OnShow, this);

    SetSizer(top_level_sizer);
    Layout();
    Refresh();
    wxGetApp().UpdateDlgDarkUI(this);
}

void AMSDryCtrWin::on_dpi_changed(const wxRect &suggested_rect)
{
    msw_rescale();
}

void AMSDryCtrWin::msw_rescale()
{
    if (!IsShown()) {
        return;
    }

    if (m_ams_filament_panel) {m_ams_filament_panel->msw_rescale();}
    if (m_trays_combo) {m_trays_combo->Rescale(); m_trays_combo->Layout(); m_trays_combo->SetFont(Label::Body_14), m_trays_combo->Refresh();}
    if (m_humidity_img && m_humidity_image.bmp().IsOk()) {m_humidity_image.msw_rescale(); m_humidity_img->SetBitmap(m_humidity_image.bmp());}
    if (m_image_placeholder && m_guide_image.bmp().IsOk()) {m_guide_image.msw_rescale();m_image_placeholder->SetBitmap(m_guide_image.bmp());}
    if (m_image_description_icon && m_description_icon_bitmap.bmp().IsOk()) {m_description_icon_bitmap.msw_rescale(); m_image_description_icon->SetBitmap(m_description_icon_bitmap.bmp());}

    // Rescale and update button sizes based on text content
    if (m_next_button) {
        m_next_button->Rescale();
        update_button_size(m_next_button);
        m_next_button->Layout();
        m_next_button->Refresh();
    }
    if (m_stop_button) {
        m_stop_button->Rescale();
        update_button_size(m_stop_button);
        m_stop_button->Layout();
        m_stop_button->Refresh();
    }
    if (m_start_button) {
        m_start_button->Rescale();
        update_button_size(m_start_button);
        m_start_button->Layout();
        m_start_button->Refresh();
    }
    if (m_back_button) {
        m_back_button->Rescale();
        update_button_size(m_back_button);
        m_back_button->Layout();
        m_back_button->Refresh();
    }
    if (m_unload_button) {
        m_unload_button->Rescale();
        update_button_size(m_unload_button);
        m_unload_button->Layout();
        m_unload_button->Refresh();
    }

    if (m_guide_page) {m_guide_page->Layout();}
    if (m_original_page) {m_original_page->Layout();}

    Fit();
    Layout();
    Refresh();
}

void AMSDryCtrWin::set_ams_id(const std::string& ams_id)
{
    m_ams_info.m_ams_id = ams_id;
    m_is_ams_changed = true;
}

void AMSDryCtrWin::update_img_description(DevAms::DryStatus status, DevAms::DrySubStatus sub_status)
{
    if (status == DevAms::DryStatus::Off || status == DevAms::DryStatus::Cooling) {
        m_image_description->SetLabel(_L("Idle"));
        m_image_description_icon->Show(false);
        return;
    }

    // Determine label text for non-idle states
    wxString label_text;
    if (status == DevAms::DryStatus::Error) {
        label_text = _L("Drying");
    } else if (sub_status == DevAms::DrySubStatus::Heating) {
        label_text = _L("Drying-Heating");
    } else if (sub_status == DevAms::DrySubStatus::Dehumidify) {
        label_text = _L("Drying-Dehumidifying");
    } else {
        m_image_description_icon->Show(false);
        return;
    }

    m_image_description->SetLabel(label_text);

    try {
        m_description_icon_bitmap = ScalableBitmap(this, "dev_ams_dry_ctr_heating_icon", 20);
        m_description_icon_bitmap.msw_rescale();
        m_image_description_icon->SetBitmap(m_description_icon_bitmap.bmp());
        m_image_description_icon->Show(true);
    } catch (Exception&) {
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << " Error loading drying icon";
        m_image_description_icon->Show(false);
    }
}

int AMSDryCtrWin::update_image(DevAmsType model, DevAms::DryStatus status, DevAms::DrySubStatus sub_status, int humidity_percent)
{
    if (model == m_ams_info.m_model && status == m_ams_info.m_dry_status
        && sub_status == m_ams_info.m_dry_sub_status && humidity_percent == m_ams_info.m_humidity_percent) {
        return 0;
    }

    std::string img_path;

    if (status == DevAms::DryStatus::Off && sub_status == DevAms::DrySubStatus::Off) {
        img_path = get_humidity_level_img_path(humidity_percent);
    } else {
        img_path = get_dry_status_img_path(model, status, sub_status);
    }

    if (img_path.empty()) {
        return 0;
    }

    m_humidity_image = ScalableBitmap(this, img_path, AMS_DRY_STATUS_IMAGE_SIZE);
    m_humidity_img->SetBitmap(m_humidity_image.bmp());

    update_img_description(status, sub_status);

    return 1;
}

bool AMSDryCtrWin::check_values_changed(DevAms* dev_ams)
{
    bool changed = false;

    if (m_ams_info.m_model != dev_ams->GetAmsType()) {
        m_ams_info.m_model = dev_ams->GetAmsType();
        changed = true;
    }

    if (dev_ams->GetDryStatus().has_value() && m_ams_info.m_dry_status != dev_ams->GetDryStatus()) {
        m_ams_info.m_dry_status = dev_ams->GetDryStatus().value();
        changed = true;
    }

    if (dev_ams->GetDrySubStatus().has_value() && m_ams_info.m_dry_sub_status != dev_ams->GetDrySubStatus()) {
        m_ams_info.m_dry_sub_status = dev_ams->GetDrySubStatus().value();
        changed = true;
    }

    if (m_ams_info.m_humidity_percent != dev_ams->GetHumidityPercent()) {
        m_ams_info.m_humidity_percent = dev_ams->GetHumidityPercent();
        changed = true;
    }

    return changed;
}

void AMSDryCtrWin::update_normal_description(DevAms* dev_ams)
{
    if (m_tray_ids.empty() || m_trays_combo->GetSelection() >= m_tray_ids.size()) { return; }

    FilamentBaseInfo info = m_tray_ids[m_trays_combo->GetSelection()];
    wxString warning_text;
    bool can_enable_button = true;
    long temp_val = 0, time_val = 0;
    m_temperature_input->GetValue().ToLong(&temp_val);
    m_time_input->GetValue().ToLong(&time_val);
    std::optional<Slic3r::DevFilamentDryingPreset> preset = DevUtilBackend::GetFilamentDryingPreset(info.filament_id);
    auto total_dry = preset.has_value() ? preset.value().ams_limitations : std::unordered_set<DevAmsType>();

    struct AmsTempLimit { DevAmsType type; int min_temp; int max_temp; const char* name; };
    static const AmsTempLimit ams_limits[] = {
        { DevAmsType::N3F, 45, 65, "AMS2" },
        { DevAmsType::N3S, 45, 85, "AMS-S" }
    };

    for (const auto& lim : ams_limits) {
        if (dev_ams->GetAmsType() == lim.type) {
            if (temp_val > lim.max_temp) {
                wxString msg = wxString::Format(_L("%s maximum drying temperature is %d\u2103." /* °C */), wxString(lim.name), lim.max_temp);
                warning_text += msg + "\n";
                can_enable_button = false;
            } else if (temp_val < lim.min_temp) {
                wxString msg = wxString::Format(_L("%s minimum drying temperature is %d\u2103." /* °C */), wxString(lim.name), lim.min_temp);
                warning_text += msg + "\n";
                can_enable_button = false;
            }
            if (total_dry.find(lim.type) == total_dry.end()) {
                warning_text += _L("This filament may not be completely dried.") + "\n\n";
            }
            break;
        }
    }

    if (m_printer_status.m_is_printing && temp_val  > m_ams_info.m_recommand_dry_temp) {
        warning_text += _L("This AMS is currently printing. To ensure print quality, the drying temperature cannot exceed the recommended drying temperature.") + "\n";
        can_enable_button = false;
    } else if (preset.has_value()) {
        // Only check heat distortion temperature when AMS has filament inserted;
        // empty AMS only needs to respect the device hardware temperature limit.
        bool has_filament_inserted = false;
        for (const auto& tray_pair : dev_ams->GetTrays()) {
            if (tray_pair.second && tray_pair.second->is_exists) {
                has_filament_inserted = true;
                break;
            }
        }
        if (has_filament_inserted) {
            auto limit_temperature = preset.value().filament_dev_ams_drying_heat_distortion_temperature;
            if (temp_val > limit_temperature) {
                warning_text += _L("The temperature shall not exceed the filament's heat distortion temperature") + "(" +
                    wxString::Format(wxT("%d"), static_cast<int>(limit_temperature)) + wxString::FromUTF8(u8"\u2103" /* °C */) + ")\n";
                can_enable_button = false;
            }
        }
    }

    if (time_val < 1) {
        warning_text += _L("Minimum time value cannot be less than 1.") + "\n";
        can_enable_button = false;
    } else if (time_val > 24) {
        warning_text += _L("Maximum time value cannot be greater than 24.") + "\n";
        can_enable_button = false;
    }

    m_next_button->Enable(can_enable_button);
    m_normal_description->SetLabel(warning_text);
    m_normal_description->Wrap(FromDIP(250));
    m_normal_description->GetParent()->Layout();
}

void AMSDryCtrWin::update_normal_state(DevAms* dev_ams)
{
    if (is_dry_ctr_idle(dev_ams)) {
        m_next_button->Show(true);
        m_normal_description->Show(true);
        m_trays_combo->Enable();
        m_temperature_input->SetEditable(true);
        m_time_input->SetEditable(true);

        m_stop_button->Hide();
        m_dry_error_sizer->Show(false);
    } else if (is_dry_ctr_err(dev_ams)) {
        m_dry_error_sizer->Show(true);
        m_next_button->Hide();
        m_normal_description->Hide();

        m_trays_combo->Hide();
        m_temperature_input->Hide();
        m_time_input->Hide();
        m_stop_button->Show(true);
    } else {
        m_next_button->Hide();
        m_normal_description->Hide();

        m_trays_combo->Disable();
        m_temperature_input->SetEditable(false);
        m_time_input->SetEditable(false);
        m_stop_button->Show(true);
        m_dry_error_sizer->Show(false);
    }

    if (m_temperature_input->GetValue().IsEmpty() || m_time_input->GetValue().IsEmpty()) {
        m_next_button->Disable();
        m_start_button->Disable();
    } else {
        m_next_button->Enable();
    }

    update_normal_description(dev_ams);
}

void AMSDryCtrWin::OnFilamentSelectionChanged(wxCommandEvent& event)
{
    int selectionIndex = event.GetSelection();
    wxString selectedFilament = event.GetString();

    auto fila_system = get_fila_system();
    if (!fila_system) {
        BOOST_LOG_TRIVIAL(info) << "AMSDryCtrWin::OnFilamentSelectionChanged: Invalid FilaSystem Pointer";
        return;
    }

    DevAms* dev_ams = fila_system->GetAmsById(m_ams_info.m_ams_id);
    if (!dev_ams) {
        BOOST_LOG_TRIVIAL(info) << "AMSDryCtrWin::OnFilamentSelectionChanged: Invalid AMS id";
        return;
    }

    std::optional<Slic3r::DevFilamentDryingPreset> preset = DevUtilBackend::GetFilamentDryingPreset(m_tray_ids[selectionIndex].filament_id);
    if (preset.has_value()) {
        DevFilamentDryingPreset info = preset.value();
        if (m_printer_status.m_is_printing) {
            m_temperature_input->SetValue(std::to_string(static_cast<int>(info.filament_dev_ams_drying_temperature_on_print[dev_ams->GetAmsType()])));
            m_time_input->SetValue(std::to_string(static_cast<int>(info.filament_dev_ams_drying_time_on_print[dev_ams->GetAmsType()])));
        } else {
            m_temperature_input->SetValue(std::to_string(static_cast<int>(info.filament_dev_ams_drying_temperature_on_idle[dev_ams->GetAmsType()])));
            m_time_input->SetValue(std::to_string(static_cast<int>(info.filament_dev_ams_drying_time_on_idle[dev_ams->GetAmsType()])));
        }
    }

    update_filament_guide_info(dev_ams);
}

wxString get_cannot_reason_text(DevAms::CannotDryReason reason)
{
    wxString cannot_reason_text;
    switch (reason)
    {
    case DevAms::CannotDryReason::InsufficientPower:
        cannot_reason_text = "*" + _L("Insufficient power") + "\n";
        cannot_reason_text += _L("  Too many AMS drying simultaneously. Please plug in the power or stop other drying processes before starting.") + "\n";
        break;
    case DevAms::CannotDryReason::AmsBusy:
        cannot_reason_text = "*" + _L("AMS is busy") + "\n";
        cannot_reason_text += _L("  AMS is calibrating | reading RFID | loading/unloading material, please wait.") + "\n";
        break;
    case DevAms::CannotDryReason::ConsumableAtAmsOutlet:
        cannot_reason_text = "*" + _L("Filament in AMS outlet") + "\n";
        cannot_reason_text += _L("  The high drying temperature may cause AMS blockage, please unload first.");
        break;
    case DevAms::CannotDryReason::InitiatingAmsDrying:
        cannot_reason_text = "*" + _L("Initiating AMS drying") + "\n";
        break;
    case DevAms::CannotDryReason::NotSupportedIn2dMode:
        cannot_reason_text = "*" + _L("Not supported in 2D mode") + "\n";
        break;
    case DevAms::CannotDryReason::DryingInProgress:
        cannot_reason_text = "*" + _L("Task in progress") + "\n";
        cannot_reason_text += _L("  The AMS might be in use during Task.") + "\n";
        break;
    case DevAms::CannotDryReason::Upgrading:
        cannot_reason_text = "*" + _L("Upgrading") + "\n";
        cannot_reason_text += _L("  Firmware update in progress, please wait...") + "\n";
        break;
    case DevAms::CannotDryReason::InsufficientPowerNeedPluginPower:
        cannot_reason_text = "*" + _L("Insufficient power") + "\n";
        cannot_reason_text += _L("  Please plug in the power and then use the drying function.") + "\n";
        break;
    case DevAms::CannotDryReason::FilamentAtAmsOutletManualUnload:
        cannot_reason_text = "*" + _L("Filament in AMS outlet") + "\n";
        cannot_reason_text += _L("  The high drying temperature may cause AMS blockage. Please unload the filament manually before proceeding.") + "\n";
        break;
    default:
        cannot_reason_text = "*" + _L("System is busy") + "\n";
        cannot_reason_text += _L("  Initiating other drying processes, please wait a few seconds...") + "\n";
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ": unknown cannot dry reason";
        break;
    }
    return cannot_reason_text;
}

wxString organize_cannot_reasons_text(std::vector<DevAms::CannotDryReason>& reasons)
{
    wxString cannot_reasons_text;
    if (std::find(reasons.begin(), reasons.end(), DevAms::CannotDryReason::DryingInProgress) != reasons.end()) {
        cannot_reasons_text += get_cannot_reason_text(DevAms::CannotDryReason::DryingInProgress);
    } else if (std::find(reasons.begin(), reasons.end(), DevAms::CannotDryReason::AmsBusy) != reasons.end()) {
        cannot_reasons_text += get_cannot_reason_text(DevAms::CannotDryReason::AmsBusy);
    } else if (std::find(reasons.begin(), reasons.end(), DevAms::CannotDryReason::ConsumableAtAmsOutlet) != reasons.end()) {
        cannot_reasons_text += get_cannot_reason_text(DevAms::CannotDryReason::ConsumableAtAmsOutlet);
    } else if (std::find(reasons.begin(), reasons.end(), DevAms::CannotDryReason::FilamentAtAmsOutletManualUnload) != reasons.end()) {
        cannot_reasons_text += get_cannot_reason_text(DevAms::CannotDryReason::FilamentAtAmsOutletManualUnload);
    }

    if (std::find(reasons.begin(), reasons.end(), DevAms::CannotDryReason::InsufficientPower) != reasons.end()) {
        cannot_reasons_text += get_cannot_reason_text(DevAms::CannotDryReason::InsufficientPower);
    }

    for (auto reason : reasons) {
        if (reason == DevAms::CannotDryReason::InsufficientPowerNeedPluginPower) {
            cannot_reasons_text += get_cannot_reason_text(DevAms::CannotDryReason::InsufficientPowerNeedPluginPower);
        } else if (reason == DevAms::CannotDryReason::NotSupportedIn2dMode) {
            cannot_reasons_text += get_cannot_reason_text(DevAms::CannotDryReason::NotSupportedIn2dMode);
        } else if (reason == DevAms::CannotDryReason::InitiatingAmsDrying) {
            cannot_reasons_text += get_cannot_reason_text(DevAms::CannotDryReason::InitiatingAmsDrying);
        } else if (reason == DevAms::CannotDryReason::Upgrading) {
            cannot_reasons_text += get_cannot_reason_text(DevAms::CannotDryReason::Upgrading);
        }
    }

    if (cannot_reasons_text.empty()) {
        cannot_reasons_text += "*" + _L("System is busy") + "\n";
        cannot_reasons_text += _L("  Initiating other drying processes, please wait a few seconds...") + "\n";
    }

    return cannot_reasons_text;
}

int AMSDryCtrWin::update_state(DevAms* dev_ams)
{
    std::vector<DevAms::CannotDryReason> cannot_reasons = dev_ams->GetCannotDryReason().has_value()?
        dev_ams->GetCannotDryReason().value(): std::vector<DevAms::CannotDryReason>();

    if (cannot_reasons.size() == 0 ||
        (cannot_reasons.size() == 1 && cannot_reasons[0] == DevAms::CannotDryReason::DryingInProgress)) {
        m_normal_state_sizer->Show(true);
        m_cannot_dry_sizer->Show(false);
        m_unload_button->Show(false);
        update_normal_state(dev_ams);
    } else if (cannot_reasons.size() > 0) {
        m_normal_state_sizer->Show(false);
        m_cannot_dry_sizer->Show(true);

        m_cannot_dry_description_label->SetLabel(organize_cannot_reasons_text(cannot_reasons));
        m_cannot_dry_description_label->Wrap(FromDIP(300));

        // Show unload button when ConsumableAtAmsOutlet reason is present
        bool has_consumable_at_outlet = std::find(cannot_reasons.begin(), cannot_reasons.end(),
            DevAms::CannotDryReason::ConsumableAtAmsOutlet) != cannot_reasons.end();
        m_unload_button->Show(has_consumable_at_outlet);
    }

    restore_stop_button_if_deadline_passed();
    restore_unload_button_if_deadline_passed();

    return 1;
}

int AMSDryCtrWin::update_ams_change(DevAms* dev_ams)
{
    if (!is_ams_changed(dev_ams)) {
        return 0;
    }

    m_ams_info.m_ams_id = dev_ams->GetAmsId();
    if (dev_ams->GetAmsType() == DevAmsType::N3F) {
        m_temperature_input->SetHint("45-65" + wxString::FromUTF8(u8"\u2103" /* °C */));
    } else if (dev_ams->GetAmsType() == DevAmsType::N3S) {
        m_temperature_input->SetHint("45-85" + wxString::FromUTF8(u8"\u2103" /* °C */));
    }

    m_time_input->SetHint("1-24 h");

    return 0;
}

int AMSDryCtrWin::update_dryness_status(DevAms* dev_ams)
{
    int updated = 0;

    if (m_ams_info.m_humidity_percent != dev_ams->GetHumidityPercent()) {
        updated += 1;
        m_ams_info.m_humidity_percent = dev_ams->GetHumidityPercent();
        m_humidity_data_label->SetLabel(std::to_string(m_ams_info.m_humidity_percent) + "%");
    }

    if (m_ams_info.m_temperature != dev_ams->GetCurrentTemperature()) {
        updated += 1;
        m_ams_info.m_temperature = dev_ams->GetCurrentTemperature();
        m_temperature_data_label->SetLabel(std::to_string(m_ams_info.m_temperature) + wxString::FromUTF8(u8"\u2103" /* °C */));
    }

    if (is_dry_ctr_idle(dev_ams)) {
        m_time_descrition_container->Show(false);
        m_original_page->Layout();
    } else {
        if (is_dry_status_changed(dev_ams)) {
            m_time_descrition_container->Show(true);
            m_original_page->Layout();
        }

        if (m_ams_info.m_left_dry_time != dev_ams->GetLeftDryTime()) {
            updated += 1;
            m_ams_info.m_left_dry_time = dev_ams->GetLeftDryTime();
            m_time_data_label->SetLabel(wxString::Format("%02d : %02d",
                m_ams_info.m_left_dry_time / 60, m_ams_info.m_left_dry_time % 60));
        }
    }

    return updated;
}

bool AMSDryCtrWin::is_tray_changed(DevAms* dev_ams)
{
    return false;
}

void AMSDryCtrWin::update_filament_guide_info(DevAms* dev_ams)
{
    if (!IsShown()) {
        return;
    }

    m_guide_page->Freeze();
    m_ams_filament_panel->Clear();
    m_ams_filament_panel->SetAmsName(dev_ams->GetDisplayName());

    // Get the temperature input value
    long input_temp = 0;
    bool valid_temp = !m_temperature_input->GetValue().IsEmpty() &&
                      m_temperature_input->GetValue().ToLong(&input_temp);
    bool can_start = true;

    // "GFA00" is Bambu's PLA id; GetFilamentDryingPreset is keyed by our OF ids.
    auto* agent = wxGetApp().getAgent();
    const std::string pla_filament_id = agent ? agent->to_orca_filament_id("GFA00") : std::string("GFA00");

    int slot_count = 0, empty_count = 0;
    for (auto& tray_pair : dev_ams->GetTrays()) {
        if (!tray_pair.second) {
            continue;
        }
        ++slot_count;
        if (!tray_pair.second->is_exists) {
            m_ams_filament_panel->AddFilamentItem("/", "dev_ams_dry_ctr_enable");
            ++empty_count;
            continue;
        }
        auto preset_opt = tray_pair.second->get_ams_drying_preset();
        wxString filament_type = tray_pair.second->get_display_filament_type();
        DevFilamentDryingPreset preset;
        if (filament_type.IsEmpty()) {
            auto fallback_preset = DevUtilBackend::GetFilamentDryingPreset(pla_filament_id);
            if (!fallback_preset) continue;                 // no PLA preset (e.g. the id map is missing): skip, don't throw
            preset = fallback_preset.value();
            filament_type = "?";
        } else if (preset_opt.has_value()) {
            preset = preset_opt.value();
        } else {
            auto fallback_preset = DevUtilBackend::GetFilamentDryingPreset(pla_filament_id);
            if (!fallback_preset) continue;
            preset = fallback_preset.value();
        }
        std::string icon_path = "dev_ams_dry_ctr_enable";
        int distortion_temp = static_cast<int>(preset.filament_dev_ams_drying_heat_distortion_temperature);
        if (valid_temp && distortion_temp < input_temp) {
            icon_path = "dev_ams_dry_ctr_disable";
            can_start = false;
        }
        m_ams_filament_panel->AddFilamentItem(filament_type, icon_path);
    }
    if (slot_count == 0) {
        can_start = false;
    }

    if (can_start) {
        m_guide_title_label->SetLabel(_L("For better drying results, remove the filament and allow it to rotate."));
        m_guide_description_label->SetLabel(_L("The AMS will automatically rotate the stored filament slots to enhance the drying performance.") +
            "\n" + _L("Alternatively, you can dry the filament without removing it.") +
            "\n" + "*" + _L("Unknown filaments will be treated as PLA."));
        m_guide_description_label->Wrap(FromDIP(300));
    } else {
        m_guide_title_label->SetLabel(_L("Please store the filament marked with an exclamation mark."));
        m_guide_description_label->SetLabel(_L("Filament left in the feeder during drying may soften because the drying temperature exceeds the softening point of materials like PLA and TPU.") +
            "\n" + "*" + _L("Unknown filaments will be treated as PLA."));
        m_guide_description_label->Wrap(FromDIP(300));
    }

    m_start_button->Enable(can_start);
    m_guide_page->Layout();
    m_guide_page->Thaw();
}

int AMSDryCtrWin::update_filament_list(DevAms* dev_ams, MachineObject* obj)
{
    const bool ams_changed = is_ams_changed(dev_ams);
    bool rebuilt_filament_list = false;

    // Build `m_tray_ids` and the combobox items from the preset bundle.
    // This list is also used as a lookup table in non-idle state (type -> name),
    // so it must be available even when the combobox is disabled.
    auto rebuild_filament_list = [&]() -> bool {
        m_trays_combo->Clear();
        m_tray_ids.clear();

        PresetBundle *preset_bundle = wxGetApp().preset_bundle;
        if (!preset_bundle || !obj) {
            return false;
        }

        std::set<std::string> filament_id_set;
        auto & filaments = preset_bundle->filaments;

        // Get nozzle diameter using the same method as AMSMaterialsSetting::Popup
        std::ostringstream stream;
        int extruder_id = obj->GetFilaSystem()->GetExtruderIdByAmsId(m_ams_info.m_ams_id);
        if (!obj->GetExtderSystem()->GetExtderById(extruder_id)) {
            BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << " get extruder id failed";
            extruder_id = 0;
        }
        stream << std::fixed << std::setprecision(1) << obj->GetExtderSystem()->GetNozzleDiameter(extruder_id);
        std::string nozzle_diameter_str = stream.str();

        for (Preset *filament_it : preset_bundle->get_filament_presets_for_machine(
                 DevPrinterConfigUtil::get_printer_display_name(obj->printer_type), nozzle_diameter_str, obj->is_support_user_preset)) {
            if (!filament_id_set.insert(filament_it->filament_id).second)
                continue;
            const std::string filament_alias = filaments.get_preset_alias(*filament_it, true);
            if (filament_alias.empty())
                continue;
            auto opt_info = preset_bundle->get_filament_by_filament_id(filament_it->filament_id);
            if (!opt_info.has_value())
                continue;

            opt_info->filament_name = filament_alias;
            m_tray_ids.push_back(std::move(*opt_info));
            m_trays_combo->Append(wxString::FromUTF8(filament_alias));
        }

        if (m_tray_ids.empty()) {
            BOOST_LOG_TRIVIAL(warning) << "AMSDryCtrWin::update_filament_list: No valid filaments found";
            return false;
        }

        return true;
    };

    if (ams_changed || m_tray_ids.empty() || m_trays_combo->GetCount() == 0) {
        // Disable start button during rebuild
        if (m_start_button) {
            m_start_button->Disable();
        }

        rebuilt_filament_list = rebuild_filament_list();
    }

    if (!is_dry_ctr_idle(dev_ams)) {
        const std::string& ams_id = dev_ams->GetAmsId();
        const auto settings_opt = dev_ams->GetDrySettings();

        // Set the combobox display label by the filament "type" string.
        // Priority: last saved selection for this AMS (if the type matches) -> fallback to current `m_tray_ids`.
        auto set_filament_label_by_type = [&](const std::string& filament_type) {
            if (filament_type.empty()) {
                return;
            }

            auto it_name = m_dry_setting.m_filament_names.find(ams_id);
            auto it_type = m_dry_setting.m_filament_type.find(ams_id);
            if (it_name != m_dry_setting.m_filament_names.end() && it_type != m_dry_setting.m_filament_type.end()
                && it_type->second == filament_type) {
                m_trays_combo->SetLabel(wxString::FromUTF8(it_name->second));
                return;
            }

            const auto it = std::find_if(m_tray_ids.begin(), m_tray_ids.end(), [&](const FilamentBaseInfo& tray) {
                return tray.filament_type == filament_type;
            });
            if (it != m_tray_ids.end()) {
                m_trays_combo->SetLabel(wxString::FromUTF8(it->filament_name));
            }
        };

        if (settings_opt.has_value()) {
            const auto& settings = settings_opt.value();
            m_temperature_input->SetValue(std::to_string(settings.dry_temp));
            m_time_input->SetValue(std::to_string(settings.dry_hour));
            set_filament_label_by_type(settings.dry_filament);
        } else {
            auto it_name = m_dry_setting.m_filament_names.find(ams_id);
            if (it_name != m_dry_setting.m_filament_names.end()) {
                m_trays_combo->SetLabel(wxString::FromUTF8(it_name->second));
                m_temperature_input->SetValue(std::to_string(m_dry_setting.m_dry_temp[ams_id]));
                m_time_input->SetValue(std::to_string(m_dry_setting.m_dry_time[ams_id]));
            }
        }

        return 0;
    }

    // Idle state: avoid re-selecting / firing selection change unless the list was rebuilt.
    if (!rebuilt_filament_list && !ams_changed && is_dry_ctr_idle()) {
        return 0;
    }

    if (m_tray_ids.empty()) {
        return 0;
    }

    // Select recommended drying temperature and default filament
    float min_dry_temp = std::numeric_limits<float>::max();
    auto* agent = wxGetApp().getAgent();
    std::string default_filament_id = agent ? agent->to_orca_filament_id("GFA00") : std::string("GFA00");   // compared against m_tray_ids[i].filament_id (our OF ids) below
    bool has_ready = false;
    const auto fallback_preset = DevUtilBackend::GetFilamentDryingPreset(default_filament_id);
    for (const auto& tray_pair : dev_ams->GetTrays()) {
        if (!tray_pair.second || !tray_pair.second->is_tray_info_ready()) continue;
        has_ready = true;
        wxString filament_type = tray_pair.second->get_display_filament_type();
        Slic3r::DevFilamentDryingPreset preset;
        if (filament_type.IsEmpty()) {
            // no filament type, is PLA
            if (!fallback_preset) continue;
            preset = fallback_preset.value();
        } else {
            auto preset_opt = tray_pair.second->get_ams_drying_preset();
            if (preset_opt.has_value()) {
                preset = preset_opt.value();
            } else {
                // no preset，is PLA
                if (!fallback_preset) continue;
                preset = fallback_preset.value();
            }
        }
        float cur_temp = m_printer_status.m_is_printing
            ? std::min({preset.filament_dev_ams_drying_temperature_on_print[dev_ams->GetAmsType()],
                preset.filament_dev_drying_softening_temperature, preset.filament_dev_ams_drying_heat_distortion_temperature})
            : preset.filament_dev_ams_drying_temperature_on_idle[dev_ams->GetAmsType()];
        if (cur_temp < min_dry_temp) {
            min_dry_temp = cur_temp;
            default_filament_id = preset.filament_id;
        }
    }
    // if no tray is ready, use PLA as default
    if (!has_ready) {
        if (fallback_preset.has_value()) {
            Slic3r::DevFilamentDryingPreset preset = fallback_preset.value();
            float cur_temp = m_printer_status.m_is_printing
                ? std::min({preset.filament_dev_ams_drying_temperature_on_print[dev_ams->GetAmsType()],
                    preset.filament_dev_drying_softening_temperature, preset.filament_dev_ams_drying_heat_distortion_temperature})
                : preset.filament_dev_ams_drying_temperature_on_idle[dev_ams->GetAmsType()];
            min_dry_temp = cur_temp;
            default_filament_id = preset.filament_id;
        }
    }
    m_ams_info.m_recommand_dry_temp = min_dry_temp;

    // Set default selection
    unsigned int default_index = 0;
    for (unsigned int i = 0; i < m_tray_ids.size(); i++) {
        if (m_tray_ids[i].filament_id == default_filament_id) {
            default_index = i;
            break;
        }
    }
    m_trays_combo->SetSelection(default_index);
    wxCommandEvent evt(wxEVT_COMBOBOX, m_trays_combo->GetId());
    evt.SetInt(default_index);
    OnFilamentSelectionChanged(evt);
    return 1;
}

std::shared_ptr<DevFilaSystem> AMSDryCtrWin::get_fila_system() const
{
    std::shared_ptr<DevFilaSystem> fila_system = m_fila_system.lock();
    if (!fila_system) {
        const_cast<AMSDryCtrWin*>(this)->Close();
    }
    return fila_system;
}

void AMSDryCtrWin::update_printer_state(MachineObject* obj)
{
    m_printer_status.m_is_printing = obj->is_in_printing()
        && obj->GetExtderSystem()->GetCurrentAmsId() == m_ams_info.m_ams_id;
}

void AMSDryCtrWin::update(std::shared_ptr<DevFilaSystem> fila_system, MachineObject* obj)
{
    if (!fila_system || !obj) {
        return;
    }

    update_printer_state(obj);
    m_fila_system = fila_system;

    DevAms* dev_ams = fila_system->GetAmsById(m_ams_info.m_ams_id);
    if (!dev_ams) {
        BOOST_LOG_TRIVIAL(info) << "AMSDryCtrWin::update: Invalid AMS id";
        m_ams_info.m_ams_id = "";
        Close();
        return;
    }

    if (!dev_ams->IsSupportRemoteDry(fila_system->GetOwner())) {
        BOOST_LOG_TRIVIAL(info) << "AMSDryCtrWin::update: Selected AMS does not support remote drying";
        Close();
        return;
    }


    update_ams_change(dev_ams);

    update_image(dev_ams->GetAmsType(),
        dev_ams->GetDryStatus().has_value()? dev_ams->GetDryStatus().value(): DevAms::DryStatus::Off,
        dev_ams->GetDrySubStatus().has_value()? dev_ams->GetDrySubStatus().value(): DevAms::DrySubStatus::Off,
        dev_ams->GetHumidityPercent());

    update_state(dev_ams);
    update_dryness_status(dev_ams);

    update_filament_list(dev_ams, obj);
    update_filament_guide_info(dev_ams);

    m_is_ams_changed = false;

    check_values_changed(dev_ams);

    Layout();
    Refresh();
}

bool AMSDryCtrWin::is_ams_changed(DevAms* dev_ams)
{
    return m_ams_info.m_ams_id != dev_ams->GetAmsId() || m_is_ams_changed;
}

bool AMSDryCtrWin::is_dry_status_changed(DevAms* dev_ams)
{
    if (!dev_ams->GetDryStatus().has_value() || !dev_ams->GetDrySubStatus().has_value()) {
        return true;
    }

    return dev_ams->GetDryStatus().value() != m_ams_info.m_dry_status
        || dev_ams->GetDrySubStatus().value() != m_ams_info.m_dry_sub_status;
}

bool AMSDryCtrWin::is_dry_ctr_idle(DevAms* dev_ams)
{
    if (!dev_ams->GetDryStatus().has_value() || !dev_ams->GetDrySubStatus().has_value()) {
        return true;
    }

    return dev_ams->GetDryStatus().value() == DevAms::DryStatus::Off
        || dev_ams->GetDryStatus().value() == DevAms::DryStatus::Cooling;
}

bool AMSDryCtrWin::is_dry_ctr_idle()
{
    return m_ams_info.m_dry_status == DevAms::DryStatus::Off || m_ams_info.m_dry_status == DevAms::DryStatus::Cooling;
}

bool AMSDryCtrWin::is_dry_ctr_err(DevAms* dev_ams)
{
    if (!dev_ams->GetDryStatus().has_value() || !dev_ams->GetDrySubStatus().has_value()) {
        return false;
    }

    return dev_ams->GetDryStatus().value() == DevAms::DryStatus::Error;
}

} // GUI
} // Slic3r