/*
 * @Author: yangzilong
 * @Date: 2021-12-08 17:45:57
 * @Last Modified by: yangzilong
 * @Last Modified time: Do not edit
 * @Email: yangzilong@objecteye.com
 * @Description:
 */

#include "task_param_manager.h"
#include "header.h"
#include "mvpt_process_assist.h"

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

// ############################################################ //
// !                Auxiliary Function                        ! //
// ############################################################ //

/* 任务配置参数的深拷贝 添加新算法 添加新case拷贝后续需要的参数 */
bool copy_algor_param_aux(const algorithm_type_t &algor_type, const std::string &task_id,
                          task_param_manager::algo_param_type_t_ *&copied_algor_param, void *&algor_param,
                          map<string, algor_open_config_param> &m_algor_config_params) {
  //! Check.
  if (!copied_algor_param || !algor_param)
    return false;

  switch (algor_type) {
  case algorithm_type_t::FACE_SNAPSHOT:
    m_algor_config_params[task_id].human_face_algors.insert(algor_type);
    goto _snapshot_param_copy;
  case algorithm_type_t::HUMAN_SNAPSHOT:
    m_algor_config_params[task_id].human_algors.insert(algor_type);
    goto _snapshot_param_copy;
  case algorithm_type_t::VEHICLE_SNAPSHOT:
    m_algor_config_params[task_id].vehicle_algors.insert(algor_type);
    goto _snapshot_param_copy;
  case algorithm_type_t::NONMOTOR_VEHICLE_SNAPSHOT: {
    m_algor_config_params[task_id].nonmotor_vehicle_algors.insert(algor_type);
  _snapshot_param_copy : {
    using algor_config_param_type = algor_config_param_snapshot;
    copied_algor_param->algor_param = new algor_config_param_type;
    *((algor_config_param_type *)(copied_algor_param->algor_param)) =
        *((algor_config_param_type *)algor_param); // deep copy.
  }
  } break;

  // 农村相关事件
  case algorithm_type_t::NONMOTOR_VEHICLE_OVERMAN:
    m_algor_config_params[task_id].nonmotor_vehicle_algors.insert(algor_type);
    goto _manned_param_copy;
  case algorithm_type_t::NONMOTOR_VEHICLE_NOHELMET:
    m_algor_config_params[task_id].nonmotor_vehicle_algors.insert(algor_type);
    goto _manned_param_copy;
  case algorithm_type_t::NONMOTOR_VEHICLE_USEPHONE:
    m_algor_config_params[task_id].nonmotor_vehicle_algors.insert(algor_type);
    goto _manned_param_copy;
  case algorithm_type_t::NONMOTOR_VEHICLE_REFIT:
    m_algor_config_params[task_id].nonmotor_vehicle_algors.insert(algor_type);
    goto _manned_param_copy;
  case algorithm_type_t::NONMOTOR_RUNNING_REDLIGHTS:
    m_algor_config_params[task_id].nonmotor_vehicle_algors.insert(algor_type);
    goto _manned_param_copy;
  case algorithm_type_t::NONMOTOR_IN_VEHICLELANE:
    m_algor_config_params[task_id].nonmotor_vehicle_algors.insert(algor_type);
    goto _manned_param_copy;
  case algorithm_type_t::NONMOTOR_CEOSSPARKLINE:
    m_algor_config_params[task_id].nonmotor_vehicle_algors.insert(algor_type);
    goto _manned_param_copy;
  case algorithm_type_t::NONMOTOR_WRONGDIRECTION:
    m_algor_config_params[task_id].nonmotor_vehicle_algors.insert(algor_type);
    goto _manned_param_copy;
  case algorithm_type_t::TRICYCLE_MANNED:
    m_algor_config_params[task_id].nonmotor_vehicle_algors.insert(algor_type);
    goto _manned_param_copy;
  case algorithm_type_t::PERSON_RUNNING_REDLIGHTS:
    m_algor_config_params[task_id].human_algors.insert(algor_type);
    goto _manned_param_copy;
  case algorithm_type_t::PERSON_IN_VEHICLELANE:
    m_algor_config_params[task_id].human_algors.insert(algor_type);
    goto _manned_param_copy;
  case algorithm_type_t::PERSON_CROSS:
    m_algor_config_params[task_id].human_algors.insert(algor_type);
    goto _manned_param_copy;
  case algorithm_type_t::VEHICLE_WRONGDIRECTION:
    m_algor_config_params[task_id].vehicle_algors.insert(algor_type);
    goto _manned_param_copy;
  case algorithm_type_t::VEHICLE_NOTGIVEWAY:
    m_algor_config_params[task_id].vehicle_algors.insert(algor_type);
    goto _manned_param_copy;
  case algorithm_type_t::VEHICLE_SOLIDLINETURNAROUND:
    m_algor_config_params[task_id].vehicle_algors.insert(algor_type);
    goto _manned_param_copy;
  case algorithm_type_t::VEHICLE_NOTDECELERATION:
    m_algor_config_params[task_id].vehicle_algors.insert(algor_type);
    goto _manned_param_copy;
  case algorithm_type_t::TRUCK_MANNED: {
    m_algor_config_params[task_id].vehicle_algors.insert(algor_type);
  _manned_param_copy : {
    using algor_config_param_type = algor_config_param_manned_incident;
    copied_algor_param->algor_param = new algor_config_param_type;
    *((algor_config_param_type *)(copied_algor_param->algor_param)) =
        *((algor_config_param_type *)algor_param); // deep copy.
  }
  } break;


  case algorithm_type_t::HUMAN_GATHER: {
    m_algor_config_params[task_id].human_algors.insert(algor_type);
    using algor_config_param_type = algor_config_param_human_gather;
    copied_algor_param->algor_param = new algor_config_param_type;
    *((algor_config_param_type *)(copied_algor_param->algor_param)) =
        *((algor_config_param_type *)algor_param); // deep copy.
  } break;


  //221026byzsh---------------------------------------------------------
  case algorithm_type_t::ROAD_WORK_DET: {
    m_algor_config_params[task_id].vehicle_algors.insert(algor_type);
    using algor_config_param_type = algor_config_param_road_work;
    copied_algor_param->algor_param = new algor_config_param_type;
    *((algor_config_param_type *)(copied_algor_param->algor_param)) =
        *((algor_config_param_type *)algor_param); // deep copy.
  } break;
  //--------------------------------------------------------------------

  //230220byzsh---------------------------------------------------------
  case algorithm_type_t::VIDEO_TIMING_SNAPSHOT: {
    m_algor_config_params[task_id].vehicle_algors.insert(algor_type);
    using algor_config_param_type = algor_config_video_timing_snapshot;
    copied_algor_param->algor_param = new algor_config_param_type;
    *((algor_config_param_type *)(copied_algor_param->algor_param)) =
        *((algor_config_param_type *)algor_param); // deep copy.
  } break;
  //--------------------------------------------------------------------

  case algorithm_type_t::PEDESTRIAN_FALL: {
    m_algor_config_params[task_id].human_algors.insert(algor_type);
    using algor_config_param_type = algor_config_param_pedestrian_fall;
    copied_algor_param->algor_param = new algor_config_param_type;
    *((algor_config_param_type *)(copied_algor_param->algor_param)) =
        *((algor_config_param_type *)algor_param); // deep copy.
  } break;

  case algorithm_type_t::PEDESTRIAN_FIGHT: {
    m_algor_config_params[task_id].human_algors.insert(algor_type);
    using algor_config_param_type = algor_config_param_pedestrian_fight;
    copied_algor_param->algor_param = new algor_config_param_type;
    *((algor_config_param_type *)(copied_algor_param->algor_param)) =
        *((algor_config_param_type *)algor_param); // deep copy.
  } break;

  case algorithm_type_t::TAKEAWAY_MEMBER_CLASSIFICATION: {
    m_algor_config_params[task_id].nonmotor_vehicle_algors.insert(algor_type);
    using algor_config_param_type = algor_config_param_takeaway_member_classification;
    copied_algor_param->algor_param = new algor_config_param_type;
    *((algor_config_param_type *)(copied_algor_param->algor_param)) =
        *((algor_config_param_type *)algor_param); // deep copy.
  } break;

  case algorithm_type_t::SMOKING_DET: {
    m_algor_config_params[task_id].human_algors.insert(algor_type);
    using algor_config_param_type = algor_config_param_smoking;
    copied_algor_param->algor_param = new algor_config_param_type;
    *((algor_config_param_type *)(copied_algor_param->algor_param)) =
        *((algor_config_param_type *)algor_param); // deep copy.
  } break;

  case algorithm_type_t::CALL_PHONE_DET: {
    m_algor_config_params[task_id].human_algors.insert(algor_type);
    using algor_config_param_type = algor_config_param_call_phone;
    copied_algor_param->algor_param = new algor_config_param_type;
    *((algor_config_param_type *)(copied_algor_param->algor_param)) =
        *((algor_config_param_type *)algor_param); // deep copy.
  } break;

  case algorithm_type_t::NO_REFLECTIVE_CLOTHING: {
    m_algor_config_params[task_id].human_algors.insert(algor_type);
    using algor_config_param_type = algor_config_param_no_reflective_clothing;
    copied_algor_param->algor_param = new algor_config_param_type;
    *((algor_config_param_type *)(copied_algor_param->algor_param)) =
        *((algor_config_param_type *)algor_param); // deep copy.
  } break;

  case algorithm_type_t::NO_SAFETY_HELMET: {
    m_algor_config_params[task_id].human_algors.insert(algor_type);
    using algor_config_param_type = algor_config_param_no_safety_helmet;
    copied_algor_param->algor_param = new algor_config_param_type;
    *((algor_config_param_type *)(copied_algor_param->algor_param)) =
        *((algor_config_param_type *)algor_param); // deep copy.
  } break;

  case algorithm_type_t::PEDESTRIAN_RETROGRADE: {
    m_algor_config_params[task_id].human_algors.insert(algor_type);
    using algor_config_param_type = algor_config_param_pedestrian_retrograde;
    copied_algor_param->algor_param = new algor_config_param_type;
    *((algor_config_param_type *)(copied_algor_param->algor_param)) =
        *((algor_config_param_type *)algor_param); // deep copy.
  } break;

  case algorithm_type_t::VEHICLE_RETROGRADE: {
    m_algor_config_params[task_id].vehicle_algors.insert(algor_type);
    using algor_config_param_type = algor_config_param_vehicle_retrograde;
    copied_algor_param->algor_param = new algor_config_param_type;
    *((algor_config_param_type *)(copied_algor_param->algor_param)) =
        *((algor_config_param_type *)algor_param); // deep copy.
  } break;

  case algorithm_type_t::PEDESTRIAN_TRESPASS: {
    m_algor_config_params[task_id].human_algors.insert(algor_type);
    using algor_config_param_type = algor_config_param_pedestrian_trespass;
    copied_algor_param->algor_param = new algor_config_param_type;
    *((algor_config_param_type *)(copied_algor_param->algor_param)) =
        *((algor_config_param_type *)algor_param); // deep copy.
  } break;

  case algorithm_type_t::VEHICLE_TRESPASS: {
    m_algor_config_params[task_id].vehicle_algors.insert(algor_type);
    using algor_config_param_type = algor_config_param_vehicle_trespass;
    copied_algor_param->algor_param = new algor_config_param_type;
    *((algor_config_param_type *)(copied_algor_param->algor_param)) =
        *((algor_config_param_type *)algor_param); // deep copy.
  } break;

  default: {
    LOG_WARN("Not Support Algorithm type {} Task id {}", int(algor_type), task_id);
    return false;
  } break;
  }

  return true;
}

