// Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#include "opencv2/core.hpp"
#include "opencv2/imgcodecs.hpp"
#include "opencv2/imgproc.hpp"
#include <chrono>
#include <iomanip>
#include <iostream>
#include <opencv2/core/utils/filesystem.hpp>
#include <ostream>
#include <vector>

#include <cstring>
#include <fstream>
#include <numeric>

#include <auto_log/autolog.h>
#include <include/cls.h>
#include <include/yaml_config.h>

using namespace std;
using namespace cv;
using namespace PaddleClas;

int main(int argc, char **argv) {
  if (argc != 2) {
    std::cerr << "[ERROR] usage: " << argv[0] << " yaml_path\n";
    exit(1);
  }

  YamlConfig config(argv[1]);
  config.PrintConfigInfo();

  std::string path =
      config.config_file["Global"]["infer_imgs"].as<std::string>();
  std::vector<std::string> img_files_list;
  if (cv::utils::fs::isDirectory(path)) {
    std::vector<cv::String> filenames;
    cv::glob(path, filenames);
    for (auto f : filenames) {
      img_files_list.push_back(f);
    }
  } else {
    img_files_list.push_back(path);
  }

  std::cout << "img_file_list length: " << img_files_list.size() << std::endl;

  Classifier classifier(config.config_file);

  double elapsed_time = 0.0;
  std::vector<double> cls_times;
  int warmup_iter = img_files_list.size() > 5 ? 5 : 0;
  for (int idx = 0; idx < img_files_list.size(); ++idx) {
    std::string img_path = img_files_list[idx];
    cv::Mat srcimg = cv::imread(img_path, cv::IMREAD_COLOR);
    if (!srcimg.data) {
      std::cerr << "[ERROR] image read failed! image path: " << img_path
                << "\n";
      exit(-1);
    }

    cv::cvtColor(srcimg, srcimg, cv::COLOR_BGR2RGB);

    double run_time = classifier.Run(srcimg, &cls_times);
    if (idx >= warmup_iter) {
      elapsed_time += run_time;
      std::cout << "Current image path: " << img_path << std::endl;
      std::cout << "Current time cost: " << run_time << " s, "
                << "average time cost in all: "
                << elapsed_time / (idx + 1 - warmup_iter) << " s." << std::endl;
    } else {
      std::cout << "Current time cost: " << run_time << " s." << std::endl;
    }
  }

  std::string presion = "fp32";

  // if (config.use_fp16)
  //   presion = "fp16";
  // if (config.benchmark) {
  //   AutoLogger autolog("Classification", config.use_gpu, config.use_tensorrt,
  //                      config.use_mkldnn, config.cpu_threads, 1,
  //                      "1, 3, 224, 224", presion, cls_times,
  //                      img_files_list.size());
  //   autolog.report();
  // }
  return 0;
}