#include "xsteam_ui.h"
xsteam_ui::xsteam_ui(QWidget *parent) : QWidget(parent),
                                        main_layout(new QVBoxLayout),
                                        info_layout(new QHBoxLayout),
                                        mind_layout(new QVBoxLayout),
                                        foot_layout(new QHBoxLayout)
{
   xsteam_init_info_layout();
   xsteam_init_mind_layout();
   xsteam_init_foot_layout();
   xsteam_init_style();
   xsteam_init_main_layout();
   xsteam_init_connect();
   slots_disable_enable_function(false);
   QFuture<void> future = QtConcurrent::run([=]()
                                            { 
     bool steam_ok=false;
     bool steamtools_ok=false;
     emit signals_src_combobox_update();
     slots_disable_enable_function(true); 
     table_load_ui_data();
     if(!xsteam_steam_steamtools_exists(steam_ok,steamtools_ok)){
         slots_msg_text("请检查steam和steamtools路径");
          btn_run_steam->setEnabled(steam_ok);
          btn_run_steamtools->setEnabled(steamtools_ok);
          btn_uid_push->setEnabled(false);
   } });
}
xsteam_ui::~xsteam_ui()
{
}
void xsteam_ui::xsteam_init_main_layout()
{
   main_layout->addLayout(mind_layout);
   main_layout->addLayout(foot_layout);
   setLayout(main_layout);
}
void xsteam_ui::xsteam_init_info_layout()
{
   info_layout = new QHBoxLayout();
   info_txt_tag = new QLabel(tr("本工具建议配合SteamTools和Steam++使用"));
   info_layout->addItem(sparcer_item);
   info_layout->addWidget(info_txt_tag);
   info_layout->addItem(sparcer_item);
}
void xsteam_ui::xsteam_init_mind_layout()
{
   server_layout = new QHBoxLayout();
   server_tag = new QLabel(tr("源数据:"));
   server_tag->setObjectName("SRC_SERVER");
   server_txt = new QComboBox();
   server_state=new QLabel();
   btn_server_edit = new QPushButton(tr("编辑源"));
   btn_server_edit->setObjectName("EDIT");
   btn_fetch_src_data = new QPushButton(tr("拉取"));
   btn_fetch_src_data->setObjectName("FETCH");
   btn_run_steamtools = new QPushButton(tr("SteamTools"));
   btn_run_steamtools->setObjectName("RUN_STEAMTOOLS");
   btn_run_steam = new QPushButton(tr("Steam"));
   btn_run_steam->setObjectName("RUN_STEAM");
   btn_run_steamdb = new QPushButton(tr("SteamDB"));
   btn_run_steamdb->setObjectName("STEAM_DB");
   btn_push_manifest = new QPushButton(tr("清单分享"));
   btn_push_manifest->setObjectName("PUSH_MANIFEST");

   server_layout->addWidget(server_tag);
   server_layout->addWidget(server_txt);
   server_layout->addWidget(server_state);
   server_layout->addWidget(btn_fetch_src_data);
   server_layout->addWidget(btn_server_edit);
   server_layout->addWidget(btn_run_steam);
   server_layout->addWidget(btn_run_steamtools);
   server_layout->addWidget(btn_run_steamdb);
   server_layout->addWidget(btn_push_manifest);
   server_layout->setStretch(0, 1);
   server_layout->setStretch(1, 7);
   server_layout->setStretch(2, 1);
   server_layout->setStretch(3, 1);

   ip_layout = new QHBoxLayout();
   ip_uid_tag = new QLabel(tr("游戏UID:"));
   ip_uid_tag->setObjectName("GAME_UID");

   ip_uid_edit = new QLineEdit("");
   ip_uid_edit->setValidator(new QRegularExpressionValidator(QRegularExpression("[0-9]+$")));
   ip_uid_edit->setMaxLength(8);
   ip_layout->addWidget(ip_uid_tag);
   ip_layout->addWidget(ip_uid_edit);
   ip_layout->setContentsMargins(2, 2, 2, 2);

   btn_dlc_push = new QPushButton(tr("获取DLC列表"));
   btn_dlc_push->setObjectName("SET_DLC");

   ip_iu_layout = new QHBoxLayout();
   btn_uid_push = new QPushButton(tr("入库"));
   btn_uid_push->setObjectName("INPUT");

   btn_uid_update = new QPushButton(tr("更新"));
   btn_uid_update->setObjectName("UPDATE");
   ip_iu_layout->addWidget(btn_uid_push);
   ip_iu_layout->addWidget(btn_uid_update);
   ip_iu_layout->setContentsMargins(2, 2, 2, 2);

   ip_data_layout = new QHBoxLayout();
   // uid info
   ip_uid_group_layout = new QHBoxLayout();
   ip_uid_group = new QGroupBox(tr("游戏信息"));
   ip_uid_group->setObjectName("GAME_INFO_GROUP");
   ip_uid_table = new xsteam_view();
   ip_uid_table->setObjectName("GAME_INFO_TABLE");
   ip_uid_table->init_view(VIEW_MODE::UID_INFO);
   ip_uid_group_layout->addWidget(ip_uid_table);
   ip_uid_group_layout->setContentsMargins(2, 2, 2, 2);
   ip_uid_group->setLayout(ip_uid_group_layout);
   // all dlc info
   ip_dlc_info_layout = new QVBoxLayout();
   ip_all_dlc_group = new QGroupBox(tr("入库信息"));
   ip_all_dlc_group->setObjectName("ALL_DLC_GROUP");
   ip_all_dlc_table = new xsteam_view();
   ip_all_dlc_table->setObjectName("ALL_DLC_TABLE");
   ip_all_dlc_table->init_view(VIEW_MODE::ALL_DLC_INFO);
   ip_in_dlc_table = new xsteam_view();
   ip_in_dlc_table->setObjectName("IN_DLC_TABLE");
   ip_in_dlc_table->init_view(VIEW_MODE::IN_DLC_INFO);

   ip_dlc_info_layout->addLayout(ip_layout);
   ip_dlc_info_layout->addWidget(btn_dlc_push);
   ip_dlc_info_layout->addWidget(ip_in_dlc_table);
   ip_dlc_info_layout->addWidget(ip_all_dlc_table);
   ip_dlc_info_layout->addLayout(ip_iu_layout);

   ip_dlc_info_layout->setContentsMargins(2, 2, 2, 2);
   ip_all_dlc_group->setLayout(ip_dlc_info_layout);

   ip_data_layout->addWidget(ip_uid_group);
   ip_data_layout->addWidget(ip_all_dlc_group);

   ip_data_layout->setStretch(0, 8);
   ip_data_layout->setStretch(1, 2);

   mind_layout->addLayout(server_layout);
   mind_layout->addLayout(info_layout);
   mind_layout->addLayout(ip_data_layout);
}
void xsteam_ui::xsteam_init_foot_layout()
{
   foot_status_data_layout = new QHBoxLayout();
   version_tips = new QLabel(tr("version:"));
   version_tips->setObjectName("VERSION_TIPS");
   version_tips_txt = new QLabel(PROJECT_VERSION);
   version_tips_txt->setObjectName("VERSION_TIPS_TXT");
   state_tips_txt = new QLabel();
   state_tips_txt->setObjectName("STATE_TIPS");
   state_tips_txt->setAlignment(Qt::AlignCenter);

   btn_xs_sets = new QPushButton();
   btn_xs_sets->setMaximumSize(25, 25);
   btn_xs_sets->setObjectName(tr("BTN_SETS"));

   btn_xs_about = new QPushButton();
   btn_xs_about->setMaximumSize(25, 25);
   btn_xs_about->setObjectName(tr("BTN_ABOUT"));

   foot_status_data_layout->addWidget(version_tips);
   foot_status_data_layout->addWidget(version_tips_txt);

   foot_status_data_layout->addItem(sparcer_item);
   foot_status_data_layout->addWidget(state_tips_txt);
   foot_status_data_layout->addItem(sparcer_item);

   foot_status_data_layout->addWidget(btn_xs_sets);
   foot_status_data_layout->addWidget(btn_xs_about);
   foot_layout->addLayout(foot_status_data_layout);
   xs_git_fetch = new xsteam_git_fetch();
}
void xsteam_ui::xsteam_init_style()
{
   main_layout->setStretch(0, 1);
   main_layout->setStretch(1, 7);
   main_layout->setStretch(2, 1);
   main_layout->setContentsMargins(5, 5, 5, 5);
}
void xsteam_ui::xsteam_init_connect()
{
   ip_uid_table->setContextMenuPolicy(Qt::CustomContextMenu);
   ip_all_dlc_table->setContextMenuPolicy(Qt::CustomContextMenu);
   ip_in_dlc_table->setContextMenuPolicy(Qt::CustomContextMenu);
   connect(btn_server_edit, SIGNAL(clicked()), this, SLOT(slots_open_server_edit()));
   connect(btn_xs_sets, SIGNAL(clicked()), this, SLOT(slots_open_setting()));
   connect(btn_run_steam, SIGNAL(clicked()), this, SLOT(slots_run_steam_steamtools()));
   connect(btn_run_steamtools, SIGNAL(clicked()), this, SLOT(slots_run_steam_steamtools()));
   connect(btn_xs_about, SIGNAL(clicked()), this, SLOT(slots_open_about()));
   connect(btn_fetch_src_data, SIGNAL(clicked()), this, SLOT(slots_fetch_src_data()));
   connect(btn_uid_push, SIGNAL(clicked()), this, SLOT(slots_imput_update_uid_push()));
   connect(btn_uid_update, SIGNAL(clicked()), this, SLOT(slots_imput_update_uid_push()));
   connect(btn_run_steamdb, SIGNAL(clicked()), this, SLOT(slots_open_steamdb()));
   connect(this, SIGNAL(signals_src_combobox_update()), this, SLOT(slots_server_combobox_load_data()));
   connect(xs_git_fetch, SIGNAL(signal_fetch_return_msg(std::string)), this, SLOT(slots_msg_text(std::string)));
   connect(xs_git_fetch, SIGNAL(signal_fetch_return_data(UidData)), this, SLOT(slots_table_append(UidData)));
   connect(ip_uid_table->selectionModel(), SIGNAL(selectionChanged(const QItemSelection &, const QItemSelection &)), this, SLOT(slots_selection_row(const QItemSelection &, const QItemSelection &)));
   connect(ip_uid_table, SIGNAL(customContextMenuRequested(QPoint)), this, SLOT(slots_rightMenu(QPoint)));
   connect(ip_all_dlc_table, SIGNAL(customContextMenuRequested(QPoint)), this, SLOT(slots_rightMenu(QPoint)));
   connect(ip_in_dlc_table, SIGNAL(customContextMenuRequested(QPoint)), this, SLOT(slots_rightMenu(QPoint)));
   connect(btn_dlc_push, SIGNAL(clicked()), this, SLOT(slots_get_uid_dlcs()));
   connect(btn_push_manifest, SIGNAL(clicked()), this, SLOT(slots_push_manifest()));
   connect(server_txt, SIGNAL(currentIndexChanged(int)), this, SLOT(slots_change_src_state(int)));
}
void xsteam_ui::slots_change_src_state(int index)
{
   QPixmap xs_pixmap;
   std::string url;
   xs_pixmap.load(":res/img/btn/net_wait.png");  
   xs_pixmap = xs_pixmap.scaled(25,25,Qt::KeepAspectRatio);
   server_state->setPixmap(xs_pixmap);
   for (auto &i : _data.s_data)
   {
      if (i.src_name == server_txt->itemText(index))
      {
         url = i.src_url;
         break;
      }
   }
   if (url != "")
   {
      QFuture<void> future = QtConcurrent::run([=](std::string _url,QPixmap _pixmap) {
          xsteam_curl* xs_curl=new xsteam_curl();
          if(xs_curl->get_url_state(_url)){
            _pixmap.load(":/res/img/btn/net_ok.png");
          }else{
            _pixmap.load(":/res/img/btn/net_error.png");
          }         
          _pixmap=_pixmap.scaled(25,25,Qt::KeepAspectRatio);
          server_state->setPixmap(_pixmap);
          delete xs_curl;
          xs_curl=nullptr;
      },url,xs_pixmap);
   }
}
void xsteam_ui::slots_get_uid_dlcs()
{
   UidData uid_data;
   uid_data.uid = ip_uid_edit->text().toStdString();
   uid_data.s_name = server_txt->currentText().toStdString();
   slots_msg_text("获取DLC信息...");
   ip_all_dlc_table->item_clear();
   ip_in_dlc_table->item_clear();
   slots_disable_enable_function(false);
   QFuture<void> future = QtConcurrent::run([=](UidData uid_data)
                                            { 
    if (xsteam_curl_steam_id_app_info(uid_data))
   {
      ip_all_dlc_table->item_append(uid_data, VIEW_MODE::ALL_DLC_INFO);
      xs_data = uid_data;
      slots_msg_text("DLC信息获取完毕");
      slots_disable_enable_function(true);
   }
   else
   {
      slots_msg_text("获取DLC信息失败!请检查UID是否正确&网络是否畅通");
      slots_disable_enable_function(true);
   } }, uid_data);
}
void xsteam_ui::slots_rightMenu(const QPoint &pos)
{
   QTableView *signalSrc = (QTableView *)sender(); // 获取到了发送该信号按钮的指针
   QModelIndex index = signalSrc->indexAt(pos);
   if (sender()->objectName() == "GAME_INFO_TABLE")
   {
      if (index.row() > -1)
      {
         // 创建菜单对象
         QMenu *m_menu = new QMenu(this);
         QAction *delete_task = new QAction(tr("移除入库"), this);
         delete_task->setData(1);
         delete_task->setObjectName(signalSrc->objectName());
         // 把QAction对象添加到菜单上
         m_menu->addAction(delete_task);
         // 连接鼠标右键点击信号
         connect(delete_task, SIGNAL(triggered()), this, SLOT(slots_delete_uid_st()));
         // 在鼠标右键点击的地方显示菜单
         m_menu->exec(QCursor::pos());
         QList<QAction *> list = m_menu->actions();
         foreach (QAction *pAction, list)
         {
            delete pAction;
         }
         delete m_menu;
      }
   }
   else if (sender()->objectName() == "ALL_DLC_TABLE")
   {
      if (index.row() > -1)
      {
         // 创建菜单对象
         QMenu *m_menu = new QMenu(this);
         QAction *add_task = new QAction(tr("增加DLC"), this);
         add_task->setData(1);
         add_task->setObjectName(signalSrc->objectName());
         // 把QAction对象添加到菜单上
         m_menu->addAction(add_task);
         // 连接鼠标右键点击信号
         connect(add_task, SIGNAL(triggered()), this, SLOT(slots_in_dlc_add()));
         // 在鼠标右键点击的地方显示菜单
         m_menu->exec(QCursor::pos());
         QList<QAction *> list = m_menu->actions();
         foreach (QAction *pAction, list)
         {
            delete pAction;
         }
         delete m_menu;
      }
   }
   else if (sender()->objectName() == "IN_DLC_TABLE")
   {
      if (index.row() > -1)
      {
         // 创建菜单对象
         QMenu *m_menu = new QMenu(this);
         QAction *delete_task = new QAction(tr("移除DLC"), this);
         delete_task->setData(1);
         delete_task->setObjectName(signalSrc->objectName());
         // 把QAction对象添加到菜单上
         m_menu->addAction(delete_task);
         // 连接鼠标右键点击信号
         connect(delete_task, SIGNAL(triggered()), this, SLOT(slots_in_dlc_delete()));
         // 在鼠标右键点击的地方显示菜单
         m_menu->exec(QCursor::pos());
         QList<QAction *> list = m_menu->actions();
         foreach (QAction *pAction, list)
         {
            delete pAction;
         }
         delete m_menu;
      }
   }
}
void xsteam_ui::slots_in_dlc_delete()
{
   int curRow = ip_in_dlc_table->currentIndex().row();
   if (curRow > -1)
   {
      QAbstractItemModel *modessl = ip_in_dlc_table->model();
      QModelIndex indextemp = modessl->index(curRow, 0);
      QString dlc_id = modessl->data(indextemp).value<QString>();
      modessl->removeRow(curRow);
      ip_in_dlc_table->setModel(modessl);
      xs_data.n_dlc.erase(std::remove(xs_data.n_dlc.begin(), xs_data.n_dlc.end(), dlc_id), xs_data.n_dlc.end());
      slots_msg_text("删除DLC:" + dlc_id.toStdString() + "成功!");
   }
}
void xsteam_ui::slots_in_dlc_add()
{
   int curRow = ip_all_dlc_table->currentIndex().row();
   if (curRow > -1)
   {
      QAbstractItemModel *modessl = ip_all_dlc_table->model();
      QModelIndex indextemp = modessl->index(curRow, 0);
      QString dlc_id = modessl->data(indextemp).value<QString>();
      xs_data.n_dlc.push_back(dlc_id.toStdString());
      ip_in_dlc_table->item_append(xs_data, VIEW_MODE::IN_DLC_INFO);
      slots_msg_text("增加DLC:" + dlc_id.toStdString() + "成功!");
   }
}
void xsteam_ui::slots_delete_uid_st()
{
   int curRow = ip_uid_table->currentIndex().row();
   if (curRow > -1)
   {
      QAbstractItemModel *modessl = ip_uid_table->model();
      QModelIndex indextemp = modessl->index(curRow, 1);
      QString d_uid = modessl->data(indextemp).value<QString>();
      modessl->removeRow(curRow);
      ip_uid_table->setModel(modessl);
      QFuture<void> future = QtConcurrent::run([=](std::string _uid)
                                               { xsteam_delete_uid_st(_uid); }, d_uid.toStdString());
   }
}
void xsteam_ui::slots_fetch_src_data()
{
   slots_msg_text("正在拉取" + server_txt->currentText().toStdString() + "数据...");
   slots_disable_enable_function(false);
   QFuture<void> future = QtConcurrent::run([=]()
                                            { 
   xsteam_git *xs_git = new xsteam_git();
   connect(xs_git, SIGNAL(signal_git_return_msg(std::string)), this, SLOT(slots_msg_text(std::string)));
   xs_git->branch_or_tags_set_opts("", server_txt->currentText().toStdString());
   if(xs_git->branch_or_tags_remote_array()){
      slots_msg_text("拉取"+server_txt->currentText().toStdString()+"完毕");
   }else{
      slots_msg_text("拉取"+server_txt->currentText().toStdString()+"失败");
   }
   delete xs_git;
   xs_git = nullptr; 
   slots_disable_enable_function(true); });
}
void xsteam_ui::slots_selection_row(const QItemSelection &current, const QItemSelection &previous)
{
   QModelIndexList indexes = current.indexes();
   if (!indexes.isEmpty())
   {
      QModelIndex index = indexes.first();
      QAbstractItemModel *model = ip_uid_table->model();
      std::string uid = (model->data(model->index(index.row(), 1)).value<QString>()).toStdString();
      for (auto x : _data.u_data)
      {
         if (x.uid == uid)
         {
            xs_data = x;
            break;
         }
      }
      for (int i = 0; i < server_txt->count(); ++i)
      {
         std::string item_str = server_txt->itemText(i).toStdString();
         if (xs_data.s_name == item_str)
         {
            server_txt->setCurrentIndex(i);
            break;
         }
      }
      ip_uid_edit->setText(QString::fromStdString(xs_data.uid));
      ip_all_dlc_table->item_append(xs_data, VIEW_MODE::ALL_DLC_INFO);
      ip_in_dlc_table->item_append(xs_data, VIEW_MODE::IN_DLC_INFO);
   }
}

