#include "Configuration.h"

//
// Read me!
//
// This file defines a configuration dialog with the user. The general
// strategy is to expose agreed  configuration parameters via a custom
// interface (See  Configuration.h). The state exposed  through this
// public   interface  reflects   stored  or   derived  data   in  the
// Configuration::impl object.   The Configuration::impl  structure is
// an implementation of the PIMPL (a.k.a.  Cheshire Cat or compilation
// firewall) implementation hiding idiom that allows internal state to
// be completely removed from the public interface.
//
// There  is a  secondary level  of parameter  storage which  reflects
// current settings UI  state, these parameters are not  copied to the
// state   store  that   the  public   interface  exposes   until  the
// Configuration:impl::accept() operation is  successful. The accept()
// operation is  tied to the settings  OK button. The normal  and most
// convenient place to store this intermediate settings UI state is in
// the data models of the UI  controls, if that is not convenient then
// separate member variables  must be used to store that  state. It is
// important for the user experience that no publicly visible settings
// are changed  while the  settings UI are  changed i.e.  all settings
// changes   must    be   deferred   until   the    "OK"   button   is
// clicked. Conversely, all changes must  be discarded if the settings
// UI "Cancel" button is clicked.
//
// There is  a complication related  to the radio interface  since the
// this module offers  the facility to test the  radio interface. This
// test means  that the  public visibility to  the radio  being tested
// must be  changed.  To  maintain the  illusion of  deferring changes
// until they  are accepted, the  original radio related  settings are
// stored upon showing  the UI and restored if the  UI is dismissed by
// canceling.
//
// It  should be  noted that  the  settings UI  lives as  long as  the
// application client that uses it does. It is simply shown and hidden
// as it  is needed rather than  creating it on demand.  This strategy
// saves a  lot of  expensive UI  drawing at the  expense of  a little
// storage and  gives a  convenient place  to deliver  settings values
// from.
//
// Here is an overview of the high level flow of this module:
//
// 1)  On  construction the  initial  environment  is initialized  and
// initial   values  for   settings  are   read  from   the  QSettings
// database. At  this point  default values for  any new  settings are
// established by  providing a  default value  to the  QSettings value
// queries. This should be the only place where a hard coded value for
// a   settings  item   is   defined.   Any   remaining  one-time   UI
// initialization is also done. At the end of the constructor a method
// initialize_models()  is called  to  load the  UI  with the  current
// settings values.
//
// 2) When the settings UI is displayed by a client calling the exec()
// operation, only temporary state need be stored as the UI state will
// already mirror the publicly visible settings state.
//
// 3) As  the user makes  changes to  the settings UI  only validation
// need be  carried out since the  UI control data models  are used as
// the temporary store of unconfirmed settings.  As some settings will
// depend  on each  other a  validate() operation  is available,  this
// operation implements a check of any complex multi-field values.
//
// 4) If the  user discards the settings changes by  dismissing the UI
// with the  "Cancel" button;  the reject()  operation is  called. The
// reject() operation calls initialize_models()  which will revert all
// the  UI visible  state  to  the values  as  at  the initial  exec()
// operation.  No   changes  are  moved   into  the  data   fields  in
// Configuration::impl that  reflect the  settings state  published by
// the public interface (Configuration.h).
//
// 5) If  the user accepts the  settings changes by dismissing  the UI
// with the "OK" button; the  accept() operation is called which calls
// the validate() operation  again and, if it passes,  the fields that
// are used  to deliver  the settings  state are  updated from  the UI
// control models  or other temporary  state variables. At the  end of
// the accept()  operation, just  before hiding  the UI  and returning
// control to the caller; the new  settings values are stored into the
// settings database by a call to the write_settings() operation, thus
// ensuring that  settings changes are  saved even if  the application
// crashes or is subsequently killed.
//
// 6)  On  destruction,  which   only  happens  when  the  application
// terminates,  the settings  are saved  to the  settings database  by
// calling the  write_settings() operation. This is  largely redundant
// but is still done to save the default values of any new settings on
// an initial run.
//
// To add a new setting:
//
// 1) Update the UI with the new widget to view and change the value.
//
// 2)  Add  a member  to  Configuration::impl  to store  the  accepted
// setting state. If the setting state is dynamic; add a new signal to
// broadcast the setting value.
//
// 3) Add a  query method to the  public interface (Configuration.h)
// to access the  new setting value. If the settings  is dynamic; this
// step  is optional  since  value  changes will  be  broadcast via  a
// signal.
//
// 4) Add a forwarding operation to implement the new query (3) above.
//
// 5)  Add a  settings read  call to  read_settings() with  a sensible
// default value. If  the setting value is dynamic, add  a signal emit
// call to broadcast the setting value change.
//
// 6) Add  code to  initialize_models() to  load the  widget control's
// data model with the current value.
//
// 7) If there is no convenient data model field, add a data member to
// store the proposed new value. Ensure  this member has a valid value
// on exit from read_settings().
//
// 8)  Add  any  required  inter-field validation  to  the  validate()
// operation.
//
// 9) Add code to the accept()  operation to extract the setting value
// from  the  widget   control  data  model  and  load   it  into  the
// Configuration::impl  member  that  reflects  the  publicly  visible
// setting state. If  the setting value is dynamic; add  a signal emit
// call to broadcast any changed state of the setting.
//
// 10) Add  a settings  write call  to save the  setting value  to the
// settings database.
//

#include <algorithm>
#include <cmath>
#include <iterator>
#include <limits>
#include <stdexcept>

#include <QAction>
#include <QApplication>
#include <QAudioDevice>
#include <QAudioInput>
#include <QColorDialog>
#include <QDateTimeEdit>
#include <QDialog>
#include <QDir>
#include <QFileDialog>
#include <QFont>
#include <QFontDialog>
#include <QFormLayout>
#include <QIntValidator>
#include <QLineEdit>
#include <QList>
#include <QLoggingCategory>
#include <QMediaDevices>
#include <QMetaType>
#include <QProcess>
#include <QRegularExpressionValidator>
#include <QScopedPointer>
#include <QSerialPortInfo>
#include <QSettings>
#include <QSoundEffect>
#include <QStandardItemModel>
#include <QStandardPaths>
#include <QString>
#include <QStringList>
#include <QStringListModel>
#include <QTemporaryFile>
#include <QThread>
#include <QTimeZone>
#include <QTimer>

#include "JS8_Include/Maidenhead.h"
#include "JS8_Include/SettingsGroup.h"
#include "JS8_Include/pimpl_impl.h"
#include "JS8_Main/Bands.h"
#include "JS8_Main/CallsignValidator.h"
#include "JS8_Main/CandidateKeyFilter.h"
#include "JS8_Main/ForeignKeyDelegate.h"
#include "JS8_Main/FrequencyLineEdit.h"
#include "JS8_Main/FrequencyList.h"
#include "JS8_Main/IARURegions.h"
#include "JS8_Main/JS8MessageBox.h"
#include "JS8_Main/MetaDataRegistry.h"
#include "JS8_Main/Modes.h"
#include "JS8_Main/StationList.h"
#include "JS8_Main/qt_helpers.h"
#include "JS8_Network/NetworkServerLookup.h"
#include "JS8_Transceiver/Transceiver.h"
#include "JS8_Transceiver/TransceiverFactory.h"
#include "JS8_Widgets/LazyFillComboBox.h"

#include "JS8_Main/varicode.h"

#include "JS8_Widgets/CheckableItemComboBox.h"
#include "moc_Configuration.cpp"
#include "ui_Configuration.h"
#include <QNetworkInterface>
#include <QStandardItemModel>

namespace {
const QRegularExpression message_alphabet{"[^\\x00-\\x1F]*"};

// Magic numbers for file validation
constexpr quint32 qrg_magic{0xadbccbdb};
constexpr quint32 qrg_version{102}; // M.mm

// Bump this versioned key every time we need to "reset" our working
// frequencies...
const char *const versionedFrequenciesSettingsKey =
    "FrequenciesForRegionModes_01";
} // namespace

//
// Dialog to get a new Frequency item
//
class FrequencyDialog final : public QDialog {
  public:
    using Item = FrequencyList_v2::Item;

    explicit FrequencyDialog(IARURegions *regions_model, Modes *modes_model,
                             QWidget *parent = nullptr)
        : QDialog{parent} {
        setWindowTitle(QApplication::applicationName() + " - " +
                       tr("Add Frequency"));
        region_combo_box_.setModel(regions_model);
        mode_combo_box_.setModel(modes_model);

        auto form_layout = new QFormLayout();
        form_layout->addRow(tr("IARU &Region:"), &region_combo_box_);
        form_layout->addRow(tr("&Mode:"), &mode_combo_box_);
        form_layout->addRow(tr("&Frequency (MHz):"), &frequency_line_edit_);

        auto main_layout = new QVBoxLayout(this);
        main_layout->addLayout(form_layout);

        auto button_box = new QDialogButtonBox{QDialogButtonBox::Ok |
                                               QDialogButtonBox::Cancel};
        main_layout->addWidget(button_box);

        connect(button_box, &QDialogButtonBox::accepted, this,
                &FrequencyDialog::accept);
        connect(button_box, &QDialogButtonBox::rejected, this,
                &FrequencyDialog::reject);
    }

    Item item() const {
        return {frequency_line_edit_.frequency(),
                Modes::value(mode_combo_box_.currentText()),
                IARURegions::value(region_combo_box_.currentText())};
    }

  private:
    QComboBox region_combo_box_;
    QComboBox mode_combo_box_;
    FrequencyLineEdit frequency_line_edit_;
};

//
// Dialog to get a new Station item
//
class StationDialog final : public QDialog {
  public:
    explicit StationDialog(StationList const *stations, Bands *bands,
                           QWidget *parent = nullptr)
        : QDialog{parent},
          filtered_bands_{new CandidateKeyFilter{bands, stations, 0, 0}},
          all_bands_{bands} {
        setWindowTitle(QApplication::applicationName() + " - " +
                       tr("Add Schedule"));

        band_.setModel(filtered_bands_.data());

        switch_at_.setTimeZone(QTimeZone::utc());

        switch_at_.setDisplayFormat("hh:mm");

        switch_until_.setTimeZone(QTimeZone::utc());

        switch_until_.setDisplayFormat("hh:mm");

        auto form_layout = new QFormLayout();
        form_layout->addRow(tr("&Frequency (MHz):"), &freq_);
        form_layout->addRow(tr("&Switch at (UTC):"), &switch_at_);
        form_layout->addRow(tr("&Until (UTC):"), &switch_until_);
        form_layout->addRow(tr("&Description:"), &description_);

        auto main_layout = new QVBoxLayout(this);
        main_layout->addLayout(form_layout);

        auto button_box = new QDialogButtonBox{QDialogButtonBox::Ok |
                                               QDialogButtonBox::Cancel};
        main_layout->addWidget(button_box);

        connect(button_box, &QDialogButtonBox::accepted, this,
                &StationDialog::accept);
        connect(button_box, &QDialogButtonBox::rejected, this,
                &StationDialog::reject);
    }

    StationList::Station station() const {
        auto band = all_bands_->find(freq_.frequency());

        auto a =
            QDateTime(QDate(2000, 1, 1), switch_at_.time(), QTimeZone::utc());
        auto b = QDateTime(QDate(2000, 1, 1), switch_until_.time(),
                           QTimeZone::utc());

        return {band, freq_.frequency(), a, b, description_.text()};
    }

    int exec() override {
        filtered_bands_->set_active_key();
        return QDialog::exec();
    }

  private:
    QScopedPointer<CandidateKeyFilter> filtered_bands_;
    Bands *all_bands_;

    QComboBox band_;
    FrequencyLineEdit freq_;
    QTimeEdit switch_at_;
    QTimeEdit switch_until_;
    QLineEdit description_;
};

class RearrangableMacrosModel : public QStringListModel {
  public:
    Qt::ItemFlags flags(QModelIndex const &index) const override {
        auto flags = QStringListModel::flags(index);
        if (index.isValid()) {
            // disallow drop onto existing items
            flags &= ~Qt::ItemIsDropEnabled;
        }
        return flags;
    }
};

//
// Class MessageItemDelegate
//
//	Item delegate for message entry such as free text message macros.
//
class MessageItemDelegate final : public QStyledItemDelegate {
  public:
    using QStyledItemDelegate::QStyledItemDelegate;

    QWidget *createEditor(QWidget *parent,
                          QStyleOptionViewItem const & /* option*/
                          ,
                          QModelIndex const & /* index */
    ) const override {
        auto editor = new QLineEdit{parent};
        editor->setFrame(false);
        editor->setValidator(
            new QRegularExpressionValidator{message_alphabet, editor});
        return editor;
    }
};

// Internal implementation of the Configuration class.
class Configuration::impl final : public QDialog {
    Q_OBJECT;

  public:
    using FrequencyDelta = Radio::FrequencyDelta;
    using port_type = Configuration::port_type;

    explicit impl(Configuration *self, QDir const &temp_directory,
                  QSettings *settings, QWidget *parent);
    ~impl();

    bool have_rig();

    void transceiver_frequency(Frequency);
    void transceiver_tx_frequency(Frequency);
    void transceiver_mode(MODE);
    void transceiver_ptt(bool);
    void sync_transceiver(bool force_signal);

    Q_SLOT int exec() override;
    Q_SLOT void accept() override;
    Q_SLOT void reject() override;
    Q_SLOT void done(int) override;

  private:
    typedef QList<QAudioDevice> AudioDevices;

    void read_settings();
    void write_settings();

    void find_audio_devices();
    QAudioDevice find_audio_device(QAudioDevice::Mode, QComboBox *,
                                   QString const &device_name);
    void load_audio_devices(QAudioDevice::Mode, QComboBox *, QAudioDevice *);
    void update_audio_channels(QComboBox const *, QComboBox const *, int, bool);
    void load_network_interfaces(CheckableItemComboBox *, QStringList current);

    static QAction *attachRequiredIndicator(QLineEdit *edit, const QString &toolTip = QStringLiteral("Required"));

    QStringList get_selected_network_interfaces(CheckableItemComboBox *);

    void find_tab(QWidget *);

    void initialize_models();
    bool split_mode() const {
        return (WSJT_RIG_NONE_CAN_SPLIT || !rig_is_dummy_) &&
               (rig_params_.split_mode != TransceiverFactory::split_mode_none);
    }
    void set_cached_mode();
    bool open_rig(bool force = false);
    // bool set_mode ();
    void close_rig();
    TransceiverFactory::ParameterPack gather_rig_data() const;
    void enumerate_rigs();
    void set_rig_invariants();
    bool validate();
    void fill_port_combo_box(QComboBox *);
    Frequency apply_calibration(Frequency) const;
    Frequency remove_calibration(Frequency) const;

    void delete_frequencies();
    void load_frequencies();
    void merge_frequencies();
    void save_frequencies();
    void reset_frequencies();
    void insert_frequency();
    FrequencyList_v2::FrequencyItems read_frequencies_file(QString const &);

    void delete_stations();
    void insert_station();

    Q_SLOT void on_psk_reporter_check_box_toggled(bool checked);
    Q_SLOT void on_enable_aprs_spotting_check_box_toggled(bool checked);
    Q_SLOT void on_notifications_check_box_toggled(bool checked);
    Q_SLOT void on_font_push_button_clicked();
    Q_SLOT void on_tableFontButton_clicked();
    Q_SLOT void on_PTT_port_combo_box_activated(int);
    Q_SLOT void on_CAT_port_combo_box_activated(int);
    Q_SLOT void on_CAT_serial_baud_combo_box_currentIndexChanged(int);
    Q_SLOT void on_CAT_data_bits_button_group_buttonClicked(QAbstractButton *);
    Q_SLOT void on_CAT_stop_bits_button_group_buttonClicked(QAbstractButton *);
    Q_SLOT void on_CAT_handshake_button_group_buttonClicked(QAbstractButton *);
    Q_SLOT void on_CAT_poll_interval_spin_box_valueChanged(int);
    Q_SLOT void on_split_mode_button_group_buttonClicked(QAbstractButton *);
    Q_SLOT void on_test_CAT_push_button_clicked();
    Q_SLOT void on_test_PTT_push_button_clicked(bool checked);
    Q_SLOT void on_force_DTR_combo_box_currentIndexChanged(int);
    Q_SLOT void on_force_RTS_combo_box_currentIndexChanged(int);
    Q_SLOT void on_rig_combo_box_currentIndexChanged(int);
    Q_SLOT void on_add_macro_push_button_clicked(bool = false);
    Q_SLOT void on_delete_macro_push_button_clicked(bool = false);
    Q_SLOT void on_PTT_method_button_group_buttonClicked(QAbstractButton *);
    Q_SLOT void on_groups_line_edit_textChanged(QString const &);
    Q_SLOT void on_info_message_line_edit_textChanged(QString const &);
    Q_SLOT void on_cq_message_line_edit_textChanged(QString const &);
    Q_SLOT void on_reply_message_line_edit_textChanged(QString const &);
    Q_SLOT void on_add_macro_line_edit_editingFinished();
    Q_SLOT void delete_macro();
    void delete_selected_macros(QModelIndexList);
    Q_SLOT void on_save_path_select_push_button_clicked(bool);
    Q_SLOT void on_calibration_intercept_spin_box_valueChanged(double);
    Q_SLOT void on_calibration_slope_ppm_spin_box_valueChanged(double);
    Q_SLOT void handle_transceiver_update(TransceiverState const &,
                                          unsigned sequence_number);
    Q_SLOT void handle_transceiver_failure(QString const &reason);
    Q_SLOT void on_cqMessagesButton_clicked();
    Q_SLOT void on_primaryHighlightButton_clicked();
    Q_SLOT void on_secondaryHighlightButton_clicked();
    Q_SLOT void on_pbMyCall_clicked();
    Q_SLOT void on_tableBackgroundButton_clicked();
    Q_SLOT void on_tableSelectedRowBackgroundButton_clicked();
    Q_SLOT void on_tableForegroundButton_clicked();
    Q_SLOT void on_rxBackgroundButton_clicked();
    Q_SLOT void on_rxForegroundButton_clicked();
    Q_SLOT void on_rxFontButton_clicked();
    Q_SLOT void on_composeBackgroundButton_clicked();
    Q_SLOT void on_composeForegroundButton_clicked();
    Q_SLOT void on_composeFontButton_clicked();
    Q_SLOT void on_txForegroundButton_clicked();
    Q_SLOT void on_txFontButton_clicked();

    // typenames used as arguments must match registered type names :(
    Q_SIGNAL void start_transceiver(unsigned seqeunce_number) const;
    Q_SIGNAL void set_transceiver(Transceiver::TransceiverState const &,
                                  unsigned sequence_number) const;
    Q_SIGNAL void stop_transceiver() const;

    Configuration *const self_; // back pointer to public interface

    QThread *transceiver_thread_;
    TransceiverFactory transceiver_factory_;
    QList<QMetaObject::Connection> rig_connections_;

    QScopedPointer<Ui::configuration_dialog> ui_;

    QSettings *settings_;

    QDir temp_dir_;
    QDir writeable_data_dir_;
    QDir default_save_directory_;
    QDir save_directory_;

    QFont font_;
    QFont next_font_;

    QFont table_font_;
    QFont next_table_font_;

    QFont rx_text_font_;
    QFont next_rx_text_font_;

    QFont tx_text_font_;
    QFont next_tx_text_font_;

    QFont compose_text_font_;
    QFont next_compose_text_font_;

    bool restart_sound_input_device_;
    bool restart_sound_output_device_;
    bool restart_notification_sound_output_device_;

    bool enable_notifications_;
    QMap<QString, bool> notifications_enabled_;
    QMap<QString, QString> notifications_paths_;

    QStringListModel macros_;
    RearrangableMacrosModel next_macros_;
    QAction *macro_delete_action_;

    Bands bands_;
    IARURegions regions_;
    IARURegions::Region region_;
    Modes modes_;
    FrequencyList_v2 frequencies_;
    FrequencyList_v2 next_frequencies_;
    StationList stations_;
    StationList next_stations_;

    QAction *frequency_delete_action_;
    QAction *frequency_insert_action_;
    QAction *load_frequencies_action_;
    QAction *save_frequencies_action_;
    QAction *merge_frequencies_action_;
    QAction *reset_frequencies_action_;
    FrequencyDialog *frequency_dialog_;

    QAction *station_hop_action_;
    QAction *station_delete_action_;
    QAction *station_insert_action_;
    StationDialog *station_dialog_;

    TransceiverFactory::ParameterPack rig_params_;
    TransceiverFactory::ParameterPack saved_rig_params_;
    TransceiverFactory::Capabilities::PortType last_port_type_;
    bool rig_is_dummy_;
    bool rig_active_;
    bool have_rig_;
    bool rig_changed_;
    TransceiverState cached_rig_state_;
    int rig_resolution_; // see Transceiver::resolution signal
    CalibrationParams calibration_;
    bool frequency_calibration_disabled_; // not persistent
    unsigned transceiver_command_number_;
    QString dynamic_grid_;
    QString dynamic_info_;
    QString dynamic_status_;

    // configuration fields that we publish
    bool auto_switch_bands_;
    QString my_callsign_;
    QString my_grid_;
    QStringList my_groups_;
    QStringList auto_whitelist_;
    QStringList auto_blacklist_;
    QStringList hb_blacklist_;
    QStringList spot_blacklist_;
    QStringList primary_highlight_words_;
    QStringList secondary_highlight_words_;
    QString eot_;
    QString mfi_;
    QString my_info_;
    QString my_status_;
    QString cq_;
    QString hb_;
    QString reply_;
    int callsign_aging_;
    int activity_aging_;
    QColor color_primary_highlight_;
    QColor next_color_primary_highlight_;
    QColor color_secondary_highlight_;
    QColor next_color_secondary_highlight_;
    QColor color_cq_;
    QColor next_color_cq_;
    QColor color_mycall_;
    QColor next_color_mycall_;

    QColor color_table_background_;
    QColor next_color_table_background_;
    QColor color_table_highlight_;
    QColor next_color_table_highlight_;
    QColor color_table_foreground_;
    QColor next_color_table_foreground_;

