#include <SoapySDR/Constants.h>
#include <imgui.h>
#include <utils/flog.h>
#include <module.h>
#include <gui/gui.h>
#include <gui/widgets/stepped_slider.h>
#include <signal_path/signal_path.h>
#include <SoapySDR/Device.hpp>
#include <SoapySDR/Modules.hpp>
#include <SoapySDR/Logger.hpp>
#include <core.h>
#include <gui/style.h>
#include <gui/smgui.h>

#define CONCAT(a, b) ((std::string(a) + b).c_str())

SDRPP_MOD_INFO{
    /* Name:            */ "soapy_source",
    /* Description:     */ "SoapySDR source module for SDR++",
    /* Author:          */ "Ryzerth",
    /* Version:         */ 0, 1, 5,
    /* Max instances    */ 1
};

ConfigManager config;

class SoapyModule : public ModuleManager::Instance {
public:
    SoapyModule(std::string name) {
        this->name = name;

        //TODO: Make module tune on source select change (in sdrpp_core)

        uiGains = new float[1];

        refresh();

        // Select default device
        config.acquire();
        std::string devName = config.conf["device"];
        config.release();
        selectDevice(devName);

        handler.ctx = this;
        handler.selectHandler = menuSelected;
        handler.deselectHandler = menuDeselected;
        handler.menuHandler = menuHandler;
        handler.startHandler = start;
        handler.stopHandler = stop;
        handler.tuneHandler = tune;
        handler.stream = &stream;
        sigpath::sourceManager.registerSource("SoapySDR", &handler);
    }

    ~SoapyModule() {
        stop(this);
        sigpath::sourceManager.unregisterSource("SoapySDR");
    }

    void postInit() {}

    void enable() {
        enabled = true;
    }

    void disable() {
        enabled = false;
    }

    bool isEnabled() {
        return enabled;
    }

    template <typename T>
    std::string to_string_with_precision(const T a_value, const int n = 6) {
        std::ostringstream out;
        out.precision(n);
        out << std::fixed << a_value;
        return out.str();
    }

private:
    void refresh() {
        txtDevList = "";
        try {
            devList = SoapySDR::Device::enumerate();
        }
        catch (const std::exception& e) {
            flog::error("Could not list devices: {}", e.what());
            return;
        }
        
        int i = 0;
        for (auto& dev : devList) {
            txtDevList += dev["label"] != "" ? dev["label"] : dev["driver"];
            txtDevList += '\0';
            i++;
        }
    }

    float selectBwBySr(double samplerate) {
        float cur = bandwidthList[1];
        std::vector<float> bwListReversed = bandwidthList;
        std::reverse(bwListReversed.begin(), bwListReversed.end());
        for (auto bw : bwListReversed) {
            if (bw >= samplerate) {
                cur = bw;
            }
            else {
                break;
            }
        }
        flog::info("Bandwidth for samplerate {0} is {1}", samplerate, cur);
        return cur;
    }

    void selectSampleRate(double samplerate) {
        flog::info("Setting sample rate to {0}", samplerate);
        if (sampleRates.size() == 0) {
            devId = -1;
            return;
        }
        bool found = false;
        int i = 0;
        for (auto& sr : sampleRates) {
            if (sr == samplerate) {
                srId = i;
                sampleRate = sr;
                found = true;
                core::setInputSampleRate(sampleRate);
                break;
            }
            i++;
        }
        if (!found) {
            // Select default sample rate
            selectSampleRate(sampleRates[0]);
        }
    }

