#include "../../include/gui/SettingsPage.hpp"
#include "../../include/gui/GsrPage.hpp"
#include "../../include/gui/Label.hpp"
#include "../../include/gui/PageStack.hpp"
#include "../../include/gui/FileChooser.hpp"
#include "../../include/gui/Subsection.hpp"
#include "../../include/gui/CustomRendererWidget.hpp"
#include "../../include/gui/Image.hpp"
#include "../../include/gui/Utils.hpp"
#include "../../include/Theme.hpp"
#include "../../include/GsrInfo.hpp"
#include "../../include/Utils.hpp"
#include "../../include/Translation.hpp"

#include <mglpp/window/Window.hpp>
#include <mglpp/window/Event.hpp>

#include <algorithm>
#include <cmath>
#include <string.h>
#include <charconv>

namespace gsr {
    static const char *custom_app_audio_tag = "[custom]";

    enum class AudioTrackType {
        DEVICE,
        APPLICATION,
        APPLICATION_CUSTOM
    };

    static const char* settings_page_type_to_title_text(SettingsPage::Type type) {
        switch(type) {
            case SettingsPage::Type::REPLAY: return TR("Instant Replay");
            case SettingsPage::Type::RECORD: return TR("Record");
            case SettingsPage::Type::STREAM: return TR("Livestream");
        }
        return "";
    }

    template <typename T>
    static T sv_to_int(std::string_view str) {
        T result = 0;
        std::from_chars(str.data(), str.data() + str.size(), result);
        return result;
    }

    SettingsPage::SettingsPage(Type type, const GsrInfo *gsr_info, Config &config, PageStack *page_stack, bool supports_window_title) :
        StaticPage(mgl::vec2f(get_theme().window_width, get_theme().window_height).floor()),
        type(type),
        config(config),
        gsr_info(gsr_info),
        page_stack(page_stack),
        supports_window_title(supports_window_title)
    {
        audio_devices = get_audio_devices();
        application_audio = get_application_audio();
        capture_options = get_supported_capture_options(*gsr_info);

        auto content_page = std::make_unique<GsrPage>(settings_page_type_to_title_text(type), TR("Settings"));
        content_page->add_button(TR("Back"), "back", get_color_theme().page_bg_color);
        content_page->on_click = [page_stack](const std::string &id) {
            if(id == "back")
                page_stack->pop();
        };
        content_page_ptr = content_page.get();
        add_widget(std::move(content_page));

        add_widgets();
        add_page_specific_widgets();
        load();
    }

    std::unique_ptr<RadioButton> SettingsPage::create_view_radio_button() {
        auto view_radio_button = std::make_unique<RadioButton>(get_theme().body_font_desc.c_str(), RadioButton::Orientation::HORIZONTAL);
        view_radio_button->add_item(TR("Simple view"), "simple");
        view_radio_button->add_item(TR("Advanced view"), "advanced");
        view_radio_button->set_horizontal_alignment(Widget::Alignment::CENTER);
        view_radio_button_ptr = view_radio_button.get();
        return view_radio_button;
    }

    std::unique_ptr<ComboBox> SettingsPage::create_record_area_box() {
        auto record_area_box = std::make_unique<ComboBox>(get_theme().body_font_desc.c_str());
        // TODO: Show options not supported but disable them
        if(capture_options.window)
            record_area_box->add_item(TR("Window"), "window");
        if(capture_options.focused)
            record_area_box->add_item(TR("Follow focused window"), "focused");
        if(capture_options.region)
            record_area_box->add_item(TR("Region"), "region");
        if(!capture_options.monitors.empty())
            record_area_box->add_item(TR("Focused monitor"), "focused_monitor");
        for(const auto &monitor : capture_options.monitors) {
            char name[256];
            snprintf(name, sizeof(name), TR("Monitor %s (%dx%d)"), monitor.name.c_str(), monitor.size.x, monitor.size.y);
            record_area_box->add_item(name, monitor.name);
        }
        if(capture_options.portal)
            record_area_box->add_item(TR("Desktop portal"), "portal");
        record_area_box_ptr = record_area_box.get();
        return record_area_box;
    }

    std::unique_ptr<Widget> SettingsPage::create_record_area() {
        auto record_area_list = std::make_unique<List>(List::Orientation::VERTICAL);
        record_area_list->add_widget(std::make_unique<Label>(get_theme().body_font_desc.c_str(), TR("Capture source:"), get_color_theme().text_color));
        record_area_list->add_widget(create_record_area_box());
        return record_area_list;
    }

    std::unique_ptr<Entry> SettingsPage::create_area_width_entry() {
        auto area_width_entry = std::make_unique<Entry>(get_theme().body_font_desc.c_str(), "1920", 2.0f*mgl::Text::get_font_size_from_font_description(get_theme().body_font_desc.c_str()) * 4);
        area_width_entry->set_number_mode(true, 1, 1 << 15);
        area_width_entry_ptr = area_width_entry.get();
        return area_width_entry;
    }

    std::unique_ptr<Entry> SettingsPage::create_area_height_entry() {
        auto area_height_entry = std::make_unique<Entry>(get_theme().body_font_desc.c_str(), "1080", 2.0f*mgl::Text::get_font_size_from_font_description(get_theme().body_font_desc.c_str()) * 4);
        area_height_entry->set_number_mode(true, 1, 1 << 15);
        area_height_entry_ptr = area_height_entry.get();
        return area_height_entry;
    }

    std::unique_ptr<List> SettingsPage::create_area_size() {
        auto area_size_params_list = std::make_unique<List>(List::Orientation::HORIZONTAL, List::Alignment::CENTER);
        area_size_params_list->add_widget(create_area_width_entry());
        area_size_params_list->add_widget(std::make_unique<Label>(get_theme().body_font_desc.c_str(), "x", get_color_theme().text_color));
        area_size_params_list->add_widget(create_area_height_entry());
        return area_size_params_list;
    }

    std::unique_ptr<List> SettingsPage::create_area_size_section() {
        auto area_size_list = std::make_unique<List>(List::Orientation::VERTICAL);
        area_size_list->add_widget(std::make_unique<Label>(get_theme().body_font_desc.c_str(), TR("Area size:"), get_color_theme().text_color));
        area_size_list->add_widget(create_area_size());
        area_size_list_ptr = area_size_list.get();
        return area_size_list;
    }

    std::unique_ptr<Entry> SettingsPage::create_video_width_entry() {
        auto video_width_entry = std::make_unique<Entry>(get_theme().body_font_desc.c_str(), "1920", 2.0f*mgl::Text::get_font_size_from_font_description(get_theme().body_font_desc.c_str()) * 4);
        video_width_entry->set_number_mode(true, 1, 1 << 15);
        video_width_entry_ptr = video_width_entry.get();
        return video_width_entry;
    }

    std::unique_ptr<Entry> SettingsPage::create_video_height_entry() {
        auto video_height_entry = std::make_unique<Entry>(get_theme().body_font_desc.c_str(), "1080", 2.0f*mgl::Text::get_font_size_from_font_description(get_theme().body_font_desc.c_str()) * 4);
        video_height_entry->set_number_mode(true, 1, 1 << 15);
        video_height_entry_ptr = video_height_entry.get();
        return video_height_entry;
    }

    std::unique_ptr<List> SettingsPage::create_video_resolution() {
        auto area_size_params_list = std::make_unique<List>(List::Orientation::HORIZONTAL, List::Alignment::CENTER);
        area_size_params_list->add_widget(create_video_width_entry());
        area_size_params_list->add_widget(std::make_unique<Label>(get_theme().body_font_desc.c_str(), "x", get_color_theme().text_color));
        area_size_params_list->add_widget(create_video_height_entry());
        return area_size_params_list;
    }

    std::unique_ptr<List> SettingsPage::create_video_resolution_section() {
        auto video_resolution_list = std::make_unique<List>(List::Orientation::VERTICAL);
        video_resolution_list->add_widget(std::make_unique<Label>(get_theme().body_font_desc.c_str(), TR("Video resolution limit:"), get_color_theme().text_color));
        video_resolution_list->add_widget(create_video_resolution());
        video_resolution_list_ptr = video_resolution_list.get();
        return video_resolution_list;
    }

    std::unique_ptr<CheckBox> SettingsPage::create_restore_portal_session_checkbox() {
        auto restore_portal_session_checkbox = std::make_unique<CheckBox>(get_theme().body_font_desc.c_str(), TR("Restore portal session"));
        restore_portal_session_checkbox->set_checked(true);
        restore_portal_session_checkbox_ptr = restore_portal_session_checkbox.get();
        return restore_portal_session_checkbox;
    }

    std::unique_ptr<List> SettingsPage::create_restore_portal_session_section() {
        auto restore_portal_session_list = std::make_unique<List>(List::Orientation::VERTICAL);
        restore_portal_session_list->add_widget(std::make_unique<Label>(get_theme().body_font_desc.c_str(), " ", get_color_theme().text_color));
        restore_portal_session_list->add_widget(create_restore_portal_session_checkbox());
        restore_portal_session_list_ptr = restore_portal_session_list.get();
        return restore_portal_session_list;
    }

    std::unique_ptr<Widget> SettingsPage::create_change_video_resolution_section() {
        auto checkbox = std::make_unique<CheckBox>(get_theme().body_font_desc.c_str(), TR("Change video resolution"));
        change_video_resolution_checkbox_ptr = checkbox.get();
        return checkbox;
    }

    std::unique_ptr<Widget> SettingsPage::create_capture_target_section() {
        auto ll = std::make_unique<List>(List::Orientation::VERTICAL);

        auto capture_target_list = std::make_unique<List>(List::Orientation::HORIZONTAL, List::Alignment::CENTER);
        capture_target_list->add_widget(create_record_area());
        capture_target_list->add_widget(create_area_size_section());
        capture_target_list->add_widget(create_video_resolution_section());
        capture_target_list->add_widget(create_restore_portal_session_section());

        ll->add_widget(std::move(capture_target_list));
        ll->add_widget(create_change_video_resolution_section());
        return std::make_unique<Subsection>(TR("Capture"), std::move(ll), mgl::vec2f(settings_scrollable_page_ptr->get_inner_size().x, 0.0f));
    }

    std::unique_ptr<List> SettingsPage::create_webcam_sources() {
        auto ll = std::make_unique<List>(List::Orientation::VERTICAL);
        ll->add_widget(std::make_unique<Label>(get_theme().body_font_desc.c_str(), TR("Webcam source:"), get_color_theme().text_color));

        auto combobox = std::make_unique<ComboBox>(get_theme().body_font_desc.c_str());
        combobox->add_item(TR("None"), "");
        for(const GsrCamera &camera : capture_options.cameras) {
            combobox->add_item(camera.path, camera.path);
        }
        webcam_sources_box_ptr = combobox.get();

        webcam_sources_box_ptr->on_selection_changed = [this](std::string_view, std::string_view id) {
            selected_camera = std::nullopt;
            selected_camera_setup = std::nullopt;
            webcam_video_format_box_ptr->clear_items();
            if(id == "") {
                webcam_body_list_ptr->set_visible(false);
                return;
            }

            auto it = std::find_if(capture_options.cameras.begin(), capture_options.cameras.end(), [&](const GsrCamera &camera) {
                return camera.path == id;
            });
            if(it == capture_options.cameras.end())
                return;

            webcam_body_list_ptr->set_visible(true);
            webcam_video_format_box_ptr->add_item(TR("Auto (recommended)"), "auto");

            if(!it->yuyv_setups.empty())
                webcam_video_format_box_ptr->add_item(TR("YUYV"), "yuyv");

            if(!it->mjpeg_setups.empty())
                webcam_video_format_box_ptr->add_item(TR("Motion-JPEG"), "mjpeg");

            const std::string prev_webcam_video_format = get_current_record_options().webcam_video_format;
            webcam_video_format_box_ptr->set_selected_item(webcam_video_format_box_ptr->get_selected_id());
            webcam_video_format_box_ptr->set_selected_item(prev_webcam_video_format);
            selected_camera = *it;
        };

        ll->add_widget(std::move(combobox));
        return ll;
    }

    std::unique_ptr<List> SettingsPage::create_webcam_video_setups() {
        auto ll = std::make_unique<List>(List::Orientation::VERTICAL);
        ll->add_widget(std::make_unique<Label>(get_theme().body_font_desc.c_str(), TR("Video setup:"), get_color_theme().text_color));

        auto combobox = std::make_unique<ComboBox>(get_theme().body_font_desc.c_str());
        webcam_video_setup_box_ptr = combobox.get();

        webcam_video_setup_box_ptr->on_selection_changed = [this](std::string_view, std::string_view id) {
            int camera_width = 0;
            int camera_height = 0;
            int camera_fps = 0;

            char id_str[256];
            snprintf(id_str, sizeof(id_str), "%.*s", (int)id.size(), id.data());
            sscanf(id_str, "%dx%d@%dhz", &camera_width, &camera_height, &camera_fps);

            RecordOptions &current_record_options = get_current_record_options();
            current_record_options.webcam_camera_width = camera_width;
            current_record_options.webcam_camera_height = camera_height;
            current_record_options.webcam_camera_fps = camera_fps;

            selected_camera_setup = GsrCameraSetup{mgl::vec2i{camera_width, camera_height}, camera_fps};
        };

        ll->add_widget(std::move(combobox));
        return ll;
    }