    QColor color_rx_background_;
    QColor next_color_rx_background_;
    QColor color_rx_foreground_;
    QColor next_color_rx_foreground_;
    QColor color_compose_background_;
    QColor next_color_compose_background_;
    QColor color_compose_foreground_;
    QColor next_color_compose_foreground_;
    QColor color_tx_foreground_;
    QColor next_color_tx_foreground_;
    QColor color_DXCC_;
    QColor next_color_DXCC_;
    QColor color_NewCall_;
    QColor next_color_NewCall_;
    double txDelay_;
    bool write_logs_;
    bool reset_activity_;
    bool check_for_updates_;
    bool tx_qsy_allowed_;
    bool spot_to_reporting_networks_;
    bool spot_to_aprs_;
    bool transmit_directed_;
    bool autoreply_on_at_startup_;
    bool autoreply_confirmation_;
    bool heartbeat_anywhere_;
    bool heartbeat_qso_pause_;
    bool heartbeat_ack_snr_;
    bool relay_disabled_;
    bool psk_reporter_tcpip_;
    bool monitor_off_at_startup_;
    bool transmit_off_at_startup_;
    bool monitor_last_used_;
    bool insert_blank_;
    bool DXCC_;
    bool ppfx_;
    bool miles_;
    bool hold_ptt_;
    bool avoid_forced_identify_;
    bool avoid_allcall_;
    bool spellcheck_;
    int heartbeat_;
    int watchdog_;
    bool TX_messages_;
    bool use_dynamic_info_;
    QString opCall_;
    QString ptt_command_;
    QString aprs_server_name_;
    port_type aprs_server_port_;

    QString udp_server_name_;
    port_type udp_server_port_;
    QString tcp_server_name_;
    port_type tcp_server_port_;
    QString n3fjp_server_name_;
    port_type n3fjp_server_port_;
    bool broadcast_to_n3fjp_;
    QString n1mm_server_name_;
    port_type n1mm_server_port_;
    bool broadcast_to_n1mm_;
    bool accept_udp_requests_;
    bool accept_tcp_requests_;
    bool udpEnabled_;
    bool tcpEnabled_;
    int tcpMaxConnections_;
    // WSJT-X Protocol settings
    bool wsjtx_protocol_enabled_;
    QString wsjtx_server_name_;
    port_type wsjtx_server_port_;
    int wsjtx_TTL_;
    bool wsjtx_accept_requests_;
    QStringList wsjtx_interface_names_;
    QString wsjtx_loopback_interface_name_;
    DataMode data_mode_;
    bool pwrBandTxMemory_;
    bool pwrBandTuneMemory_;

    QAudioDevice audio_input_device_;
    QAudioDevice next_audio_input_device_;
    AudioDevice::Channel audio_input_channel_;
    AudioDevice::Channel next_audio_input_channel_;

    QAudioDevice audio_output_device_;
    QAudioDevice next_audio_output_device_;
    AudioDevice::Channel audio_output_channel_;
    AudioDevice::Channel next_audio_output_channel_;

    QAudioDevice notification_audio_output_device_;
    QAudioDevice next_notification_audio_output_device_;

    friend class Configuration;

    void hop_to_station();
};

#include "Configuration.moc"

Q_DECLARE_LOGGING_CATEGORY(configuration_js8)

// delegate to implementation class
Configuration::Configuration(QDir const &temp_directory, QSettings *settings,
                             QWidget *parent)
    : m_{this, temp_directory, settings, parent} {}

Configuration::~Configuration() {}

QDir Configuration::writeable_data_dir() const {
    return m_->writeable_data_dir_;
}
QDir Configuration::temp_dir() const { return m_->temp_dir_; }

void Configuration::select_tab(int index) {
    m_->ui_->configuration_tabs->setCurrentIndex(index);
}
int Configuration::exec() { return m_->exec(); }
bool Configuration::is_active() const { return m_->isVisible(); }

QAudioDevice const &Configuration::audio_input_device() const {
    return m_->audio_input_device_;
}
AudioDevice::Channel Configuration::audio_input_channel() const {
    return m_->audio_input_channel_;
}
QAudioDevice const &Configuration::audio_output_device() const {
    return m_->audio_output_device_;
}
AudioDevice::Channel Configuration::audio_output_channel() const {
    return m_->audio_output_channel_;
}
QAudioDevice const &Configuration::notification_audio_output_device() const {
    return m_->notification_audio_output_device_;
}
bool Configuration::notifications_enabled() const {
    return m_->enable_notifications_;
}
QString Configuration::notification_path(const QString &key) const {
    if (!m_->enable_notifications_) {
        return "";
    }

    if (!m_->notifications_enabled_.value(key, false)) {
        return "";
    }

    return m_->notifications_paths_.value(key, "");
}
bool Configuration::restart_audio_input() const {
    return m_->restart_sound_input_device_;
}
bool Configuration::restart_audio_output() const {
    return m_->restart_sound_output_device_;
}
bool Configuration::restart_notification_audio_output() const {
    return m_->restart_notification_sound_output_device_;
}
bool Configuration::use_dynamic_grid() const { return m_->use_dynamic_info_; }
QString Configuration::my_callsign() const { return m_->my_callsign_; }
QColor Configuration::color_table_background() const {
    return m_->color_table_background_;
}
QColor Configuration::color_table_highlight() const {
    return m_->color_table_highlight_;
}
QColor Configuration::color_table_foreground() const {
    return m_->color_table_foreground_;
}
QColor Configuration::color_primary_highlight() const {
    return m_->color_primary_highlight_;
}
QColor Configuration::color_secondary_highlight() const {
    return m_->color_secondary_highlight_;
}
QColor Configuration::color_CQ() const { return m_->color_cq_; }
QColor Configuration::color_MyCall() const { return m_->color_mycall_; }
QColor Configuration::color_rx_background() const {
    return m_->color_rx_background_;
}
QColor Configuration::color_rx_foreground() const {
    return m_->color_rx_foreground_;
}
QColor Configuration::color_tx_foreground() const {
    return m_->color_tx_foreground_;
}
QColor Configuration::color_compose_background() const {
    return m_->color_compose_background_;
}
QColor Configuration::color_compose_foreground() const {
    return m_->color_compose_foreground_;
}
QColor Configuration::color_DXCC() const { return m_->color_DXCC_; }
QColor Configuration::color_NewCall() const { return m_->color_NewCall_; }
QFont Configuration::table_font() const { return m_->table_font_; }
QFont Configuration::text_font() const { return m_->font_; }
QFont Configuration::rx_text_font() const { return m_->rx_text_font_; }
QFont Configuration::tx_text_font() const { return m_->tx_text_font_; }
QFont Configuration::compose_text_font() const {
    return m_->compose_text_font_;
}
double Configuration::txDelay() const { return m_->txDelay_; }
bool Configuration::write_logs() const { return m_->write_logs_; }
bool Configuration::reset_activity() const { return m_->reset_activity_; }
bool Configuration::check_for_updates() const { return m_->check_for_updates_; }
bool Configuration::tx_qsy_allowed() const { return m_->tx_qsy_allowed_; }
bool Configuration::spot_to_reporting_networks() const {
    // rig must be open and working to spot externally
    return is_transceiver_online() && m_->spot_to_reporting_networks_;
}
void Configuration::set_spot_to_reporting_networks(bool spot) {
    if (m_->spot_to_reporting_networks_ != spot) {
        m_->spot_to_reporting_networks_ = spot;
        m_->write_settings();
    }
}

bool Configuration::spot_to_aprs() const {
    return spot_to_reporting_networks() && m_->spot_to_aprs_;
}

bool Configuration::transmit_directed() const { return m_->transmit_directed_; }
bool Configuration::autoreply_on_at_startup() const {
    // auto-reply cannot be on at startup if the callsign or grid is empty
    if (my_callsign().isEmpty() || my_grid().isEmpty()) {
        return false;
    }
    return m_->autoreply_on_at_startup_;
}
bool Configuration::autoreply_confirmation() const {
    return m_->autoreply_confirmation_;
}
bool Configuration::heartbeat_anywhere() const {
    return m_->heartbeat_anywhere_;
}
bool Configuration::heartbeat_qso_pause() const {
    return m_->heartbeat_qso_pause_;
}
bool Configuration::heartbeat_ack_snr() const {
#if JS8_HB_ACK_SNR_CONFIGURABLE
    return m_->heartbeat_ack_snr_;
#else
    return true;
#endif
}
bool Configuration::relay_off() const { return m_->relay_disabled_; }
bool Configuration::psk_reporter_tcpip() const {
    return m_->psk_reporter_tcpip_;
}
bool Configuration::monitor_off_at_startup() const {
    return m_->monitor_off_at_startup_;
}
bool Configuration::transmit_off_at_startup() const {
    return m_->transmit_off_at_startup_;
}
bool Configuration::monitor_last_used() const {
    return m_->rig_is_dummy_ || m_->monitor_last_used_;
}
bool Configuration::insert_blank() const { return m_->insert_blank_; }
bool Configuration::DXCC() const { return m_->DXCC_; }
bool Configuration::ppfx() const { return m_->ppfx_; }
bool Configuration::miles() const { return m_->miles_; }
bool Configuration::hold_ptt() const { return m_->hold_ptt_; }
bool Configuration::avoid_forced_identify() const {
    return m_->avoid_forced_identify_;
}
bool Configuration::avoid_allcall() const { return m_->avoid_allcall_; }
void Configuration::set_avoid_allcall(bool avoid) {
    if (m_->avoid_allcall_ != avoid) {
        m_->avoid_allcall_ = avoid;
        m_->write_settings();
    }
}
bool Configuration::spellcheck() const { return m_->spellcheck_; }
int Configuration::heartbeat() const { return m_->heartbeat_; }
int Configuration::watchdog() const { return m_->watchdog_; }
bool Configuration::TX_messages() const { return m_->TX_messages_; }
bool Configuration::split_mode() const { return m_->split_mode(); }
QString Configuration::opCall() const { return m_->opCall_; }
QString Configuration::ptt_command() const {
    return m_->ptt_command_.trimmed();
}
QString Configuration::aprs_server_name() const {
    return m_->aprs_server_name_;
}
auto Configuration::aprs_server_port() const -> port_type {
    return m_->aprs_server_port_;
}
QString Configuration::udp_server_name() const { return m_->udp_server_name_; }
auto Configuration::udp_server_port() const -> port_type {
    return m_->udp_server_port_;
}
QString Configuration::tcp_server_name() const { return m_->tcp_server_name_; }
auto Configuration::tcp_server_port() const -> port_type {
    return m_->tcp_server_port_;
}
bool Configuration::accept_udp_requests() const {
    return m_->accept_udp_requests_;
}
bool Configuration::accept_tcp_requests() const {
    return m_->accept_tcp_requests_;
}
// WSJT-X Protocol accessors
bool Configuration::wsjtx_protocol_enabled() const {
    return m_->wsjtx_protocol_enabled_;
}
QString Configuration::wsjtx_server_name() const {
    return m_->wsjtx_server_name_;
}
auto Configuration::wsjtx_server_port() const -> port_type {
    return m_->wsjtx_server_port_;
}
int Configuration::wsjtx_TTL() const { return m_->wsjtx_TTL_; }
bool Configuration::wsjtx_accept_requests() const {
    return m_->wsjtx_accept_requests_;
}
QStringList Configuration::wsjtx_interface_names() const {
    return m_->wsjtx_interface_names_;
}
QString Configuration::n3fjp_server_name() const {
    return m_->n3fjp_server_name_;
}
auto Configuration::n3fjp_server_port() const -> port_type {
    return m_->n3fjp_server_port_;
}
bool Configuration::broadcast_to_n3fjp() const {
    return m_->broadcast_to_n3fjp_;
}
QString Configuration::n1mm_server_name() const {
    return m_->n1mm_server_name_;
}
auto Configuration::n1mm_server_port() const -> port_type {
    return m_->n1mm_server_port_;
}
bool Configuration::broadcast_to_n1mm() const { return m_->broadcast_to_n1mm_; }
bool Configuration::udpEnabled() const { return m_->udpEnabled_; }
bool Configuration::tcpEnabled() const { return m_->tcpEnabled_; }
int Configuration::tcp_max_connections() const {
    return m_->tcpMaxConnections_;
}
Bands *Configuration::bands() { return &m_->bands_; }
Bands const *Configuration::bands() const { return &m_->bands_; }
StationList *Configuration::stations() { return &m_->stations_; }
StationList const *Configuration::stations() const { return &m_->stations_; }
bool Configuration::auto_switch_bands() const { return m_->auto_switch_bands_; }
IARURegions::Region Configuration::region() const { return m_->region_; }
FrequencyList_v2 *Configuration::frequencies() { return &m_->frequencies_; }
FrequencyList_v2 const *Configuration::frequencies() const {
    return &m_->frequencies_;
}
QStringListModel *Configuration::macros() { return &m_->macros_; }
QStringListModel const *Configuration::macros() const { return &m_->macros_; }
QDir Configuration::save_directory() const { return m_->save_directory_; }
QString Configuration::rig_name() const { return m_->rig_params_.rig_name; }
bool Configuration::pwrBandTxMemory() const { return m_->pwrBandTxMemory_; }
bool Configuration::pwrBandTuneMemory() const { return m_->pwrBandTuneMemory_; }

void Configuration::set_calibration(CalibrationParams params) {
    m_->calibration_ = params;
}

void Configuration::enable_calibration(bool on) {
    auto target_frequency =
        m_->remove_calibration(m_->cached_rig_state_.frequency());
    m_->frequency_calibration_disabled_ = !on;
    transceiver_frequency(target_frequency);
}

bool Configuration::is_transceiver_online() const { return m_->rig_active_; }

bool Configuration::is_dummy_rig() const { return m_->rig_is_dummy_; }

bool Configuration::transceiver_online() {
    qCDebug(configuration_js8)
        << "Configuration::transceiver_online: " << m_->cached_rig_state_;
    return m_->have_rig();
}

int Configuration::transceiver_resolution() const {
    return m_->rig_resolution_;
}

void Configuration::transceiver_offline() {
    qCDebug(configuration_js8)
        << "Configuration::transceiver_offline:" << m_->cached_rig_state_;
    m_->close_rig();
}

void Configuration::transceiver_frequency(Frequency f) {
    qCDebug(configuration_js8) << "Configuration::transceiver_frequency:" << f
                               << m_->cached_rig_state_;
    m_->transceiver_frequency(f);
}

void Configuration::transceiver_tx_frequency(Frequency f) {
    qCDebug(configuration_js8)
        << "Configuration::transceiver_tx_frequency:" << f
        << m_->cached_rig_state_;
    m_->transceiver_tx_frequency(f);
}

void Configuration::transceiver_mode(MODE mode) {
    qCDebug(configuration_js8)
        << "Configuration::transceiver_mode:" << mode << m_->cached_rig_state_;
    m_->transceiver_mode(mode);
}

void Configuration::transceiver_ptt(bool on) {
    qCDebug(configuration_js8)
        << "Configuration::transceiver_ptt:" << on << m_->cached_rig_state_;

    m_->transceiver_ptt(on);

    if (auto cmd = ptt_command(); !cmd.isEmpty()) {

        if (!cmd.contains("%1"))
            cmd.append(" %1");

        if (auto arguments =
                QProcess::splitCommand(cmd.arg(on ? "\"on\"" : "\"off\""));
            !arguments.isEmpty()) {
            QString program = arguments.takeFirst();
            QProcess::startDetached(program, arguments);
        }
    }
}

void Configuration::sync_transceiver(bool force_signal,
                                     bool enforce_mode_and_split) {
    qCDebug(configuration_js8)
        << "Configuration::sync_transceiver: force signal:" << force_signal
        << "enforce_mode_and_split:" << enforce_mode_and_split
        << m_->cached_rig_state_;

    m_->sync_transceiver(force_signal);
    if (!enforce_mode_and_split) {
        m_->transceiver_tx_frequency(0);
    }
}

void Configuration::invalidate_audio_input_device(QString /* error */) {
    m_->audio_input_device_ = QAudioDevice{};
}

void Configuration::invalidate_audio_output_device(QString /* error */) {
    m_->audio_output_device_ = QAudioDevice{};
}

void Configuration::invalidate_notification_audio_output_device(
    QString /* error */) {
    m_->notification_audio_output_device_ = QAudioDevice{};
}

bool Configuration::valid_n3fjp_info() const {
    // do very rudimentary checking on the n3fjp server name and port number.
    //
    auto server_name = m_->n3fjp_server_name_;
    auto port_number = m_->n3fjp_server_port_;
    return (!(server_name.trimmed().isEmpty() || port_number == 0));
}

bool Configuration::valid_n1mm_info() const {
    // do very rudimentary checking on the n1mm server name and port number.
    //
    auto server_name = m_->n1mm_server_name_;
    auto port_number = m_->n1mm_server_port_;
    return (!(server_name.trimmed().isEmpty() || port_number == 0));
}

QString Configuration::my_grid() const {
    auto grid = m_->my_grid_;
    if (m_->use_dynamic_info_ && m_->dynamic_grid_.size() >= 4) {
        grid = m_->dynamic_grid_;
    }
    return grid.trimmed();
}

QSet<QString> Configuration::my_groups() const {
    return QSet<QString>(m_->my_groups_.begin(), m_->my_groups_.end());
}

void Configuration::addGroup(QString const &group) {
    if (!Varicode::isGroupAllowed(group)) {
        JS8MessageBox::critical_message(
            m_->window(),
            QString("%1 is a group that cannot be joined").arg(group));
        return;
    }
    if (!Varicode::isCompoundCallsign(group)) {
        JS8MessageBox::critical_message(
            m_->window(), QString("%1 is not a valid group").arg(group));
        return;
    }
    QSet<QString> groups = my_groups();
    groups.insert(group.trimmed());
    m_->my_groups_ = groups.values();
    m_->write_settings();
}

void Configuration::removeGroup(QString const &group) {
    QSet<QString> groups = my_groups();
    groups.remove(group.trimmed());
    m_->my_groups_ = groups.values();
    m_->write_settings();
}

QSet<QString> Configuration::auto_whitelist() const {
    return QSet<QString>(m_->auto_whitelist_.begin(),
                         m_->auto_whitelist_.end());
}

QSet<QString> Configuration::auto_blacklist() const {
    return QSet<QString>(m_->auto_blacklist_.begin(),
                         m_->auto_blacklist_.end());
}

QSet<QString> Configuration::hb_blacklist() const {
    return QSet<QString>(m_->hb_blacklist_.begin(), m_->hb_blacklist_.end());
}

QSet<QString> Configuration::spot_blacklist() const {
    return QSet<QString>(m_->spot_blacklist_.begin(),
                         m_->spot_blacklist_.end());
}

QSet<QString> Configuration::primary_highlight_words() const {
    return QSet<QString>(m_->primary_highlight_words_.begin(),
                         m_->primary_highlight_words_.end());
}

QSet<QString> Configuration::secondary_highlight_words() const {
    return QSet<QString>(m_->secondary_highlight_words_.begin(),
                         m_->secondary_highlight_words_.end());
}

QString Configuration::eot() const { return m_->eot_; }

QString Configuration::mfi() const { return m_->mfi_; }

QString Configuration::my_info() const {
    auto info = m_->my_info_;
    if (m_->use_dynamic_info_ && !m_->dynamic_info_.isEmpty()) {
        info = m_->dynamic_info_;
    }

    return info.trimmed();
}

QString Configuration::my_status() const {
    auto status = m_->my_status_;
    if (m_->use_dynamic_info_ && !m_->dynamic_status_.isEmpty()) {
        status = m_->dynamic_status_;
    }

    return status.trimmed();
}

QString Configuration::hb_message() const { return m_->hb_.trimmed(); }

QString Configuration::cq_message() const {
    return m_->cq_.trimmed().replace("CQCQCQ", "CQ CQ CQ"); // deprecate legacy
}

QString Configuration::reply_message() const { return m_->reply_.trimmed(); }

int Configuration::callsign_aging() const { return m_->callsign_aging_; }

int Configuration::activity_aging() const { return m_->activity_aging_; }

void Configuration::set_dynamic_location(QString const &grid_descriptor) {
    m_->dynamic_grid_ = grid_descriptor.trimmed();
}

void Configuration::set_dynamic_station_info(QString const &info) {
    m_->dynamic_info_ = info.trimmed();
}

void Configuration::set_dynamic_station_status(QString const &status) {
    m_->dynamic_status_ = status.trimmed();
}

template <typename T> void setUppercase(T *t) {
    auto f = t->font();
    f.setCapitalization(QFont::AllUppercase);
    t->setFont(f);
}

QWidget *centeredCheckBox(QWidget *parent, QCheckBox **ppCheckbox) {
    auto w = new QWidget(parent);
    auto cb = new QCheckBox(parent);
    auto l = new QHBoxLayout(w);
    l->setContentsMargins(1, 1, 1, 1);
    l->setAlignment(Qt::AlignCenter);
    l->addWidget(cb);
    w->setLayout(l);
    if (ppCheckbox)
        *ppCheckbox = cb;
    return w;
}