task_param_manager::task_param_manager() {
}

/* 保存新添加任务的配置参数 */
void task_param_manager::add_task_param(string task_id, task_param task_param) {
  const int task_algor_count = task_param.algor_counts;
  printf("task_algor_count: %d\n", task_algor_count);
  for (int idx = 0; idx < task_algor_count; idx++) // loop every algor param.
  {
    algo_param_type_t_ *copied_algor_param = new algo_param_type_t_;
    auto &algor_config_param = task_param.algor_config_params[idx];
    auto &algor_param = algor_config_param.algor_init_config_param->algor_param;
    auto &algor_type = algor_config_param.algor_type;

    /* 拷贝该算法特定的算法参数 */
    if (!copy_algor_param_aux(algor_type, task_id, copied_algor_param, algor_param, m_algor_config_params)) {
      if (copied_algor_param != nullptr) {
        delete copied_algor_param;
        copied_algor_param = nullptr;
      }
      LOG_ERROR("copy param faileure task_id {} algor_type {}", task_id, int(algor_type));
      continue;
    }

    /* 拷贝通用的算法参数 */
    /* copy public param. */
    copied_algor_param->basic_param = new algor_basic_config_param_t;

    auto src_basic_param = algor_config_param.algor_init_config_param->basic_param;
    auto dst_basic_param = ((algor_init_config_param_t *)copied_algor_param)->basic_param;

    if (src_basic_param->result_folder_little) {
      dst_basic_param->result_folder_little = new char[strlen(src_basic_param->result_folder_little) + 1];
      strcpy(dst_basic_param->result_folder_little, src_basic_param->result_folder_little);
      CreateResultFolder(dst_basic_param->result_folder_little, "");
    } else
      dst_basic_param->result_folder_little = nullptr;

    if (src_basic_param->result_folder) {
      dst_basic_param->result_folder = new char[strlen(src_basic_param->result_folder) + 1];
      strcpy(dst_basic_param->result_folder, src_basic_param->result_folder);
      CreateResultFolder(dst_basic_param->result_folder, "");
    } else
      dst_basic_param->result_folder = nullptr;

    if (src_basic_param->video_folder) {
      dst_basic_param->video_folder = new char[strlen(src_basic_param->video_folder) + 1];
      strcpy(dst_basic_param->video_folder, src_basic_param->video_folder);
      CreateResultFolder(dst_basic_param->video_folder, "");
    } else
      dst_basic_param->video_folder = nullptr;

    dst_basic_param->algor_valid_rect.left_ = src_basic_param->algor_valid_rect.left_;
    dst_basic_param->algor_valid_rect.top_ = src_basic_param->algor_valid_rect.top_;
    dst_basic_param->algor_valid_rect.width_ = src_basic_param->algor_valid_rect.width_;
    dst_basic_param->algor_valid_rect.height_ = src_basic_param->algor_valid_rect.height_;

    copied_algor_param->basic_param = dst_basic_param;
    m_task_params[task_id][algor_config_param.algor_type] = copied_algor_param;
  }
}

