#include "spectrumanalyzer.h"

#include "unit.h"
#include "CustomWidgets/toggleswitch.h"
#include "Device/manualcontroldialog.h"
#include "Traces/tracemodel.h"
#include "tracewidgetsa.h"
#include "Traces/tracesmithchart.h"
#include "Traces/tracexyplot.h"
#include "Traces/traceimportdialog.h"
#include "CustomWidgets/tilewidget.h"
#include "CustomWidgets/siunitedit.h"
#include "Traces/Marker/markerwidget.h"
#include "Tools/impedancematchdialog.h"
#include "ui_main.h"
#include "Device/virtualdevice.h"
#include "preferences.h"
#include "Generator/signalgenwidget.h"

#include <QDockWidget>
#include <QDesktopWidget>
#include <QApplication>
#include <QActionGroup>
#include "CustomWidgets/informationbox.h"
#include <QDebug>
#include <QGridLayout>
#include <QVBoxLayout>
#include <QHBoxLayout>
#include <QPushButton>
#include <math.h>
#include <QToolBar>
#include <QMenu>
#include <QToolButton>
#include <QActionGroup>
#include <QSpinBox>
#include <QCheckBox>
#include <QComboBox>
#include <QSettings>
#include <algorithm>
#include <QMessageBox>
#include <QFileDialog>
#include <QFile>
#include <iostream>
#include <fstream>
#include <QDateTime>

