/** @file

    Include file for the traffic_top stats.

    @section license License

    Licensed to the Apache Software Foundation (ASF) under one
    or more contributor license agreements.  See the NOTICE file
    distributed with this work for additional information
    regarding copyright ownership.  The ASF licenses this file
    to you 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.
*/
#if HAS_CURL
#include <curl/curl.h>
#endif
#include <map>
#include <string>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <cinttypes>
#include <sys/time.h>
#include "mgmtapi.h"

struct LookupItem {
  LookupItem(const char *s, const char *n, const int t) : pretty(s), name(n), numerator(""), denominator(""), type(t) {}
  LookupItem(const char *s, const char *n, const char *d, const int t) : pretty(s), name(n), numerator(n), denominator(d), type(t)
  {
  }
  const char *pretty;
  const char *name;
  const char *numerator;
  const char *denominator;
  int type;
};
extern size_t write_data(void *ptr, size_t size, size_t nmemb, void *stream);
#if HAS_CURL
extern char curl_error[CURL_ERROR_SIZE];
#endif
extern std::string response;

namespace constant
{
const char global[]    = "\"global\": {\n";
const char start[]     = "\"proxy.process.";
const char separator[] = "\": \"";
const char end[]       = "\",\n";
}; // namespace constant

//----------------------------------------------------------------------------
class Stats
{
  using string                            = std::string;
  template <class Key, class T> using map = std::map<Key, T>;

public:
  Stats(const string &url) : _url(url)
  {
    if (url != "") {
      if (_url.substr(0, 4) != "http") {
        // looks like it is a host using it the old way
        _url = "http://" + _url + "/_stats";
      }

      // set the host
      size_t start = _url.find(":");
      size_t end   = _url.find('/', start + 3);
      _host        = _url.substr(start + 3, end - start - 3);
      end          = _host.find(":");
      if (end != string::npos) {
        _host = _host.substr(0, end);
      }
    } else {
      char hostname[25];
      hostname[sizeof(hostname) - 1] = '\0';
      gethostname(hostname, sizeof(hostname) - 1);
      _host = hostname;
    }

    _time_diff = 0;
    _old_time  = 0;
    _now       = 0;
    _time      = (struct timeval){0, 0};
    _stats     = nullptr;
    _old_stats = nullptr;
    _absolute  = false;
    lookup_table.insert(make_pair("version", LookupItem("Version", "proxy.process.version.server.short", 1)));
    lookup_table.insert(make_pair("disk_used", LookupItem("Disk Used", "proxy.process.cache.bytes_used", 1)));
    lookup_table.insert(make_pair("disk_total", LookupItem("Disk Total", "proxy.process.cache.bytes_total", 1)));
    lookup_table.insert(make_pair("ram_used", LookupItem("Ram Used", "proxy.process.cache.ram_cache.bytes_used", 1)));
    lookup_table.insert(make_pair("ram_total", LookupItem("Ram Total", "proxy.process.cache.ram_cache.total_bytes", 1)));
    lookup_table.insert(make_pair("lookups", LookupItem("Lookups", "proxy.process.http.cache_lookups", 2)));
    lookup_table.insert(make_pair("cache_writes", LookupItem("Writes", "proxy.process.http.cache_writes", 2)));
    lookup_table.insert(make_pair("cache_updates", LookupItem("Updates", "proxy.process.http.cache_updates", 2)));
    lookup_table.insert(make_pair("cache_deletes", LookupItem("Deletes", "proxy.process.http.cache_deletes", 2)));
    lookup_table.insert(make_pair("read_active", LookupItem("Read Active", "proxy.process.cache.read.active", 1)));
    lookup_table.insert(make_pair("write_active", LookupItem("Writes Active", "proxy.process.cache.write.active", 1)));
    lookup_table.insert(make_pair("update_active", LookupItem("Update Active", "proxy.process.cache.update.active", 1)));
    lookup_table.insert(make_pair("entries", LookupItem("Entries", "proxy.process.cache.direntries.used", 1)));
    lookup_table.insert(make_pair("avg_size", LookupItem("Avg Size", "disk_used", "entries", 3)));

    lookup_table.insert(make_pair("dns_entry", LookupItem("DNS Entry", "proxy.process.hostdb.cache.current_items", 1)));
    lookup_table.insert(make_pair("dns_hits", LookupItem("DNS Hits", "proxy.process.hostdb.total_hits", 2)));
    lookup_table.insert(make_pair("dns_lookups", LookupItem("DNS Lookups", "proxy.process.hostdb.total_lookups", 2)));

    // Incoming HTTP/1.1 and HTTP/2 connections - some metrics are HTTP version specific
    lookup_table.insert(make_pair("client_req", LookupItem("Requests", "proxy.process.http.incoming_requests", 2)));

    // total_client_connections
    lookup_table.insert(
      make_pair("client_conn_h1", LookupItem("New Conn HTTP/1.x", "proxy.process.http.total_client_connections", 2)));
    lookup_table.insert(
      make_pair("client_conn_h2", LookupItem("New Conn HTTP/2", "proxy.process.http2.total_client_connections", 2)));
    lookup_table.insert(make_pair("client_conn", LookupItem("New Conn", "client_conn_h1", "client_conn_h2", 6)));

    // requests / connections
    lookup_table.insert(make_pair("client_req_conn", LookupItem("Req/Conn", "client_req", "client_conn", 3)));

    // current_client_connections
    lookup_table.insert(
      make_pair("client_curr_conn_h1", LookupItem("Curr Conn HTTP/1.x", "proxy.process.http.current_client_connections", 1)));
    lookup_table.insert(
      make_pair("client_curr_conn_h2", LookupItem("Curr Conn HTTP/2", "proxy.process.http2.current_client_connections", 1)));
    lookup_table.insert(make_pair("client_curr_conn", LookupItem("Curr Conn", "client_curr_conn_h1", "client_curr_conn_h2", 9)));

    // current_active_client_connections
    lookup_table.insert(make_pair("client_actv_conn_h1",
                                  LookupItem("Active Con HTTP/1.x", "proxy.process.http.current_active_client_connections", 1)));
    lookup_table.insert(make_pair("client_actv_conn_h2",
                                  LookupItem("Active Con HTTP/2", "proxy.process.http2.current_active_client_connections", 1)));
    lookup_table.insert(make_pair("client_actv_conn", LookupItem("Active Con", "client_actv_conn_h1", "client_actv_conn_h2", 9)));

    lookup_table.insert(make_pair("server_req", LookupItem("Requests", "proxy.process.http.outgoing_requests", 2)));
    lookup_table.insert(make_pair("server_conn", LookupItem("New Conn", "proxy.process.http.total_server_connections", 2)));
    lookup_table.insert(make_pair("server_req_conn", LookupItem("Req/Conn", "server_req", "server_conn", 3)));
    lookup_table.insert(make_pair("server_curr_conn", LookupItem("Curr Conn", "proxy.process.http.current_server_connections", 1)));

    lookup_table.insert(
      make_pair("client_head", LookupItem("Head Bytes", "proxy.process.http.user_agent_response_header_total_size", 2)));
    lookup_table.insert(
      make_pair("client_body", LookupItem("Body Bytes", "proxy.process.http.user_agent_response_document_total_size", 2)));
    lookup_table.insert(
      make_pair("server_head", LookupItem("Head Bytes", "proxy.process.http.origin_server_response_header_total_size", 2)));
    lookup_table.insert(
      make_pair("server_body", LookupItem("Body Bytes", "proxy.process.http.origin_server_response_document_total_size", 2)));

    // not used directly
    lookup_table.insert(make_pair("ram_hit", LookupItem("Ram Hit", "proxy.process.cache.ram_cache.hits", 2)));
    lookup_table.insert(make_pair("ram_miss", LookupItem("Ram Misses", "proxy.process.cache.ram_cache.misses", 2)));
    lookup_table.insert(make_pair("ka_total", LookupItem("KA Total", "proxy.process.net.dynamic_keep_alive_timeout_in_total", 2)));
    lookup_table.insert(make_pair("ka_count", LookupItem("KA Count", "proxy.process.net.dynamic_keep_alive_timeout_in_count", 2)));

    lookup_table.insert(make_pair("client_abort", LookupItem("Clnt Abort", "proxy.process.http.err_client_abort_count_stat", 2)));
    lookup_table.insert(make_pair("conn_fail", LookupItem("Conn Fail", "proxy.process.http.err_connect_fail_count_stat", 2)));
    lookup_table.insert(make_pair("abort", LookupItem("Abort", "proxy.process.http.transaction_counts.errors.aborts", 2)));
    lookup_table.insert(
      make_pair("t_conn_fail", LookupItem("Conn Fail", "proxy.process.http.transaction_counts.errors.connect_failed", 2)));
    lookup_table.insert(make_pair("other_err", LookupItem("Other Err", "proxy.process.http.transaction_counts.errors.other", 2)));

    // percentage
    lookup_table.insert(make_pair("ram_ratio", LookupItem("Ram Hit", "ram_hit", "ram_hit_miss", 4)));
    lookup_table.insert(make_pair("dns_ratio", LookupItem("DNS Hit", "dns_hits", "dns_lookups", 4)));

    // percentage of requests
    lookup_table.insert(make_pair("fresh", LookupItem("Fresh", "proxy.process.http.transaction_counts.hit_fresh", 5)));
    lookup_table.insert(make_pair("reval", LookupItem("Revalidate", "proxy.process.http.transaction_counts.hit_revalidated", 5)));
    lookup_table.insert(make_pair("cold", LookupItem("Cold", "proxy.process.http.transaction_counts.miss_cold", 5)));
    lookup_table.insert(make_pair("changed", LookupItem("Changed", "proxy.process.http.transaction_counts.miss_changed", 5)));
    lookup_table.insert(make_pair("not", LookupItem("Not Cache", "proxy.process.http.transaction_counts.miss_not_cacheable", 5)));
    lookup_table.insert(make_pair("no", LookupItem("No Cache", "proxy.process.http.transaction_counts.miss_client_no_cache", 5)));

    lookup_table.insert(
      make_pair("fresh_time", LookupItem("Fresh (ms)", "proxy.process.http.transaction_totaltime.hit_fresh", "fresh", 8)));
    lookup_table.insert(
      make_pair("reval_time", LookupItem("Reval (ms)", "proxy.process.http.transaction_totaltime.hit_revalidated", "reval", 8)));
    lookup_table.insert(
      make_pair("cold_time", LookupItem("Cold (ms)", "proxy.process.http.transaction_totaltime.miss_cold", "cold", 8)));
    lookup_table.insert(
      make_pair("changed_time", LookupItem("Chang (ms)", "proxy.process.http.transaction_totaltime.miss_changed", "changed", 8)));
    lookup_table.insert(
      make_pair("not_time", LookupItem("Not (ms)", "proxy.process.http.transaction_totaltime.miss_not_cacheable", "not", 8)));
    lookup_table.insert(
      make_pair("no_time", LookupItem("No (ms)", "proxy.process.http.transaction_totaltime.miss_client_no_cache", "no", 8)));

    lookup_table.insert(make_pair("get", LookupItem("GET", "proxy.process.http.get_requests", 5)));
    lookup_table.insert(make_pair("head", LookupItem("HEAD", "proxy.process.http.head_requests", 5)));
    lookup_table.insert(make_pair("post", LookupItem("POST", "proxy.process.http.post_requests", 5)));

    lookup_table.insert(make_pair("100", LookupItem("100", "proxy.process.http.100_responses", 5)));
    lookup_table.insert(make_pair("101", LookupItem("101", "proxy.process.http.101_responses", 5)));
    lookup_table.insert(make_pair("1xx", LookupItem("1xx", "proxy.process.http.1xx_responses", 5)));
    lookup_table.insert(make_pair("200", LookupItem("200", "proxy.process.http.200_responses", 5)));
    lookup_table.insert(make_pair("201", LookupItem("201", "proxy.process.http.201_responses", 5)));
    lookup_table.insert(make_pair("202", LookupItem("202", "proxy.process.http.202_responses", 5)));
    lookup_table.insert(make_pair("203", LookupItem("203", "proxy.process.http.203_responses", 5)));
    lookup_table.insert(make_pair("204", LookupItem("204", "proxy.process.http.204_responses", 5)));
    lookup_table.insert(make_pair("205", LookupItem("205", "proxy.process.http.205_responses", 5)));
    lookup_table.insert(make_pair("206", LookupItem("206", "proxy.process.http.206_responses", 5)));
    lookup_table.insert(make_pair("2xx", LookupItem("2xx", "proxy.process.http.2xx_responses", 5)));
    lookup_table.insert(make_pair("300", LookupItem("300", "proxy.process.http.300_responses", 5)));
    lookup_table.insert(make_pair("301", LookupItem("301", "proxy.process.http.301_responses", 5)));
    lookup_table.insert(make_pair("302", LookupItem("302", "proxy.process.http.302_responses", 5)));
    lookup_table.insert(make_pair("303", LookupItem("303", "proxy.process.http.303_responses", 5)));
    lookup_table.insert(make_pair("304", LookupItem("304", "proxy.process.http.304_responses", 5)));
    lookup_table.insert(make_pair("305", LookupItem("305", "proxy.process.http.305_responses", 5)));
    lookup_table.insert(make_pair("307", LookupItem("307", "proxy.process.http.307_responses", 5)));
    lookup_table.insert(make_pair("3xx", LookupItem("3xx", "proxy.process.http.3xx_responses", 5)));
    lookup_table.insert(make_pair("400", LookupItem("400", "proxy.process.http.400_responses", 5)));
    lookup_table.insert(make_pair("401", LookupItem("401", "proxy.process.http.401_responses", 5)));
    lookup_table.insert(make_pair("402", LookupItem("402", "proxy.process.http.402_responses", 5)));
    lookup_table.insert(make_pair("403", LookupItem("403", "proxy.process.http.403_responses", 5)));
    lookup_table.insert(make_pair("404", LookupItem("404", "proxy.process.http.404_responses", 5)));
    lookup_table.insert(make_pair("405", LookupItem("405", "proxy.process.http.405_responses", 5)));
    lookup_table.insert(make_pair("406", LookupItem("406", "proxy.process.http.406_responses", 5)));
    lookup_table.insert(make_pair("407", LookupItem("407", "proxy.process.http.407_responses", 5)));
    lookup_table.insert(make_pair("408", LookupItem("408", "proxy.process.http.408_responses", 5)));
    lookup_table.insert(make_pair("409", LookupItem("409", "proxy.process.http.409_responses", 5)));
    lookup_table.insert(make_pair("410", LookupItem("410", "proxy.process.http.410_responses", 5)));
    lookup_table.insert(make_pair("411", LookupItem("411", "proxy.process.http.411_responses", 5)));
    lookup_table.insert(make_pair("412", LookupItem("412", "proxy.process.http.412_responses", 5)));
    lookup_table.insert(make_pair("413", LookupItem("413", "proxy.process.http.413_responses", 5)));
    lookup_table.insert(make_pair("414", LookupItem("414", "proxy.process.http.414_responses", 5)));
    lookup_table.insert(make_pair("415", LookupItem("415", "proxy.process.http.415_responses", 5)));
    lookup_table.insert(make_pair("416", LookupItem("416", "proxy.process.http.416_responses", 5)));
    lookup_table.insert(make_pair("4xx", LookupItem("4xx", "proxy.process.http.4xx_responses", 5)));
    lookup_table.insert(make_pair("500", LookupItem("500", "proxy.process.http.500_responses", 5)));
    lookup_table.insert(make_pair("501", LookupItem("501", "proxy.process.http.501_responses", 5)));
    lookup_table.insert(make_pair("502", LookupItem("502", "proxy.process.http.502_responses", 5)));
    lookup_table.insert(make_pair("503", LookupItem("503", "proxy.process.http.503_responses", 5)));
    lookup_table.insert(make_pair("504", LookupItem("504", "proxy.process.http.504_responses", 5)));
    lookup_table.insert(make_pair("505", LookupItem("505", "proxy.process.http.505_responses", 5)));
    lookup_table.insert(make_pair("5xx", LookupItem("5xx", "proxy.process.http.5xx_responses", 5)));

    lookup_table.insert(make_pair("s_100", LookupItem("100 B", "proxy.process.http.response_document_size_100", 5)));
    lookup_table.insert(make_pair("s_1k", LookupItem("1 KB", "proxy.process.http.response_document_size_1K", 5)));
    lookup_table.insert(make_pair("s_3k", LookupItem("3 KB", "proxy.process.http.response_document_size_3K", 5)));
    lookup_table.insert(make_pair("s_5k", LookupItem("5 KB", "proxy.process.http.response_document_size_5K", 5)));
    lookup_table.insert(make_pair("s_10k", LookupItem("10 KB", "proxy.process.http.response_document_size_10K", 5)));
    lookup_table.insert(make_pair("s_1m", LookupItem("1 MB", "proxy.process.http.response_document_size_1M", 5)));
    lookup_table.insert(make_pair("s_>1m", LookupItem("> 1 MB", "proxy.process.http.response_document_size_inf", 5)));

    // sum together
    lookup_table.insert(make_pair("ram_hit_miss", LookupItem("Ram Hit+Miss", "ram_hit", "ram_miss", 6)));
    lookup_table.insert(make_pair("client_net", LookupItem("Net (bits)", "client_head", "client_body", 7)));
    lookup_table.insert(make_pair("client_size", LookupItem("Total Size", "client_head", "client_body", 6)));
    lookup_table.insert(make_pair("client_avg_size", LookupItem("Avg Size", "client_size", "client_req", 3)));

    lookup_table.insert(make_pair("server_net", LookupItem("Net (bits)", "server_head", "server_body", 7)));
    lookup_table.insert(make_pair("server_size", LookupItem("Total Size", "server_head", "server_body", 6)));
    lookup_table.insert(make_pair("server_avg_size", LookupItem("Avg Size", "server_size", "server_req", 3)));

    lookup_table.insert(make_pair("total_time", LookupItem("Total Time", "proxy.process.http.total_transactions_time", 2)));

    // ratio
    lookup_table.insert(make_pair("client_req_time", LookupItem("Resp (ms)", "total_time", "client_req", 3)));
    lookup_table.insert(make_pair("client_dyn_ka", LookupItem("Dynamic KA", "ka_total", "ka_count", 3)));
  }

