#include "mvpt.h"
#include "../common/logger.hpp"

#include <string>
#include <queue>
#include <mutex>
#include <chrono>
#include <thread>
#include <ctime>

#include "../decoder/interface/DecoderManager.h"
#include "../decoder/interface/utiltools.hpp"
#include "../helpers/time_helper.hpp"
#include "../helpers/os_helper.hpp"
#include "../helpers/str_helper.hpp"

#include "macro_definition.h"
#include "ErrorInfo.h"
#include "SourceSingleton.hpp"
#include "mvpt_process_assist.h"

#include "../util/vpc_util.h"

// #define VEHICLE_MULTI_BOXES

// #define AUTHORIZATION
#define productSN "51C4B28135604F649671727185949A91" //linux 通途抓拍引擎产品序列号

using namespace std;


struct decode_cbk_userdata{
  string task_id;
  void* opaque;
  void* opaque1;
};

/**
 * 注意： gpuFrame 在解码器设置的显卡上，后续操作要十分注意这一点，尤其是多线程情况
 * */
void post_decod_cbk(const void * userPtr, DeviceMemory* devFrame){
    decode_cbk_userdata* ptr = (decode_cbk_userdata*)userPtr;
    if (ptr!= nullptr)
    {
        CMultiSourceProcess* _this = (CMultiSourceProcess*)ptr->opaque;
        if(nullptr != _this){
            _this->decoded_cbk(devFrame);
        }
    }
}

void decode_finished_cbk(const void * userPtr){
    decode_cbk_userdata* ptr = (decode_cbk_userdata*)userPtr;
    if (ptr!= nullptr)
    {
        CMultiSourceProcess* _this = (CMultiSourceProcess*)ptr->opaque;
        if(nullptr != _this){
            _this->task_finished(ptr->task_id);
        }
    }
    delete ptr;
    ptr = nullptr;
}

CMultiSourceProcess::CMultiSourceProcess(){
}

CMultiSourceProcess::~CMultiSourceProcess(){
  jpegUtil.jpeg_release();
}

int CMultiSourceProcess::InitAlgorthim(tsl_aiplatform_param vptParam){

  set_default_logger(LogLevel(vptParam.log_level), "multi_source_process", vptParam.log_path, vptParam.log_mem, vptParam.log_mem);
  LOG_INFO("编译时间：{} {}", __DATE__, __TIME__);

#ifndef AUTHORIZATION
  if (!CheckTime()) { //时间限制
    LOG_ERROR("sy_licence_check failed.");
    return AUTHOR_ERROR;
  }
#else
  if (!CheckLabel(vptParam.gpuid)) { //机器授权
    LOG_ERROR("CheckLabel failed.");
    return AUTHOR_ERROR;
  }
#endif

  SourceSingleton::getInstance();

  skip_frame_ = 5; 
  m_batch_size = 20;

  m_devId = vptParam.gpuid;

  m_result_cbk = vptParam.result_cbk;

  string models_dir = vptParam.models_dir;

  VPTProcess_PARAM vparam;
  vparam.gpuid = m_devId;
  vparam.max_batch = m_batch_size;
  vparam.threshold = 0.4;
  vparam.model_dir = models_dir;

  int ret = vpt_process.init(vparam);
  if (ret < 0){
    return ret;
  }

  ret = m_feature_analysis.init(m_devId, models_dir);
  if (ret < 0){
    return ret;
  }

  jpegUtil.jpeg_init(m_devId);

  m_snapshot_reprocessing = new snapshot_reprocessing(m_devId);

  VPCUtil* pVpcUtil = VPCUtil::getInstance();
  pVpcUtil->init(m_devId);

  m_pAlgorthimThread = new thread([](void* arg) {
      CMultiSourceProcess* process = (CMultiSourceProcess*)arg ;
          process->algorthim_process_thread();
      return (void*)0;
    }
    , this);

  LOG_INFO("InitAlgorthim succeed !");

  return 0;
}

/* 获取任务的状态 MQ返回 */
int CMultiSourceProcess::GetTaskStatus(const string taskID) {

  std::vector<std::string> taskids;
  std::vector<int> statues;
  int sta = 0;
  if(m_task_manager.IsPausing(taskID)){
    taskids.emplace_back(taskID);
    statues.emplace_back(2);
    sta = 2;
  } else if(m_task_manager.IsRunning(taskID)){
    taskids.emplace_back(taskID);
    statues.emplace_back(1);
    sta = 1;
  } else if(m_task_manager.IsFinished(taskID)){
    taskids.emplace_back(taskID);
    statues.emplace_back(0);
    sta = 0;
  }

  return sta;
}

