#include "mainform.h"
#include "ui_mainform.h"
#include <QMessageBox>
#include <QCoreApplication>
#include <QDir>
#include <QSettings>
#include <QTextCodec>
#include "SimpleIni.h"

#include "imediadeviceinfo.h"

#ifndef MAX_STR_LEN
#define MAX_STR_LEN 512
#endif // !MAX_STR_LEN

#ifndef MAX_PATH
#define MAX_PATH 260
#endif // !MAX_PATH

typedef int (*lpfn_get_cameracountfun)();
typedef int (*lpfn_get_videodevice_namefun)(int device_id, char* buf, int len);
typedef int (*lpfn_get_videodevice_infofun)(int device_id, char* namebuf, int namelen, char* pathbuf, int pathlen);
typedef int (*lpfn_get_videodeviceid)(const char* dev_name);

static lpfn_get_cameracountfun get_cameracount = NULL;
static lpfn_get_videodevice_namefun get_videodevice_name = NULL;
static lpfn_get_videodevice_infofun get_videodevice_info = NULL;
static lpfn_get_videodevice_namefun	get_device_fullpathname = NULL;
static lpfn_get_videodeviceid get_videodeviceid = NULL;

static QList<AudioDeviceInfo> show_audio_dev(IAudioMgr* m_pAudioMgr, DevMode flag)
{
    int icnt, ocnt;
    QList< AudioDeviceInfo> result;
    if (flag & AudioInput) {
        icnt = m_pAudioMgr->audio_get_device_count(true);
        qDebug() << "audio input devices: " << icnt;
        for (int i = 0; i < icnt; ++i) {
            char strname[MAX_PATH] = { 0 };
            m_pAudioMgr->audio_get_device_name(strname, MAX_PATH, true, i);
            qDebug() << i << "=" << strname;
            AudioDeviceInfo info;
            info.name = strname;
            info.mod = AudioInput;
            result << info;
        }
    }

    if (flag & AudioOutput) {
        ocnt = m_pAudioMgr->audio_get_device_count(false);
        qDebug() << "audio output devices: " << ocnt;
        for (int i = 0; i < ocnt; ++i) {
            char strname[MAX_PATH] = { 0 };
            m_pAudioMgr->audio_get_device_name(strname, MAX_PATH, false, i);
            AudioDeviceInfo info;
            info.name = strname;
            info.mod = AudioOutput;
            result << info;
        }
    }

    return result;
}

static QList<AudioDeviceInfo> show_video_dev()
{
    int icount = get_cameracount();
    qDebug() << "video devices:" << icount;
    QList< AudioDeviceInfo> result;
    int inumber = 0;
    for (int i = 0; i < 64 && inumber < icount; ++i) {
        char strcamera[2 * MAX_PATH] = { 0 };
        if (0 == get_device_fullpathname(i, strcamera, 2 * MAX_PATH)) {
            qDebug() << inumber++ << " " << strcamera;
            AudioDeviceInfo info;
            info.name = strcamera;
            info.mod = VideoDevice;
            result << info;
        }
    }
    return result;
}

QList<AudioDeviceInfo> MainForm::availableDevices(DevMode mode)
{
    qDebug() << "Enter " << __FUNCTION__ << " " << mode;

    QList<AudioDeviceInfo> devList;
    if (mode & VideoDevice) {
        devList.append(show_video_dev());
    } else {
        if (mode & AudioInput || mode & AudioOutput) {
            devList.append(show_audio_dev(m_pAudioMgr, mode));
        }
    }
    return devList;
}

static void __audiomgrlog(void* user_data, const char* fmt, va_list arg)
{
	
}

MainForm::MainForm(QWidget *parent):
    QWidget(parent),
    ui(new Ui::MainForm), deviceInfoLib(nullptr), rootFilePath(), m_pAudioMgr(NULL)
{
    ui->setupUi(this);
    ui->tabWidget->setVisible(false);
    connect(ui->modeBox, QOverload<int>::of(&QComboBox::activated), this, &MainForm::modeChanged);
    connect(ui->deviceBox, QOverload<int>::of(&QComboBox::activated), this, &MainForm::deviceChanged);
    ui->modeBox->setCurrentIndex(0);
    modeChanged(0);
    ui->deviceBox->setCurrentIndex(0);
    deviceChanged(0);
}

MainForm::~MainForm()
{
    delete ui;
    if (m_pAudioMgr != NULL) {
        m_pAudioMgr->audio_mgr_terminate();
        DestroyIAudioMgrObj(m_pAudioMgr);
        m_pAudioMgr = NULL;
    }
	if (deviceInfoLib != nullptr) {
        deviceInfoLib->unload();
        delete deviceInfoLib;
    }
}