Configuration::impl::impl(Configuration *self, QDir const &temp_directory,
                          QSettings *settings, QWidget *parent)
    : QDialog{parent}, self_{self}, transceiver_thread_{nullptr},
      ui_{new Ui::configuration_dialog}, settings_{settings},
      temp_dir_{temp_directory},
      writeable_data_dir_{QStandardPaths::writableLocation(
          QStandardPaths::AppLocalDataLocation)},
      restart_sound_input_device_{false}, restart_sound_output_device_{false},
      restart_notification_sound_output_device_{false}, frequencies_{&bands_},
      next_frequencies_{&bands_}, stations_{&bands_}, next_stations_{&bands_},
      frequency_dialog_{new FrequencyDialog{&regions_, &modes_, this}},
      station_dialog_{new StationDialog{&next_stations_, &bands_, this}},
      last_port_type_{TransceiverFactory::Capabilities::none},
      rig_is_dummy_{false}, rig_active_{false}, have_rig_{false},
      rig_changed_{false}, rig_resolution_{0},
      frequency_calibration_disabled_{false}, transceiver_command_number_{0} {
    ui_->setupUi(this);

    //  ui_->groupBox_6->setVisible(false);              //### Temporary ??? ###

    {
        // Find a suitable data file location
        if (!writeable_data_dir_.mkpath(".")) {
            JS8MessageBox::critical_message(
                this, tr("Failed to create data directory"),
                tr("path: \"%1\"").arg(writeable_data_dir_.absolutePath()));
            throw std::runtime_error{"Failed to create data directory"};
        }

        // Make sure the default save directory exists
        QString save_dir{"save"};
        default_save_directory_ = writeable_data_dir_;
        if (!default_save_directory_.mkpath(save_dir) ||
            !default_save_directory_.cd(save_dir)) {
            JS8MessageBox::critical_message(
                this, tr("Failed to create save directory"),
                tr("path: \"%1\%")
                    .arg(default_save_directory_.absoluteFilePath(save_dir)));
            throw std::runtime_error{"Failed to create save directory"};
        }

        // we now have a deafult save path that exists

        // make sure samples directory exists
        QString samples_dir{"samples"};
        if (!default_save_directory_.mkpath(samples_dir)) {
            JS8MessageBox::critical_message(
                this, tr("Failed to create samples directory"),
                tr("path: \"%1\"")
                    .arg(
                        default_save_directory_.absoluteFilePath(samples_dir)));
            throw std::runtime_error{"Failed to create samples directory"};
        }

        QString messages_dir{"messages"};
        if (!default_save_directory_.mkpath(messages_dir)) {
            JS8MessageBox::critical_message(
                this, tr("Failed to create messages directory"),
                tr("path: \"%1\"")
                    .arg(default_save_directory_.absoluteFilePath(
                        messages_dir)));
            throw std::runtime_error{"Failed to create messages directory"};
        }

        // copy in any new sample files to the sample directory
        QDir dest_dir{default_save_directory_};
        dest_dir.cd(samples_dir);

        QDir source_dir{":/" + samples_dir};
        source_dir.cd(save_dir);
        source_dir.cd(samples_dir);
        auto list = source_dir.entryInfoList(QStringList{{"*.wav"}},
                                             QDir::Files | QDir::Readable);
        Q_FOREACH (auto const &item, list) {
            if (!dest_dir.exists(item.fileName())) {
                QFile file{item.absoluteFilePath()};
                file.copy(dest_dir.absoluteFilePath(item.fileName()));
            }
        }
    }

    // this must be done after the default paths above are set
    read_settings();

    // set up dynamic loading of audio devices

    connect(
        ui_->sound_input_combo_box, &LazyFillComboBox::about_to_show_popup,
        [this]() {
            QGuiApplication::setOverrideCursor(QCursor{Qt::WaitCursor});

            load_audio_devices(QAudioDevice::Input, ui_->sound_input_combo_box,
                               &next_audio_input_device_);
            update_audio_channels(
                ui_->sound_input_combo_box, ui_->sound_input_channel_combo_box,
                ui_->sound_input_combo_box->currentIndex(), false);
            ui_->sound_input_channel_combo_box->setCurrentIndex(
                next_audio_input_channel_);

            QGuiApplication::restoreOverrideCursor();
        });

    connect(ui_->sound_output_combo_box, &LazyFillComboBox::about_to_show_popup,
            [this]() {
                QGuiApplication::setOverrideCursor(QCursor{Qt::WaitCursor});

                load_audio_devices(QAudioDevice::Output,
                                   ui_->sound_output_combo_box,
                                   &next_audio_output_device_);
                update_audio_channels(
                    ui_->sound_output_combo_box,
                    ui_->sound_output_channel_combo_box,
                    ui_->sound_output_combo_box->currentIndex(), true);
                ui_->sound_output_channel_combo_box->setCurrentIndex(
                    next_audio_output_channel_);

                QGuiApplication::restoreOverrideCursor();
            });

    connect(ui_->notification_sound_output_combo_box,
            &LazyFillComboBox::about_to_show_popup, [this]() {
                QGuiApplication::setOverrideCursor(QCursor{Qt::WaitCursor});

                load_audio_devices(QAudioDevice::Output,
                                   ui_->notification_sound_output_combo_box,
                                   &next_notification_audio_output_device_);

                QGuiApplication::restoreOverrideCursor();
            });

    //
    // validation
    //
    ui_->callsign_line_edit->setValidator(new CallsignValidator{this});
    ui_->grid_line_edit->setValidator(new Maidenhead::ExtendedValidator{this});

    // theme-aware indication for invalid callsign and grid fields
    attachRequiredIndicator(ui_->callsign_line_edit, "Callsign Required");
    attachRequiredIndicator(ui_->grid_line_edit, "Grid Required");

    ui_->add_macro_line_edit->setValidator(
        new QRegularExpressionValidator{message_alphabet, this});
    ui_->info_message_line_edit->setValidator(
        new QRegularExpressionValidator{message_alphabet, this});
    ui_->reply_message_line_edit->setValidator(
        new QRegularExpressionValidator{message_alphabet, this});
    ui_->cq_message_line_edit->setValidator(
        new QRegularExpressionValidator{message_alphabet, this});
    ui_->hb_message_line_edit->setValidator(
        new QRegularExpressionValidator{message_alphabet, this});
    ui_->status_message_line_edit->setValidator(
        new QRegularExpressionValidator{message_alphabet, this});
    ui_->groups_line_edit->setValidator(
        new QRegularExpressionValidator{message_alphabet, this});

    setUppercase(ui_->callsign_line_edit);
    setUppercase(ui_->grid_line_edit);
    setUppercase(ui_->add_macro_line_edit);
    setUppercase(ui_->info_message_line_edit);
    setUppercase(ui_->status_message_line_edit);
    setUppercase(ui_->reply_message_line_edit);
    setUppercase(ui_->cq_message_line_edit);
    setUppercase(ui_->hb_message_line_edit);
    setUppercase(ui_->groups_line_edit);
    setUppercase(ui_->auto_whitelist_line_edit);

    ui_->udp_server_port_spin_box->setMinimum(0);
    ui_->udp_server_port_spin_box->setMaximum(
        std::numeric_limits<port_type>::max());

    ui_->n3fjp_server_port_spin_box->setMinimum(0);
    ui_->n3fjp_server_port_spin_box->setMaximum(
        std::numeric_limits<port_type>::max());

    ui_->n1mm_server_port_spin_box->setMinimum(0);
    ui_->n1mm_server_port_spin_box->setMaximum(
        std::numeric_limits<port_type>::max());

    //
    // assign ids to radio buttons
    //
    ui_->CAT_data_bits_button_group->setId(
        ui_->CAT_default_bit_radio_button,
        TransceiverFactory::default_data_bits);
    ui_->CAT_data_bits_button_group->setId(ui_->CAT_7_bit_radio_button,
                                           TransceiverFactory::seven_data_bits);
    ui_->CAT_data_bits_button_group->setId(ui_->CAT_8_bit_radio_button,
                                           TransceiverFactory::eight_data_bits);

    ui_->CAT_stop_bits_button_group->setId(
        ui_->CAT_default_stop_bit_radio_button,
        TransceiverFactory::default_stop_bits);
    ui_->CAT_stop_bits_button_group->setId(ui_->CAT_one_stop_bit_radio_button,
                                           TransceiverFactory::one_stop_bit);
    ui_->CAT_stop_bits_button_group->setId(ui_->CAT_two_stop_bit_radio_button,
                                           TransceiverFactory::two_stop_bits);

    ui_->CAT_handshake_button_group->setId(
        ui_->CAT_handshake_default_radio_button,
        TransceiverFactory::handshake_default);
    ui_->CAT_handshake_button_group->setId(ui_->CAT_handshake_none_radio_button,
                                           TransceiverFactory::handshake_none);
    ui_->CAT_handshake_button_group->setId(
        ui_->CAT_handshake_xon_radio_button,
        TransceiverFactory::handshake_XonXoff);
    ui_->CAT_handshake_button_group->setId(
        ui_->CAT_handshake_hardware_radio_button,
        TransceiverFactory::handshake_hardware);

    ui_->PTT_method_button_group->setId(ui_->PTT_VOX_radio_button,
                                        TransceiverFactory::PTT_method_VOX);
    ui_->PTT_method_button_group->setId(ui_->PTT_CAT_radio_button,
                                        TransceiverFactory::PTT_method_CAT);
    ui_->PTT_method_button_group->setId(ui_->PTT_DTR_radio_button,
                                        TransceiverFactory::PTT_method_DTR);
    ui_->PTT_method_button_group->setId(ui_->PTT_RTS_radio_button,
                                        TransceiverFactory::PTT_method_RTS);

    ui_->TX_audio_source_button_group->setId(
        ui_->TX_source_mic_radio_button,
        TransceiverFactory::TX_audio_source_front);
    ui_->TX_audio_source_button_group->setId(
        ui_->TX_source_data_radio_button,
        TransceiverFactory::TX_audio_source_rear);

    ui_->TX_mode_button_group->setId(ui_->mode_none_radio_button,
                                     data_mode_none);
    ui_->TX_mode_button_group->setId(ui_->mode_USB_radio_button, data_mode_USB);
    ui_->TX_mode_button_group->setId(ui_->mode_data_radio_button,
                                     data_mode_data);

    ui_->split_mode_button_group->setId(ui_->split_none_radio_button,
                                        TransceiverFactory::split_mode_none);
    ui_->split_mode_button_group->setId(ui_->split_rig_radio_button,
                                        TransceiverFactory::split_mode_rig);
    ui_->split_mode_button_group->setId(ui_->split_emulate_radio_button,
                                        TransceiverFactory::split_mode_emulate);

    //
    // setup PTT port combo box drop down content
    //
    fill_port_combo_box(ui_->PTT_port_combo_box);
    ui_->PTT_port_combo_box->addItem("CAT");

    //
    // setup hooks to keep audio channels aligned with devices
    //

    connect(
        ui_->sound_input_combo_box,
        static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged),
        [this](auto const index) {
            update_audio_channels(ui_->sound_input_combo_box,
                                  ui_->sound_input_channel_combo_box, index,
                                  false);
        });

    connect(
        ui_->sound_output_combo_box,
        static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged),
        [this](auto const index) {
            update_audio_channels(ui_->sound_output_combo_box,
                                  ui_->sound_output_channel_combo_box, index,
                                  true);
        });

    //
    // setup macros list view
    //
    ui_->macros_list_view->setModel(&next_macros_);
    ui_->macros_list_view->setItemDelegate(new MessageItemDelegate{this});

    macro_delete_action_ = new QAction{tr("&Delete"), ui_->macros_list_view};
    ui_->macros_list_view->insertAction(nullptr, macro_delete_action_);
    connect(macro_delete_action_, &QAction::triggered, this,
            &Configuration::impl::delete_macro);

    // setup IARU region combo box model
    ui_->region_combo_box->setModel(&regions_);

    //
    // setup working frequencies table model & view
    //
    frequencies_.sort(FrequencyList_v2::frequency_column);

    ui_->frequencies_table_view->setModel(&next_frequencies_);
    ui_->frequencies_table_view->sortByColumn(
        FrequencyList_v2::frequency_column, Qt::AscendingOrder);
    ui_->frequencies_table_view->setColumnHidden(
        FrequencyList_v2::frequency_mhz_column, true);

    // delegates
    auto frequencies_item_delegate = new QStyledItemDelegate{this};
    frequencies_item_delegate->setItemEditorFactory(item_editor_factory());
    ui_->frequencies_table_view->setItemDelegate(frequencies_item_delegate);
    ui_->frequencies_table_view->setItemDelegateForColumn(
        FrequencyList_v2::region_column,
        new ForeignKeyDelegate{&regions_, 0, this});
    ui_->frequencies_table_view->setItemDelegateForColumn(
        FrequencyList_v2::mode_column,
        new ForeignKeyDelegate{&modes_, 0, this});

    // actions
    frequency_delete_action_ =
        new QAction{tr("&Delete"), ui_->frequencies_table_view};
    ui_->frequencies_table_view->insertAction(nullptr,
                                              frequency_delete_action_);
    connect(frequency_delete_action_, &QAction::triggered, this,
            &Configuration::impl::delete_frequencies);

    frequency_insert_action_ =
        new QAction{tr("&Insert ..."), ui_->frequencies_table_view};
    ui_->frequencies_table_view->insertAction(nullptr,
                                              frequency_insert_action_);
    connect(frequency_insert_action_, &QAction::triggered, this,
            &Configuration::impl::insert_frequency);

    load_frequencies_action_ =
        new QAction{tr("&Load ..."), ui_->frequencies_table_view};
    ui_->frequencies_table_view->insertAction(nullptr,
                                              load_frequencies_action_);
    connect(load_frequencies_action_, &QAction::triggered, this,
            &Configuration::impl::load_frequencies);

    save_frequencies_action_ =
        new QAction{tr("&Save as ..."), ui_->frequencies_table_view};
    ui_->frequencies_table_view->insertAction(nullptr,
                                              save_frequencies_action_);
    connect(save_frequencies_action_, &QAction::triggered, this,
            &Configuration::impl::save_frequencies);

    merge_frequencies_action_ =
        new QAction{tr("&Merge ..."), ui_->frequencies_table_view};
    ui_->frequencies_table_view->insertAction(nullptr,
                                              merge_frequencies_action_);
    connect(merge_frequencies_action_, &QAction::triggered, this,
            &Configuration::impl::merge_frequencies);

    reset_frequencies_action_ =
        new QAction{tr("&Reset"), ui_->frequencies_table_view};
    ui_->frequencies_table_view->insertAction(nullptr,
                                              reset_frequencies_action_);
    connect(reset_frequencies_action_, &QAction::triggered, this,
            &Configuration::impl::reset_frequencies);

    //
    // setup stations table model & view
    //
    stations_.sort(StationList::switch_at_column);

    ui_->stations_table_view->setModel(&next_stations_);
    ui_->stations_table_view->sortByColumn(StationList::switch_at_column,
                                           Qt::AscendingOrder);
    connect(ui_->auto_switch_bands_check_box, &QCheckBox::clicked,
            ui_->stations_table_view, &QTableView::setEnabled);

    // Immediately emit the auto switch band change signal to kick the scheduler
    // without having to potentially save twice
    connect(ui_->auto_switch_bands_check_box, &QCheckBox::clicked, this,
            [this](bool auto_switch_bands) {
                Q_EMIT self_->auto_switch_bands_changed(auto_switch_bands);
            });

    // delegates
    auto stations_item_delegate = new QStyledItemDelegate{this};
    stations_item_delegate->setItemEditorFactory(item_editor_factory());
    ui_->stations_table_view->setItemDelegate(stations_item_delegate);
    // ui_->stations_table_view->setItemDelegateForColumn
    // (StationList::band_column, new ForeignKeyDelegate {&bands_,
    // &next_stations_, 0, StationList::band_column, this});

    ui_->stations_table_view->resizeColumnToContents(StationList::band_column);
    ui_->stations_table_view->resizeColumnToContents(
        StationList::frequency_column);
    ui_->stations_table_view->resizeColumnToContents(
        StationList::switch_at_column);
    ui_->stations_table_view->resizeColumnToContents(
        StationList::switch_until_column);
    ui_->stations_table_view->horizontalHeader()->setSectionResizeMode(
        QHeaderView::ResizeToContents);

    // actions
    station_hop_action_ =
        new QAction{tr("&Switch to Frequency Now"), ui_->stations_table_view};
    ui_->stations_table_view->insertAction(nullptr, station_hop_action_);
    connect(station_hop_action_, &QAction::triggered, this,
            &Configuration::impl::hop_to_station);

    station_delete_action_ =
        new QAction{tr("&Delete"), ui_->stations_table_view};
    ui_->stations_table_view->insertAction(nullptr, station_delete_action_);
    connect(station_delete_action_, &QAction::triggered, this,
            &Configuration::impl::delete_stations);

    station_insert_action_ =
        new QAction{tr("&Insert ..."), ui_->stations_table_view};
    ui_->stations_table_view->insertAction(nullptr, station_insert_action_);
    connect(station_insert_action_, &QAction::triggered, this,
            &Configuration::impl::insert_station);

    // Connect to selection changes and update action states
    auto selection_model = ui_->stations_table_view->selectionModel();
    connect(selection_model, &QItemSelectionModel::selectionChanged, this,
            [this]() {
                auto selected_rows =
                    ui_->stations_table_view->selectionModel()->selectedRows();
                bool has_selection = !selected_rows.isEmpty();
                bool has_single_selection = (selected_rows.size() == 1);

                station_delete_action_->setVisible(has_selection);
                station_hop_action_->setVisible(has_single_selection);
            });

    // Initial state
    station_hop_action_->setVisible(false);
    station_delete_action_->setVisible(false);

    enumerate_rigs();
    initialize_models();

    audio_input_device_ = next_audio_input_device_;
    audio_input_channel_ = next_audio_input_channel_;
    audio_output_device_ = next_audio_output_device_;
    audio_output_channel_ = next_audio_output_channel_;
    notification_audio_output_device_ = next_notification_audio_output_device_;

    transceiver_thread_ = new QThread{this};
    transceiver_thread_->start();
}

Configuration::impl::~impl() {
    transceiver_thread_->quit();
    transceiver_thread_->wait();
    write_settings();
}

