#include <string>
#include <unordered_map>
#include <vector>
#include <type_traits>
#include <algorithm>

#include "fieldstat.h"
#include "fieldstat_internal.h"

#define TEST_PORTAL 8700
#define TEST_LINE_PROTOCOL_FILE_PATH "/tmp/metrics.out"
#define TEST_DEFAULT_FILE_PATH "/tmp/czzdefault.txt"
#define TEST_JSON_FILE_PATH "/tmp/czzjson.txt"
#define TEST_PROMETHEUS_FILE_PATH "/tmp/czzprometheus.txt"

class Reg_str
{
    public:
        Reg_str() : str_("") {}
        explicit Reg_str(const std::string &p) : str_(p) {}
        Reg_str operator+=(const Reg_str &p2) {
            str_ += p2.str_;
            return *this;
        }
        Reg_str operator+(const std::string &p2) {
            return Reg_str(str_ + p2);
        }

        Reg_str &add_any() {
            str_ += std::string("[\\s\\S]*");
            return *this;
        }
        Reg_str &add_text() {
            str_ += std::string(".*");
            return *this;
        }
        Reg_str &add_space() {
            str_ += std::string(" *");
            return *this;
        }
        Reg_str &add_endl() {
            str_ += std::string("\\n");
            return *this;
        }
        Reg_str &add(const std::string &t) {
            str_ += t;
            return *this;
        }
        Reg_str &add(int t) {
            str_ += std::to_string(t);
            return *this;
        }
        template <typename T>
        Reg_str &add_num(T t) {
            str_ += std::to_string(t);
            return *this;
        }
        Reg_str &parenthsis() {
            str_ = "(" + str_ + ")";
            return *this;
        }
        std::string get_str() {
            return str_;
        }
    private:
        std::string str_;
};

class Heavy_keeper_tester
{
    public:
        explicit Heavy_keeper_tester(const char *instance_name);
        ~Heavy_keeper_tester();
        void register_metric(const char *metric_name, int K, int out_window);

        void take_action(const char *metric_name, const char *member, int value);
        std::string read_from_file(const char *output_file_path, const char *method);
        std::string read_from_line_protocol(const char *output_file_path, const char *ip = "127.0.0.1", unsigned long portal = TEST_PORTAL);
        std::string read_from_prometheus(const char *output_file_path, unsigned long portal = 9020);
        std::string get_expected_pattern(std::string method);
        void new_window();

    protected:
        struct fieldstat_instance * instance;

    private: 
        struct action {
            std::string metric_name;
            std::string member;
            int value;
        };

        struct metric_info {
            struct metric *m;
            int id;
            int output_window;
        };
        std::unordered_map<std::string, struct metric_info> metric_map;
        std::vector<struct action> actions;
        std::vector<struct action> accu_actions;
        void sort_map(std::unordered_map<std::string, struct metric_info> &metric_map);
        std::vector<std::pair<std::string, int>> get_expected_topk(const std::string &metric_name, std::vector<struct action> &tmp_actions);
};

class Heavy_keeper_extension_test : public Heavy_keeper_tester
{
    public:
        int add_metric_of_counter(const char *metric_name, int out_window);
        struct fieldstat_instance *get_instance();
        explicit Heavy_keeper_extension_test(const char *instance_name): Heavy_keeper_tester(instance_name) {};
};

void clear_file(const char *file_paths);