SpectrumAnalyzer::SpectrumAnalyzer(AppWindow *window, QString name)
    : Mode(window, name, "SA"),
      central(new TileWidget(traceModel, window)),
      firstPointTime(0)
{
    changingSettings = false;
    averages = 1;
    singleSweep = false;
    settings = {};
    normalize.active = false;
    normalize.measuring = false;
    normalize.points = 0;
    normalize.dialog.reset();
    normalize.f_start = 0;
    normalize.f_stop = 0;
    normalize.points = 0;
    normalize.Level = nullptr;
    normalize.measure = nullptr;
    normalize.enable = nullptr;

    traceModel.setSource(TraceModel::DataSource::SA);

    // Create default traces
    preset();

    // Create menu entries and connections
    // Sweep toolbar
    auto tb_sweep = new QToolBar("Sweep");

    auto bSingle = new QPushButton("Single");
    bSingle->setToolTip("Single sweep");
    bSingle->setCheckable(true);
    connect(bSingle, &QPushButton::toggled, this, &SpectrumAnalyzer::SetSingleSweep);
    connect(this, &SpectrumAnalyzer::singleSweepChanged, bSingle, &QPushButton::setChecked);
    tb_sweep->addWidget(bSingle);

    auto eStart = new SIUnitEdit("Hz", " kMG", 6);
    // calculate width required with expected string length
    auto width = QFontMetrics(eStart->font()).width("3.00000GHz") + 15;
    eStart->setFixedWidth(width);
    eStart->setToolTip("Start frequency");
    connect(eStart, &SIUnitEdit::valueChanged, this, &SpectrumAnalyzer::SetStartFreq);
    connect(this, &SpectrumAnalyzer::startFreqChanged, eStart, &SIUnitEdit::setValueQuiet);
    tb_sweep->addWidget(new QLabel("Start:"));
    tb_sweep->addWidget(eStart);

    auto eCenter = new SIUnitEdit("Hz", " kMG", 6);
    eCenter->setFixedWidth(width);
    eCenter->setToolTip("Center frequency");
    connect(eCenter, &SIUnitEdit::valueChanged, this, &SpectrumAnalyzer::SetCenterFreq);
    connect(this, &SpectrumAnalyzer::centerFreqChanged, eCenter, &SIUnitEdit::setValueQuiet);
    tb_sweep->addWidget(new QLabel("Center:"));
    tb_sweep->addWidget(eCenter);

    auto eStop = new SIUnitEdit("Hz", " kMG", 6);
    eStop->setFixedWidth(width);
    eStop->setToolTip("Stop frequency");
    connect(eStop, &SIUnitEdit::valueChanged, this, &SpectrumAnalyzer::SetStopFreq);
    connect(this, &SpectrumAnalyzer::stopFreqChanged, eStop, &SIUnitEdit::setValueQuiet);
    tb_sweep->addWidget(new QLabel("Stop:"));
    tb_sweep->addWidget(eStop);

    auto eSpan = new SIUnitEdit("Hz", " kMG", 6);
    eSpan->setFixedWidth(width);
    eSpan->setToolTip("Span");
    connect(eSpan, &SIUnitEdit::valueChanged, this, &SpectrumAnalyzer::SetSpan);
    connect(this, &SpectrumAnalyzer::spanChanged, eSpan, &SIUnitEdit::setValueQuiet);
    tb_sweep->addWidget(new QLabel("Span:"));
    tb_sweep->addWidget(eSpan);

    auto bFull = new QPushButton(QIcon::fromTheme("zoom-fit-best", QIcon(":/icons/zoom-fit.png")), "");
    bFull->setToolTip("Full span");
    connect(bFull, &QPushButton::clicked, this, &SpectrumAnalyzer::SetFullSpan);
    tb_sweep->addWidget(bFull);

    auto bZoomIn = new QPushButton(QIcon::fromTheme("zoom-in", QIcon(":/icons/zoom-in.png")), "");
    bZoomIn->setToolTip("Zoom in");
    connect(bZoomIn, &QPushButton::clicked, this, &SpectrumAnalyzer::SpanZoomIn);
    tb_sweep->addWidget(bZoomIn);

    auto bZoomOut = new QPushButton(QIcon::fromTheme("zoom-out", QIcon(":/icons/zoom-out.png")), "");
    bZoomOut->setToolTip("Zoom out");
    connect(bZoomOut, &QPushButton::clicked, this, &SpectrumAnalyzer::SpanZoomOut);
    tb_sweep->addWidget(bZoomOut);

    auto bZero = new QPushButton("0");
    bZero->setToolTip("Zero span");
    bZero->setMaximumWidth(28);
    bZero->setMaximumHeight(24);
    connect(bZero, &QPushButton::clicked, this, &SpectrumAnalyzer::SetZeroSpan);
    tb_sweep->addWidget(bZero);

    window->addToolBar(tb_sweep);
    toolbars.insert(tb_sweep);

    // Acquisition toolbar
    auto tb_acq = new QToolBar("Acquisition");

    auto eBandwidth = new SIUnitEdit("Hz", " k", 3);
    eBandwidth->setFixedWidth(70);
    eBandwidth->setToolTip("RBW");
    connect(eBandwidth, &SIUnitEdit::valueChanged, this, &SpectrumAnalyzer::SetRBW);
    connect(this, &SpectrumAnalyzer::RBWChanged, eBandwidth, &SIUnitEdit::setValueQuiet);
    tb_acq->addWidget(new QLabel("RBW:"));
    tb_acq->addWidget(eBandwidth);

    tb_acq->addWidget(new QLabel("Window:"));
    cbWindowType = new QComboBox();
    cbWindowType->addItem("None");
    cbWindowType->addItem("Kaiser");
    cbWindowType->addItem("Hann");
    cbWindowType->addItem("Flat Top");
    cbWindowType->setCurrentIndex(1);
    connect(cbWindowType, qOverload<int>(&QComboBox::currentIndexChanged), [=](int index) {
       SetWindow((VirtualDevice::SASettings::Window) index);
    });
    tb_acq->addWidget(cbWindowType);

    tb_acq->addWidget(new QLabel("Detector:"));
    cbDetector = new QComboBox();
    cbDetector->addItem("+Peak");
    cbDetector->addItem("-Peak");
    cbDetector->addItem("Sample");
    cbDetector->addItem("Normal");
    cbDetector->addItem("Average");
    cbDetector->setCurrentIndex(0);
    connect(cbDetector, qOverload<int>(&QComboBox::currentIndexChanged), [=](int index) {
       SetDetector((VirtualDevice::SASettings::Detector) index);
    });
    tb_acq->addWidget(cbDetector);

    tb_acq->addWidget(new QLabel("Averaging:"));
    lAverages = new QLabel("0/");
    tb_acq->addWidget(lAverages);
    auto sbAverages = new QSpinBox;
    sbAverages->setRange(1, 100);
    sbAverages->setRange(1, 99);
    sbAverages->setFixedWidth(40);
    connect(sbAverages, qOverload<int>(&QSpinBox::valueChanged), this, &SpectrumAnalyzer::SetAveraging);
    connect(this, &SpectrumAnalyzer::averagingChanged, sbAverages, &QSpinBox::setValue);
    tb_acq->addWidget(sbAverages);

    cbSignalID = new QCheckBox("Signal ID");
    connect(cbSignalID, &QCheckBox::toggled, this, &SpectrumAnalyzer::SetSignalID);
    tb_acq->addWidget(cbSignalID);

    window->addToolBar(tb_acq);
    toolbars.insert(tb_acq);

    // Tracking generator toolbar
    auto tb_trackgen = new QToolBar("Tracking Generator");
    auto cbTrackGenEnable = new QCheckBox("Tracking Generator");
    connect(cbTrackGenEnable, &QCheckBox::toggled, this, &SpectrumAnalyzer::SetTGEnabled);
    connect(this, &SpectrumAnalyzer::TGStateChanged, cbTrackGenEnable, &QCheckBox::setChecked);
    tb_trackgen->addWidget(cbTrackGenEnable);

    cbTrackGenPort = new QComboBox();
    cbTrackGenPort->addItem("Port 1");
    cbTrackGenPort->addItem("Port 2");
    cbTrackGenPort->setCurrentIndex(0);
    connect(cbTrackGenPort, qOverload<int>(&QComboBox::currentIndexChanged), this, &SpectrumAnalyzer::SetTGPort);
    connect(this, &SpectrumAnalyzer::TGPortChanged, cbTrackGenPort, qOverload<int>(&QComboBox::setCurrentIndex));
    tb_trackgen->addWidget(cbTrackGenPort);

    auto dbm = new QDoubleSpinBox();
    dbm->setFixedWidth(95);
    dbm->setRange(-100.0, 100.0);
    dbm->setSingleStep(0.25);
    dbm->setSuffix("dbm");
    dbm->setToolTip("Level");
    dbm->setKeyboardTracking(false);
    connect(dbm, qOverload<double>(&QDoubleSpinBox::valueChanged), this, &SpectrumAnalyzer::SetTGLevel);
    connect(this, &SpectrumAnalyzer::TGLevelChanged, dbm, &QDoubleSpinBox::setValue);
    tb_trackgen->addWidget(new QLabel("Level:"));
    tb_trackgen->addWidget(dbm);

    auto tgOffset = new SIUnitEdit("Hz", " kMG", 6);
    tgOffset->setFixedWidth(width);
    tgOffset->setToolTip("Tracking generator offset");
    connect(tgOffset, &SIUnitEdit::valueChanged, this, &SpectrumAnalyzer::SetTGOffset);
    connect(this, &SpectrumAnalyzer::TGOffsetChanged, tgOffset, &SIUnitEdit::setValueQuiet);
    tb_trackgen->addWidget(new QLabel("Offset:"));
    tb_trackgen->addWidget(tgOffset);

    normalize.enable = new QCheckBox("Normalize");
    tb_trackgen->addWidget(normalize.enable);
    connect(normalize.enable, &QCheckBox::toggled, this, &SpectrumAnalyzer::EnableNormalization);
    normalize.Level = new SIUnitEdit("dBm", " ", 3);
    normalize.Level->setFixedWidth(width);
    normalize.Level->setValue(0);
    normalize.Level->setToolTip("Level to normalize to");
    tb_trackgen->addWidget(new QLabel("To:"));
    tb_trackgen->addWidget(normalize.Level);
    normalize.measure = new QPushButton("Measure");
    normalize.measure->setToolTip("Perform normalization measurement");
    connect(normalize.measure, &QPushButton::clicked, this, &SpectrumAnalyzer::MeasureNormalization);
    tb_trackgen->addWidget(normalize.measure);

    window->addToolBar(tb_trackgen);
    toolbars.insert(tb_trackgen);

    markerModel = new MarkerModel(traceModel, this);

    auto tracesDock = new QDockWidget("Traces");
    traceWidget = new TraceWidgetSA(traceModel, window);
    tracesDock->setWidget(traceWidget);
    window->addDockWidget(Qt::LeftDockWidgetArea, tracesDock);
    docks.insert(tracesDock);


    auto markerWidget = new MarkerWidget(*markerModel);

    auto markerDock = new QDockWidget("Marker");
    markerDock->setWidget(markerWidget);
    window->addDockWidget(Qt::BottomDockWidgetArea, markerDock);
    docks.insert(markerDock);

    // Set initial GUI state
    deviceInfoUpdated();

    SetupSCPI();

    // Set initial TG settings
    SetTGLevel(-20.0);
    SetTGOffset(0);
    SetTGEnabled(false);

    // Set initial sweep settings
    auto& pref = Preferences::getInstance();

    if(pref.Acquisition.useMedianAveraging) {
        average.setMode(Averaging::Mode::Median);
    } else {
        average.setMode(Averaging::Mode::Mean);
    }

    if(pref.Startup.RememberSweepSettings) {
        LoadSweepSettings();
    } else {
        settings.freqStart = pref.Startup.SA.start;
        settings.freqStop = pref.Startup.SA.stop;
        ConstrainAndUpdateFrequencies();
        SetRBW(pref.Startup.SA.RBW);
        SetAveraging(pref.Startup.SA.averaging);
        settings.points = 1001;
        SetWindow((VirtualDevice::SASettings::Window) pref.Startup.SA.window);
        SetDetector((VirtualDevice::SASettings::Detector) pref.Startup.SA.detector);
        SetSignalID(pref.Startup.SA.signalID);
    }

    finalize(central);
}