  void
  getStats()
  {
    if (_url == "") {
      int64_t value = 0;
      if (_old_stats != nullptr) {
        delete _old_stats;
        _old_stats = nullptr;
      }
      _old_stats = _stats;
      _stats     = new map<string, string>;

      gettimeofday(&_time, nullptr);
      double now = _time.tv_sec + (double)_time.tv_usec / 1000000;

      for (map<string, LookupItem>::const_iterator lookup_it = lookup_table.begin(); lookup_it != lookup_table.end(); ++lookup_it) {
        const LookupItem &item = lookup_it->second;

        if (item.type == 1 || item.type == 2 || item.type == 5 || item.type == 8) {
          if (strcmp(item.pretty, "Version") == 0) {
            // special case for Version information
            TSString strValue = nullptr;
            if (TSRecordGetString(item.name, &strValue) == TS_ERR_OKAY) {
              string key     = item.name;
              (*_stats)[key] = strValue;
              TSfree(strValue);
            } else {
              fprintf(stderr, "Error getting stat: %s when calling TSRecordGetString() failed: file \"%s\", line %d\n\n", item.name,
                      __FILE__, __LINE__);
              abort();
            }
          } else {
            if (TSRecordGetInt(item.name, &value) != TS_ERR_OKAY) {
              fprintf(stderr, "Error getting stat: %s when calling TSRecordGetInt() failed: file \"%s\", line %d\n\n", item.name,
                      __FILE__, __LINE__);
              abort();
            }
            string key = item.name;
            char buffer[32];
            sprintf(buffer, "%" PRId64, value);
            string foo     = buffer;
            (*_stats)[key] = foo;
          }
        }
      }
      _old_time  = _now;
      _now       = now;
      _time_diff = _now - _old_time;
    } else {
#if HAS_CURL
      CURL *curl;
      CURLcode res;

      curl = curl_easy_init();
      if (curl) {
        curl_easy_setopt(curl, CURLOPT_URL, _url.c_str());
        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_data);
        curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, curl_error);

        // update time
        gettimeofday(&_time, nullptr);
        double now = _time.tv_sec + (double)_time.tv_usec / 1000000;

        response.clear();
        response.reserve(32768); // should hopefully be smaller then 32KB
        res = curl_easy_perform(curl);

        // only if success update stats and time information
        if (res == 0) {
          if (_old_stats != nullptr) {
            delete _old_stats;
            _old_stats = nullptr;
          }
          _old_stats = _stats;
          _stats     = new map<string, string>;

          // parse
          parseResponse(response);
          _old_time  = _now;
          _now       = now;
          _time_diff = _now - _old_time;
        } else {
          fprintf(stderr, "Can't fetch url %s\n", _url.c_str());
          exit(1);
        }

        /* always cleanup */
        curl_easy_cleanup(curl);
      }
#endif
    }
  }

  int64_t
  getValue(const string &key, const map<string, string> *stats) const
  {
    map<string, string>::const_iterator stats_it = stats->find(key);
    if (stats_it == stats->end()) {
      return 0;
    }
    int64_t value = atoll(stats_it->second.c_str());
    return value;
  }

  void
  getStat(const string &key, double &value, int overrideType = 0)
  {
    string strtmp;
    int typetmp;
    getStat(key, value, strtmp, typetmp, overrideType);
  }

  void
  getStat(const string &key, string &value)
  {
    map<string, LookupItem>::const_iterator lookup_it = lookup_table.find(key);
    assert(lookup_it != lookup_table.end());
    const LookupItem &item = lookup_it->second;

    map<string, string>::const_iterator stats_it = _stats->find(item.name);
    if (stats_it == _stats->end()) {
      value = "";
    } else {
      value = stats_it->second.c_str();
    }
  }

  void
  getStat(const string &key, double &value, string &prettyName, int &type, int overrideType = 0)
  {
    // set default value
    value = 0;

    map<string, LookupItem>::const_iterator lookup_it = lookup_table.find(key);
    assert(lookup_it != lookup_table.end());
    const LookupItem &item = lookup_it->second;
    prettyName             = item.pretty;
    if (overrideType != 0) {
      type = overrideType;
    } else {
      type = item.type;
    }

    if (type == 1 || type == 2 || type == 5 || type == 8) {
      value = getValue(item.name, _stats);
      if (key == "total_time") {
        value = value / 10000000;
      }

      if ((type == 2 || type == 5 || type == 8) && _old_stats != nullptr && _absolute == false) {
        double old = getValue(item.name, _old_stats);
        if (key == "total_time") {
          old = old / 10000000;
        }
        value = (value - old) / _time_diff;
      }
    } else if (type == 3 || type == 4) {
      double numerator   = 0;
      double denominator = 0;
      getStat(item.numerator, numerator);
      getStat(item.denominator, denominator);
      if (denominator == 0) {
        value = 0;
      } else {
        value = numerator / denominator;
      }
      if (type == 4) {
        value *= 100;
      }
    } else if (type == 6 || type == 7) {
      // add rate
      double first;
      double second;
      getStat(item.numerator, first, 2);
      getStat(item.denominator, second, 2);
      value = first + second;
      if (type == 7) {
        value *= 8;
      }
    } else if (type == 9) {
      // add
      double first;
      double second;
      getStat(item.numerator, first);
      getStat(item.denominator, second);
      value = first + second;
    }

    if (type == 8) {
      double denominator;
      getStat(item.denominator, denominator, 2);
      if (denominator == 0) {
        value = 0;
      } else {
        value = value / denominator * 1000;
      }
    }

    if (type == 5) {
      double denominator = 0;
      getStat("client_req", denominator);
      if (denominator == 0) {
        value = 0;
      } else {
        value = value / denominator * 100;
      }
    }
  }

  bool
  toggleAbsolute()
  {
    if (_absolute == true) {
      _absolute = false;
    } else {
      _absolute = true;
    }

    return _absolute;
  }

  void
  parseResponse(const string &response)
  {
    // move past global
    size_t pos = response.find(constant::global);
    pos += sizeof(constant::global) - 1;

    // find parts of the line
    while (true) {
      size_t start     = response.find(constant::start, pos);
      size_t separator = response.find(constant::separator, pos);
      size_t end       = response.find(constant::end, pos);

      if (start == string::npos || separator == string::npos || end == string::npos) {
        return;
      }

      // cout << constant::start << " " << start << endl;
      // cout << constant::separator << " " << separator << endl;
      // cout << constant::end << " " << end << endl;

      string key = response.substr(start + 1, separator - start - 1);
      string value =
        response.substr(separator + sizeof(constant::separator) - 1, end - separator - sizeof(constant::separator) + 1);

      (*_stats)[key] = value;
      // cout << "key " << key << " " << "value " << value << endl;
      pos = end + sizeof(constant::end) - 1;
      // cout << "pos: " << pos << endl;
    }
  }

  const string &
  getHost() const
  {
    return _host;
  }

  ~Stats()
  {
    if (_stats != nullptr) {
      delete _stats;
    }
    if (_old_stats != nullptr) {
      delete _old_stats;
    }
  }

private:
  std::pair<std::string, LookupItem>
  make_pair(std::string s, LookupItem i)
  {
    return std::make_pair(s, i);
  }

  map<string, string> *_stats;
  map<string, string> *_old_stats;
  map<string, LookupItem> lookup_table;
  string _url;
  string _host;
  double _old_time;
  double _now;
  double _time_diff;
  struct timeval _time;
  bool _absolute;
};