    static std::vector<GsrCameraSetup> sort_camera_setup(const std::vector<GsrCameraSetup> &setups) {
        auto result = setups;
        std::sort(result.begin(), result.end(), [](const auto &a, const auto &b) {
            const uint64_t score_a = (uint64_t)a.resolution.x * (uint64_t)a.resolution.y * (uint64_t)a.fps;
            const uint64_t score_b = (uint64_t)b.resolution.x * (uint64_t)b.resolution.y * (uint64_t)b.fps;
            return score_a > score_b;
        });
        return result;
    }

    std::unique_ptr<List> SettingsPage::create_webcam_video_format() {
        auto ll = std::make_unique<List>(List::Orientation::VERTICAL);
        ll->add_widget(std::make_unique<Label>(get_theme().body_font_desc.c_str(), TR("Video format:"), get_color_theme().text_color));

        auto combobox = std::make_unique<ComboBox>(get_theme().body_font_desc.c_str());
        webcam_video_format_box_ptr = combobox.get();

        webcam_video_format_box_ptr->on_selection_changed = [this](std::string_view, std::string_view id) {
            get_current_record_options().webcam_video_format = id;

            auto it = std::find_if(capture_options.cameras.begin(), capture_options.cameras.end(), [&](const GsrCamera &camera) {
                return camera.path == webcam_sources_box_ptr->get_selected_id();
            });
            if(it == capture_options.cameras.end())
                return;

            webcam_video_setup_box_ptr->clear_items();
            if(id == "yuyv") {
                const auto setups = sort_camera_setup(it->yuyv_setups);
                for(const auto &setup : setups) {
                    char setup_str[256];
                    snprintf(setup_str, sizeof(setup_str), "%dx%d@%dhz", setup.resolution.x, setup.resolution.y, setup.fps);
                    webcam_video_setup_box_ptr->add_item(setup_str, setup_str, false);
                }
            } else if(id == "mjpeg") {
                const auto setups = sort_camera_setup(it->mjpeg_setups);
                for(const auto &setup : setups) {
                    char setup_str[256];
                    snprintf(setup_str, sizeof(setup_str), "%dx%d@%dhz", setup.resolution.x, setup.resolution.y, setup.fps);
                    webcam_video_setup_box_ptr->add_item(setup_str, setup_str, false);
                }
            } else if(id == "auto") {
                auto setups = it->yuyv_setups;
                setups.insert(setups.end(), it->mjpeg_setups.begin(), it->mjpeg_setups.end());
                setups = sort_camera_setup(setups);

                for(const auto &setup : setups) {
                    char setup_str[256];
                    snprintf(setup_str, sizeof(setup_str), "%dx%d@%dhz", setup.resolution.x, setup.resolution.y, setup.fps);
                    webcam_video_setup_box_ptr->add_item(setup_str, setup_str, false);
                }
            }

            const RecordOptions &current_record_options = get_current_record_options();
            char webcam_setup_str[256];
            snprintf(webcam_setup_str, sizeof(webcam_setup_str), "%dx%d@%dhz", current_record_options.webcam_camera_width, current_record_options.webcam_camera_height, current_record_options.webcam_camera_fps);
            webcam_video_setup_box_ptr->set_selected_item(webcam_video_setup_box_ptr->get_selected_id());
            webcam_video_setup_box_ptr->set_selected_item(webcam_setup_str);
        };

        ll->add_widget(std::move(combobox));
        return ll;
    }

    std::unique_ptr<List> SettingsPage::create_webcam_video_setup_list() {
        auto list = std::make_unique<List>(List::Orientation::HORIZONTAL);
        list->add_widget(create_webcam_video_format());
        list->add_widget(create_webcam_video_setups());
        return list;
    }

    std::unique_ptr<Widget> SettingsPage::create_webcam_location_widget() {
        const float camera_screen_width = std::min(400.0f, (float)settings_scrollable_page_ptr->get_inner_size().x * 0.90f);
        camera_screen_size = mgl::vec2f(camera_screen_width, camera_screen_width * 0.5625);

        const float screen_border = 2.0f;
        const mgl::vec2f screen_border_size(screen_border, screen_border);
        screen_inner_size = mgl::vec2f(camera_screen_size - screen_border_size*2.0f);

        const mgl::vec2f bounding_box_size(30.0f, 30.0f);

        auto camera_location_widget = std::make_unique<CustomRendererWidget>(camera_screen_size);
        camera_location_widget->draw_handler = [this, screen_border_size, screen_border](mgl::Window &window, mgl::vec2f pos, mgl::vec2f size) {
            if(!selected_camera.has_value() || !selected_camera_setup.has_value())
                return;

            pos = pos.floor();
            size = size.floor();
            const mgl::vec2i mouse_pos = window.get_mouse_position();
            const mgl::vec2f webcam_box_min_size = clamp_keep_aspect_ratio(selected_camera_setup->resolution.to_vec2f(), screen_inner_size * 0.2f);

            if(moving_webcam_box) {
                webcam_box_pos = mouse_pos.to_vec2f() - screen_border_size - webcam_box_grab_offset - pos;
            } else if(webcam_resize_corner == WebcamBoxResizeCorner::BOTTOM_RIGHT) {
                const mgl::vec2f mouse_diff = mouse_pos.to_vec2f() - webcam_resize_start_pos;
                webcam_box_size = webcam_box_size_resize_start + mouse_diff;
            }

            webcam_box_size = clamp_keep_aspect_ratio(selected_camera_setup->resolution.to_vec2f(), webcam_box_size);

            if(webcam_box_pos.x < 0.0f)
                webcam_box_pos.x = 0.0f;
            else if(webcam_box_pos.x + webcam_box_size.x > screen_inner_size.x)
                webcam_box_pos.x = screen_inner_size.x - webcam_box_size.x;

            if(webcam_box_pos.y < 0.0f)
                webcam_box_pos.y = 0.0f;
            else if(webcam_box_pos.y + webcam_box_size.y > screen_inner_size.y)
                webcam_box_pos.y = screen_inner_size.y - webcam_box_size.y;

            if(webcam_box_size.x < webcam_box_min_size.x)
                webcam_box_size.x = webcam_box_min_size.x;
            else if(webcam_box_pos.x + webcam_box_size.x > screen_inner_size.x)
                webcam_box_size.x = screen_inner_size.x - webcam_box_pos.x;

            //webcam_box_size = clamp_keep_aspect_ratio(selected_camera->size.to_vec2f(), webcam_box_size);

            if(webcam_box_size.y < webcam_box_min_size.y)
                webcam_box_size.y = webcam_box_min_size.y;
            else if(webcam_box_pos.y + webcam_box_size.y > screen_inner_size.y)
                webcam_box_size.y = screen_inner_size.y - webcam_box_pos.y;

            webcam_box_size = clamp_keep_aspect_ratio(selected_camera_setup->resolution.to_vec2f(), webcam_box_size);

            {
                draw_rectangle_outline(window, pos, size, mgl::Color(255, 0, 0, 255), screen_border);
                mgl::Text screen_text(TR("Screen"), get_theme().camera_setup_font_desc.c_str());
                screen_text.set_position((pos + size * 0.5f - screen_text.get_bounds().size * 0.5f).floor());
                window.draw(screen_text);
            }

            {
                webcam_box_drawn_size = clamp_keep_aspect_ratio(selected_camera_setup->resolution.to_vec2f(), webcam_box_size);
                webcam_box_drawn_pos = (pos + screen_border_size + webcam_box_pos).floor();

                draw_rectangle_outline(window, webcam_box_drawn_pos, webcam_box_drawn_size, mgl::Color(0, 255, 0, 255), screen_border);

                // mgl::Rectangle resize_area(webcam_box_drawn_pos + webcam_box_drawn_size - bounding_box_size*0.5f - screen_border_size*0.5f, bounding_box_size);
                // resize_area.set_color(mgl::Color(0, 0, 255, 255));
                // window.draw(resize_area);

                mgl::Text webcam_text(TR("Webcam"), get_theme().camera_setup_font_desc.c_str());
                webcam_text.set_position((webcam_box_drawn_pos + webcam_box_drawn_size * 0.5f - webcam_text.get_bounds().size * 0.5f).floor());
                window.draw(webcam_text);
            }
        };

        camera_location_widget->event_handler = [this, screen_border_size, bounding_box_size](mgl::Event &event, mgl::Window&, mgl::vec2f, mgl::vec2f) {
            switch(event.type) {
                case mgl::Event::MouseButtonPressed: {
                    if(event.mouse_button.button == mgl::Mouse::Left && webcam_resize_corner == WebcamBoxResizeCorner::NONE) {
                        const mgl::vec2f mouse_button_pos(event.mouse_button.x, event.mouse_button.y);
                        if(mgl::FloatRect(webcam_box_drawn_pos, webcam_box_drawn_size).contains(mouse_button_pos)) {
                            moving_webcam_box = true;
                            webcam_box_grab_offset = mouse_button_pos - webcam_box_drawn_pos;
                        } else {
                            moving_webcam_box = false;
                        }
                    } else if(event.mouse_button.button == mgl::Mouse::Right && !moving_webcam_box) {
                        const mgl::vec2f mouse_button_pos(event.mouse_button.x, event.mouse_button.y);
                        webcam_resize_start_pos = mouse_button_pos;
                        webcam_box_pos_resize_start = webcam_box_pos;
                        webcam_box_size_resize_start = webcam_box_size;
                        webcam_box_grab_offset = mouse_button_pos - webcam_box_drawn_pos;

                        /*if(mgl::FloatRect(webcam_box_drawn_pos - bounding_box_size*0.5f, bounding_box_size).contains(mouse_button_pos)) {
                            webcam_resize_corner = WebcamBoxResizeCorner::TOP_LEFT;
                            fprintf(stderr, "top left\n");
                        } else if(mgl::FloatRect(webcam_box_drawn_pos + mgl::vec2f(webcam_box_drawn_size.x, 0.0f) - bounding_box_size*0.5f, bounding_box_size).contains(mouse_button_pos)) {
                            webcam_resize_corner = WebcamBoxResizeCorner::TOP_RIGHT;
                            fprintf(stderr, "top right\n");
                        } else if(mgl::FloatRect(webcam_box_drawn_pos + mgl::vec2f(0.0f, webcam_box_drawn_size.y) - bounding_box_size*0.5f, bounding_box_size).contains(mouse_button_pos)) {
                            webcam_resize_corner = WebcamBoxResizeCorner::BOTTOM_LEFT;
                            fprintf(stderr, "bottom left\n");
                        } else */if(mgl::FloatRect(webcam_box_drawn_pos + webcam_box_drawn_size - bounding_box_size*0.5f - screen_border_size*0.5f, bounding_box_size).contains(mouse_button_pos)) {
                            webcam_resize_corner = WebcamBoxResizeCorner::BOTTOM_RIGHT;
                        } else {
                            webcam_resize_corner = WebcamBoxResizeCorner::NONE;
                        }
                    }
                    break;
                }
                case mgl::Event::MouseButtonReleased: {
                    if(event.mouse_button.button == mgl::Mouse::Left && webcam_resize_corner == WebcamBoxResizeCorner::NONE) {
                        moving_webcam_box = false;
                    } else if(event.mouse_button.button == mgl::Mouse::Right && !moving_webcam_box) {
                        webcam_resize_corner = WebcamBoxResizeCorner::NONE;
                    }
                    break;
                }
                default: {
                    break;
                }
            }
            return true;
        };

        return camera_location_widget;
    }

    std::unique_ptr<CheckBox> SettingsPage::create_flip_camera_checkbox() {
        auto flip_camera_horizontally_checkbox = std::make_unique<CheckBox>(get_theme().body_font_desc.c_str(), TR("Flip camera horizontally"));
        flip_camera_horizontally_checkbox_ptr = flip_camera_horizontally_checkbox.get();
        return flip_camera_horizontally_checkbox;
    }

    std::unique_ptr<List> SettingsPage::create_webcam_body() {
        auto body_list = std::make_unique<List>(List::Orientation::VERTICAL);
        webcam_body_list_ptr = body_list.get();
        body_list->set_visible(false);
        body_list->add_widget(create_webcam_location_widget());
        body_list->add_widget(std::make_unique<Label>(get_theme().body_font_desc.c_str(), TR("* Right click in the bottom right corner to resize the webcam"), get_color_theme().text_color));
        body_list->add_widget(create_flip_camera_checkbox());
        body_list->add_widget(create_webcam_video_setup_list());
        return body_list;
    }