/* 删除结束任务的配置参数 */
void task_param_manager::delete_task_param(string task_id) {
  auto it = m_task_params.find(task_id);
  if(it == m_task_params.end()){
    return;
  }

  for (auto iter : m_task_params[task_id]) // 依次删除算法配置参数
  {
    algor_basic_config_param_t *cur_param =
        ((algor_init_config_param_t *)m_task_params[task_id][iter.first])->basic_param;
    if (cur_param->result_folder_little) {
      delete[] cur_param->result_folder_little;
      cur_param->result_folder_little = nullptr;
    }
    if (cur_param->result_folder) {
      delete[] cur_param->result_folder;
      cur_param->result_folder = nullptr;
    }
    if (cur_param->video_folder) {
      delete[] cur_param->video_folder;
      cur_param->video_folder = nullptr;
    }
    if (cur_param) {
      delete ((algor_init_config_param_t *)m_task_params[task_id][iter.first])->basic_param;
      ((algor_init_config_param_t *)m_task_params[task_id][iter.first])->basic_param = nullptr;
    }

    switch (iter.first) {
    case algorithm_type_t::PEDESTRIAN_FALL: {
      algor_config_param_pedestrian_fall *algor_param =
          (algor_config_param_pedestrian_fall *)((algor_init_config_param_t *)m_task_params[task_id][iter.first])
              ->algor_param;
      if (algor_param) {
        delete (algor_config_param_pedestrian_fall *)((algor_init_config_param_t *)m_task_params[task_id][iter.first])
            ->algor_param;
        ((algor_init_config_param_t *)m_task_params[task_id][iter.first])->algor_param = nullptr;
      }
      break;
    }
    case algorithm_type_t::PEDESTRIAN_FIGHT: {
      algor_config_param_pedestrian_fight *algor_param =
          (algor_config_param_pedestrian_fight *)((algor_init_config_param_t *)m_task_params[task_id][iter.first])
              ->algor_param;
      if (algor_param) {
        delete (algor_config_param_pedestrian_fight *)((algor_init_config_param_t *)m_task_params[task_id][iter.first])
            ->algor_param;
        ((algor_init_config_param_t *)m_task_params[task_id][iter.first])->algor_param = nullptr;
      }
      break;
    }
    case algorithm_type_t::HUMAN_GATHER: {
      algor_config_param_human_gather *algor_param =
          (algor_config_param_human_gather *)((algor_init_config_param_t *)m_task_params[task_id][iter.first])
              ->algor_param;
      if (algor_param) {
        delete (algor_config_param_human_gather *)((algor_init_config_param_t *)m_task_params[task_id][iter.first])
            ->algor_param;
        ((algor_init_config_param_t *)m_task_params[task_id][iter.first])->algor_param = nullptr;
      }
      break;
    }

  
    //221026byzsh---------------------------------------------------------
    case algorithm_type_t::ROAD_WORK_DET: {
      algor_config_param_road_work *algor_param =
          (algor_config_param_road_work *)((algor_init_config_param_t *)m_task_params[task_id][iter.first])
              ->algor_param;
      if (algor_param) {
        delete (algor_config_param_road_work *)((algor_init_config_param_t *)m_task_params[task_id][iter.first])
            ->algor_param;
        ((algor_init_config_param_t *)m_task_params[task_id][iter.first])->algor_param = nullptr;
      }
      break;
    }
    //--------------------------------------------------------------------

    //230220byzsh---------------------------------------------------------
    case algorithm_type_t::VIDEO_TIMING_SNAPSHOT: {
      algor_config_video_timing_snapshot *algor_param =
          (algor_config_video_timing_snapshot *)((algor_init_config_param_t *)m_task_params[task_id][iter.first])
              ->algor_param;
      if (algor_param) {
        delete (algor_config_video_timing_snapshot *)((algor_init_config_param_t *)m_task_params[task_id][iter.first])
            ->algor_param;
        ((algor_init_config_param_t *)m_task_params[task_id][iter.first])->algor_param = nullptr;
      }
      break;
    }
    //--------------------------------------------------------------------
    // 农村相关事件
    case algorithm_type_t::NONMOTOR_VEHICLE_OVERMAN:
      goto _manned_param_delete;
    case algorithm_type_t::NONMOTOR_VEHICLE_NOHELMET:
      goto _manned_param_delete;
    case algorithm_type_t::NONMOTOR_VEHICLE_USEPHONE:
      goto _manned_param_delete;
    case algorithm_type_t::NONMOTOR_VEHICLE_REFIT:
      goto _manned_param_delete;
    case algorithm_type_t::NONMOTOR_RUNNING_REDLIGHTS:
      goto _manned_param_delete;
    case algorithm_type_t::NONMOTOR_IN_VEHICLELANE:
      goto _manned_param_delete;
    case algorithm_type_t::NONMOTOR_CEOSSPARKLINE:
      goto _manned_param_delete;
    case algorithm_type_t::NONMOTOR_WRONGDIRECTION:
      goto _manned_param_delete;
    case algorithm_type_t::TRICYCLE_MANNED:
      goto _manned_param_delete;
    case algorithm_type_t::PERSON_RUNNING_REDLIGHTS:
      goto _manned_param_delete;
    case algorithm_type_t::PERSON_IN_VEHICLELANE:
      goto _manned_param_delete;
    case algorithm_type_t::PERSON_CROSS:
      goto _manned_param_delete;
    case algorithm_type_t::VEHICLE_WRONGDIRECTION:
      goto _manned_param_delete;
    case algorithm_type_t::VEHICLE_NOTGIVEWAY:
      goto _manned_param_delete;
    case algorithm_type_t::VEHICLE_SOLIDLINETURNAROUND:
      goto _manned_param_delete;
    case algorithm_type_t::VEHICLE_NOTDECELERATION:
      goto _manned_param_delete;
    case algorithm_type_t::TRUCK_MANNED: {
    _manned_param_delete : {
      using ptr_t = algor_config_param_manned_incident;
      ptr_t *algor_param = (ptr_t *)((algor_init_config_param_t *)m_task_params[task_id][iter.first])->algor_param;
      if (algor_param) {
        delete (ptr_t *)((algor_init_config_param_t *)m_task_params[task_id][iter.first])->algor_param;
        ((algor_init_config_param_t *)m_task_params[task_id][iter.first])->algor_param = nullptr;
      }
    }
    } break;
     
    case algorithm_type_t::TAKEAWAY_MEMBER_CLASSIFICATION: {
      algor_config_param_takeaway_member_classification *algor_param =
          (algor_config_param_takeaway_member_classification *)((algor_init_config_param_t *)
                                                                    m_task_params[task_id][iter.first])
              ->algor_param;
      if (algor_param) {
        delete (algor_config_param_takeaway_member_classification *)((algor_init_config_param_t *)
                                                                         m_task_params[task_id][iter.first])
            ->algor_param;
        ((algor_init_config_param_t *)m_task_params[task_id][iter.first])->algor_param = nullptr;
      }
      break;
    }
    case algorithm_type_t::NO_REFLECTIVE_CLOTHING: {
      using ptr_t = algor_config_param_no_reflective_clothing;
      ptr_t *algor_param = (ptr_t *)((algor_init_config_param_t *)m_task_params[task_id][iter.first])->algor_param;
      if (algor_param) {
        delete (ptr_t *)((algor_init_config_param_t *)m_task_params[task_id][iter.first])->algor_param;
        ((algor_init_config_param_t *)m_task_params[task_id][iter.first])->algor_param = nullptr;
      }
      break;
    }
    case algorithm_type_t::NO_SAFETY_HELMET: {
      using ptr_t = algor_config_param_no_safety_helmet;
      ptr_t *algor_param = (ptr_t *)((algor_init_config_param_t *)m_task_params[task_id][iter.first])->algor_param;
      if (algor_param) {
        delete (ptr_t *)((algor_init_config_param_t *)m_task_params[task_id][iter.first])->algor_param;
        ((algor_init_config_param_t *)m_task_params[task_id][iter.first])->algor_param = nullptr;
      }
      break;
    }
    case algorithm_type_t::CALL_PHONE_DET: {
      using ptr_t = algor_config_param_call_phone;
      ptr_t *algor_param = (ptr_t *)((algor_init_config_param_t *)m_task_params[task_id][iter.first])->algor_param;
      if (algor_param) {
        delete (ptr_t *)((algor_init_config_param_t *)m_task_params[task_id][iter.first])->algor_param;
        ((algor_init_config_param_t *)m_task_params[task_id][iter.first])->algor_param = nullptr;
      }
      break;
    }
    case algorithm_type_t::SMOKING_DET: {
      using ptr_t = algor_config_param_smoking;
      ptr_t *algor_param = (ptr_t *)((algor_init_config_param_t *)m_task_params[task_id][iter.first])->algor_param;
      if (algor_param) {
        delete (ptr_t *)((algor_init_config_param_t *)m_task_params[task_id][iter.first])->algor_param;
        ((algor_init_config_param_t *)m_task_params[task_id][iter.first])->algor_param = nullptr;
      }
      break;
    }
    default:
      break;
    }

    if ((algor_init_config_param_t *)m_task_params[task_id][iter.first]) {
      delete (algor_init_config_param_t *)m_task_params[task_id][iter.first];
      m_task_params[task_id][iter.first] = nullptr;
    }
  }
  m_task_params.erase(task_id);

  if (m_algor_config_params.count(task_id)) {
      m_algor_config_params[task_id].human_face_algors.clear();
      m_algor_config_params[task_id].human_algors.clear();
      m_algor_config_params[task_id].nonmotor_vehicle_algors.clear();
      m_algor_config_params[task_id].vehicle_algors.clear();
      m_algor_config_params.erase(task_id);
  }

}