void SpectrumAnalyzer::deactivate()
{
    StoreSweepSettings();
    Mode::deactivate();
}

void SpectrumAnalyzer::initializeDevice()
{
    connect(window->getDevice(), &VirtualDevice::SAmeasurementReceived, this, &SpectrumAnalyzer::NewDatapoint, Qt::UniqueConnection);

    // Configure initial state of device
    SettingsChanged();
}

nlohmann::json SpectrumAnalyzer::toJSON()
{
    nlohmann::json j;
    // save current sweep/acquisition settings
    nlohmann::json sweep;
    nlohmann::json freq;
    freq["start"] = settings.freqStart;
    freq["stop"] = settings.freqStop;
    sweep["frequency"] = freq;
    sweep["single"] = singleSweep;
    nlohmann::json acq;
    acq["RBW"] = settings.RBW;
    acq["window"] = WindowToString((VirtualDevice::SASettings::Window) settings.window).toStdString();
    acq["detector"] = DetectorToString((VirtualDevice::SASettings::Detector) settings.detector).toStdString();
    acq["signal ID"] = settings.signalID ? true : false;
    sweep["acquisition"] = acq;
    nlohmann::json tracking;
    tracking["enabled"] = settings.trackingGenerator ? true : false;
    tracking["port"] = settings.trackingPort ? 2 : 1;
    tracking["offset"] = settings.trackingOffset;
    tracking["power"] = (double) settings.trackingPower / 100.0; // convert to dBm
    sweep["trackingGenerator"] = tracking;

    if(normalize.active) {
        nlohmann::json norm;
        norm["start"] = normalize.f_start;
        norm["stop"] = normalize.f_stop;
        norm["points"] = normalize.points;
        norm["level"] = normalize.Level->value();
        nlohmann::json jCorr;
        for(auto m : normalize.portCorrection) {
            jCorr[m.first.toStdString()] = m.second;
        }
        norm["corrections"] = jCorr;
        sweep["normalization"] = norm;
    }
    j["sweep"] = sweep;

    j["traces"] = traceModel.toJSON();
    j["tiles"] = central->toJSON();
    j["markers"] = markerModel->toJSON();
    return j;
}

void SpectrumAnalyzer::fromJSON(nlohmann::json j)
{
    if(j.is_null()) {
        return;
    }
    if(j.contains("traces")) {
        traceModel.fromJSON(j["traces"]);
    }
    if(j.contains("tiles")) {
        central->fromJSON(j["tiles"]);
    }
    if(j.contains("markers")) {
        markerModel->fromJSON(j["markers"]);
    }
    if(j.contains("sweep")) {
        // restore sweep settings
        auto sweep = j["sweep"];
        if(sweep.contains("frequency")) {
            auto freq = sweep["frequency"];
            SetStartFreq(freq.value("start", settings.freqStart));
            SetStopFreq(freq.value("stop", settings.freqStop));
        }
        if(sweep.contains("acquisition")) {
            auto acq = sweep["acquisition"];
            SetRBW(acq.value("RBW", settings.RBW));
            auto w = WindowFromString(QString::fromStdString(acq.value("window", "")));
            if(w == VirtualDevice::SASettings::Window::Last) {
                // invalid, keep current value
                w = (VirtualDevice::SASettings::Window) settings.window;
            }
            SetWindow(w);
            auto d = DetectorFromString(QString::fromStdString(acq.value("detector", "")));
            if(d == VirtualDevice::SASettings::Detector::Last) {
                // invalid, keep current value
                d = (VirtualDevice::SASettings::Detector) settings.detector;
            }
            SetDetector(d);
            SetSignalID(acq.value("signal ID", settings.signalID ? true : false));
        }
        if(sweep.contains("trackingGenerator")) {
            auto tracking = sweep["trackingGenerator"];
            SetTGEnabled(tracking.value("enabled", settings.trackingGenerator ? true : false));
            int port = tracking.value("port", 1);
            // Function expects 0 for port1, 1 for port2
            SetTGPort(port - 1);
            SetTGLevel(tracking.value("power", settings.trackingPower));
            SetTGOffset(tracking.value("offset", settings.trackingOffset));
        }
        if(sweep.contains("normalization")) {
            auto norm = sweep["normalization"];
            // restore normalization data
            normalize.portCorrection.clear();
            if(norm.contains("corrections")) {
                for(auto& el : norm["corrections"].items()) {
                    normalize.portCorrection[QString::fromStdString(el.key())] = {};
                    for(auto p : el.value()) {
                        normalize.portCorrection[QString::fromStdString(el.key())].push_back(p);
                    }
                }
            }
            normalize.f_start = norm.value("start", normalize.f_start);
            normalize.f_stop = norm.value("stop", normalize.f_stop);
            normalize.points = norm.value("points", normalize.points);
            normalize.Level->setValue(norm.value("level", normalize.Level->value()));
            // check correction vector size
            bool correctSize = true;
            for(auto c : normalize.portCorrection) {
                if(c.second.size() != normalize.points) {
                    correctSize = false;
                    break;
                }
            }
            EnableNormalization(correctSize);
        }
        SetSingleSweep(sweep.value("single", singleSweep));
    }
}

using namespace std;