bool CMultiSourceProcess::AddTask(task_param _cur_task_param)
{
	string task_id = _cur_task_param.task_id;

  decode_cbk_userdata* userPtr = new decode_cbk_userdata;
  userPtr->task_id = task_id;
  userPtr->opaque = this;

	FFDecConfig cfg;
	cfg.dec_name = task_id;
	cfg.uri = _cur_task_param.ipc_url;
	cfg.postDecArg = userPtr;
	cfg.post_decoded_cbk = post_decod_cbk;
	cfg.finishedDecArg = userPtr;
	cfg.decode_finished_cbk = decode_finished_cbk;
	cfg.force_tcp = true;  // rtsp用tcp
	cfg.gpuid = to_string(m_devId);
	cfg.skip_frame = _cur_task_param.skip_frame;

	if(!m_task_manager.AddTask(_cur_task_param, cfg)) {
		return false;
	}

	int input_image_width = 0;
  int input_image_height = 0;
  m_task_manager.GetResolution(cfg.dec_name, input_image_width, input_image_height);
  LOG_INFO("task_id: {} width: {} height:{}", task_id, input_image_width, input_image_height);

	// m_task_manager.SetDecKeyframe(cfg.dec_name, true); // 只对关键帧解码

  // 所有参数都准备好之后再启动解码
  bool bStart = m_task_manager.StartTask(task_id);
  if (!bStart){
    LOG_INFO("started task {} failed!", task_id);
    m_task_manager.FinishTask(task_id);
    return false;
  }

  // 人车物跟踪
	vpt_process.addTaskTracker(task_id);

	m_FinishedTaskMtx.lock();
  m_FinishedTaskMap[task_id] = false;
  m_FinishedTaskMtx.unlock();

  LOG_INFO("started task {} successed!", cfg.dec_name);

  return true;
}

int CMultiSourceProcess::CountRunningTask() {
  return m_task_manager.GetRunningTaskCount();
}

void CMultiSourceProcess::decoded_cbk(DeviceMemory* devFrame){

  do{
    if(m_bfinish){
      break;
    }
    m_DataListMtx.lock();
    if(m_RgbDataList.size() >= 100){ //缓存100帧
      m_DataListMtx.unlock();
      std::this_thread::sleep_for(std::chrono::milliseconds(3));
      continue;
    }
    m_RgbDataList.push_back(devFrame);
    m_DataListMtx.unlock();
    break;
  }while (true);
}

void CMultiSourceProcess::task_finished(const string task_id){

  std::lock_guard<std::mutex> l(m_FinishedTaskMtx);

  m_FinishedTaskMap[task_id] = true;

  LOG_INFO("task {} finished!", task_id);
}

bool CMultiSourceProcess::PauseTask(const string taskID){
  return m_task_manager.PauseTask(taskID);
}

bool CMultiSourceProcess::RestartTask(const string taskID){
    return m_task_manager.RestartTask(taskID);
}

bool CMultiSourceProcess::FinishTask(const string taskID){
  return m_task_manager.CloseDecoder(taskID);
}

int CMultiSourceProcess::snapshot_task(std::string& uri_or_name, const std::string& file_name, bool bInTask) {
  DecoderManager* pDecManager = DecoderManager::getInstance();

  DeviceMemory* devMem = nullptr;
  if(bInTask) {
    LOG_INFO("snap in task");
    devMem = m_task_manager.SnapShot(uri_or_name);
  } else {
    LOG_INFO("snap out task");
    devMem = pDecManager->snapshot_out_task(uri_or_name, m_devId);
  }
  if(devMem != nullptr) {
    JpegUtil jpegUtil;
    jpegUtil.jpeg_init(m_devId);

    acldvppPicDesc *vpcDesc= acldvppCreatePicDesc();
    acldvppSetPicDescData(vpcDesc, devMem->getMem()); 
    acldvppSetPicDescFormat(vpcDesc, PIXEL_FORMAT_YUV_SEMIPLANAR_420);
    acldvppSetPicDescWidth(vpcDesc, devMem->getWidth());
    acldvppSetPicDescHeight(vpcDesc, devMem->getHeight());
    acldvppSetPicDescWidthStride(vpcDesc, devMem->getWidthStride());
    acldvppSetPicDescHeightStride(vpcDesc, devMem->getHeightStride());
    acldvppSetPicDescSize(vpcDesc, devMem->getSize());

    bool bSaved = jpegUtil.jpeg_encode(vpcDesc, file_name);
    if(!bSaved){
      LOG_ERROR("jpeg_encode failed");
    }
    
    acldvppDestroyPicDesc(vpcDesc);

    jpegUtil.jpeg_release();

    delete devMem;
    devMem = nullptr;

    return SUCCESS;
  }

  return FAILED;
}