void Configuration::impl::initialize_models() {
    next_audio_input_device_ = audio_input_device_;
    next_audio_input_channel_ = audio_input_channel_;
    next_audio_output_device_ = audio_output_device_;
    next_audio_output_channel_ = audio_output_channel_;
    notification_audio_output_device_ = next_notification_audio_output_device_;
    restart_sound_input_device_ = false;
    restart_sound_output_device_ = false;
    restart_notification_sound_output_device_ = false;
    {
        SettingsGroup g{settings_, "Configuration"};
        find_audio_devices();
    }
    ui_->auto_switch_bands_check_box->setChecked(auto_switch_bands_);
    ui_->callsign_line_edit->setText(my_callsign_);
    ui_->grid_line_edit->setText(my_grid_.toUpper());
    ui_->callsign_aging_spin_box->setValue(callsign_aging_);
    ui_->activity_aging_spin_box->setValue(activity_aging_);
    ui_->groups_line_edit->setText(my_groups_.join(", "));
    ui_->auto_whitelist_line_edit->setText(auto_whitelist_.join(", "));
    ui_->auto_blacklist_line_edit->setText(auto_blacklist_.join(", "));
    ui_->hb_blacklist_line_edit->setText(hb_blacklist_.join(", "));
    ui_->spot_blacklist_line_edit->setText(spot_blacklist_.join(", "));
    ui_->primaryHighlightLineEdit->setText(primary_highlight_words_.join(", "));
    ui_->secondaryHighlightLineEdit->setText(
        secondary_highlight_words_.join(", "));
    ui_->eot_line_edit->setText(eot_);
    ui_->mfi_line_edit->setText(mfi_);
    ui_->info_message_line_edit->setText(my_info_.toUpper());
    ui_->status_message_line_edit->setText(my_status_.toUpper());
    ui_->cq_message_line_edit->setText(
        cq_.toUpper().replace("CQCQCQ", "CQ CQ CQ"));
    ui_->hb_message_line_edit->setText(hb_.toUpper());
    ui_->reply_message_line_edit->setText(reply_.toUpper());
    ui_->use_dynamic_grid->setChecked(use_dynamic_info_);

    ui_->tableForegroundLabel->setStyleSheet(
        QString("background: %1; color: %2")
            .arg(next_color_table_background_.name())
            .arg(next_color_table_foreground_.name()));
    ui_->tableBackgroundLabel->setStyleSheet(
        QString("background: %1; color: %2")
            .arg(next_color_table_background_.name())
            .arg(next_color_table_foreground_.name()));
    ui_->tableSelectionBackgroundLabel->setStyleSheet(
        QString("background: %1; color: %2")
            .arg(next_color_table_highlight_.name())
            .arg(next_color_table_foreground_.name()));
    ui_->primaryHighlightLabel->setStyleSheet(
        QString("background: %1; color: %2")
            .arg(next_color_primary_highlight_.name())
            .arg(next_color_table_foreground_.name()));
    ui_->secondaryHighlightLabel->setStyleSheet(
        QString("background: %1; color: %2")
            .arg(next_color_secondary_highlight_.name())
            .arg(next_color_table_foreground_.name()));
    ui_->cqMessagesLabel->setStyleSheet(
        QString("background: %1; color: %2")
            .arg(next_color_cq_.name())
            .arg(next_color_table_foreground_.name()));
    ui_->labMyCall->setStyleSheet(
        QString("background: %1; color: %2")
            .arg(next_color_mycall_.name())
            .arg(next_color_table_foreground_.name()));

    ui_->rxLabel->setStyleSheet(QString("background: %1; color: %2")
                                    .arg(color_rx_background_.name())
                                    .arg(color_rx_foreground_.name()));
    ui_->rxForegroundLabel->setStyleSheet(
        QString("background: %1; color: %2")
            .arg(color_rx_background_.name())
            .arg(color_rx_foreground_.name()));
    ui_->txForegroundLabel->setStyleSheet(
        QString("background: %1; color: %2")
            .arg(color_rx_background_.name())
            .arg(color_tx_foreground_.name()));
    ui_->composeLabel->setStyleSheet(
        QString("background: %1; color: %2")
            .arg(color_compose_background_.name())
            .arg(color_compose_foreground_.name()));

    ui_->sbTxDelay->setValue(txDelay_);
    ui_->PTT_method_button_group->button(rig_params_.ptt_type)
        ->setChecked(true);
    ui_->save_path_display_label->setText(save_directory_.absolutePath());
    ui_->write_logs_check_box->setChecked(write_logs_);
    ui_->reset_activity_check_box->setChecked(reset_activity_);
    ui_->checkForUpdates_checkBox->setChecked(check_for_updates_);
    ui_->tx_qsy_check_box->setChecked(tx_qsy_allowed_);
    ui_->psk_reporter_check_box->setChecked(spot_to_reporting_networks_);
    ui_->enable_aprs_spotting_check_box->setChecked(spot_to_aprs_);
    ui_->transmit_directed_check_box->setChecked(transmit_directed_);
    ui_->autoreply_on_check_box->setChecked(autoreply_on_at_startup_);
    ui_->autoreply_confirmation_check_box->setChecked(autoreply_confirmation_);
    ui_->heartbeat_anywhere_check_box->setChecked(heartbeat_anywhere_);
    ui_->heartbeat_qso_pause_check_box->setChecked(heartbeat_qso_pause_);
    ui_->heartbeat_ack_snr_check_box->setChecked(heartbeat_ack_snr_);
    ui_->relay_disabled_check_box->setChecked(relay_disabled_);
    ui_->psk_reporter_tcpip_check_box->setChecked(psk_reporter_tcpip_);
    ui_->monitor_off_check_box->setChecked(monitor_off_at_startup_);
    ui_->transmit_off_check_box->setChecked(transmit_off_at_startup_);
    ui_->monitor_last_used_check_box->setChecked(monitor_last_used_);
    ui_->stations_table_view->setEnabled(
        ui_->auto_switch_bands_check_box->isChecked());
    ui_->miles_check_box->setChecked(miles_);
    ui_->hold_ptt_check_box->setChecked(hold_ptt_);
    ui_->avoid_forced_identify_check_box->setChecked(avoid_forced_identify_);
    ui_->avoid_allcall_check_box->setChecked(avoid_allcall_);
    ui_->spellcheck_check_box->setChecked(spellcheck_);
    ui_->heartbeat_spin_box->setValue(heartbeat_);
    ui_->tx_watchdog_spin_box->setValue(watchdog_);
    ui_->rig_combo_box->setCurrentText(rig_params_.rig_name);
    ui_->TX_mode_button_group->button(data_mode_)->setChecked(true);
    ui_->split_mode_button_group->button(rig_params_.split_mode)
        ->setChecked(true);
    ui_->CAT_serial_baud_combo_box->setCurrentText(
        QString::number(rig_params_.baud));
    ui_->CAT_data_bits_button_group->button(rig_params_.data_bits)
        ->setChecked(true);
    ui_->CAT_stop_bits_button_group->button(rig_params_.stop_bits)
        ->setChecked(true);
    ui_->CAT_handshake_button_group->button(rig_params_.handshake)
        ->setChecked(true);
    ui_->checkBoxPwrBandTxMemory->setChecked(pwrBandTxMemory_);
    ui_->checkBoxPwrBandTuneMemory->setChecked(pwrBandTuneMemory_);
    if (rig_params_.force_dtr) {
        ui_->force_DTR_combo_box->setCurrentIndex(rig_params_.dtr_high ? 1 : 2);
    } else {
        ui_->force_DTR_combo_box->setCurrentIndex(0);
    }
    if (rig_params_.force_rts) {
        ui_->force_RTS_combo_box->setCurrentIndex(rig_params_.rts_high ? 1 : 2);
    } else {
        ui_->force_RTS_combo_box->setCurrentIndex(0);
    }
    ui_->TX_audio_source_button_group->button(rig_params_.audio_source)
        ->setChecked(true);
    ui_->CAT_poll_interval_spin_box->setValue(rig_params_.poll_interval);
    ui_->opCallEntry->setText(opCall_);
    ui_->ptt_command_line_edit->setText(ptt_command_);
    ui_->aprs_server_line_edit->setText(aprs_server_name_);
    ui_->aprs_server_port_spin_box->setValue(aprs_server_port_);
    ui_->udp_server_line_edit->setText(udp_server_name_);
    ui_->udp_server_port_spin_box->setValue(udp_server_port_);
    ui_->tcp_server_line_edit->setText(tcp_server_name_);
    ui_->tcp_server_port_spin_box->setValue(tcp_server_port_);
    ui_->accept_udp_requests_check_box->setChecked(accept_udp_requests_);
    ui_->accept_tcp_requests_check_box->setChecked(accept_tcp_requests_);
    ui_->n3fjp_server_name_line_edit->setText(n3fjp_server_name_);
    ui_->n3fjp_server_port_spin_box->setValue(n3fjp_server_port_);
    ui_->enable_n3fjp_broadcast_check_box->setChecked(broadcast_to_n3fjp_);
    ui_->n1mm_server_name_line_edit->setText(n1mm_server_name_);
    ui_->n1mm_server_port_spin_box->setValue(n1mm_server_port_);
    ui_->enable_n1mm_broadcast_check_box->setChecked(broadcast_to_n1mm_);
    ui_->tcpEnable->setChecked(tcpEnabled_);
    ui_->udpEnable->setChecked(udpEnabled_);
    ui_->tcp_max_connections_spin_box->setValue(tcpMaxConnections_);
    // WSJT-X Protocol settings
    ui_->wsjtx_enable_check_box->setChecked(wsjtx_protocol_enabled_);
    ui_->wsjtx_server_line_edit->setText(wsjtx_server_name_);
    ui_->wsjtx_server_port_spin_box->setValue(wsjtx_server_port_);
    ui_->wsjtx_TTL_spin_box->setValue(wsjtx_TTL_);
    ui_->wsjtx_accept_requests_check_box->setChecked(wsjtx_accept_requests_);
    load_network_interfaces(ui_->wsjtx_interfaces_combo_box,
                            wsjtx_interface_names_);
    ui_->calibration_intercept_spin_box->setValue(calibration_.intercept);
    ui_->calibration_slope_ppm_spin_box->setValue(calibration_.slope_ppm);

    if (rig_params_.ptt_port.isEmpty()) {
        if (ui_->PTT_port_combo_box->count()) {
            ui_->PTT_port_combo_box->setCurrentText(
                ui_->PTT_port_combo_box->itemText(0));
        }
    } else {
        ui_->PTT_port_combo_box->setCurrentText(rig_params_.ptt_port);
    }

    ui_->region_combo_box->setCurrentIndex(region_);

    next_macros_.setStringList(macros_.stringList());
    next_frequencies_.frequency_list(frequencies_.frequency_list());
    next_stations_.station_list(stations_.station_list());

    //
    // setup notifications table view
    //
    ui_->notifications_check_box->setChecked(enable_notifications_);
    on_notifications_check_box_toggled(enable_notifications_);

    QList<QPair<QString, QString>> notifyRows = {
        {"cq", "CQ Message Received"},
        {"hb", "HB Message Received"},
        {"ack", "ACK Message Received"},
        {"directed", "Directed Message Received"},
        {"inbox", "Inbox Message Received"},
        {"call_new", "New Callsign Heard"},
        {"call_old", "Worked Callsign Heard"},
    };

    int i = 0;
    auto table = ui_->notifications_table_widget;
    for (int i = ui_->notifications_table_widget->rowCount() - 1; i >= 0; i--) {
        ui_->notifications_table_widget->removeRow(i);
    }
    auto header = table->horizontalHeader();
    header->setStretchLastSection(false);
    header->setSectionResizeMode(0, QHeaderView::ResizeToContents);
    header->setSectionResizeMode(1, QHeaderView::ResizeToContents);
    header->setSectionResizeMode(2, QHeaderView::Stretch);
    header->setSectionResizeMode(3, QHeaderView::ResizeToContents);
    foreach (auto pair, notifyRows) {
        QString key = pair.first;
        QString value = pair.second;
        bool enabled = notifications_enabled_.value(key, false);
        QString path = notifications_paths_.value(key, "");

        QCheckBox *enabledCheckbox;
        auto enabledWidget = centeredCheckBox(this, &enabledCheckbox);
        enabledWidget->setMinimumWidth(100);
        if (enabledCheckbox) {
            enabledCheckbox->setObjectName("enabledCheckbox");
            enabledCheckbox->setChecked(enabled);
        }

        auto expandingPolicy =
            QSizePolicy(QSizePolicy::Expanding, QSizePolicy::Preferred);
        expandingPolicy.setHorizontalStretch(1);

        QLabel *pathLabel = new QLabel(this);
        pathLabel->setText(path);
        pathLabel->setSizePolicy(expandingPolicy);

        auto minimumPolicy =
            QSizePolicy(QSizePolicy::Minimum, QSizePolicy::Preferred);
        minimumPolicy.setHorizontalStretch(0);

        QWidget *buttonWidget = new QWidget(this);
        buttonWidget->setSizePolicy(minimumPolicy);

        QHBoxLayout *buttonLayout = new QHBoxLayout(buttonWidget);
        buttonLayout->setStretch(0, 0);
        buttonLayout->setStretch(1, 0);
        buttonLayout->setSpacing(3);
        buttonLayout->setContentsMargins(3, 1, 3, 1);
        buttonWidget->setLayout(buttonLayout);

        QPushButton *selectFilePushButton = new QPushButton("Select", this);
        selectFilePushButton->setSizePolicy(minimumPolicy);
        buttonLayout->addWidget(selectFilePushButton);

        connect(selectFilePushButton, &QPushButton::pressed, this,
                [this, pathLabel]() {
                    auto dir = QStandardPaths::standardLocations(
                        QStandardPaths::MusicLocation);
                    auto path = QFileDialog::getOpenFileName(
                        this, "Audio Notification", dir.first(),
                        "Wave Files (*.wav);;All files (*.*)");
                    if (!path.isEmpty()) {
                        pathLabel->setText(path);
                    }
                });

        QPushButton *testPushButton = new QPushButton("Test", this);
        testPushButton->setSizePolicy(minimumPolicy);
        buttonLayout->addWidget(testPushButton);

        connect(testPushButton, &QPushButton::pressed, this,
                [this, key, pathLabel]() {
                    // hack for testing...
                    notifications_enabled_[key] = true;
                    notifications_paths_[key] = pathLabel->text();
                    emit this->self_->test_notify(key);
                });

        QPushButton *clearPushButton = new QPushButton("Clear", this);
        clearPushButton->setSizePolicy(minimumPolicy);
        buttonLayout->addWidget(clearPushButton);

        connect(clearPushButton, &QPushButton::pressed, this,
                [pathLabel, enabledCheckbox]() {
                    pathLabel->clear();
                    enabledCheckbox->setChecked(false);
                });

        // row config
        int col = 0;
        table->insertRow(i);

        //
        auto eventLabelItem = new QTableWidgetItem(value);
        eventLabelItem->setData(Qt::UserRole, QVariant(key));
        table->setItem(i, col++, eventLabelItem);

        table->setCellWidget(i, col++, enabledWidget);

        table->setCellWidget(i, col++, pathLabel);

        table->setCellWidget(i, col++, buttonWidget);
        i++;
    }

    table->resizeRowsToContents();
    table->resizeColumnsToContents();

    set_rig_invariants();
}

void Configuration::impl::done(int r) {
    // do this here since window is still on screen at this point
    SettingsGroup g{settings_, "Configuration"};
    settings_->setValue("WindowGeometry", saveGeometry());

    QDialog::done(r);
}

void Configuration::impl::read_settings() {
    SettingsGroup g{settings_, "Configuration"};
    setMinimumSize(800, 400);
    restoreGeometry(settings_->value("WindowGeometry").toByteArray());
    setMinimumSize(800, 400);

    auto_switch_bands_ = settings_->value("AutoSwitchBands", false).toBool();
    my_callsign_ = settings_->value("MyCall", QString{}).toString();
    my_grid_ = settings_->value("MyGrid", QString{}).toString();
    my_groups_ = settings_->value("MyGroups", QStringList{}).toStringList();
    auto_whitelist_ =
        settings_->value("AutoWhitelist", QStringList{}).toStringList();
    auto_blacklist_ =
        settings_->value("AutoBlacklist", QStringList{}).toStringList();
    hb_blacklist_ =
        settings_->value("HBBlacklist", QStringList{}).toStringList();
    spot_blacklist_ =
        settings_->value("SpotBlacklist", QStringList{}).toStringList();
    primary_highlight_words_ =
        settings_->value("PrimaryHighlightWords", QStringList{}).toStringList();
    secondary_highlight_words_ =
        settings_->value("SecondaryHighlightWords", QStringList{})
            .toStringList();
    callsign_aging_ = settings_->value("CallsignAging", 0).toInt();
    activity_aging_ = settings_->value("ActivityAging", 2).toInt();
    eot_ = settings_->value("EOTCharacter", QString{"\u2662"}).toString();
    mfi_ = settings_->value("MFICharacter", QString{"\u2026\u2026"}).toString();
    my_info_ = settings_->value("MyInfo", QString{}).toString();
    my_status_ =
        settings_
            ->value("MyStatus", QString{"IDLE <MYIDLE> VERSION <MYVERSION>"})
            .toString();
    hb_ = settings_->value("HBMessage", QString{"HB <MYGRID4>"}).toString();
    cq_ =
        settings_->value("CQMessage", QString{"CQ CQ CQ <MYGRID4>"}).toString();
    reply_ = settings_->value("Reply", QString{"HW CPY?"}).toString();
    next_color_cq_ = color_cq_ =
        settings_->value("colorCQ", "#66ff66").toString();
    next_color_primary_highlight_ = color_primary_highlight_ =
        settings_->value("colorPrimary", "#f1c40f").toString();
    next_color_secondary_highlight_ = color_secondary_highlight_ =
        settings_->value("colorSecondary", "#ffff66").toString();
    next_color_mycall_ = color_mycall_ =
        settings_->value("colorMyCall", "#ff6666").toString();
    next_color_rx_background_ = color_rx_background_ =
        settings_->value("color_rx_background", "#ffeaa7").toString();
    next_color_rx_foreground_ = color_rx_foreground_ =
        settings_->value("color_rx_foreground", "#000000").toString();
    next_color_compose_background_ = color_compose_background_ =
        settings_->value("color_compose_background", "#ffffff").toString();
    next_color_compose_foreground_ = color_compose_foreground_ =
        settings_->value("color_compose_foreground", "#000000").toString();
    next_color_tx_foreground_ = color_tx_foreground_ =
        settings_->value("color_tx_foreground", "#ff0000").toString();
    next_color_DXCC_ = color_DXCC_ =
        settings_->value("colorDXCC", "#ff00ff").toString();
    next_color_NewCall_ = color_NewCall_ =
        settings_->value("colorNewCall", "#ffaaff").toString();

    next_color_table_background_ = color_table_background_ =
        settings_->value("colorTableBackground", "#ffffff").toString();
    next_color_table_highlight_ = color_table_highlight_ =
        settings_->value("colorTableHighlight", "#3498db").toString();
    next_color_table_foreground_ = color_table_foreground_ =
        settings_->value("colorTableForeground", "#000000").toString();

    if (next_font_.fromString(
            settings_->value("Font", QGuiApplication::font().toString())
                .toString()) &&
        next_font_ != font_) {
        font_ = next_font_;
        Q_EMIT self_->gui_text_font_changed(font_);
    } else {
        next_font_ = font_;
    }
    ui_->font_push_button->setText(QString("Application Font (%1 %2)")
                                       .arg(next_font_.family())
                                       .arg(next_font_.pointSize()));

    if (next_tx_text_font_.fromString(
            settings_->value("TXTextFont", QGuiApplication::font().toString())
                .toString()) &&
        next_tx_text_font_ != tx_text_font_) {
        tx_text_font_ = next_tx_text_font_;
        Q_EMIT self_->tx_text_font_changed(tx_text_font_);
    } else {
        next_tx_text_font_ = tx_text_font_;
    }

    ui_->txFontButton->setText(QString("Font (%1 %2)")
                                   .arg(next_tx_text_font_.family())
                                   .arg(next_tx_text_font_.pointSize()));

    if (next_rx_text_font_.fromString(
            settings_->value("RXTextFont", QGuiApplication::font().toString())
                .toString()) &&
        next_rx_text_font_ != rx_text_font_) {
        rx_text_font_ = next_rx_text_font_;
        Q_EMIT self_->rx_text_font_changed(rx_text_font_);
    } else {
        next_rx_text_font_ = rx_text_font_;
    }

    ui_->rxFontButton->setText(QString("Font (%1 %2)")
                                   .arg(next_rx_text_font_.family())
                                   .arg(next_rx_text_font_.pointSize()));

    if (next_compose_text_font_.fromString(
            settings_
                ->value("composeTextFont", QGuiApplication::font().toString())
                .toString()) &&
        next_compose_text_font_ != compose_text_font_) {
        compose_text_font_ = next_compose_text_font_;
        Q_EMIT self_->compose_text_font_changed(compose_text_font_);
    } else {
        next_compose_text_font_ = compose_text_font_;
    }
    ui_->composeFontButton->setText(
        QString("Font (%1 %2)")
            .arg(next_compose_text_font_.family())
            .arg(next_compose_text_font_.pointSize()));

    if (next_table_font_.fromString(
            settings_->value("tableFont", QGuiApplication::font().toString())
                .toString()) &&
        next_table_font_ != table_font_) {
        table_font_ = next_table_font_;
        Q_EMIT self_->table_font_changed(table_font_);
    } else {
        next_table_font_ = table_font_;
    }
    ui_->tableFontButton->setText(QString("Font (%1 %2)")
                                      .arg(next_table_font_.family())
                                      .arg(next_table_font_.pointSize()));

    txDelay_ = settings_->value("TxDelay", 0.2).toDouble();
    save_directory_.setPath(
        settings_->value("SaveDir", default_save_directory_.absolutePath())
            .toString());

    // retrieve audio channel info
    audio_input_channel_ = AudioDevice::fromString(
        settings_->value("AudioInputChannel", "Mono").toString());
    audio_output_channel_ = AudioDevice::fromString(
        settings_->value("AudioOutputChannel", "Mono").toString());

    transmit_directed_ = settings_->value("TransmitDirected", true).toBool();
    autoreply_on_at_startup_ =
        settings_->value("AutoreplyOnAtStartup", true).toBool();
    autoreply_confirmation_ =
        settings_->value("AutoreplyConfirmation", true).toBool();
    heartbeat_anywhere_ = settings_->value("BeaconAnywhere", false).toBool();
    heartbeat_qso_pause_ = settings_->value("HeartbeatQSOPause", true).toBool();
    heartbeat_ack_snr_ = settings_->value("HeartbeatAckSNR", false).toBool();
    relay_disabled_ = settings_->value("RelayOFF", false).toBool();
    monitor_off_at_startup_ = settings_->value("MonitorOFF", false).toBool();
    transmit_off_at_startup_ = settings_->value("TransmitOFF", false).toBool();
    monitor_last_used_ = settings_->value("MonitorLastUsed", false).toBool();
    spot_to_reporting_networks_ =
        settings_->value("PSKReporter", true).toBool();
    spot_to_aprs_ = settings_->value("SpotToAPRS", true).toBool();
    write_logs_ = settings_->value("WriteLogs", true).toBool();
    reset_activity_ = settings_->value("ResetActivity", false).toBool();
    check_for_updates_ = settings_->value("CheckForUpdates", true).toBool();
    psk_reporter_tcpip_ = settings_->value("PSKReporterTCPIP", false).toBool();
    tx_qsy_allowed_ = settings_->value("TxQSYAllowed", false).toBool();
    use_dynamic_info_ = settings_->value("AutoGrid", false).toBool();

    auto loadedMacros =
        settings_->value("Macros", QStringList{"TNX 73 GL"}).toStringList();

    macros_.setStringList(loadedMacros);

    region_ = settings_->value("Region", QVariant::fromValue(IARURegions::ALL))
                  .value<IARURegions::Region>();

    if (settings_->contains(versionedFrequenciesSettingsKey)) {
        auto const &v = settings_->value(versionedFrequenciesSettingsKey);
        if (v.isValid()) {
            frequencies_.frequency_list(
                v.value<FrequencyList_v2::FrequencyItems>());
        } else {
            frequencies_.reset_to_defaults();
        }
    } else {
        frequencies_.reset_to_defaults();
    }

    stations_.station_list(
        settings_->value("stations").value<StationList::Stations>());

    rig_params_.rig_name =
        settings_->value("Rig", TransceiverFactory::basic_transceiver_name_)
            .toString();
    rig_is_dummy_ =
        TransceiverFactory::basic_transceiver_name_ == rig_params_.rig_name;
    rig_params_.network_port = settings_->value("CATNetworkPort").toString();
    rig_params_.usb_port = settings_->value("CATUSBPort").toString();
    rig_params_.serial_port = settings_->value("CATSerialPort").toString();
    rig_params_.baud = settings_->value("CATSerialRate", 4800).toInt();
    rig_params_.data_bits =
        settings_
            ->value("CATDataBits",
                    QVariant::fromValue(TransceiverFactory::default_data_bits))
            .value<TransceiverFactory::DataBits>();
    rig_params_.stop_bits =
        settings_
            ->value("CATStopBits",
                    QVariant::fromValue(TransceiverFactory::default_stop_bits))
            .value<TransceiverFactory::StopBits>();
    rig_params_.handshake =
        settings_
            ->value("CATHandshake",
                    QVariant::fromValue(TransceiverFactory::handshake_default))
            .value<TransceiverFactory::Handshake>();
    rig_params_.force_dtr = settings_->value("CATForceDTR", false).toBool();
    rig_params_.dtr_high = settings_->value("DTR", false).toBool();
    rig_params_.force_rts = settings_->value("CATForceRTS", false).toBool();
    rig_params_.rts_high = settings_->value("RTS", false).toBool();
    rig_params_.ptt_type =
        settings_
            ->value("PTTMethod",
                    QVariant::fromValue(TransceiverFactory::PTT_method_VOX))
            .value<TransceiverFactory::PTTMethod>();
    rig_params_.audio_source =
        settings_
            ->value(
                "TXAudioSource",
                QVariant::fromValue(TransceiverFactory::TX_audio_source_front))
            .value<TransceiverFactory::TXAudioSource>();
    rig_params_.ptt_port = settings_->value("PTTport").toString();
    data_mode_ =
        settings_->value("DataMode", QVariant::fromValue(data_mode_none))
            .value<Configuration::DataMode>();
    insert_blank_ = settings_->value("InsertBlank", false).toBool();
    DXCC_ = settings_->value("DXCCEntity", false).toBool();
    ppfx_ = settings_->value("PrincipalPrefix", false).toBool();
    miles_ = settings_->value("Miles", false).toBool();
    hold_ptt_ = settings_->value("HoldPTT", false).toBool();
    avoid_forced_identify_ =
        settings_->value("AvoidForcedIdentify", false).toBool();
    avoid_allcall_ = settings_->value("AvoidAllcall", false).toBool();
    spellcheck_ = settings_->value("Spellcheck", true).toBool();
    heartbeat_ = settings_->value("TxBeacon", 30).toInt();
    watchdog_ = settings_->value("TxIdleWatchdog", 60).toInt();
    if (watchdog_) {
        watchdog_ = qMax(5, watchdog_);
    }
    TX_messages_ = settings_->value("Tx2QSO", true).toBool();
    rig_params_.poll_interval = settings_->value("Polling", 0).toInt();
    rig_params_.split_mode =
        settings_
            ->value("SplitMode",
                    QVariant::fromValue(TransceiverFactory::split_mode_none))
            .value<TransceiverFactory::SplitMode>();
    opCall_ = settings_->value("OpCall", "").toString();
    ptt_command_ = settings_->value("PTTCommand", "").toString();
    aprs_server_name_ =
        settings_->value("aprsServer", "rotate.aprs2.net").toString();
    aprs_server_port_ = settings_->value("aprsServerPort", 14580).toUInt();
    udp_server_name_ = settings_->value("UDPServer", "127.0.0.1").toString();
    udp_server_port_ = settings_->value("UDPServerPort", 2242).toUInt();
    // WSJT-X Protocol settings
    wsjtx_protocol_enabled_ =
        settings_->value("WSJTXProtocolEnabled", false).toBool();
    wsjtx_server_name_ =
        settings_->value("WSJTXServer", "127.0.0.1").toString();
    wsjtx_server_port_ = settings_->value("WSJTXServerPort", 2237).toUInt();
    wsjtx_TTL_ = settings_->value("WSJTXTTL", 1).toInt();
    wsjtx_accept_requests_ =
        settings_->value("WSJTXAcceptRequests", false).toBool();
    wsjtx_interface_names_ =
        settings_->value("WSJTXInterfaces", QStringList()).toStringList();
    tcp_server_name_ = settings_->value("TCPServer", "127.0.0.1").toString();
    tcp_server_port_ = settings_->value("TCPServerPort", 2442).toUInt();
    n3fjp_server_name_ =
        settings_->value("N3FJPServer", "127.0.0.1").toString();
    n3fjp_server_port_ = settings_->value("N3FJPServerPort", 1100).toUInt();
    broadcast_to_n3fjp_ = settings_->value("BroadcastToN3FJP", false).toBool();
    n1mm_server_name_ = settings_->value("N1MMServer", "127.0.0.1").toString();
    n1mm_server_port_ = settings_->value("N1MMServerPort", 2333).toUInt();
    broadcast_to_n1mm_ = settings_->value("BroadcastToN1MM", false).toBool();
    accept_udp_requests_ =
        settings_->value("AcceptUDPRequests", false).toBool();
    accept_tcp_requests_ =
        settings_->value("AcceptTCPRequests", false).toBool();
    udpEnabled_ = settings_->value("UDPEnabled", false).toBool();
    tcpEnabled_ = settings_->value("TCPEnabled", false).toBool();
    tcpMaxConnections_ = settings_->value("TCPMaxConnections", 1).toInt();
    calibration_.intercept =
        settings_->value("CalibrationIntercept", 0.).toDouble();
    calibration_.slope_ppm =
        settings_->value("CalibrationSlopePPM", 0.).toDouble();
    pwrBandTxMemory_ = settings_->value("pwrBandTxMemory", false).toBool();
    pwrBandTuneMemory_ = settings_->value("pwrBandTuneMemory", false).toBool();

    // notifications
    enable_notifications_ =
        settings_->value("EnableNotifications", false).toBool();
    notifications_enabled_.clear();
    notifications_paths_.clear();
    settings_->beginGroup("Notifications");
    {
        foreach (auto group, settings_->childGroups()) {
            settings_->beginGroup(group);
            {
                notifications_enabled_[group] =
                    settings_->value("enabled", QVariant(false)).toBool();
                notifications_paths_[group] =
                    settings_->value("path", QVariant("")).toString();
            }
            settings_->endGroup();
        }
    }
    settings_->endGroup();
}