    std::unique_ptr<Widget> SettingsPage::create_webcam_section() {
        auto ll = std::make_unique<List>(List::Orientation::VERTICAL);
        ll->add_widget(create_webcam_sources());
        ll->add_widget(create_webcam_body());
        return std::make_unique<Subsection>(TR("Webcam"), std::move(ll), mgl::vec2f(settings_scrollable_page_ptr->get_inner_size().x, 0.0f));
    }

    static bool audio_device_is_output(const std::string &audio_device_id) {
        return audio_device_id == "default_output" || ends_with(audio_device_id, ".monitor");
    }

    std::unique_ptr<ComboBox> SettingsPage::create_audio_device_selection_combobox(AudioDeviceType device_type) {
        auto audio_device_box = std::make_unique<ComboBox>(get_theme().body_font_desc.c_str());
        for(const auto &audio_device : audio_devices) {
            const bool device_is_output = audio_device_is_output(audio_device.name);
            if((device_type == AudioDeviceType::OUTPUT && device_is_output) || (device_type == AudioDeviceType::INPUT && !device_is_output)) {
                std::string description = audio_device.description;
                if(starts_with(description, "Monitor of "))
                    description.erase(0, 11);
                audio_device_box->add_item(description, audio_device.name);
            }
        }
        return audio_device_box;
    }

    static void set_application_audio_options_visible(Subsection *audio_track_subsection, bool visible, const GsrInfo &gsr_info) {
        if(!gsr_info.system_info.supports_app_audio)
            visible = false;

        List *audio_track_items_list = dynamic_cast<List*>(audio_track_subsection->get_inner_widget());

        List *buttons_list = dynamic_cast<List*>(audio_track_items_list->get_child_widget_by_index(1));
        Button *add_application_audio_button = dynamic_cast<Button*>(buttons_list->get_child_widget_by_index(2));
        add_application_audio_button->set_visible(visible);

        CheckBox *invert_app_audio_checkbox = dynamic_cast<CheckBox*>(audio_track_items_list->get_child_widget_by_index(3));
        invert_app_audio_checkbox->set_visible(visible);
    }

    static void set_application_audio_options_visible(List *audio_track_section_list_ptr, bool visible, const GsrInfo &gsr_info) {
        audio_track_section_list_ptr->for_each_child_widget([visible, &gsr_info](std::unique_ptr<Widget> &widget) {
            Subsection *audio_track_subsection = dynamic_cast<Subsection*>(widget.get());
            set_application_audio_options_visible(audio_track_subsection, visible, gsr_info);
            return true;
        });
    }

    std::unique_ptr<Button> SettingsPage::create_remove_audio_device_button(List *audio_input_list_ptr, List *audio_device_list_ptr) {
        auto remove_audio_track_button = std::make_unique<Button>(get_theme().body_font_desc.c_str(), "", mgl::vec2f(0.0f, 0.0f), mgl::Color(0, 0, 0, 0));
        remove_audio_track_button->set_icon(&get_theme().trash_texture);
        remove_audio_track_button->set_icon_padding_scale(0.75f);
        remove_audio_track_button->on_click = [this, audio_input_list_ptr, audio_device_list_ptr]() {
            audio_input_list_ptr->remove_widget(audio_device_list_ptr);
            update_application_audio_warning_visibility();
        };
        return remove_audio_track_button;
    }

    std::unique_ptr<List> SettingsPage::create_audio_device(AudioDeviceType device_type, List *audio_input_list_ptr) {
        auto audio_device_list = std::make_unique<List>(List::Orientation::HORIZONTAL, List::Alignment::CENTER);
        audio_device_list->userdata = (void*)(uintptr_t)AudioTrackType::DEVICE;
        audio_device_list->add_widget(std::make_unique<Label>(get_theme().body_font_desc.c_str(), device_type == AudioDeviceType::OUTPUT ? TR("Output device:") : TR("Input device:   "), get_color_theme().text_color));
        audio_device_list->add_widget(create_audio_device_selection_combobox(device_type));
        audio_device_list->add_widget(create_remove_audio_device_button(audio_input_list_ptr, audio_device_list.get()));
        return audio_device_list;
    }

    std::unique_ptr<Button> SettingsPage::create_add_audio_track_button() {
        auto button = std::make_unique<Button>(get_theme().body_font_desc.c_str(), TR("Add audio track"), mgl::vec2f(0.0f, 0.0f), mgl::Color(0, 0, 0, 120));
        button->on_click = [this]() {
            audio_track_section_list_ptr->add_widget(create_audio_track_section(audio_section_ptr));
        };
        button->set_visible(type != Type::STREAM);
        return button;
    }

    void SettingsPage::update_application_audio_warning_visibility() {
        audio_track_section_list_ptr->for_each_child_widget([](std::unique_ptr<Widget> &child_widget) {
            Subsection *audio_subsection = dynamic_cast<Subsection*>(child_widget.get());
            List *audio_track_section_items_list_ptr = dynamic_cast<List*>(audio_subsection->get_inner_widget());
            List *audio_input_list_ptr = dynamic_cast<List*>(audio_track_section_items_list_ptr->get_child_widget_by_index(2));
            CheckBox *application_audio_invert_checkbox_ptr = dynamic_cast<CheckBox*>(audio_track_section_items_list_ptr->get_child_widget_by_index(3));
            List *application_audio_warning_list_ptr = dynamic_cast<List*>(audio_track_section_items_list_ptr->get_child_widget_by_index(4));

            int num_output_devices = 0;
            int num_application_audio = 0;

            audio_input_list_ptr->for_each_child_widget([&num_output_devices, &num_application_audio](std::unique_ptr<Widget> &child_widget){
                List *audio_track_line = dynamic_cast<List*>(child_widget.get());
                const AudioTrackType audio_track_type = (AudioTrackType)(uintptr_t)audio_track_line->userdata;
                switch(audio_track_type) {
                    case AudioTrackType::DEVICE: {
                        Label *label = dynamic_cast<Label*>(audio_track_line->get_child_widget_by_index(0));
                        const bool is_output_device = starts_with(label->get_text(), TR("Output device"));
                        if(is_output_device)
                            num_output_devices++;
                        break;
                    }
                    case AudioTrackType::APPLICATION:
                    case AudioTrackType::APPLICATION_CUSTOM: {
                        num_application_audio++;
                        break;
                    }
                }
                return true;
            });

            application_audio_warning_list_ptr->set_visible(num_output_devices > 0 && (num_application_audio > 0 || application_audio_invert_checkbox_ptr->is_checked()));
            return true;
        });
    }

    std::unique_ptr<Button> SettingsPage::create_add_audio_output_device_button(List *audio_input_list_ptr) {
        auto button = std::make_unique<Button>(get_theme().body_font_desc.c_str(), TR("Add output device"), mgl::vec2f(0.0f, 0.0f), mgl::Color(0, 0, 0, 120));
        button->on_click = [this, audio_input_list_ptr]() {
            audio_devices = get_audio_devices();
            audio_input_list_ptr->add_widget(create_audio_device(AudioDeviceType::OUTPUT, audio_input_list_ptr));
            update_application_audio_warning_visibility();
        };
        return button;
    }

    std::unique_ptr<Button> SettingsPage::create_add_audio_input_device_button(List *audio_input_list_ptr) {
        auto button = std::make_unique<Button>(get_theme().body_font_desc.c_str(), TR("Add input device"), mgl::vec2f(0.0f, 0.0f), mgl::Color(0, 0, 0, 120));
        button->on_click = [this, audio_input_list_ptr]() {
            audio_devices = get_audio_devices();
            audio_input_list_ptr->add_widget(create_audio_device(AudioDeviceType::INPUT, audio_input_list_ptr));
        };
        return button;
    }

    std::unique_ptr<ComboBox> SettingsPage::create_application_audio_selection_combobox(List *application_audio_row) {
        auto audio_device_box = std::make_unique<ComboBox>(get_theme().body_font_desc.c_str());
        ComboBox *audio_device_box_ptr = audio_device_box.get();
        for(const auto &app_audio : application_audio) {
            audio_device_box->add_item(app_audio, app_audio);
        }
        audio_device_box->add_item(TR("Custom..."), custom_app_audio_tag);

        audio_device_box->on_selection_changed = [application_audio_row, audio_device_box_ptr](std::string_view, std::string_view id) {
            if(id == custom_app_audio_tag) {
                application_audio_row->userdata = (void*)(uintptr_t)AudioTrackType::APPLICATION_CUSTOM;
                auto custom_app_audio_entry = std::make_unique<Entry>(get_theme().body_font_desc.c_str(), "", (int)(2.0f*mgl::Text::get_font_size_from_font_description(get_theme().body_font_desc.c_str()) * 10.0f));
                application_audio_row->replace_widget(audio_device_box_ptr, std::move(custom_app_audio_entry));
            }
        };

        return audio_device_box;
    }

    std::unique_ptr<List> SettingsPage::create_application_audio(List *audio_input_list_ptr) {
        auto application_audio_list = std::make_unique<List>(List::Orientation::HORIZONTAL, List::Alignment::CENTER);
        application_audio_list->userdata = (void*)(uintptr_t)AudioTrackType::APPLICATION;
        application_audio_list->add_widget(std::make_unique<Label>(get_theme().body_font_desc.c_str(), TR("Application:     "), get_color_theme().text_color));
        application_audio_list->add_widget(create_application_audio_selection_combobox(application_audio_list.get()));
        application_audio_list->add_widget(create_remove_audio_device_button(audio_input_list_ptr, application_audio_list.get()));
        return application_audio_list;
    }

    std::unique_ptr<List> SettingsPage::create_custom_application_audio(List *audio_input_list_ptr) {
        auto application_audio_list = std::make_unique<List>(List::Orientation::HORIZONTAL, List::Alignment::CENTER);
        application_audio_list->userdata = (void*)(uintptr_t)AudioTrackType::APPLICATION_CUSTOM;
        application_audio_list->add_widget(std::make_unique<Label>(get_theme().body_font_desc.c_str(), TR("Application:     "), get_color_theme().text_color));
        application_audio_list->add_widget(std::make_unique<Entry>(get_theme().body_font_desc.c_str(), "", (int)(2.0f*mgl::Text::get_font_size_from_font_description(get_theme().body_font_desc.c_str()) * 10.0f)));
        application_audio_list->add_widget(create_remove_audio_device_button(audio_input_list_ptr, application_audio_list.get()));
        return application_audio_list;
    }

    std::unique_ptr<Button> SettingsPage::create_add_application_audio_button(List *audio_input_list_ptr) {
        auto add_audio_track_button = std::make_unique<Button>(get_theme().body_font_desc.c_str(), TR("Add application audio"), mgl::vec2f(0.0f, 0.0f), mgl::Color(0, 0, 0, 120));
        add_audio_track_button->on_click = [this, audio_input_list_ptr]() {
            application_audio = get_application_audio();
            if(application_audio.empty())
                audio_input_list_ptr->add_widget(create_custom_application_audio(audio_input_list_ptr));
            else
                audio_input_list_ptr->add_widget(create_application_audio(audio_input_list_ptr));

            update_application_audio_warning_visibility();
        };
        return add_audio_track_button;
    }

    std::unique_ptr<List> SettingsPage::create_add_audio_buttons(List *audio_input_list_ptr) {
        auto list = std::make_unique<List>(List::Orientation::HORIZONTAL, List::Alignment::CENTER);
        list->add_widget(create_add_audio_output_device_button(audio_input_list_ptr));
        list->add_widget(create_add_audio_input_device_button(audio_input_list_ptr));
        list->add_widget(create_add_application_audio_button(audio_input_list_ptr));
        return list;
    }

    std::unique_ptr<List> SettingsPage::create_audio_input_section() {
        auto list = std::make_unique<List>(List::Orientation::VERTICAL);
        //list->add_widget(create_audio_device(list.get())); // Add default_output by default
        return list;
    }

    std::unique_ptr<CheckBox> SettingsPage::create_application_audio_invert_checkbox() {
        auto application_audio_invert_checkbox = std::make_unique<CheckBox>(get_theme().body_font_desc.c_str(), TR("Record audio from all applications except the selected ones"));
        application_audio_invert_checkbox->set_checked(false);
        application_audio_invert_checkbox->on_changed = [this](bool) {
            update_application_audio_warning_visibility();
        };
        return application_audio_invert_checkbox;
    }

