/*
 * @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::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;

    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) {
      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::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);
}

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;
}