bool MainForm::loadExportFunctions()
{

    QString appDir = QCoreApplication::applicationDirPath();
    QString libAbsolutePath = appDir + "/libmediadeviceinfo.so";
    qDebug() << "Enter loadExportFunctions" << " " << libAbsolutePath;

    if (m_pAudioMgr == NULL) {
		audiomgr_callback_t t_callback = { 0 };
		t_callback.debug = &__audiomgrlog;
        m_pAudioMgr = CreateAudioMgrObj(&t_callback);
        if (m_pAudioMgr == NULL) {
            qDebug() << "Initialize AudioMgr failed";
            return false;
        } else {
            qDebug() << "Initialize AudioMgr succ";
            const int res = m_pAudioMgr->audio_mgr_initialize();
            if (res != 0) {
                qDebug() << "audio_mgr_initialize failed " << res;
                DestroyIAudioMgrObj(m_pAudioMgr);
                m_pAudioMgr = NULL;
                return false;
            } else  {
                qDebug() << "audio_mgr_initialize succ";

            }
        }
    }

    bool result = false;

    if (deviceInfoLib != nullptr) {
        return true;
    }
    qDebug() << "to load " << libAbsolutePath;
    deviceInfoLib = new QLibrary(libAbsolutePath);
    deviceInfoLib->load();

    do 
    {
        if (!deviceInfoLib->isLoaded()) {
            qDebug() << "Load libmediadeviceinfo.so failed: " << deviceInfoLib->errorString() << endl;
            break;
        }
        get_cameracount = (lpfn_get_cameracountfun)deviceInfoLib->resolve("rvc_videocap_get_device_count");
        if (!get_cameracount) {
            qDebug() << "Load rvc_videocap_get_device_count failed: " << deviceInfoLib->errorString() << endl;
            break;
        }
        get_videodevice_name = (lpfn_get_videodevice_namefun)deviceInfoLib->resolve("rvc_videocap_get_device_name");
        if (!get_videodevice_name) {
            qDebug() << "Load rvc_videocap_get_device_name failed: " << deviceInfoLib->errorString() << endl;
            break;
        }

        get_videodevice_info = (lpfn_get_videodevice_infofun)deviceInfoLib->resolve("rvc_videocap_get_device_info");
        if (!get_videodevice_info) {
            qDebug() << "Load rvc_videocap_get_device_info failed: " << deviceInfoLib->errorString() << endl;
            break;
        }

        get_device_fullpathname = (lpfn_get_videodevice_namefun)deviceInfoLib->resolve("rvc_videocap_get_device_fullpathname");
        if (!get_device_fullpathname) {
            qDebug() << "Load rvc_videocap_get_device_fullpathname failed: " << deviceInfoLib->errorString() << endl;
            break;
        }

        get_videodeviceid = (lpfn_get_videodeviceid)deviceInfoLib->resolve("rvc_videocap_get_video_device_id");
        if (!get_videodeviceid) {
            qDebug() << "Load rvc_videocap_get_video_device_id failed: " << deviceInfoLib->errorString() << endl;
            break;
        }

        result = true;

    } while (false);

    if (!result) {
        if (deviceInfoLib != nullptr) {
            deviceInfoLib->unload();
            delete deviceInfoLib;
            deviceInfoLib = nullptr;
        }
    }

    qDebug() << "Leave loadExportFunctions" << " " << result;
    return result;
}

#define COMBOX_AUDIO_INPUT_HANDFREE 0
#define COMBOX_AUDIO_OUTPUT_HANDFREE 1
#define COMBOX_AUDIO_INPUT_PICKUP 2
#define COMBOX_AUDIO_OUTPUT_PICKUP 3
#define COMBOX_CAMERA_FRONT_UP 4
#define COMBOX_CAMERA_BACK_BOTTOM 5
#define COMBOX_CAMERA_EWS 6


DevMode MainForm::convertIdx2Mode(int idx)
{
    DevMode result = DevMode::MediaALL;
    switch (idx) {
    case COMBOX_AUDIO_INPUT_HANDFREE:
        result = DevMode::AudioInput_HandFree;
        break;
    case COMBOX_AUDIO_OUTPUT_HANDFREE:
        result = DevMode::AudioOutput_HandFree;
        break;
    case COMBOX_AUDIO_INPUT_PICKUP:
        result = DevMode::AudioInput_PickUp;
        break;
    case COMBOX_AUDIO_OUTPUT_PICKUP:
        result = DevMode::AudioOutput_PickUp;
        break;
    case COMBOX_CAMERA_FRONT_UP:
        result = DevMode::VideoDevice_Env;
        break;
    case COMBOX_CAMERA_BACK_BOTTOM:
        result = DevMode::VideoDevice_Opt;
        break;
    case COMBOX_CAMERA_EWS:
        result = DevMode::VideoDevice_Ews;
        break;
    default:
        break;
    }
    return result;
}

