/*
 * Created by hangangqiang on 2023.08.29.
 */

#ifndef LEETCODE_TESTCASE_H
#define LEETCODE_TESTCASE_H

#include <memory>
#include <map>
#include <string>
#include <utility>
#include <vector>
#include "data.h"

class TestCase {
 public:
  explicit TestCase(std::string name = "") : name_(std::move(name)){};
  virtual ~TestCase() = default;
  TestCase(std::unique_ptr<Data> input, std::unique_ptr<Data> output)
      : input_(std::move(input)), output_(std::move(output)){};

  template <typename meta_type, typename T>
  TestCase &AddInput(const T &value) {
    auto meta_data = new meta_type(value);
    this->input_metas_.emplace_back(meta_data);
    return *this;
  }

  void FinishInput();

  template <typename meta_type, typename T>
  void SetInput(const T &value) {
    meta_type meta_data(value);
    this->input_ = std::make_unique<Data>(meta_data);
  }

  template <typename meta_type>
  void SetMetaIntput(const meta_type &meta_data) {
    this->input_ = std::make_unique<Data>(meta_data);
  }

  template <typename meta_type, typename T>
  void SetOutput(const T &value) {
    meta_type meta_data(value);
    this->output_ = std::make_unique<Data>(meta_data);
  }

  template <typename meta_type>
  void SetMetaOutput(const meta_type &meta_data) {
    this->output_ = std::make_unique<Data>(meta_data);
  }

  void ResetData() {
    if (this->input_ != nullptr) {
      this->input_->ResetCurse();
    }
    if (this->output_ != nullptr) {
      this->output_->ResetCurse();
    }
  }

  std::unique_ptr<Data> &GetInput() { return this->input_; }
  std::unique_ptr<Data> &GetOutput() { return this->output_; }
  std::string GetName() const { return this->name_; }
  void SetName(const std::string &name) { this->name_ = name; }

 private:
  std::string name_;
  std::vector<MetaData *> input_metas_;
  std::unique_ptr<Data> input_ = nullptr;
  std::unique_ptr<Data> output_ = nullptr;
};

#endif  // LEETCODE_TESTCASE_H