int CMultiSourceProcess::SnapShot(task_param _cur_task_param, string result_folder) 
{
  LOG_INFO("begin SnapShot task: {}", _cur_task_param.task_id);

  /* 拷贝通用的算法参数 */
  if (!result_folder.empty()) {
    CreateResultFolder(result_folder.c_str(), "");
  } else {
    result_folder = "";
  }

  std::string cur_timestamp_ms = std::to_string(helpers::timer::get_timestamp<std::chrono::milliseconds>());
  std::string file_name = std::string(result_folder) + helpers::os::sep + _cur_task_param.task_id  + "_snap_" + cur_timestamp_ms + ".jpg";

  // file_name = "/mnt/data/cmhu/tongtu/Linux_3rdparty/tsl_sdk_20220801/res/snap.jpg";
  string task_id = _cur_task_param.task_id;
  int bSnapShot = snapshot_task(task_id, file_name, true);
  if (FAILED == bSnapShot){
    string url = _cur_task_param.ipc_url;
    bSnapShot = snapshot_task(url, file_name, false);
  }
  if(SUCCESS == bSnapShot){
    LOG_INFO("SnapShot task: {} success", task_id);
  } else {
    LOG_ERROR("SnapShot task: {} failed !", task_id);
  }

  return bSnapShot;
}

void CMultiSourceProcess::CloseAllTask(){
  m_task_manager.CloseAllDecoder();
}

void CMultiSourceProcess::Release() {
    
    atlas_licence_close(&(skt_handle));	//授权

    m_task_manager.CloseAllDecoder();
    while (m_task_manager.GetRunningTaskCount() > 0) {
      std::this_thread::sleep_for(std::chrono::milliseconds(100));
    }

    m_bfinish = true;
    
    if(m_pAlgorthimThread){
        m_pAlgorthimThread->join();
        m_pAlgorthimThread = nullptr;
    }

    m_DataListMtx.lock();
    while (!m_RgbDataList.empty()){
        DeviceMemory* gpuMem = m_RgbDataList.front();
        delete gpuMem;
        gpuMem = nullptr;
        m_RgbDataList.pop_front();
    }
    m_DataListMtx.unlock();

    int size = m_RgbDataList.size();
    bool bEmpty = m_RgbDataList.empty();

     m_task_manager.Release();
    
    LOG_INFO("CloseAllTask exit.");
}

void CMultiSourceProcess::clear_finished_task(){// 清理已经结束的任务

  std::lock_guard<std::mutex> l1(m_FinishedTaskMtx);
  std::lock_guard<std::mutex> l2(m_DataListMtx);

  for (auto iter_finished = m_FinishedTaskMap.begin(); iter_finished!=m_FinishedTaskMap.end(); ){
    if(iter_finished->second){
      // 解码已经结束
      // 判断数据对列中是否还有数据
      string task_id = iter_finished->first;
      bool bFinished = true;
      for (auto iter = m_RgbDataList.begin(); iter!=m_RgbDataList.end(); ++ iter){
        DeviceMemory* gpuMem = *iter;
        if(task_id == gpuMem->getId()){
          bFinished = false;
          break;
        }
      }

      if (bFinished){
        // 解码器已经结束，且数据队列中没有改任务的数据，则做最后任务清理工作
        finish_task(task_id,false);
        iter_finished = m_FinishedTaskMap.erase(iter_finished);
        continue;
      }
    }

    ++ iter_finished;
  }
}