void SpectrumAnalyzer::NewDatapoint(VirtualDevice::SAMeasurement m)
{
    if(isActive != true) {
        return;
    }

    if(changingSettings) {
        // already setting new sweep settings, ignore incoming points from old settings
        return;
    }

    if(singleSweep && average.getLevel() == averages) {
        changingSettings = true;
        // single sweep finished
        window->getDevice()->setIdle([=](bool){
            changingSettings = false;
        });
    }

    if(m.pointNum >= settings.points) {
        qWarning() << "Ignoring point with too large point number (" << m.pointNum << ")";
        return;
    }

    auto m_avg = average.process(m);

    if(settings.freqStart == settings.freqStop) {
        // keep track of first point time
        if(m_avg.pointNum == 0) {
            firstPointTime = m_avg.us;
            m_avg.us = 0;
        } else {
            m_avg.us -= firstPointTime;
        }
    }

    if(normalize.measuring) {
        if(average.currentSweep() == averages) {
            // this is the last averaging sweep, use values for normalization
            if(normalize.portCorrection.size() > 0 || m_avg.pointNum == 0) {
                // add measurement
                for(auto m : m_avg.measurements) {
                    normalize.portCorrection[m.first].push_back(m.second);
                }
                if(m_avg.pointNum == settings.points - 1) {
                    // this was the last point
                    normalize.measuring = false;
                    normalize.f_start = settings.freqStart;
                    normalize.f_stop = settings.freqStop;
                    normalize.points = settings.points;
                    EnableNormalization(true);
                    qDebug() << "Normalization measurement complete";
                }
            }
        }
        int percentage = (((average.currentSweep() - 1) * 100) + (m_avg.pointNum + 1) * 100 / settings.points) / averages;
        normalize.dialog.setValue(percentage);
    }

    if(normalize.active) {
        double corr = pow(10.0, normalize.Level->value() / 20.0);
        for(auto &m : m_avg.measurements) {
            m.second /= normalize.portCorrection[m.first][m_avg.pointNum];
            m.second *= corr;
        }
    }

    traceModel.addSAData(m_avg, settings);
    emit dataChanged();
    if(m_avg.pointNum == settings.points - 1) {
        UpdateAverageCount();
        markerModel->updateMarkers();
    }
    static int lastPoint = 0;
    if(m_avg.pointNum > 0 && m_avg.pointNum != lastPoint + 1) {
        qWarning() << "Got point" << m_avg.pointNum << "but last received point was" << lastPoint << "("<<(m_avg.pointNum-lastPoint-1)<<"missed points)";
    }
    lastPoint = m_avg.pointNum;
}

void SpectrumAnalyzer::SettingsChanged()
{
    changingSettings = true;
    if(settings.freqStop - settings.freqStart >= 1000 || settings.freqStop - settings.freqStart <= 0) {
        settings.points = 1001;
    } else {
        settings.points = settings.freqStop - settings.freqStart + 1;
    }

    if(settings.trackingGenerator && settings.freqStop >= 25000000) {
        // Check point spacing.
        // The highband PLL used as the tracking generator is not able to reach every frequency exactly. This
        // could lead to sharp drops in the spectrum at certain frequencies. If the span is wide enough with
        // respect to the point number, it is ensured that every displayed point has at least one sample with
        // a reachable PLL frequency in it. Display a warning message if this is not the case with the current
        // settings.
        auto pointSpacing = (settings.freqStop - settings.freqStart) / (settings.points - 1);
        // The frequency resolution of the PLL is frequency dependent (due to PLL divider).
        // This code assumes some knowledge of the actual hardware and probably should be moved
        // onto the device at some point
        double minSpacing = 25000;
        auto stop = settings.freqStop;
        while(stop <= 3000000000) {
            minSpacing /= 2;
            stop *= 2;
        }
        if(pointSpacing < minSpacing) {
            auto requiredMinSpan = minSpacing * (settings.points - 1);
            auto message = QString() + "Due to PLL limitations, the tracking generator can not reach every frequency exactly. "
                            "With your current span, this could result in the signal not being detected at some bands. A minimum"
                            " span of " + Unit::ToString(requiredMinSpan, "Hz", " kMG") + " is recommended at this stop frequency.";
            InformationBox::ShowMessage("Warning", message, "TrackingGeneratorSpanTooSmallWarning");
        }
    }

    if(normalize.active) {
        // check if normalization is still valid
        if(normalize.f_start != settings.freqStart || normalize.f_stop != settings.freqStop || normalize.points != settings.points) {
            // normalization was taken at different settings, disable
            EnableNormalization(false);
            InformationBox::ShowMessage("Information", "Normalization was disabled because the span has been changed");
        }
    }

    if(window->getDevice() && isActive) {
        window->getDevice()->setSA(settings, [=](bool){
            // device received command
            changingSettings = false;
        });
    }
    average.reset(settings.points);
    UpdateAverageCount();
    traceModel.clearLiveData();
    emit traceModel.SpanChanged(settings.freqStart, settings.freqStop);
}

void SpectrumAnalyzer::SetStartFreq(double freq)
{
    settings.freqStart = freq;
    if(settings.freqStop < freq) {
        settings.freqStop = freq;
    }
    ConstrainAndUpdateFrequencies();
}

void SpectrumAnalyzer::SetStopFreq(double freq)
{
    settings.freqStop = freq;
    if(settings.freqStart > freq) {
        settings.freqStart = freq;
    }
    ConstrainAndUpdateFrequencies();
}

void SpectrumAnalyzer::SetCenterFreq(double freq)
{
    auto old_span = settings.freqStop - settings.freqStart;
    if (freq - old_span / 2 <= VirtualDevice::getInfo(window->getDevice()).Limits.minFreq) {
        // would shift start frequency below minimum
        settings.freqStart = 0;
        settings.freqStop = 2 * freq;
    } else if(freq + old_span / 2 >= VirtualDevice::getInfo(window->getDevice()).Limits.maxFreq) {
        // would shift stop frequency above maximum
        settings.freqStart = 2 * freq - VirtualDevice::getInfo(window->getDevice()).Limits.maxFreq;
        settings.freqStop = VirtualDevice::getInfo(window->getDevice()).Limits.maxFreq;
    } else {
        settings.freqStart = freq - old_span / 2;
        settings.freqStop = freq + old_span / 2;
    }
    ConstrainAndUpdateFrequencies();
}

void SpectrumAnalyzer::SetSpan(double span)
{
    auto old_center = (settings.freqStart + settings.freqStop) / 2;
    if(old_center < VirtualDevice::getInfo(window->getDevice()).Limits.minFreq + span / 2) {
        // would shift start frequency below minimum
        settings.freqStart = VirtualDevice::getInfo(window->getDevice()).Limits.minFreq;
        settings.freqStop = VirtualDevice::getInfo(window->getDevice()).Limits.minFreq + span;
    } else if(old_center > VirtualDevice::getInfo(window->getDevice()).Limits.maxFreq - span / 2) {
        // would shift stop frequency above maximum
        settings.freqStart = VirtualDevice::getInfo(window->getDevice()).Limits.maxFreq - span;
        settings.freqStop = VirtualDevice::getInfo(window->getDevice()).Limits.maxFreq;
    } else {
        settings.freqStart = old_center - span / 2;
         settings.freqStop = settings.freqStart + span;
    }
    ConstrainAndUpdateFrequencies();
}