void task_param_manager::task_param_manager_release() {
  for (auto iter : m_task_params)
    delete_task_param(iter.first);
}

/* 获取指定任务的算法配置参数 */
const algor_open_config_param *const task_param_manager::get_task_algor_param(const string &task_id) {
  auto res = m_algor_config_params.find(task_id);
  if (res == m_algor_config_params.end())
    return nullptr;
  return &res->second;
}

/* 获取指定任务&指定算法的配置参数 */
const task_param_manager::algo_param_type_t_ *const
task_param_manager::get_task_other_param(const string &task_id, const algo_type &_algo_type) {
  auto task_algor_param = get_task_other_param(task_id);
  if (task_algor_param != nullptr){
    auto res = task_algor_param->find(_algo_type);
    if (res != task_algor_param->end())
      return res->second;
  }
  
  return nullptr;
}

/* 获取指定任务的任务配置参数 */
const map<algo_type, task_param_manager::algo_param_type_t_ *> *const
task_param_manager::get_task_other_param(const string &task_id) {
  auto res = m_task_params.find(task_id);
  if (res == m_task_params.end())
    return nullptr;
  return &res->second;
}

/* 获取所有任务的算法配置参数 */
map<string, algor_open_config_param> task_param_manager::get_task_algor_params() {
  return m_algor_config_params;
}