    void selectDevice(std::string name) {
        if (devList.size() == 0) {
            devId = -1;
            return;
        }
        bool found = false;
        int i = 0;
        for (auto& args : devList) {
            if (args["label"] == name) {
                devArgs = args;
                devId = i;
                found = true;
                break;
            }
            i++;
        }
        if (!found) {
            // If device was not found, select default device instead
            selectDevice(devList[0]["label"]);
            return;
        }

        SoapySDR::Device* dev = NULL;
        try {
            dev = SoapySDR::Device::make(devArgs);
        }
        catch (const std::exception& e) {
            flog::error("Could not open device: {}", e.what());
            return;
        }

        antennaList = dev->listAntennas(SOAPY_SDR_RX, channelId);
        txtAntennaList = "";
        for (const std::string& ant : antennaList) {
            txtAntennaList += ant + '\0';
        }

        gainList = dev->listGains(SOAPY_SDR_RX, channelId);
        delete[] uiGains;
        uiGains = new float[gainList.size()];
        gainRanges.clear();

        for (auto gain : gainList) {
            gainRanges.push_back(dev->getGainRange(SOAPY_SDR_RX, channelId, gain));
        }

        SoapySDR::RangeList bandwidthRange = dev->getBandwidthRange(SOAPY_SDR_RX, channelId);

        txtBwList = "";
        bandwidthList.clear();
        bandwidthList.push_back(-1);
        txtBwList += "Auto";
        txtBwList += '\0';

        for (auto bwr : bandwidthRange) {
            float bw = bwr.minimum();
            bandwidthList.push_back(bw);
            if (bw > 1.0e3 && bw <= 1.0e6) {
                txtBwList += to_string_with_precision((bw / 1.0e3), 2) + " kHz";
            }
            else if (bw > 1.0e6) {
                txtBwList += to_string_with_precision((bw / 1.0e6), 2) + " MHz";
            }
            else {
                txtBwList += to_string_with_precision(bw, 0);
            }
            txtBwList += '\0';
        }

        sampleRates = dev->listSampleRates(SOAPY_SDR_RX, channelId);
        txtSrList = "";
        for (double sr : sampleRates) {
            if (sr > 1.0e3 && sr <= 1.0e6) {
                txtSrList += to_string_with_precision((sr / 1.0e3), 2) + " kHz";
            }
            else if (sr > 1.0e6) {
                txtSrList += to_string_with_precision((sr / 1.0e6), 2) + " MHz";
            }
            else {
                txtSrList += to_string_with_precision(sr, 0);
            }
            txtSrList += '\0';
        }

        hasAgc = dev->hasGainMode(SOAPY_SDR_RX, channelId);

        SoapySDR::Device::unmake(dev);

        config.acquire();
        if (config.conf["devices"].contains(name)) {
            if (config.conf["devices"][name].contains("antenna")) {
                uiAntennaId = config.conf["devices"][name]["antenna"];
            }
            else {
                uiAntennaId = 0;
            }
            int i = 0;
            for (auto gain : gainList) {
                if (config.conf["devices"][name]["gains"].contains(gain)) {
                    uiGains[i] = config.conf["devices"][name]["gains"][gain];
                }
                else {
                    uiGains[i] = gainRanges[i].minimum();
                }
                i++;
            }
            if (config.conf["devices"][name].contains("bandwidth")) {
                uiBandwidthId = config.conf["devices"][name]["bandwidth"];
            }
            else if (bandwidthList.size() > 2) {
                uiBandwidthId = 0;
            }
            if (hasAgc && config.conf["devices"][name].contains("agc")) {
                agc = config.conf["devices"][name]["agc"];
            }
            else {
                agc = false;
            }
            if (config.conf["devices"][name].contains("sampleRate")) {
                selectSampleRate(config.conf["devices"][name]["sampleRate"]);
            }
            else {
                selectSampleRate(sampleRates[0]);
            }
        }
        else {
            uiAntennaId = 0;
            int i = 0;
            for (auto gain : gainList) {
                uiGains[i] = gainRanges[i].minimum();
                i++;
            }
            if (bandwidthList.size() > 2)
                uiBandwidthId = 0;
            if (hasAgc) {
                agc = false;
            }
            selectSampleRate(sampleRates[0]); // Select default
        }
        config.release();
    }

    void saveCurrent() {
        json conf;
        conf["sampleRate"] = sampleRate;
        conf["antenna"] = uiAntennaId;
        int i = 0;
        for (auto gain : gainList) {
            conf["gains"][gain] = uiGains[i];
            i++;
        }
        if (bandwidthList.size() > 2)
            conf["bandwidth"] = uiBandwidthId;
        if (hasAgc) {
            conf["agc"] = agc;
        }
        config.acquire();
        config.conf["devices"][devArgs["label"]] = conf;
        config.release(true);
    }

    static void menuSelected(void* ctx) {
        SoapyModule* _this = (SoapyModule*)ctx;
        flog::info("SoapyModule '{0}': Menu Select!", _this->name);
        if (_this->devList.size() == 0) {
            return;
        }
        core::setInputSampleRate(_this->sampleRate);
    }

    static void menuDeselected(void* ctx) {
        SoapyModule* _this = (SoapyModule*)ctx;
        flog::info("SoapyModule '{0}': Menu Deselect!", _this->name);
    }