void SpectrumAnalyzer::SetFullSpan()
{
    settings.freqStart = VirtualDevice::getInfo(window->getDevice()).Limits.minFreq;
    settings.freqStop = VirtualDevice::getInfo(window->getDevice()).Limits.maxFreq;
    ConstrainAndUpdateFrequencies();
}

void SpectrumAnalyzer::SetZeroSpan()
{
    auto center = (settings.freqStart + settings.freqStop) / 2;
    SetStartFreq(center);
    SetStopFreq(center);
}

void SpectrumAnalyzer::SpanZoomIn()
{
    auto center = (settings.freqStart + settings.freqStop) / 2;
    auto old_span = settings.freqStop - settings.freqStart;
    settings.freqStart = center - old_span / 4;
    settings.freqStop = center + old_span / 4;
    ConstrainAndUpdateFrequencies();
}

void SpectrumAnalyzer::SpanZoomOut()
{
    auto center = (settings.freqStart + settings.freqStop) / 2;
    auto old_span = settings.freqStop - settings.freqStart;
    if(center > old_span) {
        settings.freqStart = center - old_span;
    } else {
        settings.freqStart = 0;
    }
    settings.freqStop = center + old_span;
    ConstrainAndUpdateFrequencies();
}

void SpectrumAnalyzer::SetSingleSweep(bool single)
{
    if(singleSweep != single) {
        singleSweep = single;
        emit singleSweepChanged(single);
    }
    SettingsChanged();
}

void SpectrumAnalyzer::SetRBW(double bandwidth)
{
    if(bandwidth > VirtualDevice::getInfo(window->getDevice()).Limits.maxRBW) {
        bandwidth = VirtualDevice::getInfo(window->getDevice()).Limits.maxRBW;
    } else if(bandwidth < VirtualDevice::getInfo(window->getDevice()).Limits.minRBW) {
        bandwidth = VirtualDevice::getInfo(window->getDevice()).Limits.minRBW;
    }
    settings.RBW = bandwidth;
    emit RBWChanged(settings.RBW);
    SettingsChanged();
}

void SpectrumAnalyzer::SetWindow(VirtualDevice::SASettings::Window w)
{
    settings.window = w;
    cbWindowType->setCurrentIndex((int) w);
    SettingsChanged();
}

void SpectrumAnalyzer::SetDetector(VirtualDevice::SASettings::Detector d)
{
    settings.detector = d;
    cbDetector->setCurrentIndex((int) d);
    SettingsChanged();
}

void SpectrumAnalyzer::SetAveraging(unsigned int averages)
{
    this->averages = averages;
    average.setAverages(averages);
    emit averagingChanged(averages);
    SettingsChanged();
}

void SpectrumAnalyzer::SetSignalID(bool enabled)
{
    settings.signalID = enabled ? 1 : 0;
    cbSignalID->setChecked(enabled);
    SettingsChanged();
}

void SpectrumAnalyzer::SetTGEnabled(bool enabled)
{
    if(enabled != settings.trackingGenerator) {
        settings.trackingGenerator = enabled;
        emit TGStateChanged(enabled);
        SettingsChanged();
    }
    normalize.Level->setEnabled(enabled);
    normalize.enable->setEnabled(enabled);
    normalize.measure->setEnabled(enabled);
    if(!enabled && normalize.active) {
        // disable normalization when TG is turned off
        EnableNormalization(false);
    }
}

void SpectrumAnalyzer::SetTGPort(int port)
{
    if(port < 0 || port >= cbTrackGenPort->count()) {
        return;
    }
    if(port != settings.trackingPort) {
        settings.trackingPort = port;
        emit TGPortChanged(port);
        if(settings.trackingGenerator) {
             SettingsChanged();
        }
    }
}

void SpectrumAnalyzer::SetTGLevel(double level)
{
    if(level > VirtualDevice::getInfo(window->getDevice()).Limits.maxdBm) {
        level = VirtualDevice::getInfo(window->getDevice()).Limits.maxdBm;
    } else if(level < VirtualDevice::getInfo(window->getDevice()).Limits.mindBm) {
        level = VirtualDevice::getInfo(window->getDevice()).Limits.mindBm;
    }
    emit TGLevelChanged(level);
    settings.trackingPower = level * 100;
    if(settings.trackingGenerator) {
        SettingsChanged();
    }
}

void SpectrumAnalyzer::SetTGOffset(double offset)
{
    settings.trackingOffset = offset;

    ConstrainAndUpdateFrequencies();
    if(settings.trackingGenerator) {
        SettingsChanged();
    }
}

void SpectrumAnalyzer::MeasureNormalization()
{
    if(!window->getDevice()) {
        return;
    }
    normalize.active = false;
    normalize.portCorrection.clear();
    for(auto m : window->getDevice()->availableSAMeasurements()) {
        normalize.portCorrection[m] = {};
    }
    normalize.measuring = true;
    normalize.dialog.setLabelText("Taking normalization measurement...");
    normalize.dialog.setCancelButtonText("Abort");
    normalize.dialog.setWindowTitle("Normalization");
    normalize.dialog.setValue(0);
    normalize.dialog.setWindowModality(Qt::ApplicationModal);
    // always show the dialog
    normalize.dialog.setMinimumDuration(0);
    connect(&normalize.dialog, &QProgressDialog::canceled, this, &SpectrumAnalyzer::AbortNormalization);
    // trigger beginning of next sweep
    SettingsChanged();
}

void SpectrumAnalyzer::AbortNormalization()
{
    EnableNormalization(false);
    ClearNormalization();
    normalize.dialog.reset();
}

void SpectrumAnalyzer::EnableNormalization(bool enabled)
{
    if(enabled != normalize.active) {
        if(enabled) {
            // check if measurements already taken
            if(normalize.f_start == settings.freqStart && normalize.f_stop == settings.freqStop && normalize.points == settings.points) {
                // same settings as with normalization measurement, can enable
                normalize.active = true;
            } else {
                // needs to take measurement first
                MeasureNormalization();
            }
        } else {
            // disabled
            normalize.active = false;
        }
    }
    normalize.enable->blockSignals(true);
    normalize.enable->setChecked(normalize.active);
    normalize.enable->blockSignals(false);
}