void Configuration::impl::find_audio_devices() {
    // Retrieve audio input device.

    if (auto const saved_name = settings_->value("SoundInName").toString();
        saved_name != next_audio_input_device_.description() ||
        next_audio_input_device_.isNull()) {
        next_audio_input_device_ = find_audio_device(
            QAudioDevice::Input, ui_->sound_input_combo_box, saved_name);
        next_audio_input_channel_ = AudioDevice::fromString(
            settings_->value("AudioInputChannel", "Mono").toString());

        update_audio_channels(
            ui_->sound_input_combo_box, ui_->sound_input_channel_combo_box,
            ui_->sound_input_combo_box->currentIndex(), false);
        ui_->sound_input_channel_combo_box->setCurrentIndex(
            next_audio_input_channel_);
    }

    // Retrieve audio output device.

    if (auto const saved_name = settings_->value("SoundOutName").toString();
        saved_name != next_audio_output_device_.description() ||
        next_audio_output_device_.isNull()) {
        next_audio_output_device_ = find_audio_device(
            QAudioDevice::Output, ui_->sound_output_combo_box, saved_name);
        next_audio_output_channel_ = AudioDevice::fromString(
            settings_->value("AudioOutputChannel", "Mono").toString());

        update_audio_channels(
            ui_->sound_output_combo_box, ui_->sound_output_channel_combo_box,
            ui_->sound_output_combo_box->currentIndex(), true);
        ui_->sound_output_channel_combo_box->setCurrentIndex(
            next_audio_output_channel_);
    }

    // Retrieve notification audio output device.

    if (auto const saved_name =
            settings_->value("NotificationSoundOutName").toString();
        saved_name != next_notification_audio_output_device_.description() ||
        next_notification_audio_output_device_.isNull()) {
        next_notification_audio_output_device_ = find_audio_device(
            QAudioDevice::Output, ui_->notification_sound_output_combo_box,
            saved_name);
    }
}

void Configuration::impl::write_settings() {
    SettingsGroup g{settings_, "Configuration"};

    settings_->setValue("AutoSwitchBands", auto_switch_bands_);
    settings_->setValue("MyCall", my_callsign_);
    settings_->setValue("MyGrid", my_grid_);
    settings_->setValue("MyGroups", my_groups_);
    settings_->setValue("AutoWhitelist", auto_whitelist_);
    settings_->setValue("AutoBlacklist", auto_blacklist_);
    settings_->setValue("HBBlacklist", hb_blacklist_);
    settings_->setValue("SpotBlacklist", spot_blacklist_);
    settings_->setValue("PrimaryHighlightWords", primary_highlight_words_);
    settings_->setValue("SecondaryHighlightWords", secondary_highlight_words_);
    settings_->setValue("EOTCharacter", eot_);
    settings_->setValue("MFICharacter", mfi_);
    settings_->setValue("MyInfo", my_info_);
    settings_->setValue("MyStatus", my_status_);
    settings_->setValue("CQMessage", cq_);
    settings_->setValue("HBMessage", hb_);
    settings_->setValue("Reply", reply_);
    settings_->setValue("CallsignAging", callsign_aging_);
    settings_->setValue("ActivityAging", activity_aging_);
    settings_->setValue("colorCQ", color_cq_);
    settings_->setValue("colorPrimary", color_primary_highlight_);
    settings_->setValue("colorSecondary", color_secondary_highlight_);
    settings_->setValue("colorMyCall", color_mycall_);
    settings_->setValue("color_rx_background", color_rx_background_);
    settings_->setValue("color_rx_foreground", color_rx_foreground_);
    settings_->setValue("color_compose_background", color_compose_background_);
    settings_->setValue("color_compose_foreground", color_compose_foreground_);
    settings_->setValue("color_tx_foreground", color_tx_foreground_);
    settings_->setValue("colorDXCC", color_DXCC_);
    settings_->setValue("colorNewCall", color_NewCall_);

    settings_->setValue("colorTableBackground", color_table_background_);
    settings_->setValue("colorTableHighlight", color_table_highlight_);
    settings_->setValue("colorTableForeground", color_table_foreground_);

    settings_->setValue("Font", font_.toString());
    settings_->setValue("RXTextFont", rx_text_font_.toString());
    settings_->setValue("TXTextFont", tx_text_font_.toString());
    settings_->setValue("composeTextFont", compose_text_font_.toString());
    settings_->setValue("tableFont", table_font_.toString());

    settings_->setValue("TxDelay", txDelay_);
    settings_->setValue("PTTMethod", QVariant::fromValue(rig_params_.ptt_type));
    settings_->setValue("PTTport", rig_params_.ptt_port);
    settings_->setValue("SaveDir", save_directory_.absolutePath());
    if (!audio_input_device_.isNull()) {
        settings_->setValue("SoundInName", audio_input_device_.description());
        settings_->setValue("AudioInputChannel",
                            AudioDevice::toString(audio_input_channel_));
    }
    if (!audio_output_device_.isNull()) {
        settings_->setValue("SoundOutName", audio_output_device_.description());
        settings_->setValue("AudioOutputChannel",
                            AudioDevice::toString(audio_output_channel_));
    }
    if (!notification_audio_output_device_.isNull()) {
        settings_->setValue("NotificationSoundOutName",
                            notification_audio_output_device_.description());
    }
    settings_->setValue("TransmitDirected", transmit_directed_);
    settings_->setValue("AutoreplyOnAtStartup", autoreply_on_at_startup_);
    settings_->setValue("AutoreplyConfirmation", autoreply_confirmation_);
    settings_->setValue("BeaconAnywhere", heartbeat_anywhere_);
    settings_->setValue("HeartbeatQSOPause", heartbeat_qso_pause_);
    settings_->setValue("HeartbeatAckSNR", heartbeat_ack_snr_);
    settings_->setValue("RelayOFF", relay_disabled_);
    settings_->setValue("MonitorOFF", monitor_off_at_startup_);
    settings_->setValue("TransmitOFF", transmit_off_at_startup_);
    settings_->setValue("MonitorLastUsed", monitor_last_used_);
    settings_->setValue("PSKReporter", spot_to_reporting_networks_);
    settings_->setValue("SpotToAPRS", spot_to_aprs_);
    settings_->setValue("WriteLogs", write_logs_);
    settings_->setValue("ResetActivity", reset_activity_);
    settings_->setValue("CheckForUpdates", check_for_updates_);
    settings_->setValue("PSKReporterTCPIP", psk_reporter_tcpip_);
    settings_->setValue("TxQSYAllowed", tx_qsy_allowed_);
    settings_->setValue("Macros", macros_.stringList());
    settings_->setValue(versionedFrequenciesSettingsKey,
                        QVariant::fromValue(frequencies_.frequency_list()));
    settings_->setValue("stations",
                        QVariant::fromValue(stations_.station_list()));
    settings_->setValue("Rig", rig_params_.rig_name);
    settings_->setValue("CATNetworkPort", rig_params_.network_port);
    settings_->setValue("CATUSBPort", rig_params_.usb_port);
    settings_->setValue("CATSerialPort", rig_params_.serial_port);
    settings_->setValue("CATSerialRate", rig_params_.baud);
    settings_->setValue("CATDataBits",
                        QVariant::fromValue(rig_params_.data_bits));
    settings_->setValue("CATStopBits",
                        QVariant::fromValue(rig_params_.stop_bits));
    settings_->setValue("CATHandshake",
                        QVariant::fromValue(rig_params_.handshake));
    settings_->setValue("DataMode", QVariant::fromValue(data_mode_));
    settings_->setValue("InsertBlank", insert_blank_);
    settings_->setValue("DXCCEntity", DXCC_);
    settings_->setValue("PrincipalPrefix", ppfx_);
    settings_->setValue("Miles", miles_);
    settings_->setValue("HoldPTT", hold_ptt_);
    settings_->setValue("AvoidForcedIdentify", avoid_forced_identify_);
    settings_->setValue("AvoidAllcall", avoid_allcall_);
    settings_->setValue("Spellcheck", spellcheck_);
    settings_->setValue("TxBeacon", heartbeat_);
    settings_->setValue("TxIdleWatchdog", watchdog_);
    settings_->setValue("Tx2QSO", TX_messages_);
    settings_->setValue("CATForceDTR", rig_params_.force_dtr);
    settings_->setValue("DTR", rig_params_.dtr_high);
    settings_->setValue("CATForceRTS", rig_params_.force_rts);
    settings_->setValue("RTS", rig_params_.rts_high);
    settings_->setValue("TXAudioSource",
                        QVariant::fromValue(rig_params_.audio_source));
    settings_->setValue("Polling", rig_params_.poll_interval);
    settings_->setValue("SplitMode",
                        QVariant::fromValue(rig_params_.split_mode));
    settings_->setValue("OpCall", opCall_);
    settings_->setValue("PTTCommand", ptt_command_);
    settings_->setValue("aprsServer", aprs_server_name_);
    settings_->setValue("aprsServerPort", aprs_server_port_);
    settings_->setValue("UDPServer", udp_server_name_);
    settings_->setValue("UDPServerPort", udp_server_port_);
    // WSJT-X Protocol settings
    settings_->setValue("WSJTXProtocolEnabled", wsjtx_protocol_enabled_);
    settings_->setValue("WSJTXServer", wsjtx_server_name_);
    settings_->setValue("WSJTXServerPort", wsjtx_server_port_);
    settings_->setValue("WSJTXTTL", wsjtx_TTL_);
    settings_->setValue("WSJTXAcceptRequests", wsjtx_accept_requests_);
    settings_->setValue("WSJTXInterfaces", wsjtx_interface_names_);
    settings_->setValue("TCPServer", tcp_server_name_);
    settings_->setValue("TCPServerPort", tcp_server_port_);
    settings_->setValue("N3FJPServer", n3fjp_server_name_);
    settings_->setValue("N3FJPServerPort", n3fjp_server_port_);
    settings_->setValue("BroadcastToN3FJP", broadcast_to_n3fjp_);
    settings_->setValue("N1MMServer", n1mm_server_name_);
    settings_->setValue("N1MMServerPort", n1mm_server_port_);
    settings_->setValue("BroadcastToN1MM", broadcast_to_n1mm_);
    settings_->setValue("AcceptUDPRequests", accept_udp_requests_);
    settings_->setValue("AcceptTCPRequests", accept_tcp_requests_);
    settings_->setValue("UDPEnabled", udpEnabled_);
    settings_->setValue("TCPEnabled", tcpEnabled_);
    settings_->setValue("TCPMaxConnections", tcpMaxConnections_);
    settings_->setValue("CalibrationIntercept", calibration_.intercept);
    settings_->setValue("CalibrationSlopePPM", calibration_.slope_ppm);
    settings_->setValue("pwrBandTxMemory", pwrBandTxMemory_);
    settings_->setValue("pwrBandTuneMemory", pwrBandTuneMemory_);
    settings_->setValue("Region", QVariant::fromValue(region_));
    settings_->setValue("AutoGrid", use_dynamic_info_);

    // notifications
    settings_->setValue("EnableNotifications", enable_notifications_);
    settings_->beginGroup("Notifications");
    {
        foreach (auto key, notifications_enabled_.keys()) {
            settings_->beginGroup(key);
            {
                settings_->setValue(
                    "enabled",
                    QVariant(notifications_enabled_.value(key, false)));
                settings_->setValue(
                    "path", QVariant(notifications_paths_.value(key, "")));
            }
            settings_->endGroup();
        }
    }
    settings_->endGroup();
}

void Configuration::impl::set_rig_invariants() {
    auto const &rig = ui_->rig_combo_box->currentText();
    auto const &ptt_port = ui_->PTT_port_combo_box->currentText();
    auto ptt_method = static_cast<TransceiverFactory::PTTMethod>(
        ui_->PTT_method_button_group->checkedId());

    auto CAT_PTT_enabled = transceiver_factory_.has_CAT_PTT(rig);
    auto CAT_indirect_serial_PTT =
        transceiver_factory_.has_CAT_indirect_serial_PTT(rig);
    auto asynchronous_CAT = transceiver_factory_.has_asynchronous_CAT(rig);
    auto is_hw_handshake =
        ui_->CAT_handshake_group_box->isEnabled() &&
        TransceiverFactory::handshake_hardware ==
            static_cast<TransceiverFactory::Handshake>(
                ui_->CAT_handshake_button_group->checkedId());

    ui_->test_CAT_push_button->setStyleSheet({});

    ui_->CAT_poll_interval_label->setEnabled(!asynchronous_CAT);
    ui_->CAT_poll_interval_spin_box->setEnabled(!asynchronous_CAT);

    auto port_type = transceiver_factory_.CAT_port_type(rig);

    bool is_serial_CAT(TransceiverFactory::Capabilities::serial == port_type);
    auto const &cat_port = ui_->CAT_port_combo_box->currentText();

    // only enable CAT option if transceiver has CAT PTT
    ui_->PTT_CAT_radio_button->setEnabled(CAT_PTT_enabled);

    auto enable_ptt_port = TransceiverFactory::PTT_method_CAT != ptt_method &&
                           TransceiverFactory::PTT_method_VOX != ptt_method;
    ui_->PTT_port_combo_box->setEnabled(enable_ptt_port);
    // if PTT port is not enabled, fill it with the text of the CAT port
    if (!enable_ptt_port) {
        ui_->PTT_port_combo_box->lineEdit()->setText(
            ui_->CAT_port_combo_box->currentText());
    }
    ui_->PTT_port_label->setEnabled(enable_ptt_port);

    dynamic_cast<QStandardItemModel *>(ui_->PTT_port_combo_box->model())
        ->item(ui_->PTT_port_combo_box->findText("CAT"))
        ->setEnabled(CAT_indirect_serial_PTT);

    if (!CAT_indirect_serial_PTT) {
        if ("CAT" == ui_->PTT_port_combo_box->currentText() &&
            ui_->PTT_port_combo_box->currentIndex() > 0) {
            ui_->PTT_port_combo_box->setCurrentIndex(
                ui_->PTT_port_combo_box->currentIndex() - 1);
        }
    }
    ui_->PTT_RTS_radio_button->setEnabled(
        !(is_serial_CAT && ptt_port == cat_port && is_hw_handshake));

    if (TransceiverFactory::basic_transceiver_name_ == rig) {
        // makes no sense with rig as "None"
        ui_->monitor_last_used_check_box->setEnabled(false);

        ui_->catTab->setEnabled(false);
        // ui_->CAT_control_group_box->setEnabled (false);
        ui_->test_CAT_push_button->setEnabled(false);
        ui_->test_PTT_push_button->setEnabled(
            TransceiverFactory::PTT_method_DTR == ptt_method ||
            TransceiverFactory::PTT_method_RTS == ptt_method);
        ui_->TX_audio_source_group_box->setEnabled(false);
    } else {
        ui_->monitor_last_used_check_box->setEnabled(true);
        ui_->catTab->setEnabled(true);
        // ui_->CAT_control_group_box->setEnabled (true);
        ui_->test_CAT_push_button->setEnabled(true);
        ui_->test_PTT_push_button->setEnabled(false);
        ui_->TX_audio_source_group_box->setEnabled(
            transceiver_factory_.has_CAT_PTT_mic_data(rig) &&
            TransceiverFactory::PTT_method_CAT == ptt_method);
        if (port_type != last_port_type_) {
            last_port_type_ = port_type;
            switch (port_type) {
            case TransceiverFactory::Capabilities::serial:
                fill_port_combo_box(ui_->CAT_port_combo_box);
                ui_->CAT_port_combo_box->setCurrentText(
                    rig_params_.serial_port);
                if (ui_->CAT_port_combo_box->currentText().isEmpty() &&
                    ui_->CAT_port_combo_box->count()) {
                    ui_->CAT_port_combo_box->setCurrentText(
                        ui_->CAT_port_combo_box->itemText(0));
                }
                ui_->CAT_port_label->setText(tr("Serial Port:"));
                ui_->CAT_port_combo_box->setToolTip(
                    tr("Serial port used for CAT control"));
                ui_->CAT_port_combo_box->setEnabled(true);
                break;

            case TransceiverFactory::Capabilities::network:
                ui_->CAT_port_combo_box->clear();
                ui_->CAT_port_combo_box->setCurrentText(
                    rig_params_.network_port);
                ui_->CAT_port_label->setText(tr("Network Server:"));
                ui_->CAT_port_combo_box->setToolTip(
                    tr("Optional hostname and port of network service.\n"
                       "Leave blank for a sensible default on this machine.\n"
                       "Formats:\n"
                       "\thostname:port\n"
                       "\tIPv4-address:port\n"
                       "\t[IPv6-address]:port"));
                ui_->CAT_port_combo_box->setEnabled(true);
                break;

            case TransceiverFactory::Capabilities::usb:
                ui_->CAT_port_combo_box->clear();
                ui_->CAT_port_combo_box->setCurrentText(rig_params_.usb_port);
                ui_->CAT_port_label->setText(tr("USB Device:"));
                ui_->CAT_port_combo_box->setToolTip(
                    tr("Optional device identification.\n"
                       "Leave blank for a sensible default for the rig.\n"
                       "Format:\n"
                       "\t[VID[:PID[:VENDOR[:PRODUCT]]]]"));
                ui_->CAT_port_combo_box->setEnabled(true);
                break;

            default:
                ui_->CAT_port_combo_box->clear();
                ui_->CAT_port_combo_box->setEnabled(false);
                break;
            }
        }

        ui_->CAT_serial_port_parameters_group_box->setEnabled(is_serial_CAT);

        ui_->force_DTR_combo_box->setEnabled(
            is_serial_CAT &&
            (cat_port != ptt_port || !ui_->PTT_DTR_radio_button->isEnabled() ||
             !ui_->PTT_DTR_radio_button->isChecked()));
        ui_->force_RTS_combo_box->setEnabled(
            is_serial_CAT && !is_hw_handshake &&
            (cat_port != ptt_port || !ui_->PTT_RTS_radio_button->isEnabled() ||
             !ui_->PTT_RTS_radio_button->isChecked()));
    }
    ui_->mode_group_box->setEnabled(
        WSJT_RIG_NONE_CAN_SPLIT ||
        TransceiverFactory::basic_transceiver_name_ != rig);
    ui_->split_operation_group_box->setEnabled(
        WSJT_RIG_NONE_CAN_SPLIT ||
        TransceiverFactory::basic_transceiver_name_ != rig);
}