    static void start(void* ctx) {
        SoapyModule* _this = (SoapyModule*)ctx;
        if (_this->running) { return; }
        if (_this->devId < 0) {
            flog::error("No device available");
            return;
        }

        try {
            _this->dev = SoapySDR::Device::make(_this->devArgs);
        }
        catch (const std::exception& e) {
            flog::error("Failed to open device: {}", e.what());
            return;
        }

        _this->dev->setSampleRate(SOAPY_SDR_RX, _this->channelId, _this->sampleRate);

        _this->dev->setAntenna(SOAPY_SDR_RX, _this->channelId, _this->antennaList[_this->uiAntennaId]);

        if (_this->bandwidthList.size() > 2) {
            if (_this->bandwidthList[_this->uiBandwidthId] == -1)
                _this->dev->setBandwidth(SOAPY_SDR_RX, _this->channelId, _this->selectBwBySr(_this->sampleRates[_this->srId]));
            else
                _this->dev->setBandwidth(SOAPY_SDR_RX, _this->channelId, _this->bandwidthList[_this->uiBandwidthId]);
        }

        if (_this->hasAgc) {
            _this->dev->setGainMode(SOAPY_SDR_RX, _this->channelId, _this->agc);
        }

        int i = 0;
        for (auto gain : _this->gainList) {
            _this->dev->setGain(SOAPY_SDR_RX, _this->channelId, gain, _this->uiGains[i]);
            i++;
        }

        _this->dev->setFrequency(SOAPY_SDR_RX, _this->channelId, _this->freq);

        _this->devStream = _this->dev->setupStream(SOAPY_SDR_RX, "CF32");
        _this->dev->activateStream(_this->devStream);
        _this->running = true;
        _this->workerThread = std::thread(_worker, _this);
        flog::info("SoapyModule '{0}': Start!", _this->name);
    }

    static void stop(void* ctx) {
        SoapyModule* _this = (SoapyModule*)ctx;
        if (!_this->running) { return; }
        _this->running = false;
        _this->dev->deactivateStream(_this->devStream);
        _this->dev->closeStream(_this->devStream);
        _this->stream.stopWriter();
        _this->workerThread.join();
        _this->stream.clearWriteStop();
        SoapySDR::Device::unmake(_this->dev);

        flog::info("SoapyModule '{0}': Stop!", _this->name);
    }

    static void tune(double freq, void* ctx) {
        SoapyModule* _this = (SoapyModule*)ctx;
        _this->freq = freq;
        if (_this->running) {
            _this->dev->setFrequency(SOAPY_SDR_RX, _this->channelId, freq);
        }
        flog::info("SoapyModule '{0}': Tune: {1}!", _this->name, freq);
    }

