#include "xsteam_ui.h"
xsteam_ui::xsteam_ui(QWidget *parent) : QWidget(parent),
                                        main_layout(new QVBoxLayout),
                                        head_layout(new QHBoxLayout),
                                        mind_layout(new QVBoxLayout),
                                        foot_layout(new QHBoxLayout)
{
   // xsteam_init_head_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(head_layout);
   main_layout->addLayout(mind_layout);
   main_layout->addLayout(foot_layout);
   setLayout(main_layout);
}
void xsteam_ui::xsteam_init_head_layout()
{
   head_tag = new QLabel();
   head_tag->setText(tr("Public Steam"));
   QFont font("Microsoft YaHei", 10, 75);
   head_tag->setFont(font);
   head_layout->addItem(sparcer_item);
   head_layout->addWidget(head_tag);
   head_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();
   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");

   server_layout->addWidget(server_tag);
   server_layout->addWidget(server_txt);
   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->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("457140");
   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("DLC信息"));
   ip_all_dlc_group->setObjectName("ALL_DLC_GROUP");
   ip_all_dlc_table = new xsteam_view();
   ip_all_dlc_table->init_view(VIEW_MODE::ALL_DLC_INFO);
   ip_in_dlc_table = new xsteam_view();
   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, 7);
   ip_data_layout->setStretch(1, 3);

   mind_layout->addLayout(server_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);
   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_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)));
}
void xsteam_ui::slots_rightMenu(const QPoint &pos)
{
   QTableView *signalSrc = (QTableView *)sender(); // 获取到了发送该信号按钮的指针
   QModelIndex index = signalSrc->indexAt(pos);
   if (index.row() > -1)
   {
      // 创建菜单对象
      QMenu *m_menu = new QMenu(this);
      QAction *delete_task = new QAction(tr("移除入库"), this);
      QAction *update_task = new QAction(tr("更新入库"), this);
      delete_task->setData(1);
      update_task->setData(2);
      delete_task->setObjectName(signalSrc->objectName());
      update_task->setObjectName(signalSrc->objectName());
      // 把QAction对象添加到菜单上
      m_menu->addAction(delete_task);
      m_menu->addAction(update_task);
      // 连接鼠标右键点击信号
      connect(delete_task, SIGNAL(triggered()), this, SLOT(slots_delete_uid_st()));
      connect(update_task, SIGNAL(triggered()), this, SLOT(slots_updata_uid_st()));
      // 在鼠标右键点击的地方显示菜单
      m_menu->exec(QCursor::pos());
      QList<QAction *> list = m_menu->actions();
      foreach (QAction *pAction, list)
         delete pAction;
      delete m_menu;
   }
}
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 uid = modessl->data(indextemp).value<QString>();
      modessl->removeRow(curRow);
      ip_uid_table->setModel(modessl);
      QFuture<void> future = QtConcurrent::run([=]()
      { 
         xsteam_delete_uid_st(uid.toStdString());
      });        
   }
}
void xsteam_ui::slots_updata_uid_st()
{
}
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();
      UidData u_data;
      for (auto x : _data.u_data)
      {
         if (x.uid == uid)
         {
            u_data = x;
            break;
         }
      }
      ip_all_dlc_table->item_append(u_data, VIEW_MODE::ALL_DLC_INFO);
      ip_in_dlc_table->item_append(u_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);
}
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_open_server_edit()
{
   xs_src_edit_ui = xsteam_src_edit_ui::Instance();
   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_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_open_setting()
{
   xs_sets_ui = xsteam_set_ui::Instance();
   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->setGeometry(((QWidget *)this->parent())->geometry());
   xs_about_ui->exec();
}
void xsteam_ui::slots_table_append(UidData u_data)
{
   // 增加条目到游戏表格
   ip_uid_table->item_append(u_data, VIEW_MODE::UID_INFO);
   // 清空状态显示
   slots_msg_text("");
   // 增加到全局变量内
   _data.u_data.push_back(u_data);
   // 写入data.json->保存功能
   QFuture<void> future = QtConcurrent::run([=]()
                                            { xsteam_save_data_write(); });
}
void xsteam_ui::slots_imput_uid_push()
{

   InputData i_data;
   UidData u_data;
   bool steam_ok = false;
   bool steamtools_ok = false;
   i_data.t_g_uid = ip_uid_edit->text().toStdString();
   i_data.t_s_name = server_txt->currentText().toStdString();
   if (xsteam_uid_exists(i_data.t_g_uid))
   {
      slots_msg_text("当前游戏已入库!请勿反复入库");
      return;
   }
   if (!xsteam_steam_steamtools_exists(steam_ok, steamtools_ok))
   {
      slots_msg_text("请检查steam和steamtools路径");
      return;
   }
   if(!xsteam_src_data_exists(i_data.t_s_name)){
      slots_msg_text("请先拉取源服务器清单列表到本地");
      return;
   }
   slots_disable_enable_function(false);
   QFuture<void> future = QtConcurrent::run([=](InputData i_data, UidData u_data)
                                            { 
      xs_git_fetch->fecth_uid_to_steam(i_data, u_data);
      slots_disable_enable_function(true); }, i_data, u_data);
}