QStringList splitGroups(QString groupsString, bool filter) {
    QStringList groups;
    if (groupsString.isEmpty()) {
        return groups;
    }

    foreach (QString group, groupsString.split(",")) {
        auto g = group.trimmed();
        if (filter && !g.startsWith("@")) {
            continue;
        }
        groups.append(group.trimmed().toUpper());
    }

    return groups;
}

QStringList splitWords(QString callsString) {
    QStringList calls;
    if (callsString.isEmpty()) {
        return calls;
    }

    foreach (QString call, callsString.split(",")) {
        auto g = call.trimmed();
        calls.append(call.trimmed().toUpper());
    }

    return calls;
}

bool Configuration::impl::validate() {
    if (ui_->eot_line_edit->text().trimmed().left(2).isEmpty()) {
        JS8MessageBox::critical_message(
            this, tr("Please enter an end of transmission character"));
        return false;
    }

    auto callsign = ui_->callsign_line_edit->text().toUpper().trimmed();
    if (!Varicode::isValidCallsign(callsign, nullptr) ||
        callsign.startsWith("@")) {
        JS8MessageBox::critical_message(
            this, tr("The callsign format you provided is not supported"));
        return false;
    }

    if (!ui_->grid_line_edit->hasAcceptableInput()) {
        JS8MessageBox::critical_message(
            this, tr("The grid you provided is not valid"));
        return false;
    }

    foreach (
        auto group,
        splitGroups(ui_->groups_line_edit->text().toUpper().trimmed(), false)) {
        if (!Varicode::isGroupAllowed(group)) {
            JS8MessageBox::critical_message(
                this,
                QString("%1 is a group that cannot be joined").arg(group));
            return false;
        }
        if (!Varicode::isCompoundCallsign(group)) {
            JS8MessageBox::critical_message(
                this, QString("%1 is not a valid group").arg(group));
            return false;
        }
    }

    foreach (
        auto call,
        splitWords(ui_->auto_whitelist_line_edit->text().toUpper().trimmed())) {
        if (!Varicode::isValidCallsign(call, nullptr)) {
            JS8MessageBox::critical_message(
                this,
                QString("%1 is not a valid callsign to whitelist").arg(call));
            return false;
        }
    }

    auto hb = ui_->hb_message_line_edit->text().toUpper().trimmed();
    if (!hb.isEmpty() && !(hb.startsWith("HB") || hb.contains(callsign))) {
        JS8MessageBox::critical_message(
            this, QString("The HB message format is invalid. It must either "
                          "start with \"HB\" or contain your callsign."));
        return false;
    }

    auto cq = ui_->cq_message_line_edit->text().toUpper().trimmed();
    if (!cq.isEmpty() && !(cq.startsWith("CQ") || cq.contains(callsign))) {
        JS8MessageBox::critical_message(
            this, QString("The CQ message format is invalid. It must either "
                          "start with \"CQ\" or contain your callsign."));
        return false;
    }

    if ((ui_->sound_input_combo_box->currentIndex() < 0) &&
        next_audio_input_device_.isNull()) {
        find_tab(ui_->sound_input_combo_box);
        JS8MessageBox::critical_message(this, tr("Invalid audio input device"));
        return false;
    }

    if ((ui_->sound_input_channel_combo_box->currentIndex() < 0) &&
        next_audio_input_device_.isNull()) {
        find_tab(ui_->sound_input_combo_box);
        JS8MessageBox::critical_message(this, tr("Invalid audio input device"));
        return false;
    }

    if ((ui_->sound_output_combo_box->currentIndex() < 0) &&
        next_audio_output_device_.isNull()) {
        find_tab(ui_->sound_output_combo_box);
        JS8MessageBox::information_message(this,
                                           tr("Invalid audio output device"));
        // don't reject as we can work without an audio output
    }

    if ((ui_->notification_sound_output_combo_box->currentIndex() < 0) &&
        next_notification_audio_output_device_.isNull()) {
        find_tab(ui_->notification_sound_output_combo_box);
        JS8MessageBox::information_message(
            this, tr("Invalid notification audio output device"));
        // don't reject as we can work without a notification audio output
    }

    if (!ui_->PTT_method_button_group->checkedButton()->isEnabled()) {
        JS8MessageBox::critical_message(this, tr("Invalid PTT method"));
        return false;
    }

    auto ptt_method = static_cast<TransceiverFactory::PTTMethod>(
        ui_->PTT_method_button_group->checkedId());
    if (auto const ptt_port = ui_->PTT_port_combo_box->currentText();
        (TransceiverFactory::PTT_method_DTR == ptt_method ||
         TransceiverFactory::PTT_method_RTS == ptt_method) &&
        (ptt_port.isEmpty() ||
         !(dynamic_cast<QStandardItemModel *>(ui_->PTT_port_combo_box->model())
               ->item(ui_->PTT_port_combo_box->findText(ptt_port))
               ->isEnabled()))) {
        JS8MessageBox::critical_message(this, tr("Invalid PTT port"));
        return false;
    }

    return true;
}

int Configuration::impl::exec() {
    // macros can be modified in the main window
    next_macros_.setStringList(macros_.stringList());

    have_rig_ = rig_active_;         // record that we started with a rig open
    saved_rig_params_ = rig_params_; // used to detect changes that
                                     // require the Transceiver to be
                                     // re-opened
    rig_changed_ = false;

    initialize_models();
    return QDialog::exec();
}

TransceiverFactory::ParameterPack Configuration::impl::gather_rig_data() const {
    TransceiverFactory::ParameterPack result;
    result.rig_name = ui_->rig_combo_box->currentText();

    switch (transceiver_factory_.CAT_port_type(result.rig_name)) {
    case TransceiverFactory::Capabilities::network:
        result.network_port = ui_->CAT_port_combo_box->currentText();
        result.usb_port = rig_params_.usb_port;
        result.serial_port = rig_params_.serial_port;
        break;

    case TransceiverFactory::Capabilities::usb:
        result.usb_port = ui_->CAT_port_combo_box->currentText();
        result.network_port = rig_params_.network_port;
        result.serial_port = rig_params_.serial_port;
        break;

    default:
        result.serial_port = ui_->CAT_port_combo_box->currentText();
        result.network_port = rig_params_.network_port;
        result.usb_port = rig_params_.usb_port;
        break;
    }

    result.baud = ui_->CAT_serial_baud_combo_box->currentText().toInt();
    result.data_bits = static_cast<TransceiverFactory::DataBits>(
        ui_->CAT_data_bits_button_group->checkedId());
    result.stop_bits = static_cast<TransceiverFactory::StopBits>(
        ui_->CAT_stop_bits_button_group->checkedId());
    result.handshake = static_cast<TransceiverFactory::Handshake>(
        ui_->CAT_handshake_button_group->checkedId());
    result.force_dtr = ui_->force_DTR_combo_box->isEnabled() &&
                       ui_->force_DTR_combo_box->currentIndex() > 0;
    result.dtr_high = ui_->force_DTR_combo_box->isEnabled() &&
                      1 == ui_->force_DTR_combo_box->currentIndex();
    result.force_rts = ui_->force_RTS_combo_box->isEnabled() &&
                       ui_->force_RTS_combo_box->currentIndex() > 0;
    result.rts_high = ui_->force_RTS_combo_box->isEnabled() &&
                      1 == ui_->force_RTS_combo_box->currentIndex();
    result.poll_interval = ui_->CAT_poll_interval_spin_box->value();
    result.ptt_type = static_cast<TransceiverFactory::PTTMethod>(
        ui_->PTT_method_button_group->checkedId());

    // don't allow CAT for None rig
    if (result.rig_name == "None" &&
        result.ptt_type == TransceiverFactory::PTT_method_CAT) {
        result.ptt_type = TransceiverFactory::PTT_method_VOX;
    }

    result.ptt_port = ui_->PTT_port_combo_box->currentText();
    result.audio_source = static_cast<TransceiverFactory::TXAudioSource>(
        ui_->TX_audio_source_button_group->checkedId());
    result.split_mode = static_cast<TransceiverFactory::SplitMode>(
        ui_->split_mode_button_group->checkedId());
    return result;
}

void Configuration::impl::accept() {
    // Called when OK button is clicked.

    if (!validate()) {
        return; // not accepting
    }

    // extract all rig related configuration parameters into temporary
    // structure for checking if the rig needs re-opening without
    // actually updating our live state
    auto temp_rig_params = gather_rig_data();

    // open_rig() uses values from models so we use it to validate the
    // Transceiver settings before agreeing to accept the configuration
    if (temp_rig_params != rig_params_ && !open_rig()) {
        return; // not accepting
    }

    QDialog::accept(); // do this before accessing custom
                       // models so that any changes in
                       // delegates in views get flushed to
                       // the underlying models before we
                       // access them

    sync_transceiver(true); // force an update

    //
    // from here on we are bound to accept the new configuration
    // parameters so extract values from models and make them live
    //

    if (next_font_ != font_) {
        font_ = next_font_;
        Q_EMIT self_->gui_text_font_changed(font_);
    }

    if (next_tx_text_font_ != tx_text_font_) {
        tx_text_font_ = next_tx_text_font_;
        Q_EMIT self_->tx_text_font_changed(tx_text_font_);
    }

    if (next_rx_text_font_ != rx_text_font_) {
        rx_text_font_ = next_rx_text_font_;
        Q_EMIT self_->rx_text_font_changed(rx_text_font_);
    }

    if (next_compose_text_font_ != compose_text_font_) {
        compose_text_font_ = next_compose_text_font_;
        Q_EMIT self_->compose_text_font_changed(compose_text_font_);
    }

    if (next_table_font_ != table_font_) {
        table_font_ = next_table_font_;
        Q_EMIT self_->table_font_changed(table_font_);
    }

    color_primary_highlight_ = next_color_primary_highlight_;
    color_secondary_highlight_ = next_color_secondary_highlight_;
    color_cq_ = next_color_cq_;
    color_mycall_ = next_color_mycall_;
    color_rx_background_ = next_color_rx_background_;
    color_rx_foreground_ = next_color_rx_foreground_;
    color_compose_background_ = next_color_compose_background_;
    color_compose_foreground_ = next_color_compose_foreground_;
    color_tx_foreground_ = next_color_tx_foreground_;
    color_DXCC_ = next_color_DXCC_;
    color_NewCall_ = next_color_NewCall_;
    color_table_background_ = next_color_table_background_;
    color_table_highlight_ = next_color_table_highlight_;
    color_table_foreground_ = next_color_table_foreground_;

    Q_EMIT self_->colors_changed();

    rig_params_ = temp_rig_params; // now we can go live with the rig
                                   // related configuration parameters
    rig_is_dummy_ =
        TransceiverFactory::basic_transceiver_name_ == rig_params_.rig_name;

    if (auto const &selected_device =
            ui_->sound_input_combo_box->currentData().value<QAudioDevice>();
        selected_device != next_audio_input_device_) {
        next_audio_input_device_ = selected_device;
    }

    if (auto const &selected_device =
            ui_->sound_output_combo_box->currentData().value<QAudioDevice>();
        selected_device != next_audio_output_device_) {
        next_audio_output_device_ = selected_device;
    }

    if (auto const &selected_device =
            ui_->notification_sound_output_combo_box->currentData()
                .value<QAudioDevice>();
        selected_device != next_notification_audio_output_device_) {
        next_notification_audio_output_device_ = selected_device;
    }

    if (auto const selected_channel = static_cast<AudioDevice::Channel>(
            ui_->sound_input_channel_combo_box->currentIndex());
        selected_channel != next_audio_input_channel_) {
        next_audio_input_channel_ = selected_channel;
    }
    Q_ASSERT(next_audio_input_channel_ <= AudioDevice::Right);

    if (auto const selected_channel = static_cast<AudioDevice::Channel>(
            ui_->sound_output_channel_combo_box->currentIndex());
        selected_channel != next_audio_output_channel_) {
        next_audio_output_channel_ = selected_channel;
    }
    Q_ASSERT(next_audio_output_channel_ <= AudioDevice::Both);

    if (audio_input_device_ != next_audio_input_device_ ||
        next_audio_input_device_.isNull()) {
        audio_input_device_ = next_audio_input_device_;
        restart_sound_input_device_ = true;
    }
    if (audio_input_channel_ != next_audio_input_channel_) {
        audio_input_channel_ = next_audio_input_channel_;
        restart_sound_input_device_ = true;
    }

    if (audio_output_device_ != next_audio_output_device_ ||
        next_audio_output_device_.isNull()) {
        audio_output_device_ = next_audio_output_device_;
        restart_sound_output_device_ = true;
    }
    if (audio_output_channel_ != next_audio_output_channel_) {
        audio_output_channel_ = next_audio_output_channel_;
        restart_sound_output_device_ = true;
    }

    if (notification_audio_output_device_ !=
            next_notification_audio_output_device_ ||
        next_notification_audio_output_device_.isNull()) {
        notification_audio_output_device_ =
            next_notification_audio_output_device_;
        restart_notification_sound_output_device_ = true;
    }

    qCDebug(configuration_js8)
        << "Configure::accept: audio i/p:" << audio_input_device_.description()
        << "chan:" << audio_input_channel_
        << "o/p:" << audio_output_device_.description()
        << "chan:" << audio_output_channel_
        << "n:" << notification_audio_output_device_.description()
        << "reset i/p:" << restart_sound_input_device_
        << "reset o/p:" << restart_sound_output_device_
        << "reset n:" << restart_notification_sound_output_device_;

    my_callsign_ = ui_->callsign_line_edit->text().toUpper().trimmed();
    my_grid_ = ui_->grid_line_edit->text().toUpper().trimmed();
    my_groups_ =
        splitGroups(ui_->groups_line_edit->text().toUpper().trimmed(), true);
    auto_whitelist_ =
        splitWords(ui_->auto_whitelist_line_edit->text().toUpper().trimmed());
    auto_blacklist_ =
        splitWords(ui_->auto_blacklist_line_edit->text().toUpper().trimmed());
    hb_blacklist_ =
        splitWords(ui_->hb_blacklist_line_edit->text().toUpper().trimmed());
    spot_blacklist_ =
        splitWords(ui_->spot_blacklist_line_edit->text().toUpper().trimmed());
    primary_highlight_words_ =
        splitWords(ui_->primaryHighlightLineEdit->text().toUpper().trimmed());
    secondary_highlight_words_ =
        splitWords(ui_->secondaryHighlightLineEdit->text().toUpper().trimmed());
    cq_ = ui_->cq_message_line_edit->text().toUpper();
    hb_ = ui_->hb_message_line_edit->text().toUpper();
    reply_ = ui_->reply_message_line_edit->text().toUpper();
    eot_ = ui_->eot_line_edit->text();
    mfi_ = ui_->mfi_line_edit->text();
    my_info_ = ui_->info_message_line_edit->text().toUpper();
    my_status_ = ui_->status_message_line_edit->text().toUpper();
    callsign_aging_ = ui_->callsign_aging_spin_box->value();
    activity_aging_ = ui_->activity_aging_spin_box->value();
    spot_to_reporting_networks_ = ui_->psk_reporter_check_box->isChecked();
    spot_to_aprs_ = ui_->enable_aprs_spotting_check_box->isChecked();
    psk_reporter_tcpip_ = ui_->psk_reporter_tcpip_check_box->isChecked();
    txDelay_ = ui_->sbTxDelay->value();
    write_logs_ = ui_->write_logs_check_box->isChecked();
    reset_activity_ = ui_->reset_activity_check_box->isChecked();
    check_for_updates_ = ui_->checkForUpdates_checkBox->isChecked();
    tx_qsy_allowed_ = ui_->tx_qsy_check_box->isChecked();
    transmit_directed_ = ui_->transmit_directed_check_box->isChecked();
    autoreply_on_at_startup_ = ui_->autoreply_on_check_box->isChecked();
    autoreply_confirmation_ =
        ui_->autoreply_confirmation_check_box->isChecked();
    heartbeat_anywhere_ = ui_->heartbeat_anywhere_check_box->isChecked();
    heartbeat_qso_pause_ = ui_->heartbeat_qso_pause_check_box->isChecked();
    heartbeat_ack_snr_ = ui_->heartbeat_ack_snr_check_box->isChecked();
    relay_disabled_ = ui_->relay_disabled_check_box->isChecked();
    monitor_off_at_startup_ = ui_->monitor_off_check_box->isChecked();
    transmit_off_at_startup_ = ui_->transmit_off_check_box->isChecked();
    monitor_last_used_ = ui_->monitor_last_used_check_box->isChecked();
    miles_ = ui_->miles_check_box->isChecked();
    hold_ptt_ = ui_->hold_ptt_check_box->isChecked();
    avoid_forced_identify_ = ui_->avoid_forced_identify_check_box->isChecked();
    avoid_allcall_ = ui_->avoid_allcall_check_box->isChecked();
    spellcheck_ = ui_->spellcheck_check_box->isChecked();
    heartbeat_ = ui_->heartbeat_spin_box->value();
    watchdog_ = ui_->tx_watchdog_spin_box->value();
    data_mode_ = static_cast<DataMode>(ui_->TX_mode_button_group->checkedId());
    save_directory_.setPath(ui_->save_path_display_label->text());
    calibration_.intercept = ui_->calibration_intercept_spin_box->value();
    calibration_.slope_ppm = ui_->calibration_slope_ppm_spin_box->value();
    pwrBandTxMemory_ = ui_->checkBoxPwrBandTxMemory->isChecked();
    pwrBandTuneMemory_ = ui_->checkBoxPwrBandTuneMemory->isChecked();
    opCall_ = ui_->opCallEntry->text();
    ptt_command_ = ui_->ptt_command_line_edit->text();
    aprs_server_name_ = ui_->aprs_server_line_edit->text();
    aprs_server_port_ = ui_->aprs_server_port_spin_box->value();

    auto const newAutoSwitchBands =
        ui_->auto_switch_bands_check_box->isChecked();
    auto_switch_bands_ = newAutoSwitchBands;

    // Emit this even if the value has not changed as a way to reset the
    // scheduler.
    // TODO this is smelly, revisit when we make the scheduler smarter
    Q_EMIT self_->auto_switch_bands_changed(auto_switch_bands_);

    auto const newUdpEnabled = ui_->udpEnable->isChecked();
    auto const newUdpServerName = ui_->udp_server_line_edit->text();
    if (newUdpServerName != udp_server_name_ || newUdpEnabled != udpEnabled_) {
        udp_server_name_ = newUdpServerName;
        udpEnabled_ = newUdpEnabled;

        Q_EMIT self_->udp_server_name_changed(udpEnabled_ ? newUdpServerName
                                                          : "");
    }

    auto newUdpPort = ui_->udp_server_port_spin_box->value();
    if (newUdpPort != udp_server_port_) {
        udp_server_port_ = newUdpPort;
        Q_EMIT self_->udp_server_port_changed(newUdpPort);
    }

    auto newTcpEnabled = ui_->tcpEnable->isChecked();
    auto newTcpServer = ui_->tcp_server_line_edit->text();
    if (newTcpServer != tcp_server_name_ || newTcpEnabled != tcpEnabled_) {
        tcp_server_name_ = newTcpServer;
        tcpEnabled_ = newTcpEnabled;

        Q_EMIT self_->tcp_server_changed(tcpEnabled_ ? newTcpServer : "");
    }

    auto newTcpPort = ui_->tcp_server_port_spin_box->value();
    if (newTcpPort != tcp_server_port_) {
        tcp_server_port_ = newTcpPort;
        Q_EMIT self_->tcp_server_port_changed(newTcpPort);
    }

    auto newTcpMaxConnections = ui_->tcp_max_connections_spin_box->value();
    if (newTcpMaxConnections != tcpMaxConnections_) {
        tcpMaxConnections_ = newTcpMaxConnections;
        Q_EMIT self_->tcp_max_connections_changed(newTcpMaxConnections);
    }

    accept_udp_requests_ = ui_->accept_udp_requests_check_box->isChecked();
    accept_tcp_requests_ = ui_->accept_tcp_requests_check_box->isChecked();

    auto new_n3fjp_server = ui_->n3fjp_server_name_line_edit->text();
    n3fjp_server_name_ = new_n3fjp_server;
    auto new_n3fjp_port = ui_->n3fjp_server_port_spin_box->value();
    n3fjp_server_port_ = new_n3fjp_port;
    broadcast_to_n3fjp_ = ui_->enable_n3fjp_broadcast_check_box->isChecked();

    auto new_n1mm_server = ui_->n1mm_server_name_line_edit->text();
    n1mm_server_name_ = new_n1mm_server;
    auto new_n1mm_port = ui_->n1mm_server_port_spin_box->value();
    n1mm_server_port_ = new_n1mm_port;
    broadcast_to_n1mm_ = ui_->enable_n1mm_broadcast_check_box->isChecked();

    // WSJT-X Protocol settings
    auto new_wsjtx_enabled = ui_->wsjtx_enable_check_box->isChecked();
    auto new_wsjtx_server = ui_->wsjtx_server_line_edit->text();
    auto new_wsjtx_port = ui_->wsjtx_server_port_spin_box->value();
    auto new_wsjtx_ttl = ui_->wsjtx_TTL_spin_box->value();
    auto new_wsjtx_accept_requests =
        ui_->wsjtx_accept_requests_check_box->isChecked();
    auto new_wsjtx_interfaces =
        get_selected_network_interfaces(ui_->wsjtx_interfaces_combo_box);

    if (new_wsjtx_enabled != wsjtx_protocol_enabled_) {
        wsjtx_protocol_enabled_ = new_wsjtx_enabled;
        Q_EMIT self_->wsjtx_protocol_enabled_changed(wsjtx_protocol_enabled_);
    }

    if (new_wsjtx_server != wsjtx_server_name_ ||
        new_wsjtx_enabled != wsjtx_protocol_enabled_) {
        wsjtx_server_name_ = new_wsjtx_server;
        Q_EMIT self_->wsjtx_server_changed(
            wsjtx_protocol_enabled_ ? new_wsjtx_server : "");
    }

    if (new_wsjtx_port != wsjtx_server_port_) {
        wsjtx_server_port_ = new_wsjtx_port;
        Q_EMIT self_->wsjtx_server_port_changed(new_wsjtx_port);
    }

    if (new_wsjtx_ttl != wsjtx_TTL_) {
        wsjtx_TTL_ = new_wsjtx_ttl;
        Q_EMIT self_->wsjtx_TTL_changed(new_wsjtx_ttl);
    }

    wsjtx_accept_requests_ = new_wsjtx_accept_requests;

    if (new_wsjtx_interfaces != wsjtx_interface_names_) {
        wsjtx_interface_names_ = new_wsjtx_interfaces;
        Q_EMIT self_->wsjtx_interfaces_changed(wsjtx_interface_names_);
    }

    if (macros_.stringList() != next_macros_.stringList()) {
        macros_.setStringList(next_macros_.stringList());
    }

    region_ = IARURegions::value(ui_->region_combo_box->currentText());

    if (frequencies_.frequency_list() != next_frequencies_.frequency_list()) {
        frequencies_.frequency_list(next_frequencies_.frequency_list());
        frequencies_.sort(FrequencyList_v2::frequency_column);
    }

    if (stations_.station_list() != next_stations_.station_list()) {
        stations_.station_list(next_stations_.station_list());
        stations_.sort(StationList::switch_at_column);

        Q_EMIT self_->band_schedule_changed(this->stations_);
    }

    if (ui_->use_dynamic_grid->isChecked() && !use_dynamic_info_) {
        // turning on so clear it so only the next location update gets used
        dynamic_grid_.clear();
    }
    use_dynamic_info_ = ui_->use_dynamic_grid->isChecked();

    // notifications
    enable_notifications_ = ui_->notifications_check_box->isChecked();

    for (int i = 0; i < ui_->notifications_table_widget->rowCount(); i++) {
        // event
        auto eventItem = ui_->notifications_table_widget->item(i, 0);
        auto key = eventItem->data(Qt::UserRole).toString();
        if (key.isEmpty()) {
            continue;
        }

        auto enabledWidget = ui_->notifications_table_widget->cellWidget(i, 1);
        QCheckBox *enabledCheckbox =
            enabledWidget->findChild<QCheckBox *>("enabledCheckbox");
        if (enabledCheckbox) {
            notifications_enabled_[key] = enabledCheckbox->isChecked();
        }

        auto pathWidget = ui_->notifications_table_widget->cellWidget(i, 2);
        QLabel *pathLabel = qobject_cast<QLabel *>(pathWidget);
        if (pathLabel) {
            notifications_paths_[key] = pathLabel->text();
        }
    }

    write_settings(); // make visible to all
}