    static void menuHandler(void* ctx) {
        SoapyModule* _this = (SoapyModule*)ctx;

        // If no device is selected, draw only the refresh button
        if (_this->devId < 0) {
            SmGui::FillWidth();
            SmGui::ForceSync();
            if (SmGui::Button(CONCAT("Refresh##_dev_select_", _this->name))) {
                _this->refresh();
                _this->selectDevice(config.conf["device"]);
            }
            return;
        }

        if (_this->running) { SmGui::BeginDisabled(); }

        SmGui::FillWidth();
        SmGui::ForceSync();
        if (SmGui::Combo(CONCAT("##_dev_select_", _this->name), &_this->devId, _this->txtDevList.c_str())) {
            _this->selectDevice(_this->devList[_this->devId]["label"]);
            config.acquire();
            config.conf["device"] = _this->devList[_this->devId]["label"];
            config.release(true);
        }

        if (SmGui::Combo(CONCAT("##_sr_select_", _this->name), &_this->srId, _this->txtSrList.c_str())) {
            _this->selectSampleRate(_this->sampleRates[_this->srId]);
            if (_this->bandwidthList.size() > 2 && _this->running && _this->bandwidthList[_this->uiBandwidthId] == -1)
                _this->dev->setBandwidth(SOAPY_SDR_RX, _this->channelId, _this->selectBwBySr(_this->sampleRates[_this->srId]));
            _this->saveCurrent();
        }

        SmGui::SameLine();
        SmGui::FillWidth();
        if (SmGui::Button(CONCAT("Refresh##_dev_select_", _this->name))) {
            _this->refresh();
            _this->selectDevice(config.conf["device"]);
        }

        if (_this->running) { SmGui::EndDisabled(); }

        if (_this->antennaList.size() > 1) {
            SmGui::LeftLabel("Antenna");
            SmGui::FillWidth();
            if (SmGui::Combo(CONCAT("##_antenna_select_", _this->name), &_this->uiAntennaId, _this->txtAntennaList.c_str())) {
                if (_this->running)
                    _this->dev->setAntenna(SOAPY_SDR_RX, _this->channelId, _this->antennaList[_this->uiAntennaId]);
                _this->saveCurrent();
            }
        }

        // float gainNameLen = 0;
        // float len;
        // for (auto gain : _this->gainList) {
        //     len = ImGui::CalcTextSize((gain + " gain").c_str()).x;
        //     if (len > gainNameLen) {
        //         gainNameLen = len;
        //     }
        // }
        // gainNameLen += 5.0f;

        if (_this->hasAgc) {
            if (SmGui::Checkbox((std::string("AGC##_agc_sel_") + _this->name).c_str(), &_this->agc)) {
                if (_this->running) { _this->dev->setGainMode(SOAPY_SDR_RX, _this->channelId, _this->agc); }
                // When disabled, reset the gains
                if (!_this->agc) {
                    int i = 0;
                    for (auto gain : _this->gainList) {
                        _this->dev->setGain(SOAPY_SDR_RX, _this->channelId, gain, _this->uiGains[i]);
                        i++;
                    }
                }
                _this->saveCurrent();
            }
        }

        int i = 0;
        char buf[128];
        for (auto gain : _this->gainList) {
            sprintf(buf, "%s gain", gain.c_str());
            SmGui::LeftLabel(buf);
            // ImGui::SetCursorPosX(gainNameLen);
            // ImGui::SetNextItemWidth(menuWidth - gainNameLen);
            float step = _this->gainRanges[i].step();
            bool res;
            SmGui::FillWidth();
            if (step == 0.0f) {
                res = SmGui::SliderFloat((std::string("##_gain_sel_") + _this->name + gain).c_str(), &_this->uiGains[i], _this->gainRanges[i].minimum(), _this->gainRanges[i].maximum());
            }
            else {
                res = SmGui::SliderFloatWithSteps((std::string("##_gain_sel_") + _this->name + gain).c_str(), &_this->uiGains[i], _this->gainRanges[i].minimum(), _this->gainRanges[i].maximum(), step);
            }
            if (res) {
                if (_this->running) {
                    _this->dev->setGain(SOAPY_SDR_RX, _this->channelId, gain, _this->uiGains[i]);
                }
                _this->saveCurrent();
            }
            i++;
        }
        if (_this->bandwidthList.size() > 2) {
            SmGui::LeftLabel("Bandwidth");
            SmGui::FillWidth();
            if (SmGui::Combo(CONCAT("##_bw_select_", _this->name), &_this->uiBandwidthId, _this->txtBwList.c_str())) {
                if (_this->running) {
                    if (_this->bandwidthList[_this->uiBandwidthId] == -1)
                        _this->dev->setBandwidth(SOAPY_SDR_RX, _this->channelId, _this->selectBwBySr(_this->sampleRates[_this->srId]));
                    else
                        _this->dev->setBandwidth(SOAPY_SDR_RX, _this->channelId, _this->bandwidthList[_this->uiBandwidthId]);
                }
                _this->saveCurrent();
            }
        }
    }

    static void _worker(SoapyModule* _this) {
        int blockSize = _this->sampleRate / 200.0f;
        int flags = 0;
        long long timeMs = 0;

        while (_this->running) {
            int res = _this->dev->readStream(_this->devStream, (void**)&_this->stream.writeBuf, blockSize, flags, timeMs);
            if (res < 1) {
                continue;
            }
            if (!_this->stream.swap(res)) { return; }
        }
    }

    std::string name;
    bool enabled = true;
    dsp::stream<dsp::complex_t> stream;
    SoapySDR::Stream* devStream;
    SourceManager::SourceHandler handler;
    SoapySDR::KwargsList devList;
    SoapySDR::Kwargs devArgs;
    SoapySDR::Device* dev;
    std::string txtDevList;
    std::string txtSrList;
    std::thread workerThread;
    int devId = -1;
    double freq;
    double sampleRate;
    bool running = false;
    bool hasAgc = false;
    bool agc = false;
    std::vector<double> sampleRates;
    int srId = -1;
    float* uiGains;
    int channelCount = 1;
    int channelId = 0;
    int uiAntennaId = 0;
    std::vector<std::string> antennaList;
    std::string txtAntennaList;
    std::vector<std::string> gainList;
    std::vector<SoapySDR::Range> gainRanges;
    int uiBandwidthId = 0;
    std::vector<float> bandwidthList;
    std::string txtBwList;
};

MOD_EXPORT void _INIT_() {
    config.setPath(core::args["root"].s() + "/soapy_source_config.json");
    json defConf;
    defConf["device"] = "";
    defConf["devices"] = json({});
    config.load(defConf);
    config.enableAutoSave();
}

MOD_EXPORT ModuleManager::Instance* _CREATE_INSTANCE_(std::string name) {
    return new SoapyModule(name);
}

MOD_EXPORT void _DELETE_INSTANCE_(ModuleManager::Instance* instance) {
    delete (SoapyModule*)instance;
}

MOD_EXPORT void _END_() {
    config.disableAutoSave();
    config.save();
}
