#include "xsteam_ex.h"
#include <iostream>
#include <filesystem>

void xsteam_init_opts()
{
   // current dir
   ex_base_exe_path = QDir::currentPath();
   // current dir+/
   ex_base_exe_ex = ex_base_exe_path + QStringLiteral("/");
   // current dir+/save
   ex_save_path = ex_base_exe_path + QStringLiteral("/save");
   // current dir+/save/
   ex_save_path_ex = ex_save_path + QStringLiteral("/");
   xsteam_data_unserialize();
   if (_data.s_data.size() > 0)
   {
      for (auto x : _data.s_data)
      {
         xsteam_branch_tag_data_read(x.src_name);
      }
   }
}
void xsteam_vdf_free_dir_file(UidData u_data)
{
}
void xsteam_git2_error_check(int error)
{
   if (error != 0)
   {
      const git_error *err = git_error_last();
      if (err)
      {
         printf("ERROR %d: %s\n", err->klass, err->message);
      }
      else
      {
         printf("ERROR %d: no detailed info\n", error);
      }
   }
}
void xsteam_msg_tip(QWidget *parent, QString tipInfo)
{
   UNUSED(parent);
   QMessageBox::information(nullptr, "TIP", tipInfo);
}
void xsteam_msg_error(QWidget *parent, QString tipInfo)
{
   UNUSED(parent);
   QMessageBox::information(nullptr, "ERROR", tipInfo);
}
bool xsteam_msg_select(QWidget *parent, QString tipText)
{
   QMessageBox *msgBox = nullptr;
   if (msgBox != nullptr)
   {
      delete msgBox;
      msgBox = nullptr;
   }
   msgBox = new QMessageBox(parent);
   msgBox->setWindowModality(Qt::WindowModal);
   msgBox->setAttribute(Qt::WA_DeleteOnClose);
   msgBox->setWindowFlags(msgBox->windowFlags() | Qt::WindowStaysOnTopHint);
   msgBox->setInformativeText(tipText);
   msgBox->setStandardButtons(QMessageBox::Ok | QMessageBox::Cancel);
   msgBox->setStyleSheet("QLabel{"
                         "qproperty-alignment:AlignHCenter;"
                         "min-width: 400px;"
                         "min-height: 20px; "
                         "}");
   int msgRet = msgBox->exec();
   if (msgRet == QMessageBox::Ok)
   {
      return true;
   }
   return false;
}
void xsteam_branch_tag_data_read(std::string _src_name)
{
   QString save_file_str = ex_save_path_ex + "tags_" + QString::fromStdString(_src_name) + ".data";
   if (!QFile(save_file_str).exists())
   {
      return;
   }
   _data.s_ex_data[_src_name].clear();
   std::ifstream file(save_file_str.toStdString(), std::ios::binary);
   if (!file.is_open())
   {
      qDebug() << "Failed to open file: " << save_file_str;
   }
   std::string line;
   while (std::getline(file, line))
   {
      // qDebug() << "Line_Branch_Tag:" << QString::fromStdString(line);
      _data.s_ex_data[_src_name].push_back(line);
   }
   file.close();
}
vdf::object xsteam_vdf_read(QString vdf_path)
{
   std::basic_ifstream<char> _T_File(vdf_path.toStdString(), std::ios::in);
   if (!_T_File.is_open())
   {
      throw std::runtime_error("Failed to open file: " + vdf_path.toStdString());
   }
   std::stringstream buffer;
   buffer << _T_File.rdbuf();
   std::string vdf_str = buffer.str();
   vdf::object vdf_data;
   bool ok = false;
   vdf_data = vdf::read(vdf_str.begin(), vdf_str.end(), &ok);
   return vdf_data;
}
void xsteam_vdf_write(QString vdf_file, vdf::object &vdf_data)
{
   std::ofstream _T_W_File(vdf_file.toStdString().c_str());
   std::unordered_map<std::basic_string<char>, std::shared_ptr<vdf::basic_object<char>>> _childs;
   std::unordered_map<std::basic_string<char>, std::basic_string<char>> _attribs;
   for (auto x : vdf_data.childs)
   {
      if (x.first == "Software")
      {
         _childs.emplace(x.first, x.second);
      }
      else if (x.first == "streaming")
      {
         _childs.emplace(x.first, x.second);
      }
      else if (x.first == "Music")
      {
         _childs.emplace(x.first, x.second);
      }
      else if (x.first == "AuthorizedDevice")
      {
         _childs.emplace(x.first, x.second);
      }
      vdf_data.childs.erase(x.first);
   }
   for (auto u : vdf_data.attribs)
   {
      if (u.first == "SDL_GamepadBind")
      {
         vdf_data.attribs.erase(u.first);
      }
   }
   vdf_data.childs.swap(_childs);
   vdf_data.attribs.swap(_attribs);
   vdf::write(_T_W_File, vdf_data);
}
// 从拉取的库中读取key的信息以std::map类型返回
void xsteam_vdf_read_key(vdf::object vdf_data, UidData &u_data)
{
   std::cout << vdf_data.name << std::endl;
   std::map<std::string, std::string> keys;
   u_data.uid_key.clear();
   for (auto &k : vdf_data.childs)
   {
      std::string u_id = k.first;
      std::string u_key = k.second->attribs.find("DecryptionKey")->second;
      // 游戏UID depots的key
      qDebug() << QString::fromStdString(u_id) << ":" << QString::fromStdString(u_key);
      u_data.uid_key.insert(std::pair<std::string, std::string>(u_id, u_key));
   }
}
// 读取指定uid目录下的文件名
void xsteam_vdf_manifest_name(QString uid_dir, UidData &u_data)
{
   QDir _uid_dir(uid_dir);
   QStringList manifest_list = _uid_dir.entryList(QStringList() << "*.manifest", QDir::Files);
   u_data.manifest.clear();
   for (auto &x : manifest_list)
   {
      u_data.manifest.push_back(x.toStdString());
   }
}
void xsteam_vdf_manifest_move(UidData &u_data)
{

   // vdf manifest dir str
   QString src_manifest_dir_str = ex_base_exe_ex + QString::fromStdString(u_data.uid);
   // steam steamtools dir
   QString steam_tools_dir_depotcache_str = QString::fromStdString(_data.x_config.steam_dir) + "/depotcache";
   for (auto f : u_data.manifest)
   {
      qDebug() << f.c_str();
      // src manifest file path str
      QString src_manifest_file_str = src_manifest_dir_str + "/" + QString::fromStdString(f);
      // src QFile object
      if (QDir(src_manifest_dir_str).exists() && QFile(src_manifest_file_str).exists() && QDir(steam_tools_dir_depotcache_str).exists())
      {
         QString dest_manifest_file_str = steam_tools_dir_depotcache_str + "/" + QString::fromStdString(f);
         QFile::copy(src_manifest_file_str, dest_manifest_file_str);
      }
      else
      {
         return;
      }
   }
}
void xsteam_vdf_edit(vdf::object, std::map<std::string, std::string> data, VDF_EDIT_MODE edit_mode)
{
   if (edit_mode == VDF_EDIT_MODE::ADD)
   {
   }
}
// curl get steam id info to _data
bool xsteam_curl_steam_id_app_info(UidData &u_data)
{
   xsteam_curl *_x_curl = new xsteam_curl();
   auto info_str = _x_curl->get_steam_id_info(_data.x_config.steam_api_url, u_data.uid);
   delete _x_curl;
   _x_curl = nullptr;
   if (info_str == "error" || info_str == "")
   {
      return false;
   }
   json info_json;
   try
   {
      info_json = json::parse(info_str);
   }
   catch (json::parse_error &e)
   {
      std::cerr << "解析错误：" << e.what() << std::endl;
      std::cerr << "位置：字符索引 " << e.byte << std::endl;
      return false;
   }
   qDebug() << QString::fromStdString(info_json.dump(4));
   for (auto &root_data : info_json.items())
   {
      auto node_data = root_data.value().at("data").items();
      for (auto &data : node_data)
      {
         if (data.value().is_string())
         {
            if (data.key() == "name")
            {
               u_data.name = data.value();
            }
         }
         if (data.value().is_array())
         {
            if (data.key() == "dlc")
            {
               if (data.value().size() > 0)
               {

                  u_data.r_dlc.clear();
                  for (auto x : data.value())
                  {
                     u_data.r_dlc.push_back(x.dump());
                  }
               }
            }
         }
      }
   }
   if (u_data.name != "")
   {
      //_data.u_data.push_back(u_data);
      return true;
   }
   return false;
}
// 读取xsteam软件保存在save目录下的data.json并且反序列化读取到全局变量内
void xsteam_data_unserialize()
{
   QString save_file = ex_save_path_ex + "data.json";
   if (!QDir(ex_save_path).exists())
   {
      QDir().mkdir(ex_save_path);
   }
   if (QFile(save_file).exists())
   {
      QFile _save_file(save_file);
      _save_file.open(QIODevice::ReadOnly | QIODevice::Text);
      std::string temp_str = _save_file.readAll().toStdString();
      _save_file.close();
      json j3 = json::parse(temp_str);
      if (j3 == nullptr)
      {
         return;
      }
      for (auto &k : j3.items())
      {
         // 托管数据服务器列表反序列化
         if (k.value().is_object() && k.key() == "src_data")
         {
            for (auto &u : k.value().items())
            {
               SrcData _src_data = {};
               _src_data.src_name = u.value().at("src_name");
               if (u.value().at("src_type") == 0)
               {
                  _src_data.src_type = GIT_MODE::BRANCH;
               }
               else
               {
                  _src_data.src_type = GIT_MODE::TAG;
               }
               _src_data.src_url = u.value().at("src_url");
               _data.s_data.push_back(_src_data);
            }
         }
         // 入库游戏信息列表反序列化
         if (k.value().is_object() && k.key() == "uid_data")
         {
            // x的key是uid x的value是内容
            for (auto &x : k.value().items())
            {
               UidData _temp_data = {};
               _temp_data.name = x.value().at("Name");
               _temp_data.uid = x.value().at("Uid");
               _temp_data.i_time = x.value().at("In_Time");
               _temp_data.m_time = x.value().at("Up_Time");
               _temp_data.ico = x.value().at("Ico");
               _temp_data.s_name = x.value().at("Src_Name");

               if (x.value().contains("Manifest"))
               {
                  _temp_data.manifest = x.value().at("Manifest").get<std::vector<std::string>>();
               }
               if (x.value().contains("UidKey"))
               {
                  _temp_data.uid_key = x.value().at("UidKey").get<std::map<std::string, std::string>>();
               }
               if (x.value().contains("ALL_DLC"))
               {
                  _temp_data.r_dlc = x.value().at("ALL_DLC").get<std::vector<std::string>>();
               }
               if (x.value().contains("IN_DLC"))
               {
                  _temp_data.n_dlc = x.value().at("IN_DLC").get<std::vector<std::string>>();
               }
               std::cout << "manifest size:" << _temp_data.manifest.size() << std::endl;
               std::cout << "uid_key size:" << _temp_data.uid_key.size() << std::endl;
               std::cout << "all_dlc size:" << _temp_data.r_dlc.size() << std::endl;
               std::cout << "in_dlc size:" << _temp_data.n_dlc.size() << std::endl;
               _data.u_data.push_back(_temp_data);
            }
         }
      }
      _data.x_config.style = j3.at("xsteam_sets").at("style");
      _data.x_config.font = j3.at("xsteam_sets").at("font");
      _data.x_config.font_bold = j3.at("xsteam_sets").at("font_bold");
      _data.x_config.steam_dir = j3.at("xsteam_sets").at("steam_dir");
      _data.x_config.steamtools_dir = j3.at("xsteam_sets").at("steamtools_dir");
      _data.x_config.steamtools_st_dir = j3.at("xsteam_sets").at("steamtools_st_dir");
      _data.x_config.steam_api_url = j3.at("xsteam_sets").at("steam_api_url");
      _data.x_config.steam_logo_url = j3.at("xsteam_sets").at("steam_logo_url");
   }
   else
   {
      // 当本地保存数据文件不存在或者读取data.json文件出错或者导致用户修改配置使得读取data.json出错.
      // 默认测试数据源
      for (int i = 0; i <= ex_default_src_name.count() - 1; i++)
      {
         SrcData _src_data;
         _src_data.src_name = ex_default_src_name[i].toStdString();
         _src_data.src_url = ex_default_src_url[i].toStdString();
         _src_data.src_type = GIT_MODE::TAG;
         _data.s_data.push_back(_src_data);
      }

      // 默认配置
      _data.x_config.font = 0;
      _data.x_config.font_bold = 0;
      _data.x_config.style = 1;
      QSettings settings("HKEY_CURRENT_USER\\Software\\Valve\\Steam", QSettings::NativeFormat);
      _data.x_config.steam_dir = (settings.value("SteamPath", "").toString()).toStdString();
      _data.x_config.steam_api_url = "https://store.steampowered.com/api/appdetails/?appids=";
      _data.x_config.steam_logo_url = "https://shared.cloudflare.steamstatic.com/store_item_assets/steam/apps/";
      _data.x_config.steamtools_dir = _data.x_config.steam_dir + "/config/stUI/";
      _data.x_config.steamtools_st_dir = _data.x_config.steam_dir + "/config/stplug-in/";
   }
}
// 序列化全局变量中需要保存在data.json目录下的数据
json xsteam_data_serialize(json jsonData)
{
   // 序列化数据托管服务器
   if (_data.s_data.size() > 0)
   {
      for (auto &k : _data.s_data)
      {
         jsonData[toStr(src_data)][k.src_name][toStr(src_name)] = k.src_name;
         jsonData[toStr(src_data)][k.src_name][toStr(src_type)] = k.src_type;
         jsonData[toStr(src_data)][k.src_name][toStr(src_url)] = k.src_url;
      }
   }
   // 序列化入库游戏数据
   if (_data.u_data.size() > 0)
   {
      for (auto &u : _data.u_data)
      {
         // 游戏名
         jsonData[toStr(uid_data)][u.uid][toStr(Name)] = u.name;
         // 游戏UID
         jsonData[toStr(uid_data)][u.uid][toStr(Uid)] = u.uid;
         // 游戏入库时间
         jsonData[toStr(uid_data)][u.uid][toStr(In_Time)] = u.i_time;
         // 游戏清单最后更新时间
         jsonData[toStr(uid_data)][u.uid][toStr(Up_Time)] = u.m_time;
         // 游戏ico图标参数
         jsonData[toStr(uid_data)][u.uid][toStr(Ico)] = u.ico;
         jsonData[toStr(uid_data)][u.uid][toStr(Src_Name)] = u.s_name;
         // 游戏清单列表
         for (auto &w : u.manifest)
         {
            jsonData[toStr(uid_data)][u.uid][toStr(Manifest)].push_back(w);
         }
         for (auto &[x, y] : u.uid_key)
         {
            jsonData[toStr(uid_data)][u.uid][toStr(UidKey)][x] = y;
         }
         // 游戏所有DLC清单
         for (auto w : u.r_dlc)
         {
            jsonData[toStr(uid_data)][u.uid][toStr(ALL_DLC)].push_back(w);
         }
         // 游戏已经入库DLC清单
         for (auto w : u.n_dlc)
         {
            jsonData[toStr(uid_data)][u.uid][toStr(IN_DLC)].push_back(w);
         }
      }
   }
   jsonData[toStr(xsteam_sets)][toStr(style)] = _data.x_config.style;
   jsonData[toStr(xsteam_sets)][toStr(font)] = _data.x_config.font;
   jsonData[toStr(xsteam_sets)][toStr(font_bold)] = _data.x_config.font_bold;
   jsonData[toStr(xsteam_sets)][toStr(steam_dir)] = _data.x_config.steam_dir;
   jsonData[toStr(xsteam_sets)][toStr(steamtools_dir)] = _data.x_config.steamtools_dir;
   jsonData[toStr(xsteam_sets)][toStr(steamtools_st_dir)] = _data.x_config.steamtools_st_dir;
   jsonData[toStr(xsteam_sets)][toStr(steam_api_url)] = _data.x_config.steam_api_url;
   jsonData[toStr(xsteam_sets)][toStr(steam_logo_url)] = _data.x_config.steam_logo_url;
   return jsonData;
}
void xsteam_save_data_write()
{
   QString save_file = ex_save_path_ex + "data.json";
   json jsonData = nullptr;
   jsonData = xsteam_data_serialize(jsonData);
   std::ofstream out(save_file.toStdString(), std::ios::binary);
   std::cout << jsonData << std::endl;
   out << std::setw(4) << jsonData;
   out.close();
}
bool xsteam_lua_to_com(UidData u_data)
{
   // 文件路径的设定和检测
   QString lua_file = ex_base_exe_ex + QString::fromStdString(u_data.uid) + ".lua";
   QString lua_packa_file = ex_base_exe_ex + "luapacka.exe";
   QString lua_to_steam_st = QString::fromStdString(_data.x_config.steamtools_st_dir) + QString::fromStdString(u_data.uid) + ".st";
   QFile _lua_file(lua_file);
   QFile _lua_packa_file(lua_packa_file);
   if (_lua_file.exists())
   {
      QFile::remove(lua_file);
   }
   std::ofstream dp(lua_file.toStdString());
   if (!dp.is_open())
   {
      xsteam_msg_error(nullptr, "写入lua文件错误");
      return false;
   }
   // 游戏的uid和DLC的uid拟合输出lua脚本文件
   QString lua_str;
   // 增加游戏uid
   /*
   1-一般游戏的UID和DLC末尾为0是游戏的解锁代码
   2-一般UID内末尾为1则是windows系统的文件包
    */
   // 游戏UID-0
   lua_str = "addappid(" + QString::fromStdString(u_data.uid) + ",1,\"None\")";
   dp << lua_str.toStdString() << "\n";
   qDebug() << "UID_KEY_0" << lua_str.toStdString();
   // 增加已经入库的DLC的UID-0
   for (auto &x : u_data.n_dlc)
   {
      // 增加DLC的uid同时必须和uid_key列表的u比对只增加远程服务器有的DLC
      lua_str = "addappid(" + QString::fromStdString(x) + ",1,\"None\")";
      dp << lua_str.toStdString() << "\n";
      qDebug() << "DLC_KEY_0" << lua_str.toStdString();
   }
   for (auto &[uid, key] : u_data.uid_key)
   {
      if (std::to_string((std::stoi(u_data.uid) + 1)) == uid)
      {
         // 增加游戏本体的uid和key
         lua_str = "addappid(" + QString::fromStdString(uid) + ",1," + "\"" + QString::fromStdString(key) + "\"" + ")";
         dp << lua_str.toStdString() << "\n";
         qDebug() << "UID_KEY:" << lua_str.toStdString();
      }
   }
   for (auto &d_id : u_data.n_dlc)
   {
      for (auto &[uid, key] : u_data.uid_key)
      {
         if (std::to_string((std::stoi(d_id) + 1)) == uid)
         {
            // 增加DLC的uid和key
            lua_str = "addappid(" + QString::fromStdString(uid) + ",1," + "\"" + QString::fromStdString(key) + "\"" + ")";
            dp << lua_str.toStdString() << "\n";
            qDebug() << "DLC_KEY:" << lua_str.toStdString();
         }
      }
   }

   dp.close();
   qDebug() << "n_dlc_size:" << u_data.n_dlc;
   // luapacka文件不存在则释放luapacka.exe文件
   if (!_lua_packa_file.exists())
   {
      QFile f_dp;
      f_dp.copy(":/res/bin/luapacka.exe", lua_packa_file);
      f_dp.close();
   }
   // 输入lua脚本文件输出lua二进制文件
   QProcess *m_cmd = new QProcess();
   std::cout << "lua_packa_file:" << lua_packa_file.toStdString() << std::endl;
   std::cout << "lua_file:" << lua_file.toStdString() << std::endl;
   std::cout << "lua_to_steam_st:" << lua_to_steam_st.toStdString() << std::endl;
   m_cmd->setWorkingDirectory(ex_base_exe_path);
   m_cmd->start(lua_packa_file, QStringList() << lua_file << lua_to_steam_st);
   m_cmd->waitForFinished();
   m_cmd->kill();
   delete m_cmd;
   m_cmd = nullptr;
   std::cout << "lua_file exists:" << _lua_file.exists() << std::endl;
   std::cout << "lua_packa_file exists:" << _lua_packa_file.exists() << std::endl;
   if (_lua_file.exists())
   {
      _lua_file.remove();
   };
   if (_lua_packa_file.exists())
   {
      QFile::setPermissions(lua_packa_file,QFile::ReadOther | QFile::WriteOther);
      _lua_packa_file.remove();
   };
   return true;
}
void xsteam_run_steam_steamtools(RUN_MODE _mode)
{

   QString run_steam_steamtools_path;
   QString _tips;
   if (_mode == RUN_MODE::STEAM)
   {
      run_steam_steamtools_path = QString::fromStdString(_data.x_config.steam_dir) + "/steam.exe";
      _tips = "未检测到Steam安装,请先配置Steam路径";
   }
   else if (_mode == RUN_MODE::STEAMTOOLS)
   {
      run_steam_steamtools_path = QString::fromStdString(_data.x_config.steamtools_dir) + "Steamtools.exe";
      _tips = "未检测到SteamTools安装,请先配置SteamTools路径";
   }
   if (QFile(run_steam_steamtools_path).exists())
   {
      QFuture<void> future = QtConcurrent::run([=]()
                                               { 
         QProcess *m_cmd = new QProcess();
         m_cmd->startDetached(run_steam_steamtools_path);
         m_cmd->waitForFinished();
         m_cmd->kill();
         delete m_cmd;
         m_cmd = nullptr; });
   }
   else
   {
      xsteam_msg_error(nullptr, _tips);
   }
}
bool xsteam_uid_exists(std::string uid)
{
   for (auto u : _data.u_data)
   {
      if (u.uid == uid)
      {
         return true;
      }
   }
   return false;
}
bool xsteam_steam_steamtools_exists(bool &steam_ok, bool &steamtools_ok)
{
   if (!_data.x_config.steam_dir.empty())
   {
      if (QDir(QString::fromStdString(_data.x_config.steam_dir)).exists())
      {
         steam_ok = true;
      }
   }
   if (!_data.x_config.steamtools_dir.empty())
   {
      if (QDir(QString::fromStdString(_data.x_config.steamtools_dir)).exists())
      {
         steamtools_ok = true;
      }
   }
   return steam_ok && steamtools_ok;
}
void xsteam_delete_uid_st(std::string uid)
{
   for (auto it = _data.u_data.begin(); it != _data.u_data.end(); ++it)
   {
      if (it->uid == uid)
      {
         QFile st(QString::fromStdString(_data.x_config.steamtools_st_dir + uid + ".st"));
         if (st.exists())
         {
            st.remove();
         }
         _data.u_data.erase(it);
         xsteam_save_data_write();       
         break;
      }
   }
}
bool xsteam_src_data_exists(std::string src_name)
{
   QString save_file_str = ex_save_path_ex + "tags_" + QString::fromStdString(src_name) + ".data";
   if (QFile(save_file_str).exists())
   {
      return true;
   }
   return false;
}