void Configuration::impl::reject() {
    initialize_models(); // reverts to settings as at exec ()

    // check if the Transceiver instance changed, in which case we need
    // to re open any prior Transceiver type
    if (rig_changed_) {
        if (have_rig_) {
            // we have to do this since the rig has been opened since we
            // were exec'ed even though it might fail
            open_rig();
        } else {
            close_rig();
        }
    }

    QDialog::reject();
}

void Configuration::impl::on_psk_reporter_check_box_toggled(bool checked) {
    ui_->enable_aprs_spotting_check_box->setEnabled(checked);

    bool spot = ui_->enable_aprs_spotting_check_box->isChecked();
    ui_->aprs_server_line_edit->setEnabled(spot && checked);
    ui_->aprs_server_port_spin_box->setEnabled(spot && checked);
}

void Configuration::impl::on_enable_aprs_spotting_check_box_toggled(
    bool checked) {
    ui_->aprs_server_line_edit->setEnabled(checked);
    ui_->aprs_server_port_spin_box->setEnabled(checked);
}

void Configuration::impl::on_notifications_check_box_toggled(bool checked) {
    ui_->notifications_table_widget->setEnabled(checked);
}

void Configuration::impl::on_font_push_button_clicked() {
    next_font_ = QFontDialog::getFont(0, next_font_, this, tr("Font Chooser")
#if QT_VERSION >= 0x050201
                                                               ,
                                      QFontDialog::DontUseNativeDialog
#endif
    );
    ui_->font_push_button->setText(QString("Application Font (%1 %2)")
                                       .arg(next_font_.family())
                                       .arg(next_font_.pointSize()));
}

void Configuration::impl::on_tableFontButton_clicked() {
    next_table_font_ =
        QFontDialog::getFont(0, next_table_font_, this, tr("Font Chooser")
#if QT_VERSION >= 0x050201
                                                            ,
                             QFontDialog::DontUseNativeDialog
#endif
        );

    ui_->tableFontButton->setText(QString("Font (%1 %2)")
                                      .arg(next_table_font_.family())
                                      .arg(next_table_font_.pointSize()));
}

QColor getColor(QColor initial, QWidget *parent, QString title) {
    QList<QColor> custom = {QColor("#66FF66"), QColor("#FF6666"),
                            QColor("#FFEAA7"), QColor("#3498DB")};

    auto d = new QColorDialog(initial, parent);
    d->setWindowTitle(title);
    for (int i = 0; i < custom.length(); i++) {
        d->setCustomColor(i, custom.at(i));
    }

    if (d->exec() == QColorDialog::Accepted) {
        return d->selectedColor();
    } else {
        return initial;
    }
}

void Configuration::impl::on_cqMessagesButton_clicked() {
    auto new_color = getColor(next_color_cq_, this, "CQ Messages Color");
    if (new_color.isValid()) {
        next_color_cq_ = new_color;
        ui_->cqMessagesLabel->setStyleSheet(
            QString("background: %1; color: %2")
                .arg(next_color_cq_.name())
                .arg(next_color_table_foreground_.name()));
    }
}

void Configuration::impl::on_primaryHighlightButton_clicked() {
    auto new_color = getColor(next_color_primary_highlight_, this,
                              "Primary Highlight Color");
    if (new_color.isValid()) {
        next_color_primary_highlight_ = new_color;
        ui_->primaryHighlightLabel->setStyleSheet(
            QString("background: %1; color: %2")
                .arg(next_color_primary_highlight_.name())
                .arg(next_color_table_foreground_.name()));
    }
}

void Configuration::impl::on_secondaryHighlightButton_clicked() {
    auto new_color = getColor(next_color_secondary_highlight_, this,
                              "Secondary Highlight Color");
    if (new_color.isValid()) {
        next_color_secondary_highlight_ = new_color;
        ui_->secondaryHighlightLabel->setStyleSheet(
            QString("background: %1; color: %2")
                .arg(next_color_secondary_highlight_.name())
                .arg(next_color_table_foreground_.name()));
    }
}

void Configuration::impl::on_pbMyCall_clicked() {
    auto new_color =
        getColor(next_color_mycall_, this, "Directed Messages Color");
    if (new_color.isValid()) {
        next_color_mycall_ = new_color;
        ui_->labMyCall->setStyleSheet(
            QString("background: %1; color: %2")
                .arg(next_color_mycall_.name())
                .arg(next_color_table_foreground_.name()));
    }
}

void Configuration::impl::on_tableBackgroundButton_clicked() {
    auto new_color =
        getColor(next_color_table_background_, this, "Table Background Color");
    if (new_color.isValid()) {
        next_color_table_background_ = new_color;
        ui_->tableForegroundLabel->setStyleSheet(
            QString("background: %1; color: %2")
                .arg(next_color_table_background_.name())
                .arg(next_color_table_foreground_.name()));
        ui_->tableBackgroundLabel->setStyleSheet(
            QString("background: %1; color: %2")
                .arg(next_color_table_background_.name())
                .arg(next_color_table_foreground_.name()));
    }
}

void Configuration::impl::on_tableSelectedRowBackgroundButton_clicked() {
    auto new_color = getColor(next_color_table_highlight_, this,
                              "Table Selected Row Background Color");
    if (new_color.isValid()) {
        next_color_table_highlight_ = new_color;
        ui_->tableSelectionBackgroundLabel->setStyleSheet(
            QString("background: %1; color: %2")
                .arg(next_color_table_highlight_.name())
                .arg(next_color_table_foreground_.name()));
    }
}

void Configuration::impl::on_tableForegroundButton_clicked() {
    auto new_color =
        getColor(next_color_table_foreground_, this, "Table Foreground Color");
    if (new_color.isValid()) {
        next_color_table_foreground_ = new_color;
        ui_->tableForegroundLabel->setStyleSheet(
            QString("background: %1; color: %2")
                .arg(next_color_table_background_.name())
                .arg(next_color_table_foreground_.name()));
        ui_->tableBackgroundLabel->setStyleSheet(
            QString("background: %1; color: %2")
                .arg(next_color_table_background_.name())
                .arg(next_color_table_foreground_.name()));
        ui_->tableSelectionBackgroundLabel->setStyleSheet(
            QString("background: %1; color: %2")
                .arg(next_color_table_highlight_.name())
                .arg(next_color_table_foreground_.name()));
        ui_->primaryHighlightLabel->setStyleSheet(
            QString("background: %1; color: %2")
                .arg(next_color_primary_highlight_.name())
                .arg(next_color_table_foreground_.name()));
        ui_->secondaryHighlightLabel->setStyleSheet(
            QString("background: %1; color: %2")
                .arg(next_color_secondary_highlight_.name())
                .arg(next_color_table_foreground_.name()));
        ui_->cqMessagesLabel->setStyleSheet(
            QString("background: %1; color: %2")
                .arg(next_color_cq_.name())
                .arg(next_color_table_foreground_.name()));
        ui_->labMyCall->setStyleSheet(
            QString("background: %1; color: %2")
                .arg(next_color_mycall_.name())
                .arg(next_color_table_foreground_.name()));
    }
}

void Configuration::impl::on_rxBackgroundButton_clicked() {
    auto new_color = getColor(next_color_rx_background_, this,
                              "Received Messages Background Color");
    if (new_color.isValid()) {
        next_color_rx_background_ = new_color;
        ui_->rxLabel->setStyleSheet(QString("background: %1; color: %2")
                                        .arg(color_rx_background_.name())
                                        .arg(color_rx_foreground_.name()));
        ui_->rxForegroundLabel->setStyleSheet(
            QString("background: %1; color: %2")
                .arg(next_color_rx_background_.name())
                .arg(next_color_rx_foreground_.name()));
        ui_->txForegroundLabel->setStyleSheet(
            QString("background: %1; color: %2")
                .arg(next_color_rx_background_.name())
                .arg(next_color_tx_foreground_.name()));
    }
}

void Configuration::impl::on_rxForegroundButton_clicked() {
    auto new_color = getColor(next_color_rx_foreground_, this,
                              "Received Messages Foreground Color");
    if (new_color.isValid()) {
        next_color_rx_foreground_ = new_color;
        ui_->rxLabel->setStyleSheet(QString("background: %1; color: %2")
                                        .arg(color_rx_background_.name())
                                        .arg(color_rx_foreground_.name()));
        ui_->rxForegroundLabel->setStyleSheet(
            QString("background: %1; color: %2")
                .arg(next_color_rx_background_.name())
                .arg(next_color_rx_foreground_.name()));
        ui_->txForegroundLabel->setStyleSheet(
            QString("background: %1; color: %2")
                .arg(next_color_rx_background_.name())
                .arg(next_color_tx_foreground_.name()));
    }
}

void Configuration::impl::on_rxFontButton_clicked() {
    next_rx_text_font_ =
        QFontDialog::getFont(0, next_rx_text_font_, this, tr("Font Chooser")
#if QT_VERSION >= 0x050201
                                                              ,
                             QFontDialog::DontUseNativeDialog
#endif
        );
    ui_->rxFontButton->setText(QString("Font (%1 %2)")
                                   .arg(next_rx_text_font_.family())
                                   .arg(next_rx_text_font_.pointSize()));
}

void Configuration::impl::on_composeBackgroundButton_clicked() {
    auto new_color = getColor(next_color_compose_background_, this,
                              "Compose Messages Background Color");
    if (new_color.isValid()) {
        next_color_compose_background_ = new_color;
        ui_->composeLabel->setStyleSheet(
            QString("background: %1; color: %2")
                .arg(next_color_compose_background_.name())
                .arg(next_color_compose_foreground_.name()));
    }
}

void Configuration::impl::on_composeForegroundButton_clicked() {
    auto new_color = getColor(next_color_compose_foreground_, this,
                              "Compose Messages Foreground Color");
    if (new_color.isValid()) {
        next_color_compose_foreground_ = new_color;
        ui_->composeLabel->setStyleSheet(
            QString("background: %1; color: %2")
                .arg(next_color_compose_background_.name())
                .arg(next_color_compose_foreground_.name()));
    }
}

void Configuration::impl::on_txForegroundButton_clicked() {
    auto new_color = getColor(next_color_tx_foreground_, this,
                              "Transmitted Messages Foreground Color");
    if (new_color.isValid()) {
        next_color_tx_foreground_ = new_color;
        ui_->rxForegroundLabel->setStyleSheet(
            QString("background: %1; color: %2")
                .arg(next_color_rx_background_.name())
                .arg(next_color_rx_foreground_.name()));
        ui_->txForegroundLabel->setStyleSheet(
            QString("background: %1; color: %2")
                .arg(next_color_rx_background_.name())
                .arg(next_color_tx_foreground_.name()));
    }
}

void Configuration::impl::on_txFontButton_clicked() {
    next_tx_text_font_ =
        QFontDialog::getFont(0, next_tx_text_font_, this, tr("Font Chooser")
#if QT_VERSION >= 0x050201
                                                              ,
                             QFontDialog::DontUseNativeDialog
#endif
        );

    ui_->txFontButton->setText(QString("Font (%1 %2)")
                                   .arg(next_tx_text_font_.family())
                                   .arg(next_tx_text_font_.pointSize()));
}

void Configuration::impl::on_composeFontButton_clicked() {
    next_compose_text_font_ = QFontDialog::getFont(
        0, next_compose_text_font_, this, tr("Font Chooser")
#if QT_VERSION >= 0x050201
                                              ,
        QFontDialog::DontUseNativeDialog
#endif
    );
    ui_->composeFontButton->setText(
        QString("Font (%1 %2)")
            .arg(next_compose_text_font_.family())
            .arg(next_compose_text_font_.pointSize()));
}

void Configuration::impl::on_PTT_port_combo_box_activated(int /* index */) {
    set_rig_invariants();
}

void Configuration::impl::on_CAT_port_combo_box_activated(int /* index */) {
    set_rig_invariants();
}

void Configuration::impl::on_CAT_serial_baud_combo_box_currentIndexChanged(
    int /* index */) {
    set_rig_invariants();
}

void Configuration::impl::on_CAT_handshake_button_group_buttonClicked(
    QAbstractButton *) {
    set_rig_invariants();
}

void Configuration::impl::on_rig_combo_box_currentIndexChanged(
    int /* index */) {
    set_rig_invariants();
}

void Configuration::impl::on_CAT_data_bits_button_group_buttonClicked(
    QAbstractButton *) {
    set_rig_invariants();
}

void Configuration::impl::on_CAT_stop_bits_button_group_buttonClicked(
    QAbstractButton *) {
    set_rig_invariants();
}

void Configuration::impl::on_CAT_poll_interval_spin_box_valueChanged(
    int /* value */) {
    set_rig_invariants();
}

void Configuration::impl::on_split_mode_button_group_buttonClicked(
    QAbstractButton *) {
    set_rig_invariants();
}

void Configuration::impl::on_test_CAT_push_button_clicked() {
    if (!validate()) {
        return;
    }

    ui_->test_CAT_push_button->setStyleSheet({});
    if (open_rig(true)) {
        // Q_EMIT sync (true);
    }

    set_rig_invariants();
}

void Configuration::impl::on_test_PTT_push_button_clicked(bool checked) {
    ui_->test_PTT_push_button->setChecked(!checked); // let status
                                                     // update check us
    if (!validate()) {
        return;
    }

    if (rig_active_) {
        // Update the data mode from the UI before testing PTT
        data_mode_ =
            static_cast<DataMode>(ui_->TX_mode_button_group->checkedId());
        Q_EMIT self_->transceiver_ptt(checked);
    }
}

void Configuration::impl::on_force_DTR_combo_box_currentIndexChanged(
    int /* index */) {
    set_rig_invariants();
}

void Configuration::impl::on_force_RTS_combo_box_currentIndexChanged(
    int /* index */) {
    set_rig_invariants();
}

void Configuration::impl::on_PTT_method_button_group_buttonClicked(
    QAbstractButton *) {
    set_rig_invariants();
}

void Configuration::impl::on_groups_line_edit_textChanged(QString const &) {}

void Configuration::impl::on_info_message_line_edit_textChanged(
    QString const &) {}

void Configuration::impl::on_cq_message_line_edit_textChanged(QString const &) {
}

void Configuration::impl::on_reply_message_line_edit_textChanged(
    QString const &) {}

void Configuration::impl::on_add_macro_line_edit_editingFinished() {
    ui_->add_macro_line_edit->setText(
        ui_->add_macro_line_edit->text().toUpper());
}

void Configuration::impl::on_delete_macro_push_button_clicked(
    bool /* checked */) {
    auto selection_model = ui_->macros_list_view->selectionModel();
    if (selection_model->hasSelection()) {
        // delete all selected items
        delete_selected_macros(selection_model->selectedRows());
    }
}

void Configuration::impl::delete_macro() {
    auto selection_model = ui_->macros_list_view->selectionModel();
    if (!selection_model->hasSelection()) {
        // delete item under cursor if any
        auto index = selection_model->currentIndex();
        if (index.isValid()) {
            next_macros_.removeRow(index.row());
        }
    } else {
        // delete the whole selection
        delete_selected_macros(selection_model->selectedRows());
    }
}

void Configuration::impl::delete_selected_macros(
    QModelIndexList selected_rows) {
    // sort in reverse row order so that we can delete without changing
    // indices underneath us
    std::sort(selected_rows.begin(), selected_rows.end(),
              [](QModelIndex const &lhs, QModelIndex const &rhs) {
                  return rhs.row() < lhs.row(); // reverse row ordering
              });

    // now delete them
    Q_FOREACH (auto index, selected_rows) {
        next_macros_.removeRow(index.row());
    }
}

void Configuration::impl::on_add_macro_push_button_clicked(bool /* checked */) {
    if (next_macros_.insertRow(next_macros_.rowCount())) {
        auto index = next_macros_.index(next_macros_.rowCount() - 1);
        ui_->macros_list_view->setCurrentIndex(index);
        next_macros_.setData(index, ui_->add_macro_line_edit->text().toUpper());
        ui_->add_macro_line_edit->clear();
    }
}

void Configuration::impl::delete_frequencies() {
    auto selection_model = ui_->frequencies_table_view->selectionModel();
    selection_model->select(selection_model->selection(),
                            QItemSelectionModel::SelectCurrent |
                                QItemSelectionModel::Rows);
    next_frequencies_.removeDisjointRows(selection_model->selectedRows());
    ui_->frequencies_table_view->resizeColumnToContents(
        FrequencyList_v2::mode_column);
}

void Configuration::impl::load_frequencies() {
    auto file_name = QFileDialog::getOpenFileName(
        this, tr("Load Working Frequencies"),
        writeable_data_dir_.absolutePath(),
        tr("Frequency files (*.qrg);;All files (*.*)"));
    if (!file_name.isNull()) {
        auto const list = read_frequencies_file(file_name);
        if (list.size() &&
            (!next_frequencies_.frequency_list().size() ||
             JS8MessageBox::Yes ==
                 JS8MessageBox::query_message(
                     this, tr("Replace Working Frequencies"),
                     tr("Are you sure you want to discard your current "
                        "working frequencies and replace them with the "
                        "loaded ones?")))) {
            next_frequencies_.frequency_list(list); // update the model
        }
    }
}

void Configuration::impl::merge_frequencies() {
    auto file_name = QFileDialog::getOpenFileName(
        this, tr("Merge Working Frequencies"),
        writeable_data_dir_.absolutePath(),
        tr("Frequency files (*.qrg);;All files (*.*)"));
    if (!file_name.isNull()) {
        next_frequencies_.frequency_list_merge(
            read_frequencies_file(file_name)); // update the model
    }
}

FrequencyList_v2::FrequencyItems
Configuration::impl::read_frequencies_file(QString const &file_name) {
    QFile frequencies_file{file_name};
    frequencies_file.open(QFile::ReadOnly);
    QDataStream ids{&frequencies_file};
    FrequencyList_v2::FrequencyItems list;
    quint32 magic;
    ids >> magic;
    if (qrg_magic != magic) {
        JS8MessageBox::warning_message(this, tr("Not a valid frequencies file"),
                                       tr("Incorrect file magic"));
        return list;
    }
    quint32 version;
    ids >> version;
    // handle version checks and QDataStream version here if
    // necessary
    if (version > qrg_version) {
        JS8MessageBox::warning_message(this, tr("Not a valid frequencies file"),
                                       tr("Version is too new"));
        return list;
    }

    // de-serialize the data using version if necessary to
    // handle old schemata
    ids >> list;

    if (ids.status() != QDataStream::Ok || !ids.atEnd()) {
        JS8MessageBox::warning_message(this, tr("Not a valid frequencies file"),
                                       tr("Contents corrupt"));
        list.clear();
        return list;
    }

    return list;
}

void Configuration::impl::save_frequencies() {
    auto file_name = QFileDialog::getSaveFileName(
        this, tr("Save Working Frequencies"),
        writeable_data_dir_.absolutePath(),
        tr("Frequency files (*.qrg);;All files (*.*)"));
    if (!file_name.isNull()) {
        QFile frequencies_file{file_name};
        frequencies_file.open(QFile::WriteOnly);
        QDataStream ods{&frequencies_file};
        auto selection_model = ui_->frequencies_table_view->selectionModel();
        if (selection_model->hasSelection() &&
            JS8MessageBox::Yes ==
                JS8MessageBox::query_message(
                    this, tr("Only Save Selected  Working Frequencies"),
                    tr("Are you sure you want to save only the "
                       "working frequencies that are currently selected? "
                       "Click No to save all."))) {
            selection_model->select(selection_model->selection(),
                                    QItemSelectionModel::SelectCurrent |
                                        QItemSelectionModel::Rows);
            ods << qrg_magic << qrg_version
                << next_frequencies_.frequency_list(
                       selection_model->selectedRows());
        } else {
            ods << qrg_magic << qrg_version
                << next_frequencies_.frequency_list();
        }
    }
}