    std::unique_ptr<Widget> SettingsPage::create_application_audio_warning() {
        auto list = std::make_unique<List>(List::Orientation::HORIZONTAL);
        list->set_spacing(0.003f);
        list->set_visible(false);

        const int font_character_size = 2.0f*mgl::Text::get_font_size_from_font_description(get_theme().body_font_desc.c_str());
        list->add_widget(std::make_unique<Image>(&get_theme().warning_texture, mgl::vec2f(font_character_size, font_character_size), Image::ScaleBehavior::SCALE));
        list->add_widget(std::make_unique<Label>(get_theme().body_font_desc.c_str(), TR("Recording output devices and application audio may record all output audio, which is likely\nnot what you want to do. Remove the output devices."), get_color_theme().text_color));

        return list;
    }

    static void update_audio_track_titles(List *audio_track_section_list_ptr) {
        int index = 0;
        audio_track_section_list_ptr->for_each_child_widget([&index](std::unique_ptr<Widget> &widget) {
            char audio_track_name[32];
            snprintf(audio_track_name, sizeof(audio_track_name), TR("Audio track #%d"), 1 + index);
            ++index;

            Subsection *subsection = dynamic_cast<Subsection*>(widget.get());
            List *subesection_items = dynamic_cast<List*>(subsection->get_inner_widget());
            Label *audio_track_title = dynamic_cast<Label*>(dynamic_cast<List*>(subesection_items->get_child_widget_by_index(0))->get_child_widget_by_index(0));
            audio_track_title->set_text(audio_track_name);
            return true;
        });
    }

    std::unique_ptr<List> SettingsPage::create_audio_track_title_and_remove(Subsection *audio_track_subsection, const char *title) {
        auto list = std::make_unique<List>(List::Orientation::HORIZONTAL, List::Alignment::CENTER);
        list->add_widget(std::make_unique<Label>(get_theme().title_font_desc.c_str(), title, get_color_theme().text_color));

        auto remove_track_button = std::make_unique<Button>(get_theme().body_font_desc.c_str(), "", mgl::vec2f(0.0f, 0.0f), mgl::Color(0, 0, 0, 0));
        remove_track_button->set_icon(&get_theme().trash_texture);
        remove_track_button->set_icon_padding_scale(0.75f);
        remove_track_button->on_click = [this, audio_track_subsection]() {
            audio_track_section_list_ptr->remove_widget(audio_track_subsection);
            update_audio_track_titles(audio_track_section_list_ptr);
        };
        list->add_widget(std::move(remove_track_button));
        list->set_visible(type != Type::STREAM);
        return list;
    }

    std::unique_ptr<Subsection> SettingsPage::create_audio_track_section(Widget *parent_widget) {
        char audio_track_name[32];
        snprintf(audio_track_name, sizeof(audio_track_name), TR("Audio track #%d"), 1 + (int)audio_track_section_list_ptr->get_num_children());

        auto audio_input_section = create_audio_input_section();
        List *audio_input_section_ptr = audio_input_section.get();

        auto list = std::make_unique<List>(List::Orientation::VERTICAL);
        List *list_ptr = list.get();
        auto subsection = std::make_unique<Subsection>("", std::move(std::move(list)), mgl::vec2f(parent_widget->get_inner_size().x, 0.0f));
        subsection->set_bg_color(mgl::Color(35, 40, 44));

        list_ptr->add_widget(create_audio_track_title_and_remove(subsection.get(), audio_track_name));
        list_ptr->add_widget(create_add_audio_buttons(audio_input_section_ptr));
        list_ptr->add_widget(std::move(audio_input_section));
        list_ptr->add_widget(create_application_audio_invert_checkbox());
        list_ptr->add_widget(create_application_audio_warning());

        set_application_audio_options_visible(subsection.get(), view_radio_button_ptr->get_selected_id() == "advanced", *gsr_info);
        return subsection;
    }

    std::unique_ptr<List> SettingsPage::create_audio_track_section_list() {
        auto list = std::make_unique<List>(List::Orientation::VERTICAL);
        audio_track_section_list_ptr = list.get();
        return list;
    }

    std::unique_ptr<Widget> SettingsPage::create_audio_section() {
        auto audio_device_section_list = std::make_unique<List>(List::Orientation::VERTICAL);
        List *audio_device_section_list_ptr = audio_device_section_list.get();

        auto subsection = std::make_unique<Subsection>(TR("Audio"), std::move(audio_device_section_list), mgl::vec2f(settings_scrollable_page_ptr->get_inner_size().x, 0.0f));
        audio_section_ptr = subsection.get();
        audio_device_section_list_ptr->add_widget(create_add_audio_track_button());
        audio_device_section_list_ptr->add_widget(create_audio_track_section_list());
        audio_device_section_list_ptr->add_widget(create_audio_codec());
        return subsection;
    }

    std::unique_ptr<List> SettingsPage::create_video_quality_box() {
        auto list = std::make_unique<List>(List::Orientation::VERTICAL);
        list->add_widget(std::make_unique<Label>(get_theme().body_font_desc.c_str(), TR("Video quality:"), get_color_theme().text_color));

        auto video_quality_box = std::make_unique<ComboBox>(get_theme().body_font_desc.c_str());
        if(type == Type::REPLAY || type == Type::STREAM)
            video_quality_box->add_item(TR("Constant bitrate (Recommended)"), "custom");
        else
            video_quality_box->add_item(TR("Constant bitrate"), "custom");
        video_quality_box->add_item(TR("Medium"), "medium");
        video_quality_box->add_item(TR("High"), "high");
        if(type == Type::REPLAY || type == Type::STREAM)
            video_quality_box->add_item(TR("Very high"), "very_high");
        else
            video_quality_box->add_item(TR("Very high (Recommended)"), "very_high");
        video_quality_box->add_item(TR("Ultra"), "ultra");

        if(type == Type::REPLAY || type == Type::STREAM)
            video_quality_box->set_selected_item("custom");
        else
            video_quality_box->set_selected_item("very_high");

        video_quality_box_ptr = video_quality_box.get();
        list->add_widget(std::move(video_quality_box));

        return list;
    }

    std::unique_ptr<List> SettingsPage::create_video_bitrate_entry() {
        auto list = std::make_unique<List>(List::Orientation::HORIZONTAL, List::Alignment::CENTER);
        auto video_bitrate_entry = std::make_unique<Entry>(get_theme().body_font_desc.c_str(), "8000", (int)(2.0f*mgl::Text::get_font_size_from_font_description(get_theme().body_font_desc.c_str()) * 5));
        video_bitrate_entry->set_number_mode(true, 1, 500000);
        video_bitrate_entry_ptr = video_bitrate_entry.get();
        list->add_widget(std::move(video_bitrate_entry));

        if(type == Type::STREAM) {
            auto size_mb_label = std::make_unique<Label>(get_theme().body_font_desc.c_str(), "", get_color_theme().text_color);
            Label *size_mb_label_ptr = size_mb_label.get();
            list->add_widget(std::move(size_mb_label));

            video_bitrate_entry_ptr->on_changed = [size_mb_label_ptr](std::string_view text) {
                const double video_bitrate_mbits_per_seconds = (double)sv_to_int<int64_t>(text) / 1024.0;
                char buffer[32];
                snprintf(buffer, sizeof(buffer), "%.2fMbps", video_bitrate_mbits_per_seconds);
                size_mb_label_ptr->set_text(buffer);
            };
        }

        return list;
    }

    std::unique_ptr<List> SettingsPage::create_video_bitrate() {
        auto video_bitrate_list = std::make_unique<List>(List::Orientation::VERTICAL);
        video_bitrate_list->add_widget(std::make_unique<Label>(get_theme().body_font_desc.c_str(), TR("Video bitrate (Kbps):"), get_color_theme().text_color));
        video_bitrate_list->add_widget(create_video_bitrate_entry());
        video_bitrate_list_ptr = video_bitrate_list.get();
        return video_bitrate_list;
    }

    std::unique_ptr<ComboBox> SettingsPage::create_color_range_box() {
        auto color_range_box = std::make_unique<ComboBox>(get_theme().body_font_desc.c_str());
        color_range_box->add_item(TR("Limited"), "limited");
        color_range_box->add_item(TR("Full"), "full");
        color_range_box_ptr = color_range_box.get();
        return color_range_box;
    }

    std::unique_ptr<List> SettingsPage::create_color_range() {
        auto color_range_list = std::make_unique<List>(List::Orientation::VERTICAL);
        color_range_list->add_widget(std::make_unique<Label>(get_theme().body_font_desc.c_str(), TR("Color range:"), get_color_theme().text_color));
        color_range_list->add_widget(create_color_range_box());
        color_range_list_ptr = color_range_list.get();
        return color_range_list;
    }

    std::unique_ptr<List> SettingsPage::create_video_quality_section() {
        auto quality_list = std::make_unique<List>(List::Orientation::HORIZONTAL);
        quality_list->add_widget(create_video_quality_box());
        quality_list->add_widget(create_video_bitrate());
        quality_list->add_widget(create_color_range());
        return quality_list;
    }

    std::unique_ptr<ComboBox> SettingsPage::create_video_codec_box() {
        auto video_codec_box = std::make_unique<ComboBox>(get_theme().body_font_desc.c_str());
        // TODO: Show options not supported but disable them.
        // TODO: Show error if no encoders are supported.
        // TODO: Show warning (once) if only software encoder is available.
        video_codec_box->add_item(TR("Auto (Recommended)"), "auto");
        if(gsr_info->supported_video_codecs.h264)
            video_codec_box->add_item(TR("H264"), "h264");
        if(gsr_info->supported_video_codecs.hevc)
            video_codec_box->add_item(TR("HEVC"), "hevc");
        if(gsr_info->supported_video_codecs.hevc_10bit)
            video_codec_box->add_item(TR("HEVC (10 bit, reduces banding)"), "hevc_10bit");
        if(gsr_info->supported_video_codecs.hevc_hdr)
            video_codec_box->add_item(TR("HEVC (HDR)"), "hevc_hdr");
        if(gsr_info->supported_video_codecs.av1)
            video_codec_box->add_item(TR("AV1"), "av1");
        if(gsr_info->supported_video_codecs.av1_10bit)
            video_codec_box->add_item(TR("AV1 (10 bit, reduces banding)"), "av1_10bit");
        if(gsr_info->supported_video_codecs.av1_hdr)
            video_codec_box->add_item(TR("AV1 (HDR)"), "av1_hdr");
        if(gsr_info->supported_video_codecs.vp8)
            video_codec_box->add_item(TR("VP8"), "vp8");
        if(gsr_info->supported_video_codecs.vp9)
            video_codec_box->add_item(TR("VP9"), "vp9");
        if(gsr_info->supported_video_codecs.h264_software)
            video_codec_box->add_item(TR("H264 Software Encoder (Slow, not recommended)"), "h264_software");
        video_codec_box_ptr = video_codec_box.get();
        return video_codec_box;
    }

    std::unique_ptr<List> SettingsPage::create_video_codec() {
        auto video_codec_list = std::make_unique<List>(List::Orientation::VERTICAL);
        video_codec_list->add_widget(std::make_unique<Label>(get_theme().body_font_desc.c_str(), TR("Video codec:"), get_color_theme().text_color));
        video_codec_list->add_widget(create_video_codec_box());
        video_codec_ptr = video_codec_list.get();
        return video_codec_list;
    }

    std::unique_ptr<ComboBox> SettingsPage::create_audio_codec_box() {
        auto audio_codec_box = std::make_unique<ComboBox>(get_theme().body_font_desc.c_str());
        audio_codec_box->add_item(TR("Opus (Recommended)"), "opus");
        audio_codec_box->add_item(TR("AAC"), "aac");
        audio_codec_box_ptr = audio_codec_box.get();
        return audio_codec_box;
    }

    std::unique_ptr<List> SettingsPage::create_audio_codec() {
        auto audio_codec_list = std::make_unique<List>(List::Orientation::VERTICAL);
        audio_codec_list->add_widget(std::make_unique<Label>(get_theme().body_font_desc.c_str(), TR("Audio codec:"), get_color_theme().text_color));
        audio_codec_list->add_widget(create_audio_codec_box());
        audio_codec_ptr = audio_codec_list.get();
        return audio_codec_list;
    }

    std::unique_ptr<Entry> SettingsPage::create_framerate_entry() {
        auto framerate_entry = std::make_unique<Entry>(get_theme().body_font_desc.c_str(), "60", (int)(2.0f*mgl::Text::get_font_size_from_font_description(get_theme().body_font_desc.c_str()) * 3));
        framerate_entry->set_number_mode(true, 1, 500);
        framerate_entry_ptr = framerate_entry.get();
        return framerate_entry;
    }

    std::unique_ptr<List> SettingsPage::create_framerate() {
        auto framerate_list = std::make_unique<List>(List::Orientation::VERTICAL);
        framerate_list->add_widget(std::make_unique<Label>(get_theme().body_font_desc.c_str(), TR("Frame rate:"), get_color_theme().text_color));
        framerate_list->add_widget(create_framerate_entry());
        return framerate_list;
    }