bool CMultiSourceProcess::finish_task(const string taskID, const bool delete_snapshot){

  // 任务结束，关闭跟踪
  if (!vpt_process.finishTaskTracker(taskID))
    LOG_ERROR("Finish VPT Tracker failed, task_id: {}", taskID);
 
  m_snapshot_reprocessing->release_finished_locus_snapshot(taskID);

  m_task_manager.FinishTask(taskID);

  for (auto iter = m_RgbDataList.begin(); iter!=m_RgbDataList.end(); ++ iter){
    DeviceMemory* gpuMem = *iter;
    if(taskID == gpuMem->getId()){
      m_RgbDataList.erase(iter);
    }
  }

  return true;
}

int CMultiSourceProcess::algorthim_process_thread(){
    LOG_INFO("algorthim_process_thread start...");

    while (true){
#ifndef AUTHORIZATION
        if (!CheckTime()) { //时间限制
          LOG_FATAL("authority failed!");
          break;
        }
#else
        if (check_label == -1) { //机器授权
          LOG_FATAL("authority failed!");
          break;
        }
        if (!UpdateLabel()) {
          LOG_FATAL("authority failed!");
          break;
        }
#endif
        if(m_bfinish){
            break;
        }

        clear_finished_task(); 

        m_DataListMtx.lock();
        vector<DeviceMemory*> vec_gpuMem;
        
        while (!m_RgbDataList.empty()){
            DeviceMemory* gpuMem = m_RgbDataList.front();
            if(gpuMem->getMem() == nullptr) {
              LOG_WARN("mem is null");
            } else {
              vec_gpuMem.push_back(gpuMem);
            }
            
            m_RgbDataList.pop_front();
            if(vec_gpuMem.size() >= m_batch_size){
                break;
            }
        }
        m_DataListMtx.unlock();
        
        if(vec_gpuMem.size() <= 0){ 
            std::this_thread::sleep_for(std::chrono::milliseconds(3));
            continue;
        }

        // auto record_t1 = std::chrono::system_clock::now();
        auto vptprocess1 = std::chrono::system_clock::now();
        algorthim_vpt(vec_gpuMem); 
        auto vptprocess2 = std::chrono::system_clock::now(); 
        auto vptprocess_time = std::chrono::duration_cast<std::chrono::milliseconds>(vptprocess2 - vptprocess1).count(); 
        // LOG_INFO("Process per frame cost time: {} ms fps: {}", vptprocess_time/vec_gpuMem.size(), 1000/(vptprocess_time/vec_gpuMem.size()));

        // auto record_t2 = std::chrono::system_clock::now();
        // auto record_time = std::chrono::duration_cast<std::chrono::milliseconds>(record_t2 - record_t1).count(); 
        // LOG_INFO("Record per frame cost time: {} ms fps: {}", record_time/vec_gpuMem.size(), 1000/(record_time/vec_gpuMem.size()));
        for(int i=0;i < vec_gpuMem.size(); i++){
            DeviceMemory* mem = vec_gpuMem[i];
            if(mem->getSize() <= 0){
              continue;
            }
            delete mem;
            mem = nullptr;
        }
        vec_gpuMem.clear();
        vector<DeviceMemory*>().swap(vec_gpuMem); // free.
    }
    
    LOG_INFO("algorthim_process_thread exit.");

    return 0;
}

int CMultiSourceProcess::algorthim_vpt(vector<DeviceMemory*> vec_gpuMem){

    vector<string> vpt_interest_task_id;
    vector<DeviceMemory*> vec_vptMem;
    for (int i = 0; i < vec_gpuMem.size(); i++) {
        DeviceMemory* mem = vec_gpuMem[i];

        vpt_interest_task_id.push_back(mem->getId());
        vec_vptMem.push_back(mem);
    }

    /* 待检测的图片不为空 开始检测 */
    if (!vec_vptMem.empty()) {
      vector<vector<int>> deleteObjectID;
      deleteObjectID.resize(vpt_interest_task_id.size());
      vector<vector<onelevel_det_result>> unUsedResult;
      vector<onelevel_det_result> vptResult(0);

      /* 一级检测器，内部已完成跟踪操作 */
      vpt_process.process(vec_vptMem, vptResult, deleteObjectID, unUsedResult); // do det & track.

      m_snapshot_reprocessing->screen_effective_snapshot(vptResult); 

      /* 快照优选（内部可实现不同的快照优选策略） */
      m_snapshot_reprocessing->update_bestsnapshot(vec_vptMem, vptResult);
      /*  for snapshot algorithm. 轨迹结束目标 做最后的结果返回（当前返回算法结果+快照保存路径）*/
      vehicle_snapshot(vpt_interest_task_id, deleteObjectID);

      vptResult.clear();
      unUsedResult.clear();
      deleteObjectID.clear();
    }

    vec_vptMem.clear();
    vpt_interest_task_id.clear();

    return 0;
}