void MainForm::modeChanged(int idx)
{
    ui->deviceBox->clear();
    DevMode mode = convertIdx2Mode(idx);
    if (deviceInfoLib != nullptr || loadExportFunctions()) {
        for (auto& deviceInfo : availableDevices(mode))
            ui->deviceBox->addItem(deviceInfo.name, QVariant::fromValue(deviceInfo));
    }
    ui->deviceBox->setCurrentIndex(0);
    deviceChanged(0);
}

void MainForm::deviceChanged(int idx)
{
    if (ui->deviceBox->count() == 0)
        return;
    if (idx == -1) {
        int newIdx = 0;
        const int selectIdx = ui->modeBox->currentIndex();
        DevMode mode = convertIdx2Mode(selectIdx);
        QVariant curName = getCurrentActiveDev(mode);
        for (int i = 0; i < ui->deviceBox->count() && curName.isValid(); ++i) {
            AudioDeviceInfo item = ui->deviceBox->itemData(i).value<AudioDeviceInfo>();
            qDebug() << "devicechange: "  << item.name << " vs " << curName.toString();
            if (item.name == curName.toString()) {
                newIdx = i;
                break;
            }
        }
        ui->deviceBox->setCurrentIndex(newIdx);
        qDebug() << "pre deviceChanged -1 with " << newIdx;
        deviceChanged(newIdx);
        qDebug() << "return deviceChanged -1 with " << newIdx;
        return;
    }

    qDebug() << "pre pre deviceChanged normal with " << idx;
    ui->deviceBox->itemData(idx).value<AudioDeviceInfo>();
    // device has changed
    qDebug() << "pre deviceChanged normal with " << idx;
    m_deviceInfo = ui->deviceBox->itemData(idx).value<AudioDeviceInfo>();
    qDebug() << "return deviceChanged normal with " << idx;
}

void MainForm::on_loadBtn_clicked()
{
    qDebug() << "Enter " << __FUNCTION__;
    const int selectIdx = ui->modeBox->currentIndex();
    modeChanged(selectIdx);
}

void MainForm::on_saveBtn_clicked()
{
    qDebug() << "Enter " << __FUNCTION__;
    const int selectIdx = ui->modeBox->currentIndex();
    DevMode mode = convertIdx2Mode(selectIdx);
    if (!setCurrentActiveDevThirdParty(mode, m_deviceInfo.name)) {
        QMessageBox::critical(this, "错误", "写入失败！请重试");
    } else {
        QMessageBox::information(this, "提示", "已应用！");
    }
}

QVariant MainForm::getCurrentActiveDev(DevMode mode)
{
    QString configPath = getRootIniPath();
    QSettings settings(configPath, QSettings::IniFormat);
    settings.setIniCodec("UTF-8");
    QVariant result;
    switch (mode) {
    case AudioInput_HandFree:
        settings.beginGroup("Audio");
        result = settings.value("handfree_in_dev");
        settings.endGroup();
        break;
    case AudioOutput_HandFree:
        settings.beginGroup("Audio");
        result = settings.value("handfree_out_dev");
        settings.endGroup();
        break;
    case AudioInput_PickUp:
        settings.beginGroup("Audio");
        result = settings.value("pickup_in_dev");
        settings.endGroup();
        break;
    case AudioOutput_PickUp:
        settings.beginGroup("Audio");
        result = settings.value("pickup_out_dev");
        settings.endGroup();
        break;
    case VideoDevice_Env:
        settings.beginGroup("Video");
        result = settings.value("EnvCamera");
        settings.endGroup();
        break;
    case VideoDevice_Opt:
        settings.beginGroup("Video");
        result = settings.value("OptCamera");
        settings.endGroup();
        break;
    case VideoDevice_Ews:
        settings.beginGroup("Video");
        result = settings.value("EwsCamera");
        settings.endGroup();
        break;
    case MediaALL:
        break;
    default:
        break;
    }

    qDebug() << "get " << mode << " " << result;
    return result;
}