void SpectrumAnalyzer::ClearNormalization()
{
    EnableNormalization(false);
    normalize.active = false;
    normalize.measuring = false;
    normalize.points = 0;
    normalize.portCorrection.clear();
    normalize.f_start = 0;
    normalize.f_stop = 0;
}

void SpectrumAnalyzer::SetNormalizationLevel(double level)
{
    normalize.Level->setValueQuiet(level);
    emit NormalizationLevelChanged(level);
}

void SpectrumAnalyzer::SetupSCPI()
{
    auto scpi_freq = new SCPINode("FREQuency");
    SCPINode::add(scpi_freq);
    scpi_freq->add(new SCPICommand("SPAN", [=](QStringList params) -> QString {
        unsigned long long newval;
        if(!SCPI::paramToULongLong(params, 0, newval)) {
            return SCPI::getResultName(SCPI::Result::Error);
        } else {
            SetSpan(newval);
            return SCPI::getResultName(SCPI::Result::Empty);
        }
    }, [=](QStringList) -> QString {
        return QString::number(settings.freqStop - settings.freqStart, 'f', 0);
    }));
    scpi_freq->add(new SCPICommand("START", [=](QStringList params) -> QString {
        unsigned long long newval;
        if(!SCPI::paramToULongLong(params, 0, newval)) {
            return SCPI::getResultName(SCPI::Result::Error);
        } else {
            SetStartFreq(newval);
            return SCPI::getResultName(SCPI::Result::Empty);
        }
    }, [=](QStringList) -> QString {
        return QString::number(settings.freqStart, 'f', 0);
    }));
    scpi_freq->add(new SCPICommand("CENTer", [=](QStringList params) -> QString {
        unsigned long long newval;
        if(!SCPI::paramToULongLong(params, 0, newval)) {
            return SCPI::getResultName(SCPI::Result::Error);
        } else {
            SetCenterFreq(newval);
            return SCPI::getResultName(SCPI::Result::Empty);
        }
    }, [=](QStringList) -> QString {
        return QString::number((settings.freqStart + settings.freqStop)/2, 'f', 0);
    }));
    scpi_freq->add(new SCPICommand("STOP", [=](QStringList params) -> QString {
        unsigned long long newval;
        if(!SCPI::paramToULongLong(params, 0, newval)) {
            return SCPI::getResultName(SCPI::Result::Error);
        } else {
            SetStopFreq(newval);
            return SCPI::getResultName(SCPI::Result::Empty);
        }
    }, [=](QStringList) -> QString {
        return QString::number(settings.freqStop, 'f', 0);
    }));
    scpi_freq->add(new SCPICommand("FULL", [=](QStringList params) -> QString {
        Q_UNUSED(params)
        SetFullSpan();
        return SCPI::getResultName(SCPI::Result::Empty);
    }, nullptr));
    scpi_freq->add(new SCPICommand("ZERO", [=](QStringList params) -> QString {
        Q_UNUSED(params)
        SetZeroSpan();
        return SCPI::getResultName(SCPI::Result::Empty);
    }, nullptr));
    auto scpi_acq = new SCPINode("ACQuisition");
    SCPINode::add(scpi_acq);
    scpi_acq->add(new SCPICommand("RBW", [=](QStringList params) -> QString {
        unsigned long long newval;
        if(!SCPI::paramToULongLong(params, 0, newval)) {
            return SCPI::getResultName(SCPI::Result::Error);
        } else {
            SetRBW(newval);
            return SCPI::getResultName(SCPI::Result::Empty);
        }
    }, [=](QStringList) -> QString {
        return QString::number(settings.RBW);
    }));
    scpi_acq->add(new SCPICommand("WINDow", [=](QStringList params) -> QString {
        if (params.size() != 1) {
            return SCPI::getResultName(SCPI::Result::Error);
        }
        if (params[0] == "NONE") {
            SetWindow(VirtualDevice::SASettings::Window::None);
        } else if(params[0] == "KAISER") {
            SetWindow(VirtualDevice::SASettings::Window::Kaiser);
        } else if(params[0] == "HANN") {
            SetWindow(VirtualDevice::SASettings::Window::Hann);
        } else if(params[0] == "FLATTOP") {
            SetWindow(VirtualDevice::SASettings::Window::FlatTop);
        } else {
            return "INVALID WINDOW";
        }
        return SCPI::getResultName(SCPI::Result::Empty);
    }, [=](QStringList) -> QString {
        switch((VirtualDevice::SASettings::Window) settings.window) {
        case VirtualDevice::SASettings::Window::None: return "NONE";
        case VirtualDevice::SASettings::Window::Kaiser: return "KAISER";
        case VirtualDevice::SASettings::Window::Hann: return "HANN";
        case VirtualDevice::SASettings::Window::FlatTop: return "FLATTOP";
        default: return SCPI::getResultName(SCPI::Result::Error);
        }
    }));
    scpi_acq->add(new SCPICommand("DETector", [=](QStringList params) -> QString {
        if (params.size() != 1) {
            return SCPI::getResultName(SCPI::Result::Error);
        }
        if (params[0] == "+PEAK") {
            SetDetector(VirtualDevice::SASettings::Detector::PPeak);
        } else if(params[0] == "-PEAK") {
            SetDetector(VirtualDevice::SASettings::Detector::NPeak);
        } else if(params[0] == "NORMAL") {
            SetDetector(VirtualDevice::SASettings::Detector::Normal);
        } else if(params[0] == "SAMPLE") {
            SetDetector(VirtualDevice::SASettings::Detector::Sample);
        } else if(params[0] == "AVERAGE") {
            SetDetector(VirtualDevice::SASettings::Detector::Average);
        } else {
            return "INVALID MDOE";
        }
        return SCPI::getResultName(SCPI::Result::Empty);
    }, [=](QStringList) -> QString {
        switch((VirtualDevice::SASettings::Detector) settings.detector) {
        case VirtualDevice::SASettings::Detector::PPeak: return "+PEAK";
        case VirtualDevice::SASettings::Detector::NPeak: return "-PEAK";
        case VirtualDevice::SASettings::Detector::Normal: return "NORMAL";
        case VirtualDevice::SASettings::Detector::Sample: return "SAMPLE";
        case VirtualDevice::SASettings::Detector::Average: return "AVERAGE";
        default: return SCPI::getResultName(SCPI::Result::Error);
        }
    }));
    scpi_acq->add(new SCPICommand("AVG", [=](QStringList params) -> QString {
        unsigned long long newval;
        if(!SCPI::paramToULongLong(params, 0, newval)) {
            return SCPI::getResultName(SCPI::Result::Error);
        } else {
            SetAveraging(newval);
            return SCPI::getResultName(SCPI::Result::Empty);
        }
    }, [=](QStringList) -> QString {
        return QString::number(averages);
    }));
    scpi_acq->add(new SCPICommand("AVGLEVel", nullptr, [=](QStringList) -> QString {
        return QString::number(average.getLevel());
    }));
    scpi_acq->add(new SCPICommand("FINished", nullptr, [=](QStringList) -> QString {
        return average.getLevel() == averages ? "TRUE" : "FALSE";
    }));
    scpi_acq->add(new SCPICommand("LIMit", nullptr, [=](QStringList) -> QString {
        return central->allLimitsPassing() ? "PASS" : "FAIL";
    }));
    scpi_acq->add(new SCPICommand("SIGid", [=](QStringList params) -> QString {
        if (params.size() != 1) {
            return SCPI::getResultName(SCPI::Result::Error);
        }
        if(params[0] == "1" || params[0] == "TRUE") {
            SetSignalID(true);
        } else if(params[0] == "0" || params[0] == "FALSE") {
            SetSignalID(false);
        } else {
            return SCPI::getResultName(SCPI::Result::Error);
        }
        return SCPI::getResultName(SCPI::Result::Empty);
    }, [=](QStringList) -> QString {
        return settings.signalID ? SCPI::getResultName(SCPI::Result::True) : SCPI::getResultName(SCPI::Result::False);
    }));
    scpi_acq->add(new SCPICommand("SINGLE", [=](QStringList params) -> QString {
        bool single;
        if(!SCPI::paramToBool(params, 0, single)) {
            return SCPI::getResultName(SCPI::Result::Error);
        } else {
            SetSingleSweep(single);
            return SCPI::getResultName(SCPI::Result::Empty);
        }
    }, [=](QStringList) -> QString {
        return singleSweep ? SCPI::getResultName(SCPI::Result::True): SCPI::getResultName(SCPI::Result::False);
    }));
    auto scpi_tg = new SCPINode("TRACKing");
    SCPINode::add(scpi_tg);
    scpi_tg->add(new SCPICommand("ENable", [=](QStringList params) -> QString {
        if (params.size() != 1) {
            return SCPI::getResultName(SCPI::Result::Error);
        }
        if(params[0] == "1" || params[0] == "TRUE") {
            SetTGEnabled(true);
        } else if(params[0] == "0" || params[0] == "FALSE") {
            SetTGEnabled(false);
        } else {
            return SCPI::getResultName(SCPI::Result::Error);
        }
        return SCPI::getResultName(SCPI::Result::Empty);
    }, [=](QStringList) -> QString {
        return settings.trackingGenerator ? SCPI::getResultName(SCPI::Result::True) : SCPI::getResultName(SCPI::Result::False);
    }));
    scpi_tg->add(new SCPICommand("Port", [=](QStringList params) -> QString {
        if (params.size() != 1) {
            return SCPI::getResultName(SCPI::Result::Error);
        }
        unsigned long long newval;
        if(!SCPI::paramToULongLong(params, 0, newval)) {
            return SCPI::getResultName(SCPI::Result::Error);
        } else if(newval <= VirtualDevice::getInfo(window->getDevice()).ports){
            SetTGPort(newval);
            return SCPI::getResultName(SCPI::Result::Empty);
        } else {
            // invalid port number
            return SCPI::getResultName(SCPI::Result::Error);
        }
        return SCPI::getResultName(SCPI::Result::Empty);
    }, [=](QStringList) -> QString {
        return QString::number(settings.trackingPort);
    }));
    scpi_tg->add(new SCPICommand("LVL", [=](QStringList params) -> QString {
        double newval;
        if(!SCPI::paramToDouble(params, 0, newval)) {
            return SCPI::getResultName(SCPI::Result::Error);
        } else {
            SetTGLevel(newval);
            return SCPI::getResultName(SCPI::Result::Empty);
        }
    }, [=](QStringList) -> QString {
        return QString::number(settings.trackingPower / 100.0);
    }));
    scpi_tg->add(new SCPICommand("OFFset", [=](QStringList params) -> QString {
        long newval;
        if(!SCPI::paramToLong(params, 0, newval)) {
            return SCPI::getResultName(SCPI::Result::Error);
        } else {
            SetTGOffset(newval);
            return SCPI::getResultName(SCPI::Result::Empty);
        }
    }, [=](QStringList) -> QString {
        return QString::number(settings.trackingOffset);
    }));
    auto scpi_norm = new SCPINode("NORMalize");
    scpi_tg->add(scpi_norm);
    scpi_norm->add(new SCPICommand("ENable", [=](QStringList params) -> QString {
        if (params.size() != 1) {
            return SCPI::getResultName(SCPI::Result::Error);
        }
        if(params[0] == "1" || params[0] == "TRUE") {
            EnableNormalization(true);
        } else if(params[0] == "0" || params[0] == "FALSE") {
            EnableNormalization(false);
        } else {
            return SCPI::getResultName(SCPI::Result::Error);
        }
        return SCPI::getResultName(SCPI::Result::Empty);
    }, [=](QStringList) -> QString {
        return normalize.active ? SCPI::getResultName(SCPI::Result::True) : SCPI::getResultName(SCPI::Result::False);
    }));
    scpi_norm->add(new SCPICommand("MEASure", [=](QStringList params) -> QString {
        Q_UNUSED(params)
        MeasureNormalization();
        return "";
    }, nullptr));
    scpi_norm->add(new SCPICommand("LVL", [=](QStringList params) -> QString {
        double newval;
        if(!SCPI::paramToDouble(params, 0, newval)) {
            return SCPI::getResultName(SCPI::Result::Error);
        } else {
            SetNormalizationLevel(newval);
            return SCPI::getResultName(SCPI::Result::Empty);
        }
    }, [=](QStringList) -> QString {
        return QString::number(normalize.Level->value());
    }));
    SCPINode::add(traceWidget);
}