// for snapshot algorithm. 轨迹结束目标 做最后的结果返回（当前返回算法结果+快照保存路径）
void CMultiSourceProcess::vehicle_snapshot(vector<string>& vpt_interest_task_id, vector<vector<int>> deleteObjectID) {

  for (int i = 0; i < deleteObjectID.size(); i++) // loop taskId.
  {
    string task_id = vpt_interest_task_id[i];
    for (int &j : deleteObjectID[i]) // loop algor type.
    {
      OBJ_KEY obj_key = {task_id, j};
      // 该路任务开启了抓拍功能 开始抓拍保存；若未开启抓拍，清空显存资源
      vehicle_locus_finished(obj_key);
    }
  }
}

void CMultiSourceProcess::vehicle_locus_finished(const OBJ_KEY obj_key) {

  map<OBJ_KEY, OBJ_VALUE> _total_snapshot_info = m_snapshot_reprocessing->get_total_snapshot_info();
  if(_total_snapshot_info.size() <= 0){
    LOG_WARN("_total_snapshot_info size: {}", _total_snapshot_info.size());
    return;
  }

  auto it = _total_snapshot_info.find(obj_key);
  if (it == _total_snapshot_info.end()) {
    // LOG_WARN("object not found: {}, {}", obj_key.video_id, obj_key.obj_id);
    return;
  }

  const OBJ_VALUE obj_value = it->second;

  TaskInfo* info = m_task_manager.GetTaskInfo(obj_key.video_id);
      
  string result_folder = info->result_folder + "/snapshot";
  string result_folder_little = info->result_folder_little + "/snapshot_lite";

  if (!result_folder.empty()) {
		CreateResultFolder(result_folder.c_str(), "");
	} else {
		LOG_ERROR("result_folder is empty!");
	}

  if (!result_folder_little.empty()) {
		CreateResultFolder(result_folder_little.c_str(), "");
	} else {
		LOG_ERROR("result_folder_little is empty!");
	}

  LOG_DEBUG("update task_id {} obj_id {}", obj_key.video_id, obj_key.obj_id);

  std::string cur_timestamp_ms =  std::to_string(helpers::timer::get_cur_time_ms());
  // 原图
  std::string ori_pic_path = result_folder + helpers::os::sep + obj_key.video_id + "_" + std::to_string(obj_key.obj_id) + "_" + cur_timestamp_ms + ".jpg";
  // 抠图
  string object_file_name = result_folder_little + helpers::os::sep + obj_key.video_id + "_" + std::to_string(obj_key.obj_id) + "_" + cur_timestamp_ms + ".jpg";

  ObjectInfo res_obj;
  res_obj.task_id = obj_key.video_id;              //该物体属于的任务ID号
  res_obj.task_frame_count = obj_value.frameCount;     //该物体当前出现的帧号
  res_obj.object_id = obj_key.obj_id;            //该物体的ID号
  res_obj.left = obj_value.obj_pos.left_;                 //该物体位置的左坐标
  res_obj.top = obj_value.obj_pos.top_;                  //该物体位置的上坐标
  res_obj.right = obj_value.obj_pos.left_ + obj_value.obj_pos.width_;                //该物体位置的右坐标
  res_obj.bottom = obj_value.obj_pos.top_ + obj_value.obj_pos.height_;               //该物体位置的下坐标
  res_obj.index = obj_value.index.index;                //该物体所属类别的编号
  res_obj.confidence = obj_value.confidence;        //该物体的置信度
  res_obj.ori_pic_path = ori_pic_path;
  res_obj.ori_img_info = obj_value.snapShot;
  res_obj.obj_pic_path = object_file_name;
  res_obj.obj_img_info = obj_value.snapShotLittle;
  res_obj.str_ts_ms = cur_timestamp_ms;
  m_feature_analysis.update_object_info(res_obj, obj_value.snapShotLittle);
 
  bool bSaved = save_obj_pic(res_obj);
  if (bSaved)
  {
    m_result_cbk(res_obj);
  }

  m_snapshot_reprocessing->release_finished_locus_snapshot(obj_key.video_id, obj_key.obj_id, true); 

}