bool MainForm::setCurrentActiveDevThirdParty(DevMode mode, QVariant value)
{
    QString configPath = getRootIniPath();
    CSimpleIniA ini;
    ini.SetUnicode(true);

    QByteArray ba = configPath.toLatin1();
    const char* str = ba.data();
    SI_Error rc = ini.LoadFile(str);
    if (rc != SI_OK) {
        qDebug() << "Load file " << configPath << " failed: " << rc;
        return false;
    };

    ini.SetSpaces(false);
    ini.SetMultiLine(false);

    const char* newValue = value.toByteArray().data();
    bool result = false;

    switch (mode) {
    case AudioInput_HandFree:
        rc = ini.SetValue("Audio", "handfree_in_dev", newValue);
        if(rc == SI_INSERTED) rc = ini.SetValue("Audio", "handfree_in_dev", newValue);
        result = !(rc < 0);
        break;
    case AudioOutput_HandFree:
        rc = ini.SetValue("Audio", "handfree_out_dev", newValue);
        if (rc == SI_INSERTED) rc = ini.SetValue("Audio", "handfree_out_dev", newValue);
        result = !(rc < 0);
        break;
    case AudioInput_PickUp:
        rc = ini.SetValue("Audio", "pickup_in_dev", newValue);
        if (rc == SI_INSERTED) rc = ini.SetValue("Audio", "pickup_in_dev", newValue);
        result = !(rc < 0);
        break;
    case AudioOutput_PickUp:
        rc = ini.SetValue("Audio", "pickup_out_dev", newValue);
        if (rc == SI_INSERTED) rc = ini.SetValue("Audio", "pickup_out_dev", newValue);
        result = !(rc < 0);
        break;
    case VideoDevice_Env:
        rc = ini.SetValue("Video", "EnvCamera", newValue);
        if (rc == SI_INSERTED) rc = ini.SetValue("Video", "EnvCamera", newValue);
        result = !(rc < 0);
        break;
    case VideoDevice_Opt:
        rc = ini.SetValue("Video", "OptCamera", newValue);
        if (rc == SI_INSERTED) rc = ini.SetValue("Video", "OptCamera", newValue);
        result = !(rc < 0);
        break;
    case VideoDevice_Ews:
        rc = ini.SetValue("Video", "EwsCamera", newValue);
        if (rc == SI_INSERTED) rc = ini.SetValue("Video", "EwsCamera", newValue);
        result = !(rc < 0);
        break;
    case MediaALL:
        break;
    default:
        break;
    }

    if (result && (rc = ini.SaveFile(str, false)) < 0) {
        if (result) {
            qDebug() << "SaveFile failed: " << rc;
            result = false;
        }
    }

    if (result) {
        QVariant newValue = getCurrentActiveDev(mode);
        if (newValue != value) {
            qDebug() << "newValue: " << newValue << " vs " << value;
            result = false;
        }
    }
    return result;
}


bool MainForm::setCurrentActiveDev(DevMode mode, QVariant value)
{
    QString configPath = getRootIniPath();
    QSettings settings(configPath, QSettings::IniFormat);
    settings.setIniCodec("UTF-8");
    //QVariant persistentValue(value);
    QString persistentValue = QString::fromLocal8Bit(value.toByteArray());
    QTextCodec* codec = QTextCodec::codecForName("UTF8");
    persistentValue = codec->fromUnicode(value.toString());
    qDebug() << "fromUnicode: " << persistentValue;
    bool result = false;
    switch (mode) {
    case AudioInput_HandFree:
        settings.beginGroup("Audio");
        settings.setValue("handfree_in_dev", persistentValue);
        settings.endGroup();
        result = true;
        break;
    case AudioOutput_HandFree:
        settings.beginGroup("Audio");
        settings.setValue("handfree_out_dev", persistentValue);
        settings.endGroup();
        result = true;
        break;
    case AudioInput_PickUp:
        settings.beginGroup("Audio");
        settings.setValue("pickup_in_dev", persistentValue);
        settings.endGroup();
        result = true;
        break;
    case AudioOutput_PickUp:
        settings.beginGroup("Audio");
        settings.setValue("pickup_out_dev", persistentValue);
        settings.endGroup();
        result = true;
        break;
    case VideoDevice_Env:
        settings.beginGroup("Video");
        settings.setValue("EnvCamera", persistentValue);
        settings.endGroup();
        result = true;
        break;
    case VideoDevice_Opt:
        settings.beginGroup("Video");
        settings.setValue("OptCamera", persistentValue);
        settings.endGroup();
        result = true;
        break;
    case VideoDevice_Ews:
        settings.beginGroup("Video");
        settings.setValue("EwsCamera", persistentValue);
        settings.endGroup();
        result = true;
        break;
    case MediaALL:
        break;
    default:
        break;
    }
    if (result) {
        QVariant newValue = getCurrentActiveDev(mode);
        if (newValue != value) {
            qDebug() << "newValue: " << newValue << " vs " << value;
            result = false;
        }
    }
    return result;
}

QString MainForm::getRootIniPath()
{
    if (rootFilePath.isEmpty()) {
        QString appDir = QCoreApplication::applicationDirPath();
        QDir dir(appDir); //bin
        dir.cdUp(); //1.2.3.4
        dir.cdUp(); //version
        dir.cdUp(); //Run
        dir.cd("hardwarecfg");
        QString rootIniPath = dir.absolutePath() + "/root.ini";
        //QFileInfoList rootInis = dir.entryInfoList(QStringList() << "root.ini", QDir::Files);
        qDebug() << "root path at media page: " << rootIniPath;
        rootFilePath = rootIniPath;
    }
    return rootFilePath;
}