void SpectrumAnalyzer::UpdateAverageCount()
{
    lAverages->setText(QString::number(average.getLevel()) + "/");
}

void SpectrumAnalyzer::ConstrainAndUpdateFrequencies()
{
    if(settings.freqStop > VirtualDevice::getInfo(window->getDevice()).Limits.maxFreq) {
        settings.freqStop = VirtualDevice::getInfo(window->getDevice()).Limits.maxFreq;
    }
    if(settings.freqStart > settings.freqStop) {
        settings.freqStart = settings.freqStop;
    }
    if(settings.freqStart < VirtualDevice::getInfo(window->getDevice()).Limits.minFreq) {
        settings.freqStart = VirtualDevice::getInfo(window->getDevice()).Limits.minFreq;
    }

    bool trackingOffset_limited = false;
    if(settings.freqStop + settings.trackingOffset > VirtualDevice::getInfo(window->getDevice()).Limits.maxFreq) {
        trackingOffset_limited = true;
        settings.trackingOffset = VirtualDevice::getInfo(window->getDevice()).Limits.maxFreq - settings.freqStop;
    }
    if(settings.freqStart + settings.trackingOffset < VirtualDevice::getInfo(window->getDevice()).Limits.minFreq) {
        trackingOffset_limited = true;
        settings.trackingOffset = VirtualDevice::getInfo(window->getDevice()).Limits.minFreq - settings.freqStart;
    }
    if(trackingOffset_limited) {
        InformationBox::ShowMessage("Warning", "The selected tracking generator offset is not reachable for all frequencies with the current span. "
                                    "The tracking generator offset has been constrained according to the selected start and stop frequencies");
    }
    emit startFreqChanged(settings.freqStart);
    emit stopFreqChanged(settings.freqStop);
    emit spanChanged(settings.freqStop - settings.freqStart);
    emit centerFreqChanged((settings.freqStop + settings.freqStart)/2);
    emit TGOffsetChanged(settings.trackingOffset);
    SettingsChanged();
}