void xsteam_ui::slots_open_steamdb()
{
   QDesktopServices::openUrl(QUrl("https://steamdb.info/"));
}

void xsteam_ui::slots_msg_text(std::string info)
{
   QFuture<void> future = QtConcurrent::run([=](std::string info)
                                            { state_tips_txt->setText(QString::fromStdString(info)); }, info);
}
void xsteam_ui::slots_disable_enable_function(bool state)
{
   server_txt->setEnabled(state);
   btn_server_edit->setEnabled(state);
   btn_fetch_src_data->setEnabled(state);
   btn_uid_push->setEnabled(state);
   btn_run_steam->setEnabled(state);
   btn_run_steamtools->setEnabled(state);
   btn_uid_update->setEnabled(state);
   btn_dlc_push->setEnabled(state);
}
void xsteam_ui::slots_server_combobox_load_data()
{
   server_txt->clear();
   for (auto &u : _data.s_data)
   {
      server_txt->addItem(QString::fromStdString(u.src_name));
   }
   server_txt->setCurrentIndex(0);
}
void xsteam_ui::table_load_ui_data()
{
   for (auto x : _data.u_data)
   {
      ip_uid_table->item_append(x, VIEW_MODE::UID_INFO);
   }
}
void xsteam_ui::slots_run_steam_steamtools()
{

   QObject *obj = QObject::sender();
   if (obj->objectName() == "RUN_STEAM")
   {
      xsteam_run_steam_steamtools(RUN_MODE::STEAM);
   }
   else if (obj->objectName() == "RUN_STEAMTOOLS")
   {
      xsteam_run_steam_steamtools(RUN_MODE::STEAMTOOLS);
   }
}
void xsteam_ui::slots_push_manifest()
{
   xs_push_manifest = xsteam_push_manifest::Instance();
   xs_push_manifest->setMaximumSize(((QWidget *)this->parent())->width(), ((QWidget *)this->parent())->height() - 25);
   xs_push_manifest->setGeometry(((QWidget *)this->parent())->geometry());
   xs_push_manifest->exec();
}
void xsteam_ui::slots_open_server_edit()
{
   xs_src_edit_ui = xsteam_src_edit_ui::Instance();
   xs_src_edit_ui->setMaximumSize(660, 580);
   xs_src_edit_ui->setGeometry(((QWidget *)this->parent())->geometry());
   connect(xs_src_edit_ui, SIGNAL(signals_update()), this, SLOT(slots_server_combobox_load_data()));
   xs_src_edit_ui->exec();
}
void xsteam_ui::slots_open_setting()
{
   xs_sets_ui = xsteam_set_ui::Instance();
   xs_sets_ui->setMaximumSize(660, 580);
   xs_sets_ui->setGeometry(((QWidget *)this->parent())->geometry());
   xs_sets_ui->exec();
}
void xsteam_ui::slots_open_about()
{
   xs_about_ui = xsteam_about_ui::Instance();
   xs_about_ui->setMaximumSize(440, 580);
   xs_about_ui->setGeometry(((QWidget *)this->parent())->geometry());
   xs_about_ui->exec();
}