    std::unique_ptr<ComboBox> SettingsPage::create_framerate_mode_box() {
        auto framerate_mode_box = std::make_unique<ComboBox>(get_theme().body_font_desc.c_str());
        framerate_mode_box->add_item(TR("Auto (Recommended)"), "auto");
        framerate_mode_box->add_item(TR("Constant"), "cfr");
        framerate_mode_box->add_item(TR("Variable"), "vfr");
        if(gsr_info->system_info.display_server == DisplayServer::X11)
            framerate_mode_box->add_item(TR("Sync to content"), "content");
        else
            framerate_mode_box->add_item(TR("Sync to content (Only X11 or desktop portal capture)"), "content");
        framerate_mode_box_ptr = framerate_mode_box.get();
        return framerate_mode_box;
    }

    std::unique_ptr<List> SettingsPage::create_framerate_mode() {
        auto framerate_mode_list = std::make_unique<List>(List::Orientation::VERTICAL);
        framerate_mode_list->add_widget(std::make_unique<Label>(get_theme().body_font_desc.c_str(), TR("Frame rate mode:"), get_color_theme().text_color));
        framerate_mode_list->add_widget(create_framerate_mode_box());
        framerate_mode_list_ptr = framerate_mode_list.get();
        return framerate_mode_list;
    }

    std::unique_ptr<List> SettingsPage::create_framerate_section() {
        auto framerate_info_list = std::make_unique<List>(List::Orientation::HORIZONTAL);
        framerate_info_list->add_widget(create_framerate());
        framerate_info_list->add_widget(create_framerate_mode());
        return framerate_info_list;
    }
    
    std::unique_ptr<Widget> SettingsPage::create_record_cursor_section() {
        auto record_cursor_checkbox = std::make_unique<CheckBox>(get_theme().body_font_desc.c_str(), TR("Record cursor"));
        record_cursor_checkbox->set_checked(true);
        record_cursor_checkbox_ptr = record_cursor_checkbox.get();
        return record_cursor_checkbox;
    }

    std::unique_ptr<Widget> SettingsPage::create_video_section() {
        auto video_section_list = std::make_unique<List>(List::Orientation::VERTICAL);
        video_section_list->add_widget(create_video_quality_section());
        video_section_list->add_widget(create_video_codec());
        video_section_list->add_widget(create_framerate_section());
        video_section_list->add_widget(create_record_cursor_section());
        return std::make_unique<Subsection>(TR("Video"), std::move(video_section_list), mgl::vec2f(settings_scrollable_page_ptr->get_inner_size().x, 0.0f));
    }

    std::unique_ptr<Widget> SettingsPage::create_settings() {
        auto page_list = std::make_unique<List>(List::Orientation::VERTICAL);
        page_list->set_spacing(0.018f);
        page_list->add_widget(create_view_radio_button());
        auto scrollable_page = std::make_unique<ScrollablePage>(content_page_ptr->get_inner_size() - mgl::vec2f(0.0f, page_list->get_size().y + 0.018f * get_theme().window_height));
        settings_scrollable_page_ptr = scrollable_page.get();
        page_list->add_widget(std::move(scrollable_page));

        auto settings_list = std::make_unique<List>(List::Orientation::VERTICAL);
        settings_list->set_spacing(0.018f);
        settings_list->add_widget(create_capture_target_section());
        settings_list->add_widget(create_webcam_section());
        settings_list->add_widget(create_audio_section());
        settings_list->add_widget(create_video_section());
        settings_list_ptr = settings_list.get();
        settings_scrollable_page_ptr->add_widget(std::move(settings_list));
        return page_list;
    }

    void SettingsPage::add_widgets() {
        content_page_ptr->add_widget(create_settings());

        record_area_box_ptr->on_selection_changed = [this](std::string_view, std::string_view id) {
            const bool focused_selected = id == "focused";
            const bool portal_selected = id == "portal";
            area_size_list_ptr->set_visible(focused_selected);
            video_resolution_list_ptr->set_visible(!focused_selected && change_video_resolution_checkbox_ptr->is_checked());
            change_video_resolution_checkbox_ptr->set_visible(!focused_selected);
            restore_portal_session_list_ptr->set_visible(portal_selected);
            return true;
        };

        change_video_resolution_checkbox_ptr->on_changed = [this](bool checked) {
            const bool focused_selected = record_area_box_ptr->get_selected_id() == "focused";
            video_resolution_list_ptr->set_visible(!focused_selected && checked);
        };

        video_quality_box_ptr->on_selection_changed = [this](std::string_view, std::string_view id) {
            const bool custom_selected = id == "custom";
            video_bitrate_list_ptr->set_visible(custom_selected);

            if(estimated_file_size_ptr)
                estimated_file_size_ptr->set_visible(custom_selected);

            return true;
        };
        video_quality_box_ptr->on_selection_changed("", video_quality_box_ptr->get_selected_id());

        if(!capture_options.monitors.empty())
            record_area_box_ptr->set_selected_item("focused_monitor");
        else if(capture_options.portal)
            record_area_box_ptr->set_selected_item("portal");
        else if(capture_options.window)
            record_area_box_ptr->set_selected_item("window");
        else
            record_area_box_ptr->on_selection_changed("", "");
    }

    void SettingsPage::add_page_specific_widgets() {
        switch(type) {
            case Type::REPLAY:
                add_replay_widgets();
                break;
            case Type::RECORD:
                add_record_widgets();
                break;
            case Type::STREAM:
                add_stream_widgets();
                break;
        }
    }

    std::unique_ptr<List> SettingsPage::create_save_directory(const char *label) {
        auto save_directory_list = std::make_unique<List>(List::Orientation::VERTICAL);
        save_directory_list->add_widget(std::make_unique<Label>(get_theme().body_font_desc.c_str(), label, get_color_theme().text_color));
        auto save_directory_button = std::make_unique<Button>(get_theme().body_font_desc.c_str(), get_videos_dir().c_str(), mgl::vec2f(0.0f, 0.0f), mgl::Color(0, 0, 0, 120));
        save_directory_button_ptr = save_directory_button.get();
        save_directory_button->on_click = [this]() {
            auto select_directory_page = std::make_unique<GsrPage>(TR("File"), TR("Settings"));
            select_directory_page->add_button(TR("Save"), "save", get_color_theme().tint_color);
            select_directory_page->add_button(TR("Cancel"), "cancel", get_color_theme().page_bg_color);

            auto file_chooser = std::make_unique<FileChooser>(save_directory_button_ptr->get_text(), select_directory_page->get_inner_size());
            FileChooser *file_chooser_ptr = file_chooser.get();
            select_directory_page->add_widget(std::move(file_chooser));

            select_directory_page->on_click = [this, file_chooser_ptr](const std::string &id) {
                if(id == "save") {
                    save_directory_button_ptr->set_text(file_chooser_ptr->get_current_directory());
                    page_stack->pop();
                } else if(id == "cancel") {
                    page_stack->pop();
                }
            };

            page_stack->push(std::move(select_directory_page));
        };
        save_directory_list->add_widget(std::move(save_directory_button));
        return save_directory_list;
    }

    std::unique_ptr<ComboBox> SettingsPage::create_container_box() {
        auto container_box = std::make_unique<ComboBox>(get_theme().body_font_desc.c_str());
        container_box->add_item("mp4", "mp4");
        container_box->add_item("mkv", "matroska");
        container_box->add_item("flv", "flv");
        container_box->add_item("mov", "mov");
        container_box_ptr = container_box.get();
        return container_box;
    }

    std::unique_ptr<List> SettingsPage::create_container_section() {
        auto container_list = std::make_unique<List>(List::Orientation::VERTICAL);
        container_list->add_widget(std::make_unique<Label>(get_theme().body_font_desc.c_str(), TR("Container:"), get_color_theme().text_color));
        container_list->add_widget(create_container_box());
        return container_list;
    }

    std::unique_ptr<List> SettingsPage::create_replay_time_entry() {
        auto list = std::make_unique<List>(List::Orientation::HORIZONTAL, List::Alignment::CENTER);

        auto replay_time_entry = std::make_unique<Entry>(get_theme().body_font_desc.c_str(), "60", 2.0f*mgl::Text::get_font_size_from_font_description(get_theme().body_font_desc.c_str()) * 4);
        replay_time_entry->set_number_mode(true, 1, 86400);
        replay_time_entry_ptr = replay_time_entry.get();
        list->add_widget(std::move(replay_time_entry));

        auto replay_time_label = std::make_unique<Label>(get_theme().body_font_desc.c_str(), "00h:00m:00s", get_color_theme().text_color);
        replay_time_label_ptr = replay_time_label.get();
        list->add_widget(std::move(replay_time_label));

        return list;
    }

    std::unique_ptr<List> SettingsPage::create_replay_time() {
        auto replay_time_list = std::make_unique<List>(List::Orientation::VERTICAL);
        replay_time_list->add_widget(std::make_unique<Label>(get_theme().body_font_desc.c_str(), TR("Replay duration in seconds:"), get_color_theme().text_color));
        replay_time_list->add_widget(create_replay_time_entry());
        return replay_time_list;
    }

    std::unique_ptr<List> SettingsPage::create_replay_storage() {
        auto list = std::make_unique<List>(List::Orientation::VERTICAL);
        list->add_widget(std::make_unique<Label>(get_theme().body_font_desc.c_str(), TR("Where should temporary replay data be stored?"), get_color_theme().text_color));
        auto replay_storage_button = std::make_unique<RadioButton>(get_theme().body_font_desc.c_str(), RadioButton::Orientation::HORIZONTAL);
        replay_storage_button_ptr = replay_storage_button.get();
        replay_storage_button->add_item(TR("RAM"), "ram");
        replay_storage_button->add_item(TR("Disk (Not recommended on SSDs)"), "disk");

        replay_storage_button->on_selection_changed = [this](std::string_view, std::string_view id) {
            update_estimated_replay_file_size(id);
            return true;
        };

        list->add_widget(std::move(replay_storage_button));
        list->set_visible(gsr_info->system_info.gsr_version >= GsrVersion{5, 5, 0});
        return list;
    }

    std::unique_ptr<RadioButton> SettingsPage::create_start_replay_automatically() {
        auto radiobutton = std::make_unique<RadioButton>(get_theme().body_font_desc.c_str(), RadioButton::Orientation::VERTICAL);
        radiobutton->add_item(TR("Don't turn on replay automatically"), "dont_turn_on_automatically");
        radiobutton->add_item(TR("Turn on replay when this program starts"), "turn_on_at_system_startup");
        radiobutton->add_item(TR("Turn on replay when starting a game"), "turn_on_at_game_launch");
        turn_on_replay_automatically_mode_ptr = radiobutton.get();
        return radiobutton;
    }

    std::unique_ptr<Widget> SettingsPage::create_start_replay_automatically_section() {
        auto list = std::make_unique<List>(List::Orientation::VERTICAL);
        list->add_widget(create_start_replay_automatically());

        auto checkbox = std::make_unique<CheckBox>(get_theme().body_font_desc.c_str(), TR("Only turn on replay if a power supply is connected"));
        replay_power_supply_checkbox_ptr = checkbox.get();
        list->add_widget(std::move(checkbox));

        return list;
    }

    std::unique_ptr<CheckBox> SettingsPage::create_save_replay_in_game_folder() {
        char text[256];
        snprintf(text, sizeof(text), TR("Save video in a folder based on the games name%s"), supports_window_title ? "" : TR(" (X11 applications only)"));
        auto checkbox = std::make_unique<CheckBox>(get_theme().body_font_desc.c_str(), text);
        save_replay_in_game_folder_ptr = checkbox.get();
        return checkbox;
    }

    std::unique_ptr<CheckBox> SettingsPage::create_restart_replay_on_save() {
        auto checkbox = std::make_unique<CheckBox>(get_theme().body_font_desc.c_str(), TR("Restart replay on save"));
        restart_replay_on_save = checkbox.get();
        return checkbox;
    }

    std::unique_ptr<Label> SettingsPage::create_estimated_replay_file_size() {
        auto label = std::make_unique<Label>(get_theme().body_font_desc.c_str(), "Estimated video max file size in RAM: 57.60MB", get_color_theme().text_color);
        estimated_file_size_ptr = label.get();
        return label;
    }

    void SettingsPage::update_estimated_replay_file_size(std::string_view replay_storage_type) {
        const int64_t replay_time_seconds = sv_to_int<int64_t>(replay_time_entry_ptr->get_text());
        const int64_t video_bitrate_bps = sv_to_int<int64_t>(video_bitrate_entry_ptr->get_text()) * 1000LL / 8LL;
        const double video_filesize_mb = ((double)replay_time_seconds * (double)video_bitrate_bps) / 1000.0 / 1000.0 * 1.024;

        char buffer[256];
        snprintf(buffer, sizeof(buffer), TR("Estimated video max file size %s: %.2fMB.\nChange video bitrate or replay duration to change file size."), replay_storage_type == "ram" ? TR("in RAM") : TR("on disk"), video_filesize_mb);
        estimated_file_size_ptr->set_text(buffer);
    }