/* 获取所有任务的其他配置参数 */
map<string, map<algo_type, task_param_manager::algo_param_type_t_ *>> task_param_manager::get_task_other_params() {
  return m_task_params;
}

bool task_param_manager::task_has_vpt_algor(const std::string &task_id) {
  auto algor_map = get_task_other_param(task_id);
    if (algor_map == nullptr)
      return false;

    return (algor_map->find(algorithm_type_t::HUMAN_GATHER) != algor_map->end() ||
            algor_map->find(algorithm_type_t::HUMAN_SNAPSHOT) != algor_map->end() ||
            algor_map->find(algorithm_type_t::NONMOTOR_VEHICLE_SNAPSHOT) != algor_map->end() ||
            algor_map->find(algorithm_type_t::SMOKING_DET) != algor_map->end() ||
            algor_map->find(algorithm_type_t::NO_REFLECTIVE_CLOTHING) != algor_map->end() ||
            algor_map->find(algorithm_type_t::NO_SAFETY_HELMET) != algor_map->end() ||
            algor_map->find(algorithm_type_t::CALL_PHONE_DET) != algor_map->end() ||
            algor_map->find(algorithm_type_t::VEHICLE_SNAPSHOT) != algor_map->end() ||
            algor_map->find(algorithm_type_t::TAKEAWAY_MEMBER_CLASSIFICATION) != algor_map->end() ||
            algor_map->find(algorithm_type_t::PEDESTRIAN_FALL) != algor_map->end() ||
            algor_map->find(algorithm_type_t::PEDESTRIAN_FIGHT) != algor_map->end() ||
            algor_map->find(algorithm_type_t::PEDESTRIAN_RETROGRADE) != algor_map->end() ||
            algor_map->find(algorithm_type_t::VEHICLE_RETROGRADE) != algor_map->end() ||
            algor_map->find(algorithm_type_t::PEDESTRIAN_TRESPASS) != algor_map->end() ||
            algor_map->find(algorithm_type_t::VEHICLE_TRESPASS) != algor_map->end() ||
            algor_map->find(algorithm_type_t::NONMOTOR_VEHICLE_NOHELMET) != algor_map->end() ||
            algor_map->find(algorithm_type_t::NONMOTOR_VEHICLE_OVERMAN) != algor_map->end() ||
            algor_map->find(algorithm_type_t::NONMOTOR_VEHICLE_USEPHONE) != algor_map->end() ||
            algor_map->find(algorithm_type_t::NONMOTOR_VEHICLE_REFIT) != algor_map->end() ||
            algor_map->find(algorithm_type_t::NONMOTOR_RUNNING_REDLIGHTS) != algor_map->end() ||
            algor_map->find(algorithm_type_t::NONMOTOR_CEOSSPARKLINE) != algor_map->end() ||
            algor_map->find(algorithm_type_t::NONMOTOR_IN_VEHICLELANE) != algor_map->end() ||
            algor_map->find(algorithm_type_t::NONMOTOR_WRONGDIRECTION) != algor_map->end() ||
            algor_map->find(algorithm_type_t::PERSON_IN_VEHICLELANE) != algor_map->end() ||
            algor_map->find(algorithm_type_t::PERSON_RUNNING_REDLIGHTS) != algor_map->end() ||
            algor_map->find(algorithm_type_t::PERSON_CROSS) != algor_map->end() ||
            algor_map->find(algorithm_type_t::VEHICLE_WRONGDIRECTION) != algor_map->end() ||
            algor_map->find(algorithm_type_t::VEHICLE_SOLIDLINETURNAROUND) != algor_map->end() ||
            algor_map->find(algorithm_type_t::VEHICLE_NOTGIVEWAY) != algor_map->end() ||
            algor_map->find(algorithm_type_t::VEHICLE_NOTDECELERATION) != algor_map->end() ||
            algor_map->find(algorithm_type_t::TRICYCLE_MANNED) != algor_map->end() ||
            algor_map->find(algorithm_type_t::TRUCK_MANNED) != algor_map->end());
}

