#include "device_menu.h"

#define ACTION_DEVICE_NAME_PROPERTY "device_name"

device_menu::device_menu(QWidget *parent)
    : QMenu(parent)
    , cur_action_(nullptr), none_action_(nullptr)
{
    group_action_ = new QActionGroup(this);
    deviceMenuUpdate(nullptr);
    connect(group_action_, SIGNAL(triggered(QAction*)), this, SLOT(on_act_triggered(QAction*)));
}

device_menu::device_menu(const QString &title, QWidget *parent)
    : QMenu(title, parent)
    , cur_action_(nullptr), none_action_(nullptr)
{
    group_action_ = new QActionGroup(this);
    deviceMenuUpdate(nullptr);
    connect(group_action_, SIGNAL(triggered(QAction*)), this, SLOT(on_act_triggered(QAction*)));
}

QMenu* device_menu::find_device_menu(const QString& dev_name)
{
    std::lock_guard<std::mutex>    lock(mutex_);
    std::vector<POPMENU>::iterator it = std::find(menus_.begin(), menus_.end(), dev_name);

    if(it == menus_.end())
        return nullptr;
    else
        return it->menu;
}
QAction* device_menu::find_device_config(const QString& dev_name, const QString& cfg_name)
{
  std::lock_guard<std::mutex>    lock(mutex_);
  std::vector<POPMENU>::iterator it = std::find(menus_.begin(), menus_.end(), dev_name);

    if(it == menus_.end())
        return NULL;

    for(size_t i = 0; i < it->actions.size(); ++i)
    {
        if(it->actions[i]->text() == cfg_name)
            return it->actions[i];
    }

    return NULL;
}

void device_menu::connectedDevice(const QString &device)
{
    QMenu* menu = find_device_menu(device);
    if (menu)
        menu->setEnabled(true);
}

void device_menu::disconnectedDevice(const QString &device)
{
    QMenu* menu = find_device_menu(device);
    if (menu)
        menu->setEnabled(false);
}

void device_menu::setOptionChecked(const QString &device, const QString &opt, bool checked)
{
    QAction* act = find_device_config(device, opt);

    if(act)
    {
        act->setChecked(checked);
        if(checked)
            cur_action_ = act;
        else
        {
            if(cur_action_ == act)
                cur_action_ = nullptr;
        }
    }
    else if(checked)
        cur_action_ = nullptr;
}

void device_menu::get_online_devices(QList<QString>& dev_names)
{
    std::lock_guard<std::mutex>    lock(mutex_);

    for(size_t i = 0; i < menus_.size(); ++i)
    {
        if(menus_[i].menu->isEnabled())
            dev_names.push_back(menus_[i].menu->title());
    }
}

void device_menu::deviceMenuUpdate(dev_que* que)
{
    std::lock_guard<std::mutex>    lock(mutex_);

    cur_action_ = nullptr;
    if(none_action_)
    {
        removeAction(none_action_);
        none_action_ = nullptr;
    }

    for(size_t i = 0; i < menus_.size(); ++i)
        menus_[i].menu->setEnabled(false);
    if (!que || que->scanners() == 0)
    {
        if(menus_.empty())
        {
            none_action_ = addAction(tr("no device"));
            none_action_->setEnabled(false);
        }

        return;
    }

    for (size_t i = 0; i < que->scanners(); i++)
    {
        SCANNER s = que->get_at(i);
        std::vector<POPMENU>::iterator it = std::find(menus_.begin(), menus_.end(), QString::fromStdString((s.name)));
        POPMENU pm;
        std::vector<std::string>    schemes;

        if(it == menus_.end())
            pm.menu = addMenu(QString::fromStdString(s.name));
        else
        {
            pm = *it;
            menus_.erase(it);
        }
        pm.menu->setEnabled(true);
        pm.menu->setToolTipsVisible(true);
        for(size_t j = 0; j < pm.actions.size(); ++j)
        {
            pm.menu->removeAction(pm.actions[j]);
            group_action_->removeAction(pm.actions[j]);
        }
        pm.actions.clear();
        s.cfg->get_all_schemes(schemes);
        for (size_t j = 0; j < schemes.size(); j++)
        {
            QAction *child = group_action_->addAction(QString::fromStdString(schemes[j]));
            child->setProperty(ACTION_DEVICE_NAME_PROPERTY, QVariant(QString::fromStdString(s.name)));
            child->setCheckable(true);

            if(que->opened_scanner_name() == s.name &&
                    schemes[j] == s.cfg->get_current_scheme_name())
            {
                cur_action_ = child;
                child->setChecked(true);
            }

            pm.menu->addAction(child);
            pm.actions.push_back(child);

            QString tips;
            if(tips.isNull())
            {
                tips = tr("default setting");
            }
        //    child->setToolTip(tips);
        }
        menus_.push_back(pm);
        s.cfg->release();
    }
}

void device_menu::on_act_triggered(QAction* act)
{
    QString deviceName = act->property(ACTION_DEVICE_NAME_PROPERTY).toString();
    QString opt = act->text();
    bool checked_now = act->isChecked();

    if(cur_action_ == act)
    {
        checked_now = false;
        act->setChecked(false);
        cur_action_ = nullptr;
//        emit scanOptionsChanged("", "", false);
//        return;
    }
    else {
        cur_action_ = act;
        checked_now = true;
    }

    emit scanOptionsChanged(deviceName, opt, checked_now);
}