void Configuration::impl::reset_frequencies() {
    if (JS8MessageBox::Yes ==
        JS8MessageBox::query_message(
            this, tr("Reset Working Frequencies"),
            tr("Are you sure you want to discard your current "
               "working frequencies and replace them with default "
               "ones?"))) {
        next_frequencies_.reset_to_defaults();
    }
}

void Configuration::impl::insert_frequency() {
    if (QDialog::Accepted == frequency_dialog_->exec()) {
        ui_->frequencies_table_view->setCurrentIndex(
            next_frequencies_.add(frequency_dialog_->item()));
        ui_->frequencies_table_view->resizeColumnToContents(
            FrequencyList_v2::mode_column);
    }
}

void Configuration::impl::hop_to_station() {
    /*
     * If there is a valid selection in the station table, create a station
     * instance from the row data and emit the manual_band_hop_requested signal
     */
    auto selection_model = ui_->stations_table_view->selectionModel();
    if (!selection_model || !selection_model->hasSelection()) {
        return;
    }

    auto selected_rows = selection_model->selectedRows();
    if (selected_rows.isEmpty()) {
        return;
    }

    QModelIndex index = selected_rows.back();

    // Get the time strings
    QString switch_at_str =
        index.sibling(index.row(), StationList::Column::switch_at_column)
            .data(Qt::EditRole)
            .toString();
    QString switch_until_str =
        index.sibling(index.row(), StationList::Column::switch_until_column)
            .data(Qt::EditRole)
            .toString();

    // Create QDateTime objects with today's date and the times from the model
    QTime at_time = QTime::fromString(switch_at_str, "hh:mm");
    QTime until_time = QTime::fromString(switch_until_str, "hh:mm");

    StationList::Station station{
        index.sibling(index.row(), StationList::Column::band_column)
            .data(Qt::EditRole)
            .toString(),
        index.sibling(index.row(), StationList::Column::frequency_column)
            .data(Qt::EditRole)
            .value<Radio::Frequency>(),
        QDateTime(QDate(2000, 1, 1), at_time, QTimeZone::utc()),
        QDateTime(QDate(2000, 1, 1), until_time, QTimeZone::utc()),
        index.sibling(index.row(), StationList::Column::description_column)
            .data(Qt::EditRole)
            .toString()};

    Q_EMIT self_->manual_band_hop_requested(station);
}

void Configuration::impl::delete_stations() {
    auto selection_model = ui_->stations_table_view->selectionModel();
    selection_model->select(selection_model->selection(),
                            QItemSelectionModel::SelectCurrent |
                                QItemSelectionModel::Rows);
    next_stations_.removeDisjointRows(selection_model->selectedRows());
    ui_->stations_table_view->resizeColumnToContents(StationList::band_column);
    ui_->stations_table_view->resizeColumnToContents(
        StationList::frequency_column);
    ui_->stations_table_view->resizeColumnToContents(
        StationList::switch_at_column);
    ui_->stations_table_view->resizeColumnToContents(
        StationList::switch_until_column);
}

void Configuration::impl::insert_station() {
    if (QDialog::Accepted == station_dialog_->exec()) {
        auto station = station_dialog_->station();
        if (station.frequency_ == 0) {
            Frequency l;
            Frequency h;
            if (bands_.findFreq(station.band_name_, &l, &h)) {
                station.frequency_ = l;
            }
        }

        ui_->stations_table_view->setCurrentIndex(next_stations_.add(station));
        ui_->stations_table_view->resizeColumnToContents(
            StationList::band_column);
        ui_->stations_table_view->resizeColumnToContents(
            StationList::frequency_column);
        ui_->stations_table_view->resizeColumnToContents(
            StationList::switch_at_column);
        ui_->stations_table_view->resizeColumnToContents(
            StationList::switch_until_column);
    }
}

void Configuration::impl::on_save_path_select_push_button_clicked(
    bool /* checked */) {
    QFileDialog fd{this, tr("Save Directory"),
                   ui_->save_path_display_label->text()};
    fd.setFileMode(QFileDialog::Directory);
    fd.setOption(QFileDialog::ShowDirsOnly);
    if (fd.exec()) {
        if (fd.selectedFiles().size()) {
            ui_->save_path_display_label->setText(fd.selectedFiles().at(0));
        }
    }
}

void Configuration::impl::on_calibration_intercept_spin_box_valueChanged(
    double) {
    rig_active_ = false; // force reset
}

void Configuration::impl::on_calibration_slope_ppm_spin_box_valueChanged(
    double) {
    rig_active_ = false; // force reset
}

bool Configuration::impl::have_rig() {
    if (!open_rig()) {
        JS8MessageBox::critical_message(this, tr("Rig control error"),
                                        tr("Failed to open connection to rig"));
    }
    return rig_active_;
}

bool Configuration::impl::open_rig(bool force) {
    auto result = false;

    auto const rig_data = gather_rig_data();
    if (force || !rig_active_ || rig_data != saved_rig_params_) {
        try {
            close_rig();

            // create a new Transceiver object
            auto rig =
                transceiver_factory_.create(rig_data, transceiver_thread_);
            cached_rig_state_ = Transceiver::TransceiverState{};

            // hook up Configuration transceiver control signals to Transceiver
            // slots
            //
            // these connections cross the thread boundary
            rig_connections_
                << connect(this, &Configuration::impl::set_transceiver,
                           rig.get(), &Transceiver::set);

            // hook up Transceiver signals to Configuration signals
            //
            // these connections cross the thread boundary
            rig_connections_ << connect(
                rig.get(), &Transceiver::resolution, this,
                [this](int resolution) { rig_resolution_ = resolution; });
            rig_connections_
                << connect(rig.get(), &Transceiver::update, this,
                           &Configuration::impl::handle_transceiver_update);
            rig_connections_
                << connect(rig.get(), &Transceiver::failure, this,
                           &Configuration::impl::handle_transceiver_failure);

            // setup thread safe startup and close down semantics
            rig_connections_
                << connect(this, &Configuration::impl::start_transceiver,
                           rig.get(), &Transceiver::start);
            rig_connections_
                << connect(this, &Configuration::impl::stop_transceiver,
                           rig.get(), &Transceiver::stop);

            auto p = rig.release(); // take ownership

            // schedule destruction on thread quit
            connect(transceiver_thread_, &QThread::finished, p,
                    &QObject::deleteLater);

            // schedule eventual destruction for non-closing situations
            //
            // must   be   queued    connection   to   avoid   premature
            // self-immolation  since finished  signal  is  going to  be
            // emitted from  the object that  will get destroyed  in its
            // own  stop  slot  i.e.  a   same  thread  signal  to  slot
            // connection which by  default will be reduced  to a method
            // function call.
            connect(p, &Transceiver::finished, p, &Transceiver::deleteLater,
                    Qt::QueuedConnection);

            ui_->test_CAT_push_button->setStyleSheet({});
            rig_active_ = true;
            Q_EMIT start_transceiver(
                ++transceiver_command_number_); // start rig on its thread
            result = true;
        } catch (std::exception const &e) {
            handle_transceiver_failure(e.what());
        }

        saved_rig_params_ = rig_data;
        rig_changed_ = true;
    } else {
        result = true;
    }
    return result;
}

void Configuration::impl::set_cached_mode() {
    MODE mode{Transceiver::UNK};
    // override cache mode with what we want to enforce which includes
    // UNK (unknown) where we want to leave the rig mode untouched
    switch (data_mode_) {
    case data_mode_USB:
        mode = Transceiver::USB;
        break;
    case data_mode_data:
        mode = Transceiver::DIG_U;
        break;
    default:
        break;
    }

    cached_rig_state_.mode(mode);
}

void Configuration::impl::transceiver_frequency(Frequency f) {
    cached_rig_state_.online(true); // we want the rig online
    set_cached_mode();

    // apply any offset & calibration
    // we store the offset here for use in feedback from the rig, we
    // cannot absolutely determine if the offset should apply but by
    // simply picking an offset when the Rx frequency is set and
    // sticking to it we get sane behaviour
    cached_rig_state_.frequency(apply_calibration(f));

    Q_EMIT set_transceiver(cached_rig_state_, ++transceiver_command_number_);
}

void Configuration::impl::transceiver_tx_frequency(Frequency f) {
    Q_ASSERT(!f || split_mode());
    if (split_mode()) {
        cached_rig_state_.online(true); // we want the rig online
        set_cached_mode();
        cached_rig_state_.split(f);
        cached_rig_state_.tx_frequency(f);

        // lookup offset for tx and apply calibration
        if (f) {
            // apply and offset and calibration
            // we store the offset here for use in feedback from the
            // rig, we cannot absolutely determine if the offset should
            // apply but by simply picking an offset when the Rx
            // frequency is set and sticking to it we get sane behaviour
            cached_rig_state_.tx_frequency(apply_calibration(f));
        }

        Q_EMIT set_transceiver(cached_rig_state_,
                               ++transceiver_command_number_);
    }
}

void Configuration::impl::transceiver_mode(MODE m) {
    cached_rig_state_.online(true); // we want the rig online
    cached_rig_state_.mode(m);
    Q_EMIT set_transceiver(cached_rig_state_, ++transceiver_command_number_);
}

void Configuration::impl::transceiver_ptt(bool on) {
    cached_rig_state_.online(true); // we want the rig online
    set_cached_mode();
    cached_rig_state_.ptt(on);
    Q_EMIT set_transceiver(cached_rig_state_, ++transceiver_command_number_);
}

void Configuration::impl::sync_transceiver(bool /*force_signal*/) {
    // pass this on as cache must be ignored
    // Q_EMIT sync (force_signal);
}

void Configuration::impl::handle_transceiver_update(
    TransceiverState const &state, unsigned sequence_number) {
    qCDebug(configuration_js8)
        << "Configuration::handle_transceiver_update: Transceiver State #:"
        << sequence_number << state;

    // only follow rig on some information, ignore other stuff
    cached_rig_state_.online(state.online());
    cached_rig_state_.frequency(state.frequency());
    cached_rig_state_.mode(state.mode());
    cached_rig_state_.split(state.split());

    if (state.online()) {
        ui_->test_PTT_push_button->setChecked(state.ptt());

        if (isVisible()) {
            ui_->test_CAT_push_button->setStyleSheet(
                "QPushButton {background-color: green;}");

            auto const &rig = ui_->rig_combo_box->currentText();
            auto ptt_method = static_cast<TransceiverFactory::PTTMethod>(
                ui_->PTT_method_button_group->checkedId());
            auto CAT_PTT_enabled = transceiver_factory_.has_CAT_PTT(rig);
            ui_->test_PTT_push_button->setEnabled(
                (TransceiverFactory::PTT_method_CAT == ptt_method &&
                 CAT_PTT_enabled) ||
                TransceiverFactory::PTT_method_DTR == ptt_method ||
                TransceiverFactory::PTT_method_RTS == ptt_method);
        }
    } else {
        close_rig();
    }

    // pass on to clients if current command is processed
    if (sequence_number == transceiver_command_number_) {
        TransceiverState reported_state{state};
        // take off calibration & offset
        reported_state.frequency(
            remove_calibration(reported_state.frequency()));

        if (reported_state.tx_frequency()) {
            // take off calibration & offset
            reported_state.tx_frequency(
                remove_calibration(reported_state.tx_frequency()));
        }

        Q_EMIT self_->transceiver_update(reported_state);
    }
}

void Configuration::impl::handle_transceiver_failure(QString const &reason) {
    qCDebug(configuration_js8)
        << "Configuration::handle_transceiver_failure: reason:" << reason;
    close_rig();
    ui_->test_PTT_push_button->setChecked(false);

    if (isVisible()) {
        JS8MessageBox::critical_message(this, tr("Rig failure"), reason);
    } else {
        // pass on if our dialog isn't active
        Q_EMIT self_->transceiver_failure(reason);
    }
}

void Configuration::impl::close_rig() {
    ui_->test_PTT_push_button->setEnabled(false);

    // revert to no rig configured
    if (rig_active_) {
        ui_->test_CAT_push_button->setStyleSheet(
            "QPushButton {background-color: red;}");
        Q_EMIT stop_transceiver();
        for (auto const &connection : rig_connections_) {
            disconnect(connection);
        }
        rig_connections_.clear();
        rig_active_ = false;
    }
}

// find the audio device that matches the specified name, also
// populate into the selection combo box with any devices we find in
// the search

QAudioDevice
Configuration::impl::find_audio_device(QAudioDevice::Mode const mode,
                                       QComboBox *const combo_box,
                                       QString const &device_name) {
    if (device_name.size()) {
        Q_EMIT self_->enumerating_audio_devices();

        auto const &devices = mode == QAudioDevice::Input
                                  ? QMediaDevices::audioInputs()
                                  : QMediaDevices::audioOutputs();

        for (auto const &p : devices) {
            if (p.mode() == mode && p.description() == device_name) {
                combo_box->insertItem(0, p.description(),
                                      QVariant::fromValue(p));
                combo_box->setCurrentIndex(0);
                return p;
            }
        }

        // Insert a place holder for the not found device.

        combo_box->insertItem(0,
                              device_name + " (" +
                                  tr("Not found", "audio device missing") + ")",
                              QVariant::fromValue(QAudioDevice{}));
        combo_box->setCurrentIndex(0);
    }

    return {};
}

// load the available audio devices into the selection combo box and
// select the default device if the current device isn't set or isn't
// available

void Configuration::impl::load_audio_devices(QAudioDevice::Mode const mode,
                                             QComboBox *combo_box,
                                             QAudioDevice *device) {
    combo_box->clear();

    Q_EMIT self_->enumerating_audio_devices();
    int current_index = -1;

    auto const &devices = mode == QAudioDevice::Input
                              ? QMediaDevices::audioInputs()
                              : QMediaDevices::audioOutputs();

    for (auto const &p : devices) {
        qCDebug(configuration_js8)
            << "Configuration::impl::load_audio_devices" << Qt::endl
            << "                      id:" << p.id() << Qt::endl
            << "                    name:" << p.description() << Qt::endl
            << "                    mode:" << p.mode() << Qt::endl
            << "    channelConfiguration:" << p.channelConfiguration()
            << Qt::endl
            << "  supportedSampleFormats:" << p.supportedSampleFormats()
            << Qt::endl
            << "         preferredFormat:" << p.preferredFormat();

        auto const formats = p.supportedSampleFormats();

        // Filter out devices that do not support PCM sample formats.

        if (std::any_of(formats.begin(), formats.end(), [](auto const format) {
                return (format == QAudioFormat::SampleFormat::Int16 ||
                        format == QAudioFormat::SampleFormat::Int32 ||
                        format == QAudioFormat::SampleFormat::Float);
            })) {
            combo_box->addItem(p.description(), QVariant::fromValue(p));

            if (p == *device) {
                current_index = combo_box->count() - 1;
            }
        }
    }

    combo_box->setCurrentIndex(current_index);
}

// Enable only the channels that are supported by the selected audio device.
// The function above will have provided the device channel configuration,
// which is a QAudioFormat::ChannelConfig enumeration, as the item data of
// the source combo box.
//
// - If the channel configuration isn't unknown, then the device is usable,
//   perhaps only with a monaural channel, but at least usable.
//
// - If the device is usable, and has a configuration something other than
//   a monaural channel, then we're at least looking at a stereo device.
//   The device might have many more channels that just a left and right,
//   but it's at least stereo.

void Configuration::impl::update_audio_channels(
    QComboBox const *const source_combo_box, QComboBox const *combo_box,
    int const index, bool const allow_both) {
    auto const config = source_combo_box->itemData(index)
                            .value<QAudioDevice>()
                            .channelConfiguration();
    auto const usable = config != QAudioFormat::ChannelConfigUnknown;
    auto const mono = usable && config == QAudioFormat::ChannelConfigMono;
    auto const stereo = usable && config != QAudioFormat::ChannelConfigMono;
    auto model = dynamic_cast<QStandardItemModel *>(combo_box->model());

    model->item(AudioDevice::Mono)->setEnabled(mono);
    model->item(AudioDevice::Left)->setEnabled(stereo);
    model->item(AudioDevice::Right)->setEnabled(stereo);
    model->item(AudioDevice::Both)->setEnabled(stereo && allow_both);
}

void Configuration::impl::find_tab(QWidget *target) {
    for (auto const *parent = target->parentWidget(); parent;
         parent = parent->parentWidget()) {
        if (auto const index = ui_->configuration_tabs->indexOf(parent);
            index != -1) {
            ui_->configuration_tabs->setCurrentIndex(index);
            break;
        }
    }
    target->setFocus();
}

// load all the supported rig names into the selection combo box
void Configuration::impl::enumerate_rigs() {
    ui_->rig_combo_box->clear();

    auto rigs = transceiver_factory_.supported_transceivers();

    for (auto r = rigs.cbegin(); r != rigs.cend(); ++r) {
        if ("None" == r.key()) {
            // put None first
            ui_->rig_combo_box->insertItem(0, r.key(), r.value().model_number_);
        } else {
            int i;
            for (i = 1; i < ui_->rig_combo_box->count() &&
                        (r.key().toLower() >
                         ui_->rig_combo_box->itemText(i).toLower());
                 ++i)
                ;
            if (i < ui_->rig_combo_box->count())
                ui_->rig_combo_box->insertItem(i, r.key(),
                                               r.value().model_number_);
            else
                ui_->rig_combo_box->addItem(r.key(), r.value().model_number_);
        }
    }

    ui_->rig_combo_box->setCurrentText(rig_params_.rig_name);
}

void Configuration::impl::fill_port_combo_box(QComboBox *cb) {
    auto current_text = cb->currentText();
    cb->clear();
    Q_FOREACH (auto const &p, QSerialPortInfo::availablePorts()) {
        if (!p.portName().contains("NULL")) // virtual serial port pairs
        {
            // remove possibly confusing Windows device path (OK because
            // it gets added back by Hamlib)
            cb->addItem(
                p.systemLocation().remove(QRegularExpression{R"(^\\\\\.\\)"}));
        }
    }
    cb->addItem("USB");
    cb->setEditText(current_text);
}

auto Configuration::impl::apply_calibration(Frequency f) const -> Frequency {
    if (frequency_calibration_disabled_)
        return f;
    return std::llround(calibration_.intercept +
                        (1. + calibration_.slope_ppm / 1.e6) * f);
}

auto Configuration::impl::remove_calibration(Frequency f) const -> Frequency {
    if (frequency_calibration_disabled_)
        return f;
    return std::llround((f - calibration_.intercept) /
                        (1. + calibration_.slope_ppm / 1.e6));
}

// load the available network interfaces into the selection combo box
void Configuration::impl::load_network_interfaces(
    CheckableItemComboBox *combo_box, QStringList current) {
    combo_box->clear();
    for (auto const &net_if : QNetworkInterface::allInterfaces()) {
        auto flags = QNetworkInterface::IsUp | QNetworkInterface::CanMulticast;
        if ((net_if.flags() & flags) == flags) {
            bool check_it = current.contains(net_if.name());
            if (net_if.flags() & QNetworkInterface::IsLoopBack) {
                wsjtx_loopback_interface_name_ = net_if.name();
                if (!current.size()) {
                    check_it = true;
                }
            }
            auto item = combo_box->addCheckItem(
                net_if.humanReadableName(), net_if.name(),
                check_it ? Qt::Checked : Qt::Unchecked);
            auto tip =
                QString{"name(index): %1(%2) - %3"}
                    .arg(net_if.name())
                    .arg(net_if.index())
                    .arg(net_if.flags() & QNetworkInterface::IsUp ? "Up"
                                                                  : "Down");
            auto hw_addr = net_if.hardwareAddress();
            if (hw_addr.size()) {
                tip += QString{"\nhw: %1"}.arg(net_if.hardwareAddress());
            }
            auto aes = net_if.addressEntries();
            if (aes.size()) {
                tip += "\naddresses:";
                for (auto const &ae : aes) {
                    tip += QString{"\n  ip: %1/%2"}
                               .arg(ae.ip().toString())
                               .arg(ae.prefixLength());
                }
            }
            item->setToolTip(tip);
        }
    }
}

// Attaches a trailing warning icon that shows when `isInvalid()` returns true.
// Returns the QAction* in case you want to tweak tooltip/icon later.
QAction* Configuration::impl::attachRequiredIndicator(QLineEdit *edit,
                                                      const QString &toolTip)
{
    Q_ASSERT(edit);

    QAction *warn = edit->addAction(
        edit->style()->standardIcon(QStyle::SP_MessageBoxWarning),
        QLineEdit::TrailingPosition);

    warn->setToolTip(toolTip);
    warn->setVisible(false);

    auto update = [edit, warn]() {
        const bool invalid = edit->text().trimmed().isEmpty();
        warn->setVisible(invalid);
    };

    connect(edit, &QLineEdit::textChanged, edit,
                     [update](const QString&) { update(); });
    connect(edit, &QLineEdit::editingFinished, edit, update);

    update();
    return warn;
}

// get the selected network interfaces from the selection combo box
QStringList Configuration::impl::get_selected_network_interfaces(
    CheckableItemComboBox *combo_box) {
    QStringList interfaces;
    auto model = static_cast<QStandardItemModel *>(combo_box->model());
    for (int row = 0; row < model->rowCount(); ++row) {
        if (Qt::Checked == model->item(row)->checkState()) {
            interfaces << model->item(row)->data().toString();
        }
    }
    return interfaces;
}

#if !defined(QT_NO_DEBUG_STREAM)
ENUM_QDEBUG_OPS_IMPL(Configuration, DataMode);
#endif

ENUM_QDATASTREAM_OPS_IMPL(Configuration, DataMode);

ENUM_CONVERSION_OPS_IMPL(Configuration, DataMode);

Q_LOGGING_CATEGORY(configuration_js8, "configuration.js8", QtWarningMsg)