void xsteam_ui::slots_table_append(UidData u_data)
{
   if (xs_state == PUSH_MODE::PUSH_ADD)
   {
      // 增加条目到游戏表格
      ip_uid_table->item_append(u_data, VIEW_MODE::UID_INFO);
      // 清空状态显示
      slots_msg_text(u_data.uid + "入库完毕!");
      // 增加到全局变量内
      _data.u_data.push_back(u_data);
      // 写入data.json->保存功能
   }
   else if (xs_state == PUSH_MODE::PUSH_UPDATE)
   {
      for (auto &x : _data.u_data)
      {
         if (x.uid == u_data.uid)
         {
            x = u_data;
            break;
         }
      }
      ip_uid_table->item_clear();
      table_load_ui_data();
      slots_msg_text(u_data.uid + "更新完毕!");
   }
   QFuture<void> future = QtConcurrent::run([=]()
                                            { xsteam_save_data_write(); });
}
void xsteam_ui::slots_imput_update_uid_push()
{
   bool steam_ok = false;
   bool steamtools_ok = false;
   if (ip_uid_edit->text().toStdString() == "")
   {
      slots_msg_text("入库UID不能为空");
      return;
   }
   if (!xsteam_steam_steamtools_exists(steam_ok, steamtools_ok))
   {
      slots_msg_text("请检查steam和steamtools路径");
      return;
   }
   if (!xsteam_src_data_exists(server_txt->currentText().toStdString()))
   {
      slots_msg_text("请先拉取源服务器清单列表到本地");
      return;
   }
   if (sender()->objectName() == "INPUT")
   {
      if (xsteam_uid_exists(ip_uid_edit->text().toStdString()))
      {
         slots_msg_text("当前游戏已入库!请勿反复入库");
         return;
      }
      xs_state = PUSH_MODE::PUSH_ADD;
   }
   else
   {
      xs_state = PUSH_MODE::PUSH_UPDATE;
   }
   slots_imput_uid_push();
}
void xsteam_ui::slots_imput_uid_push()
{
   xs_data.s_name = server_txt->currentText().toStdString();
   slots_disable_enable_function(false);
   QFuture<void> future = QtConcurrent::run([=](UidData u_data)
                                            { 
      xs_git_fetch->fecth_uid_to_steam(xs_data);
      slots_disable_enable_function(true); }, xs_data);
}