    void SettingsPage::update_replay_time_text() {
        int seconds = sv_to_int<int>(replay_time_entry_ptr->get_text());

        const int hours = seconds / 60 / 60;
        seconds -= (hours * 60 * 60);

        const int minutes = seconds / 60;
        seconds -= (minutes * 60);

        char buffer[256];
        snprintf(buffer, sizeof(buffer), "%02dh:%02dm:%02ds", hours, minutes, seconds);
        replay_time_label_ptr->set_text(buffer);
    }

    void SettingsPage::view_changed(bool advanced_view) {
        color_range_list_ptr->set_visible(advanced_view);
        audio_codec_ptr->set_visible(advanced_view);
        video_codec_ptr->set_visible(advanced_view);
        framerate_mode_list_ptr->set_visible(advanced_view);
        set_application_audio_options_visible(audio_track_section_list_ptr, advanced_view, *gsr_info);
        settings_scrollable_page_ptr->reset_scroll();
    }

    RecordOptions& SettingsPage::get_current_record_options() {
        switch(type) {
            default:
                assert(false);
            case Type::REPLAY: return config.replay_config.record_options;
            case Type::RECORD: return config.record_config.record_options;
            case Type::STREAM: return config.streaming_config.record_options;
        }
    }

    std::unique_ptr<CheckBox> SettingsPage::create_led_indicator(const char *type) {
        char label_str[256];
        snprintf(label_str, sizeof(label_str), TR("Show %s status with scroll lock LED"), type);

        auto checkbox = std::make_unique<CheckBox>(get_theme().body_font_desc.c_str(), label_str);
        checkbox->set_checked(false);
        led_indicator_checkbox_ptr = checkbox.get();
        return checkbox;
    }

    std::unique_ptr<CheckBox> SettingsPage::create_notifications(const char *type) {
        char label_str[256];
        snprintf(label_str, sizeof(label_str), TR("Show %s notifications"), type);
        auto checkbox = std::make_unique<CheckBox>(get_theme().body_font_desc.c_str(), label_str);
        checkbox->set_checked(true);
        show_notification_checkbox_ptr = checkbox.get();
        return checkbox;
    }

    std::unique_ptr<List> SettingsPage::create_indicator(const char *type) {
        auto list = std::make_unique<List>(List::Orientation::VERTICAL);
        list->add_widget(create_notifications(type));
        list->add_widget(create_led_indicator(type));
        return list;
    }

    std::unique_ptr<Widget> SettingsPage::create_low_power_mode() {
        auto list = std::make_unique<List>(List::Orientation::HORIZONTAL, List::Alignment::CENTER);
        list->set_visible(gsr_info->gpu_info.vendor == GpuVendor::AMD);

        auto checkbox = std::make_unique<CheckBox>(get_theme().body_font_desc.c_str(), TR("Record in low-power mode"));
        low_power_mode_checkbox_ptr = checkbox.get();

        list->add_widget(std::move(checkbox));

        auto info = std::make_unique<Image>(&get_theme().question_mark_texture, low_power_mode_checkbox_ptr->get_size(), Image::ScaleBehavior::SCALE);
        info->set_tooltip_text(
            TR("Do not force the GPU to go into high performance mode when recording.\n"
               "May affect recording performance, especially when playing a video at the same time.\n"
               "If enabled then it's recommended to use sync to content frame rate mode to reduce power usage when idle.")
        );
        Image *info_ptr = info.get();
        info->on_mouse_move = [info_ptr](bool inside) {
            if(inside)
                set_current_tooltip(info_ptr);
            else
                remove_as_current_tooltip(info_ptr);
        };
        list->add_widget(std::move(info));

        return list;
    }

    void SettingsPage::add_replay_widgets() {
        auto file_info_list = std::make_unique<List>(List::Orientation::VERTICAL);
        auto file_info_data_list = std::make_unique<List>(List::Orientation::HORIZONTAL);
        file_info_data_list->add_widget(create_save_directory(TR("Directory to save replays:")));
        file_info_data_list->add_widget(create_container_section());
        file_info_data_list->add_widget(create_replay_time());
        file_info_list->add_widget(std::move(file_info_data_list));
        file_info_list->add_widget(create_estimated_replay_file_size());
        settings_list_ptr->add_widget(std::make_unique<Subsection>(TR("File info"), std::move(file_info_list), mgl::vec2f(settings_scrollable_page_ptr->get_inner_size().x, 0.0f)));

        auto general_list = std::make_unique<List>(List::Orientation::VERTICAL);
        general_list->add_widget(create_replay_storage());
        general_list->add_widget(create_save_replay_in_game_folder());
        if(gsr_info->system_info.gsr_version >= GsrVersion{5, 0, 3})
            general_list->add_widget(create_restart_replay_on_save());
        general_list->add_widget(create_low_power_mode());

        settings_list_ptr->add_widget(std::make_unique<Subsection>(TR("General"), std::move(general_list), mgl::vec2f(settings_scrollable_page_ptr->get_inner_size().x, 0.0f)));
        settings_list_ptr->add_widget(std::make_unique<Subsection>(TR("Replay indicator"), create_indicator(TR("replay")), mgl::vec2f(settings_scrollable_page_ptr->get_inner_size().x, 0.0f)));
        settings_list_ptr->add_widget(std::make_unique<Subsection>(TR("Autostart"), create_start_replay_automatically_section(), mgl::vec2f(settings_scrollable_page_ptr->get_inner_size().x, 0.0f)));

        view_radio_button_ptr->on_selection_changed = [this](std::string_view, std::string_view id) {
            view_changed(id == "advanced");
            return true;
        };
        view_radio_button_ptr->on_selection_changed(TR("Simple"), "simple");

        replay_time_entry_ptr->on_changed = [this](std::string_view) {
            update_estimated_replay_file_size(replay_storage_button_ptr->get_selected_id());
            update_replay_time_text();
        };

        video_bitrate_entry_ptr->on_changed = [this](std::string_view) {
            update_estimated_replay_file_size(replay_storage_button_ptr->get_selected_id());
        };
    }

    std::unique_ptr<CheckBox> SettingsPage::create_save_recording_in_game_folder() {
        char text[256];
        snprintf(text, sizeof(text), TR("Save video in a folder based on the games name%s"), supports_window_title ? "" : TR(" (X11 applications only)"));
        auto checkbox = std::make_unique<CheckBox>(get_theme().body_font_desc.c_str(), text);
        save_recording_in_game_folder_ptr = checkbox.get();
        return checkbox;
    }

    std::unique_ptr<Label> SettingsPage::create_estimated_record_file_size() {
        auto label = std::make_unique<Label>(get_theme().body_font_desc.c_str(), "Estimated video file size per minute (excluding audio): 345.60MB", get_color_theme().text_color);
        estimated_file_size_ptr = label.get();
        return label;
    }

    void SettingsPage::update_estimated_record_file_size() {
        const int64_t video_bitrate_bps = sv_to_int<int64_t>(video_bitrate_entry_ptr->get_text()) * 1000LL / 8LL;
        const double video_filesize_mb_per_minute = (60.0 * (double)video_bitrate_bps) / 1000.0 / 1000.0 * 1.024;

        char buffer[512];
        snprintf(buffer, sizeof(buffer), TR("Estimated video file size per minute (excluding audio): %.2fMB"), video_filesize_mb_per_minute);
        estimated_file_size_ptr->set_text(buffer);
    }

    void SettingsPage::add_record_widgets() {
        auto file_info_list = std::make_unique<List>(List::Orientation::VERTICAL);
        auto file_info_data_list = std::make_unique<List>(List::Orientation::HORIZONTAL);
        file_info_data_list->add_widget(create_save_directory(TR("Directory to save videos:")));
        file_info_data_list->add_widget(create_container_section());
        file_info_list->add_widget(std::move(file_info_data_list));
        file_info_list->add_widget(create_estimated_record_file_size());

        settings_list_ptr->add_widget(std::make_unique<Subsection>(TR("File info"), std::move(file_info_list), mgl::vec2f(settings_scrollable_page_ptr->get_inner_size().x, 0.0f)));

        auto general_list = std::make_unique<List>(List::Orientation::VERTICAL);
        general_list->add_widget(create_save_recording_in_game_folder());
        general_list->add_widget(create_low_power_mode());

        settings_list_ptr->add_widget(std::make_unique<Subsection>(TR("General"), std::move(general_list), mgl::vec2f(settings_scrollable_page_ptr->get_inner_size().x, 0.0f)));
        settings_list_ptr->add_widget(std::make_unique<Subsection>(TR("Recording indicator"), create_indicator(TR("recording")), mgl::vec2f(settings_scrollable_page_ptr->get_inner_size().x, 0.0f)));

        view_radio_button_ptr->on_selection_changed = [this](std::string_view, std::string_view id) {
            view_changed(id == "advanced");
            return true;
        };
        view_radio_button_ptr->on_selection_changed(TR("Simple"), "simple");

        video_bitrate_entry_ptr->on_changed = [this](std::string_view) {
            update_estimated_record_file_size();
        };
    }

    std::unique_ptr<ComboBox> SettingsPage::create_streaming_service_box() {
        auto streaming_service_box = std::make_unique<ComboBox>(get_theme().body_font_desc.c_str());
        streaming_service_box->add_item(TR("Twitch"), "twitch");
        streaming_service_box->add_item(TR("YouTube"), "youtube");
        streaming_service_box->add_item(TR("Rumble"), "rumble");
        streaming_service_box->add_item(TR("Kick"), "kick");
        streaming_service_box->add_item(TR("Custom"), "custom");
        streaming_service_box_ptr = streaming_service_box.get();
        return streaming_service_box;
    }

    std::unique_ptr<List> SettingsPage::create_streaming_service_section() {
        auto streaming_service_list = std::make_unique<List>(List::Orientation::VERTICAL);
        streaming_service_list->add_widget(std::make_unique<Label>(get_theme().body_font_desc.c_str(), TR("Stream service:"), get_color_theme().text_color));
        streaming_service_list->add_widget(create_streaming_service_box());
        return streaming_service_list;
    }

    static std::unique_ptr<Button> create_mask_toggle_button(Entry *entry_to_toggle, mgl::vec2f size) {
        auto button = std::make_unique<Button>(get_theme().body_font_desc.c_str(), "", size, mgl::Color(0, 0, 0, 0));
        Button *button_ptr = button.get();
        button->set_icon(&get_theme().masked_texture);
        button->on_click = [entry_to_toggle, button_ptr]() {
            const bool is_masked = entry_to_toggle->is_masked();
            button_ptr->set_icon(is_masked ? &get_theme().unmasked_texture : &get_theme().masked_texture);
            entry_to_toggle->set_masked(!is_masked);
        };
        return button;
    }

    static Entry* add_stream_key_entry_to_list(List *stream_key_list) {
        auto list = std::make_unique<List>(List::Orientation::HORIZONTAL, List::Alignment::CENTER);
        auto key_entry = std::make_unique<Entry>(get_theme().body_font_desc.c_str(), "", 2.0f*mgl::Text::get_font_size_from_font_description(get_theme().body_font_desc.c_str()) * 20);
        key_entry->set_masked(true);
        Entry *key_entry_ptr = key_entry.get();
        const float mask_icon_size = key_entry_ptr->get_size().y * 0.9f;
        list->add_widget(std::move(key_entry));
        list->add_widget(create_mask_toggle_button(key_entry_ptr, mgl::vec2f(mask_icon_size, mask_icon_size)));
        stream_key_list->add_widget(std::move(list));
        return key_entry_ptr;
    }

    std::unique_ptr<List> SettingsPage::create_stream_key_section() {
        auto stream_key_list = std::make_unique<List>(List::Orientation::VERTICAL);
        stream_key_list->add_widget(std::make_unique<Label>(get_theme().body_font_desc.c_str(), TR("Stream key:"), get_color_theme().text_color));

        twitch_stream_key_entry_ptr = add_stream_key_entry_to_list(stream_key_list.get());
        youtube_stream_key_entry_ptr = add_stream_key_entry_to_list(stream_key_list.get());
        rumble_stream_key_entry_ptr = add_stream_key_entry_to_list(stream_key_list.get());

        stream_key_list_ptr = stream_key_list.get();
        return stream_key_list;
    }

    std::unique_ptr<List> SettingsPage::create_stream_kick_url() {
        auto list = std::make_unique<List>(List::Orientation::VERTICAL);
        auto stream_url_entry = std::make_unique<Entry>(get_theme().body_font_desc.c_str(), "", 2.0f*mgl::Text::get_font_size_from_font_description(get_theme().body_font_desc.c_str()) * 20);
        kick_stream_url_entry_ptr = stream_url_entry.get();
        list->add_widget(std::make_unique<Label>(get_theme().body_font_desc.c_str(), TR("Stream URL:"), get_color_theme().text_color));
        list->add_widget(std::move(stream_url_entry));
        return list;
    }

