#pragma once
#include "paddle_api.h"
#include "paddle_inference_api.h"
#include <postprocess_op.h>
#include <preprocess_op.h>
namespace ANSCENTER
{
  class StructureLayoutRecognizer
  {
  public:
      StructureLayoutRecognizer() {}
      bool Initialize(const std::string &model_dir, const bool &use_gpu, const int &gpu_id,
        const int &gpu_mem, const int &cpu_math_library_num_threads,
        const bool &use_mkldnn, const std::string &label_path,
        const bool &use_tensorrt, const std::string &precision,
        const double &layout_score_threshold,
        const double &layout_nms_threshold)
    {
          try {
              this->use_gpu_ = use_gpu;
              this->gpu_id_ = gpu_id;
              this->gpu_mem_ = gpu_mem;
              this->cpu_math_library_num_threads_ = cpu_math_library_num_threads;
              this->use_mkldnn_ = use_mkldnn;
              this->use_tensorrt_ = use_tensorrt;
              this->precision_ = precision;

              this->post_processor_.init(label_path, layout_score_threshold,
                  layout_nms_threshold);
              return LoadModel(model_dir);

          }
          catch (std::exception& e) {
              std::cout << "StructureLayoutRecognizer::StructureLayoutRecognizer" << e.what() << std::endl;
              return false;
          }
    }

    // Load Paddle inference model
    bool LoadModel(const std::string &model_dir);

    void Run(cv::Mat img, std::vector<StructurePredictResult> &result);

  private:
    std::shared_ptr<paddle_infer::Predictor> predictor_;

    bool use_gpu_ = false;
    int gpu_id_ = 0;
    int gpu_mem_ = 4000;
    int cpu_math_library_num_threads_ = 4;
    bool use_mkldnn_ = false;

    std::vector<float> mean_ = {0.485f, 0.456f, 0.406f};
    std::vector<float> scale_ = {1 / 0.229f, 1 / 0.224f, 1 / 0.225f};
    bool is_scale_ = true;

    bool use_tensorrt_ = false;
    std::string precision_ = "fp32";

    // pre-process
    Resize resize_op_;
    Normalize normalize_op_;
    Permute permute_op_;

    // post-process
    PicodetPostProcessor post_processor_;
  };
} // namespace ANSOCR