bool task_param_manager::task_has_face_algor(const std::string &task_id) {
    auto algor_map = get_task_other_param(task_id);
    if (nullptr != algor_map){
      return algor_map->find(algorithm_type_t::FACE_SNAPSHOT) != algor_map->end();
    }
    
    return false;
}

int task_param_manager::get_video_timing_snapshot_interval(std::string& task_id) {
  auto algor_map = get_task_other_param(task_id);
    if (algor_map != nullptr) {

      // 设置定时截图的时间间隔
      auto algor = algor_map->find(algorithm_type_t::VIDEO_TIMING_SNAPSHOT);
      if(algor != algor_map->end()){
        task_param_manager::algo_param_type_t_* cur_task_params = algor->second;
        if(cur_task_params){
          int frame_stride = ((algor_config_video_timing_snapshot*)cur_task_params->algor_param)->frame_stride;
          LOG_INFO("task {} snap time interval: {} s", task_id, frame_stride);
          // 单位是ms, 乘以 1000 编成s
          return frame_stride * 1000;
        }
      }

      // 测试代码
      // auto algor_face = algor_map->find(algorithm_type_t::FACE_SNAPSHOT);
      // if(algor_face != algor_map->end()){
      //   const algor_basic_config_param_t *cur_param = ((algor_init_config_param_t *)(algor_face->second))->basic_param;
      //   LOG_INFO("face_snapshot, result_folder: {}  result_folder_little: {}", cur_param->result_folder, cur_param->result_folder_little);
    // }
    }

    return -1;
}