    std::unique_ptr<List> SettingsPage::create_stream_kick_key() {
        auto list = std::make_unique<List>(List::Orientation::HORIZONTAL, List::Alignment::CENTER);
        auto stream_key_entry = std::make_unique<Entry>(get_theme().body_font_desc.c_str(), "", 2.0f*mgl::Text::get_font_size_from_font_description(get_theme().body_font_desc.c_str()) * 20);
        stream_key_entry->set_masked(true);
        kick_stream_key_entry_ptr = stream_key_entry.get();
        const float mask_icon_size = kick_stream_key_entry_ptr->get_size().y * 1.0f;
        list->add_widget(std::move(stream_key_entry));
        list->add_widget(create_mask_toggle_button(kick_stream_key_entry_ptr, mgl::vec2f(mask_icon_size, mask_icon_size)));
        return list;
    }

    std::unique_ptr<List> SettingsPage::create_stream_kick_section() {
        auto kick_stream_list = std::make_unique<List>(List::Orientation::VERTICAL);

        auto stream_url_list = std::make_unique<List>(List::Orientation::HORIZONTAL);
        stream_url_list->add_widget(create_stream_kick_url());

        kick_stream_list->add_widget(std::move(stream_url_list));
        kick_stream_list->add_widget(std::make_unique<Label>(get_theme().body_font_desc.c_str(), TR("Stream key:"), get_color_theme().text_color));
        kick_stream_list->add_widget(create_stream_kick_key());

        kick_stream_list_ptr = kick_stream_list.get();
        return kick_stream_list;
    }

    std::unique_ptr<List> SettingsPage::create_stream_custom_url() {
        auto list = std::make_unique<List>(List::Orientation::VERTICAL);
        auto stream_url_entry = std::make_unique<Entry>(get_theme().body_font_desc.c_str(), "", 2.0f*mgl::Text::get_font_size_from_font_description(get_theme().body_font_desc.c_str()) * 20);
        stream_url_entry_ptr = stream_url_entry.get();
        list->add_widget(std::make_unique<Label>(get_theme().body_font_desc.c_str(), TR("Stream URL:"), get_color_theme().text_color));
        list->add_widget(std::move(stream_url_entry));
        return list;
    }

    std::unique_ptr<List> SettingsPage::create_stream_custom_key() {
        auto list = std::make_unique<List>(List::Orientation::HORIZONTAL, List::Alignment::CENTER);
        auto stream_key_entry = std::make_unique<Entry>(get_theme().body_font_desc.c_str(), "", 2.0f*mgl::Text::get_font_size_from_font_description(get_theme().body_font_desc.c_str()) * 20);
        stream_key_entry->set_masked(true);
        stream_key_entry_ptr = stream_key_entry.get();
        const float mask_icon_size = stream_key_entry_ptr->get_size().y * 0.9f;
        list->add_widget(std::move(stream_key_entry));
        list->add_widget(create_mask_toggle_button(stream_key_entry_ptr, mgl::vec2f(mask_icon_size, mask_icon_size)));
        return list;
    }

    std::unique_ptr<List> SettingsPage::create_stream_custom_section() {
        auto custom_stream_list = std::make_unique<List>(List::Orientation::VERTICAL);

        auto stream_url_list = std::make_unique<List>(List::Orientation::HORIZONTAL);
        stream_url_list->add_widget(create_stream_custom_url());
        stream_url_list->add_widget(create_stream_container());

        custom_stream_list->add_widget(std::move(stream_url_list));
        custom_stream_list->add_widget(std::make_unique<Label>(get_theme().body_font_desc.c_str(), TR("Stream key:"), get_color_theme().text_color));
        custom_stream_list->add_widget(create_stream_custom_key());

        custom_stream_list_ptr = custom_stream_list.get();
        return custom_stream_list;
    }

    std::unique_ptr<ComboBox> SettingsPage::create_stream_container_box() {
        auto container_box = std::make_unique<ComboBox>(get_theme().body_font_desc.c_str());
        container_box->add_item("mp4", "mp4");
        container_box->add_item("flv", "flv");
        container_box->add_item("ts", "mpegts");
        container_box->add_item("m3u8", "hls");
        container_box_ptr = container_box.get();
        return container_box;
    }
    
    std::unique_ptr<List> SettingsPage::create_stream_container() {
        auto container_list = std::make_unique<List>(List::Orientation::VERTICAL);
        container_list->add_widget(std::make_unique<Label>(get_theme().body_font_desc.c_str(), TR("Container:"), get_color_theme().text_color));
        container_list->add_widget(create_stream_container_box());
        return container_list;
    }

    void SettingsPage::add_stream_widgets() {
        auto streaming_info_list = std::make_unique<List>(List::Orientation::HORIZONTAL);
        streaming_info_list->add_widget(create_streaming_service_section());
        streaming_info_list->add_widget(create_stream_key_section());
        streaming_info_list->add_widget(create_stream_kick_section());
        streaming_info_list->add_widget(create_stream_custom_section());

        settings_list_ptr->add_widget(std::make_unique<Subsection>(TR("Streaming info"), std::move(streaming_info_list), mgl::vec2f(settings_scrollable_page_ptr->get_inner_size().x, 0.0f)));

        auto general_list = std::make_unique<List>(List::Orientation::VERTICAL);
        general_list->add_widget(create_low_power_mode());

        settings_list_ptr->add_widget(std::make_unique<Subsection>(TR("General"), std::move(general_list), mgl::vec2f(settings_scrollable_page_ptr->get_inner_size().x, 0.0f)));
        settings_list_ptr->add_widget(std::make_unique<Subsection>(TR("Streaming indicator"), create_indicator(TR("streaming")), mgl::vec2f(settings_scrollable_page_ptr->get_inner_size().x, 0.0f)));

        streaming_service_box_ptr->on_selection_changed = [this](std::string_view, std::string_view id) {
            const bool twitch_option = id == "twitch";
            const bool youtube_option = id == "youtube";
            const bool rumble_option = id == "rumble";
            const bool kick_option = id == "kick";
            const bool custom_option = id == "custom";
            stream_key_list_ptr->set_visible(!custom_option && !kick_option);
            custom_stream_list_ptr->set_visible(custom_option);
            kick_stream_list_ptr->set_visible(kick_option);
            twitch_stream_key_entry_ptr->get_parent_widget()->set_visible(twitch_option);
            youtube_stream_key_entry_ptr->get_parent_widget()->set_visible(youtube_option);
            rumble_stream_key_entry_ptr->get_parent_widget()->set_visible(rumble_option);
            return true;
        };
        streaming_service_box_ptr->on_selection_changed("Twitch", "twitch");

        view_radio_button_ptr->on_selection_changed = [this](std::string_view, std::string_view id) {
            view_changed(id == "advanced");
            return true;
        };
        view_radio_button_ptr->on_selection_changed(TR("Simple"), "simple");
    }

    void SettingsPage::on_navigate_away_from_page() {
        save();
    }

    void SettingsPage::load() {
        switch(type) {
            case Type::REPLAY:
                load_replay();
                break;
            case Type::RECORD:
                load_record();
                break;
            case Type::STREAM:
                load_stream();
                break;
        }
    }

    void SettingsPage::save() {
        Config prev_config = config;
        switch(type) {
            case Type::REPLAY:
                save_replay();
                break;
            case Type::RECORD:
                save_record();
                break;
            case Type::STREAM:
                save_stream();
                break;
        }
        save_config(config);

        if(on_config_changed && config != prev_config)
            on_config_changed();
    }

    static const std::string* get_application_audio_by_name_case_insensitive(const std::vector<std::string> &application_audio, const std::string &name) {
        for(const auto &app_audio : application_audio) {
            if(strcasecmp(app_audio.c_str(), name.c_str()) == 0)
                return &app_audio;
        }
        return nullptr;
    }

    void SettingsPage::load_audio_tracks(const RecordOptions &record_options) {
        audio_track_section_list_ptr->clear();
        for(const AudioTrack &audio_track : record_options.audio_tracks_list) {
            auto audio_track_section = create_audio_track_section(audio_section_ptr);
            List *audio_track_section_items_list_ptr = dynamic_cast<List*>(audio_track_section->get_inner_widget());
            List *audio_input_list_ptr = dynamic_cast<List*>(audio_track_section_items_list_ptr->get_child_widget_by_index(2));
            CheckBox *application_audio_invert_checkbox_ptr = dynamic_cast<CheckBox*>(audio_track_section_items_list_ptr->get_child_widget_by_index(3));
            application_audio_invert_checkbox_ptr->set_checked(audio_track.application_audio_invert);

            audio_input_list_ptr->clear();
            for(const std::string &audio_input : audio_track.audio_inputs) {
                if(starts_with(audio_input, "app:")) {
                    if(!gsr_info->system_info.supports_app_audio)
                        continue;

                    std::string audio_track_name = audio_input.substr(4);
                    const std::string *app_audio = get_application_audio_by_name_case_insensitive(application_audio, audio_track_name);
                    if(app_audio) {
                        std::unique_ptr<List> application_audio_widget = create_application_audio(audio_input_list_ptr);
                        ComboBox *application_audio_box = dynamic_cast<ComboBox*>(application_audio_widget->get_child_widget_by_index(1));
                        application_audio_box->set_selected_item(*app_audio);
                        audio_input_list_ptr->add_widget(std::move(application_audio_widget));
                    } else {
                        std::unique_ptr<List> application_audio_widget = create_custom_application_audio(audio_input_list_ptr);
                        Entry *application_audio_entry = dynamic_cast<Entry*>(application_audio_widget->get_child_widget_by_index(1));
                        application_audio_entry->set_text(std::move(audio_track_name));
                        audio_input_list_ptr->add_widget(std::move(application_audio_widget));
                    }
                } else if(starts_with(audio_input, "device:")) {
                    const std::string device_name = audio_input.substr(7);
                    const AudioDeviceType audio_device_type = audio_device_is_output(device_name) ? AudioDeviceType::OUTPUT : AudioDeviceType::INPUT;
                    std::unique_ptr<List> audio_track_widget = create_audio_device(audio_device_type, audio_input_list_ptr);
                    ComboBox *audio_device_box = dynamic_cast<ComboBox*>(audio_track_widget->get_child_widget_by_index(1));
                    audio_device_box->set_selected_item(device_name);
                    audio_input_list_ptr->add_widget(std::move(audio_track_widget));
                } else {
                    const AudioDeviceType audio_device_type = audio_device_is_output(audio_input) ? AudioDeviceType::OUTPUT : AudioDeviceType::INPUT;
                    std::unique_ptr<List> audio_track_widget = create_audio_device(audio_device_type, audio_input_list_ptr);
                    ComboBox *audio_device_box = dynamic_cast<ComboBox*>(audio_track_widget->get_child_widget_by_index(1));
                    audio_device_box->set_selected_item(audio_input);
                    audio_input_list_ptr->add_widget(std::move(audio_track_widget));
                }
            }

            audio_track_section_list_ptr->add_widget(std::move(audio_track_section));

            if(type == Type::STREAM)
                break;
        }

        if(type == Type::STREAM && audio_track_section_list_ptr->get_num_children() == 0) {
            auto audio_track_section = create_audio_track_section(audio_section_ptr);
            audio_track_section_list_ptr->add_widget(std::move(audio_track_section));
        }

        update_application_audio_warning_visibility();
    }