void SpectrumAnalyzer::LoadSweepSettings()
{
    QSettings s;
    auto& pref = Preferences::getInstance();
    settings.freqStart = s.value("SAStart", pref.Startup.SA.start).toULongLong();
    settings.freqStop = s.value("SAStop", pref.Startup.SA.stop).toULongLong();
    ConstrainAndUpdateFrequencies();
    SetRBW(s.value("SARBW", pref.Startup.SA.RBW).toUInt());
    settings.points = 1001;
    SetWindow((VirtualDevice::SASettings::Window) s.value("SAWindow", pref.Startup.SA.window).toInt());
    SetDetector((VirtualDevice::SASettings::Detector) s.value("SADetector", pref.Startup.SA.detector).toInt());
    SetSignalID(s.value("SASignalID", pref.Startup.SA.signalID).toBool());
    SetAveraging(s.value("SAAveraging", pref.Startup.SA.averaging).toInt());
}

void SpectrumAnalyzer::StoreSweepSettings()
{
    QSettings s;
    s.setValue("SAStart", static_cast<unsigned long long>(settings.freqStart));
    s.setValue("SAStop", static_cast<unsigned long long>(settings.freqStop));
    s.setValue("SARBW", settings.RBW);
    s.setValue("SAWindow", (int) settings.window);
    s.setValue("SADetector", (int) settings.detector);
    s.setValue("SAAveraging", averages);
    s.setValue("SASignalID", static_cast<bool>(settings.signalID));
}

void SpectrumAnalyzer::createDefaultTracesAndGraphs(int ports)
{
    central->clear();
    auto traceXY = new TraceXYPlot(traceModel);
    traceXY->setYAxis(0, YAxis::Type::Magnitude, false, false, -120,0,10);
    traceXY->setYAxis(1, YAxis::Type::Disabled, false, true, 0,0,1);
    traceXY->updateSpan(settings.freqStart, settings.freqStop);

    central->setPlot(traceXY);

    QColor defaultColors[] = {Qt::yellow, Qt::blue, Qt::red, Qt::green, Qt::gray, Qt::cyan, Qt::magenta, Qt::white};

    for(int i=0;i<ports;i++) {
        QString param = "PORT"+QString::number(i+1);
        auto trace = new Trace(param, defaultColors[i], param);
        traceModel.addTrace(trace);
        traceXY->enableTrace(trace, true);
    }
}

void SpectrumAnalyzer::setAveragingMode(Averaging::Mode mode)
{
    average.setMode(mode);
}

void SpectrumAnalyzer::preset()
{
    for(auto t : traceModel.getTraces()) {
        if(Trace::isSAParameter(t->name())) {
            traceModel.removeTrace(t);
        }
    }
    // Create default traces
    createDefaultTracesAndGraphs(VirtualDevice::getInfo(window->getDevice()).ports);
}

void SpectrumAnalyzer::deviceInfoUpdated()
{
    // new device connected, throw away normalization
    ClearNormalization();
    auto tgPort = cbTrackGenPort->currentIndex();
    cbTrackGenPort->clear();
    for(unsigned int i=0;i<VirtualDevice::getInfo(window->getDevice()).ports;i++) {
        cbTrackGenPort->addItem("Port "+QString::number(i+1));
    }
    SetTGPort(tgPort);
}

QString SpectrumAnalyzer::WindowToString(VirtualDevice::SASettings::Window w)
{
    switch(w) {
    case VirtualDevice::SASettings::Window::None: return "None";
    case VirtualDevice::SASettings::Window::Kaiser: return "Kaiser";
    case VirtualDevice::SASettings::Window::Hann: return "Hann";
    case VirtualDevice::SASettings::Window::FlatTop: return "FlatTop";
    default: return "Unknown";
    }
}

VirtualDevice::SASettings::Window SpectrumAnalyzer::WindowFromString(QString s)
{
    for(int i=0;i<(int)VirtualDevice::SASettings::Window::Last;i++) {
        if(WindowToString((VirtualDevice::SASettings::Window) i) == s) {
            return (VirtualDevice::SASettings::Window) i;
        }
    }
    // not found
    return VirtualDevice::SASettings::Window::Last;
}

QString SpectrumAnalyzer::DetectorToString(VirtualDevice::SASettings::Detector d)
{
    switch(d) {
    case VirtualDevice::SASettings::Detector::PPeak: return "+Peak";
    case VirtualDevice::SASettings::Detector::NPeak: return "-Peak";
    case VirtualDevice::SASettings::Detector::Sample: return "Sample";
    case VirtualDevice::SASettings::Detector::Normal: return "Normal";
    case VirtualDevice::SASettings::Detector::Average: return "Average";
    default: return "Unknown";
    }
}

VirtualDevice::SASettings::Detector SpectrumAnalyzer::DetectorFromString(QString s)
{
    for(int i=0;i<(int)VirtualDevice::SASettings::Detector::Last;i++) {
        if(DetectorToString((VirtualDevice::SASettings::Detector) i) == s) {
            return (VirtualDevice::SASettings::Detector) i;
        }
    }
    // not found
    return VirtualDevice::SASettings::Detector::Last;
}