bool CMultiSourceProcess::save_obj_pic(ObjectInfo& res_obj) 
{
  bool bSaved = false;

  do
  {
    // 原图
    if(!res_obj.ori_pic_path.empty()){
      bSaved = jpegUtil.jpeg_encode(res_obj.ori_img_info.pic_desc, res_obj.ori_pic_path);
      if(!bSaved){
        LOG_ERROR("jpeg_encode failed");
        break;
      }
    }
    // 抠图
    if(!res_obj.obj_pic_path.empty()){
      bSaved = jpegUtil.jpeg_encode(res_obj.obj_img_info.pic_desc, res_obj.obj_pic_path);
      if(!bSaved){
        LOG_ERROR("jpeg_encode failed");
        break;
      }
    }
  } while (0);
  
  return bSaved;
}

bool CMultiSourceProcess::CheckTime() {
 
    long long deadline_ts = helpers::timer::get_ts_by_day_ms(2026, 4, 1);
    long long cur_ts = helpers::timer::get_cur_time_ms();
    
    if (cur_ts < deadline_ts)
    {
      return true;
    }
    else
    {
        return false;
    }
}

bool CMultiSourceProcess::CheckLabel(int devId) {
  	const char *token_password = "mvpt_dq_ascend_arm_2025";
    std::string guid = std::string("mvpt_dq_ascend_arm")+std::to_string(devId);
    atlas_licence_param lic_param;
    memset(&lic_param, 0, sizeof(atlas_licence_param));
    sprintf(lic_param.product_id, "%s", productSN);
    sprintf(lic_param.guid, "%s",guid.c_str());
    sprintf(lic_param.token_pwd, "%s", token_password);
    lic_param.channel_num = 1;
    atlas_licence_token param_token;
    memset(&param_token, 0, sizeof(atlas_licence_token));

    int result = atlas_licence_connect(&(skt_handle), lic_param, &param_token);
    //printf("result:%d,code:%d,msg:%s \n", result, param_token.code, param_token.msg);
    //printf("token:%s\n", param_token.token);
    std::string recv_token = std::string(param_token.token);

    //atlas_licence_check_param check_param;
    memset(&(check_param), 0, sizeof(atlas_licence_check_param));
    sprintf(check_param.token_pwd, "%s", token_password);
    sprintf(check_param.time, "%s", "2023-01-10 20:00:00");
    sprintf(check_param.token, "%s", recv_token .c_str());
    check_param.consume = 2;

    //授权check------------
    check_label = -1;//初始值
    std::cout << "sy_licence_check start." << std::endl;
    atlas_licence_check_result check_result;
    memset(&check_result, 0, sizeof(atlas_licence_check_result));
    check_result.code = -1;

    int res = atlas_licence_check(skt_handle, check_param, &check_result);
    if(res!=0) {
      std::cout << "sy_licence_check failed." << std::endl;
      return false;
    }
    //std::cout << "code:" << check_result.code << ",msg:" << check_result.msg << std::endl;
    if(check_result.code!=0) {
      std::cout << "code:" << check_result.code << ",msg:" << check_result.msg << std::endl;
      return false;
    }
    std::cout << "sy_licence_check end." << std::endl;

    check_label = 0;//授权成功
    return true;
}

bool CMultiSourceProcess::UpdateLabel() {
    //获取系统时间，每个月1号check一次授权
    struct tm* info;
    int nYear, nMonth, nDay;
    time_t raw;
    time(&raw);
    info = localtime(&raw);
    nYear = info->tm_year + 1900;
    nMonth = info->tm_mon + 1;
    nDay = info->tm_mday;
    if(nDay==1) {
      if(check_label ==0) {
        LOG_INFO("atlas_licence_check start.");
        atlas_licence_check_result check_result;
        memset(&check_result, 0, sizeof(atlas_licence_check_result));
        check_result.code = -1;

        int res = atlas_licence_check(skt_handle, check_param, &check_result);
        if(res!=0) {
          LOG_FATAL("sy_licence_check failed.");
          return false;
        }
        if(check_result.code!=0) {
          check_label = -1;
          LOG_FATAL("atlas_licence_check code:{}, msg:{}",check_result.code, check_result.msg);
          return false;
        }
        LOG_INFO("atlas_licence_check end.");
        check_label =1;
      }
    }
    else {
      check_label =0;
    }
    return true;
}