    void SettingsPage::load_common(RecordOptions &record_options) {
        record_area_box_ptr->set_selected_item(record_options.record_area_option);
        change_video_resolution_checkbox_ptr->set_checked(record_options.change_video_resolution);
        load_audio_tracks(record_options);
        color_range_box_ptr->set_selected_item(record_options.color_range);
        video_quality_box_ptr->set_selected_item(record_options.video_quality);
        video_codec_box_ptr->set_selected_item(record_options.video_codec);
        audio_codec_box_ptr->set_selected_item(record_options.audio_codec);
        framerate_mode_box_ptr->set_selected_item(record_options.framerate_mode);
        view_radio_button_ptr->set_selected_item(record_options.advanced_view ? "advanced" : "simple");
        // TODO:
        //record_options.overclock = false;
        record_cursor_checkbox_ptr->set_checked(record_options.record_cursor);
        restore_portal_session_checkbox_ptr->set_checked(record_options.restore_portal_session);
        show_notification_checkbox_ptr->set_checked(record_options.show_notifications);
        led_indicator_checkbox_ptr->set_checked(record_options.use_led_indicator);
        low_power_mode_checkbox_ptr->set_checked(record_options.low_power_mode);

        char webcam_setup_str[256];
        snprintf(webcam_setup_str, sizeof(webcam_setup_str), "%dx%d@%dhz", record_options.webcam_camera_width, record_options.webcam_camera_height, record_options.webcam_camera_fps);

        webcam_sources_box_ptr->set_selected_item(record_options.webcam_source);
        flip_camera_horizontally_checkbox_ptr->set_checked(record_options.webcam_flip_horizontally);
        webcam_video_format_box_ptr->set_selected_item(record_options.webcam_video_format);
        webcam_video_setup_box_ptr->set_selected_item(webcam_setup_str);
        webcam_box_pos.x = ((float)record_options.webcam_x / 100.0f) * screen_inner_size.x;
        webcam_box_pos.y = ((float)record_options.webcam_y / 100.0f) * screen_inner_size.y;
        webcam_box_size.x = ((float)record_options.webcam_width / 100.0f * screen_inner_size.x);
        webcam_box_size.y = ((float)record_options.webcam_height / 100.0f * screen_inner_size.y);

        if(selected_camera_setup.has_value())
            webcam_box_size = clamp_keep_aspect_ratio(selected_camera_setup->resolution.to_vec2f(), webcam_box_size);

        if(record_options.record_area_width == 0)
            record_options.record_area_width = 1920;

        if(record_options.record_area_height == 0)
            record_options.record_area_height = 1080;

        if(record_options.video_width == 0)
            record_options.video_width = 1920;

        if(record_options.video_height == 0)
            record_options.video_height = 1080;

        if(record_options.record_area_width < 32)
            record_options.record_area_width = 32;
        area_width_entry_ptr->set_text(std::to_string(record_options.record_area_width));

        if(record_options.record_area_height < 32)
            record_options.record_area_height = 32;
        area_height_entry_ptr->set_text(std::to_string(record_options.record_area_height));

        if(record_options.video_width < 32)
            record_options.video_width = 32;
        video_width_entry_ptr->set_text(std::to_string(record_options.video_width));

        if(record_options.video_height < 32)
            record_options.video_height = 32;
        video_height_entry_ptr->set_text(std::to_string(record_options.video_height));

        if(record_options.fps < 1)
            record_options.fps = 1;
        framerate_entry_ptr->set_text(std::to_string(record_options.fps));

        if(record_options.video_bitrate < 1)
            record_options.video_bitrate = 1;
        video_bitrate_entry_ptr->set_text(std::to_string(record_options.video_bitrate));
    }

    void SettingsPage::load_replay() {
        load_common(config.replay_config.record_options);
        replay_storage_button_ptr->set_selected_item(config.replay_config.replay_storage);
        turn_on_replay_automatically_mode_ptr->set_selected_item(config.replay_config.turn_on_replay_automatically_mode);
        save_replay_in_game_folder_ptr->set_checked(config.replay_config.save_video_in_game_folder);
        replay_power_supply_checkbox_ptr->set_checked(config.replay_config.only_start_replay_if_power_supply_connected);
        if(restart_replay_on_save)
            restart_replay_on_save->set_checked(config.replay_config.restart_replay_on_save);
        
        save_directory_button_ptr->set_text(config.replay_config.save_directory);
        container_box_ptr->set_selected_item(config.replay_config.container);

        if(config.replay_config.replay_time < 2)
            config.replay_config.replay_time = 2;
        if(config.replay_config.replay_time > 86400)
            config.replay_config.replay_time = 86400;
        replay_time_entry_ptr->set_text(std::to_string(config.replay_config.replay_time));
    }

    void SettingsPage::load_record() {
        load_common(config.record_config.record_options);
        save_recording_in_game_folder_ptr->set_checked(config.record_config.save_video_in_game_folder);
        save_directory_button_ptr->set_text(config.record_config.save_directory);
        container_box_ptr->set_selected_item(config.record_config.container);
    }

    void SettingsPage::load_stream() {
        load_common(config.streaming_config.record_options);
        streaming_service_box_ptr->set_selected_item(config.streaming_config.streaming_service);
        youtube_stream_key_entry_ptr->set_text(config.streaming_config.youtube.stream_key);
        twitch_stream_key_entry_ptr->set_text(config.streaming_config.twitch.stream_key);
        rumble_stream_key_entry_ptr->set_text(config.streaming_config.rumble.stream_key);
        kick_stream_url_entry_ptr->set_text(config.streaming_config.kick.stream_url);
        kick_stream_key_entry_ptr->set_text(config.streaming_config.kick.stream_key);
        stream_url_entry_ptr->set_text(config.streaming_config.custom.url);
        stream_key_entry_ptr->set_text(config.streaming_config.custom.key);
        container_box_ptr->set_selected_item(config.streaming_config.custom.container);
    }

    static void save_audio_tracks(std::vector<AudioTrack> &audio_tracks, List *audio_track_section_list_ptr) {
        audio_tracks.clear();
        audio_track_section_list_ptr->for_each_child_widget([&audio_tracks](std::unique_ptr<Widget> &child_widget) {
            Subsection *audio_subsection = dynamic_cast<Subsection*>(child_widget.get());
            List *audio_track_section_items_list_ptr = dynamic_cast<List*>(audio_subsection->get_inner_widget());
            List *audio_input_list_ptr = dynamic_cast<List*>(audio_track_section_items_list_ptr->get_child_widget_by_index(2));
            CheckBox *application_audio_invert_checkbox_ptr = dynamic_cast<CheckBox*>(audio_track_section_items_list_ptr->get_child_widget_by_index(3));

            audio_tracks.push_back({std::vector<std::string>{}, application_audio_invert_checkbox_ptr->is_checked()});
            audio_input_list_ptr->for_each_child_widget([&audio_tracks](std::unique_ptr<Widget> &child_widget){
                List *audio_track_line = dynamic_cast<List*>(child_widget.get());
                const AudioTrackType audio_track_type = (AudioTrackType)(uintptr_t)audio_track_line->userdata;
                switch(audio_track_type) {
                    case AudioTrackType::DEVICE: {
                        ComboBox *audio_device_box = dynamic_cast<ComboBox*>(audio_track_line->get_child_widget_by_index(1));
                        audio_tracks.back().audio_inputs.push_back("device:" + std::string(audio_device_box->get_selected_id()));
                        break;
                    }
                    case AudioTrackType::APPLICATION: {
                        ComboBox *application_audio_box = dynamic_cast<ComboBox*>(audio_track_line->get_child_widget_by_index(1));
                        audio_tracks.back().audio_inputs.push_back("app:" + std::string(application_audio_box->get_selected_id()));
                        break;
                    }
                    case AudioTrackType::APPLICATION_CUSTOM: {
                        Entry *application_audio_entry = dynamic_cast<Entry*>(audio_track_line->get_child_widget_by_index(1));
                        audio_tracks.back().audio_inputs.push_back("app:" + std::string(application_audio_entry->get_text()));
                        break;
                    }
                }
                return true;
            });

            return true;
        });
    }

    void SettingsPage::save_common(RecordOptions &record_options) {
        std::stoi("23");
        record_options.record_area_option = record_area_box_ptr->get_selected_id();
        record_options.record_area_width = sv_to_int<int32_t>(area_width_entry_ptr->get_text());
        record_options.record_area_height = sv_to_int<int32_t>(area_height_entry_ptr->get_text());
        record_options.video_width = sv_to_int<int32_t>(video_width_entry_ptr->get_text());
        record_options.video_height = sv_to_int<int32_t>(video_height_entry_ptr->get_text());
        record_options.fps = sv_to_int<int32_t>(framerate_entry_ptr->get_text());
        record_options.video_bitrate = sv_to_int<int32_t>(video_bitrate_entry_ptr->get_text());
        record_options.change_video_resolution = change_video_resolution_checkbox_ptr->is_checked();
        save_audio_tracks(record_options.audio_tracks_list, audio_track_section_list_ptr);
        record_options.color_range = color_range_box_ptr->get_selected_id();
        record_options.video_quality = video_quality_box_ptr->get_selected_id();
        record_options.video_codec = video_codec_box_ptr->get_selected_id();
        record_options.audio_codec = audio_codec_box_ptr->get_selected_id();
        record_options.framerate_mode = framerate_mode_box_ptr->get_selected_id();
        record_options.advanced_view = view_radio_button_ptr->get_selected_id() == "advanced";
        // TODO:
        //record_options.overclock = false;
        record_options.record_cursor = record_cursor_checkbox_ptr->is_checked();
        record_options.restore_portal_session = restore_portal_session_checkbox_ptr->is_checked();
        record_options.show_notifications = show_notification_checkbox_ptr->is_checked();
        record_options.use_led_indicator = led_indicator_checkbox_ptr->is_checked();
        record_options.low_power_mode = low_power_mode_checkbox_ptr->is_checked();

        // TODO: Set selected_camera_setup properly when updating and shit

        if(selected_camera_setup.has_value())
            webcam_box_size = clamp_keep_aspect_ratio(selected_camera_setup->resolution.to_vec2f(), webcam_box_size);

        record_options.webcam_source = webcam_sources_box_ptr->get_selected_id();
        record_options.webcam_flip_horizontally = flip_camera_horizontally_checkbox_ptr->is_checked();
        record_options.webcam_x = std::round((webcam_box_pos.x / screen_inner_size.x) * 100.0f);
        record_options.webcam_y = std::round((webcam_box_pos.y / screen_inner_size.y) * 100.0f);
        record_options.webcam_width = std::round((webcam_box_size.x / screen_inner_size.x) * 100.0f);
        record_options.webcam_height = std::round((webcam_box_size.y / screen_inner_size.y) * 100.0f);

        if(record_options.record_area_width == 0)
            record_options.record_area_width = 1920;

        if(record_options.record_area_height == 0)
            record_options.record_area_height = 1080;

        if(record_options.video_width == 0)
            record_options.video_width = 1920;

        if(record_options.video_height == 0)
            record_options.video_height = 1080;

        if(record_options.record_area_width < 32) {
            record_options.record_area_width = 32;
            area_width_entry_ptr->set_text("32");
        }

        if(record_options.record_area_height < 32) {
            record_options.record_area_height = 32;
            area_height_entry_ptr->set_text("32");
        }

        if(record_options.video_width < 32) {
            record_options.video_width = 32;
            video_width_entry_ptr->set_text("32");
        }

        if(record_options.video_height < 32) {
            record_options.video_height = 32;
            video_height_entry_ptr->set_text("32");
        }

        if(record_options.fps < 1) {
            record_options.fps = 1;
            framerate_entry_ptr->set_text("1");
        }

        if(record_options.video_bitrate < 1) {
            record_options.video_bitrate = 1;
            video_bitrate_entry_ptr->set_text("1");
        }
    }

    void SettingsPage::save_replay() {
        save_common(config.replay_config.record_options);
        config.replay_config.turn_on_replay_automatically_mode = turn_on_replay_automatically_mode_ptr->get_selected_id();
        config.replay_config.save_video_in_game_folder = save_replay_in_game_folder_ptr->is_checked();
        config.replay_config.only_start_replay_if_power_supply_connected = replay_power_supply_checkbox_ptr->is_checked();
        if(restart_replay_on_save)
            config.replay_config.restart_replay_on_save = restart_replay_on_save->is_checked();
        config.replay_config.save_directory = save_directory_button_ptr->get_text();
        config.replay_config.container = container_box_ptr->get_selected_id();
        config.replay_config.replay_time = sv_to_int<int32_t>(replay_time_entry_ptr->get_text());
        config.replay_config.replay_storage = replay_storage_button_ptr->get_selected_id();

        if(config.replay_config.replay_time < 5) {
            config.replay_config.replay_time = 5;
            replay_time_entry_ptr->set_text("5");
        }
    }

    void SettingsPage::save_record() {
        save_common(config.record_config.record_options);
        config.record_config.save_video_in_game_folder = save_recording_in_game_folder_ptr->is_checked();
        config.record_config.save_directory = save_directory_button_ptr->get_text();
        config.record_config.container = container_box_ptr->get_selected_id();
    }

    void SettingsPage::save_stream() {
        save_common(config.streaming_config.record_options);
        config.streaming_config.streaming_service = streaming_service_box_ptr->get_selected_id();
        config.streaming_config.youtube.stream_key = youtube_stream_key_entry_ptr->get_text();
        config.streaming_config.twitch.stream_key = twitch_stream_key_entry_ptr->get_text();
        config.streaming_config.rumble.stream_key = rumble_stream_key_entry_ptr->get_text();
        config.streaming_config.kick.stream_url = kick_stream_url_entry_ptr->get_text();
        config.streaming_config.kick.stream_key = kick_stream_key_entry_ptr->get_text();
        config.streaming_config.custom.url = stream_url_entry_ptr->get_text();
        config.streaming_config.custom.key = stream_key_entry_ptr->get_text();
        config.streaming_config.custom.container = container_box_ptr->get_selected_id();
    }
}