/** @file

  @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.
 */

#include <ts/ts.h>

#include <stdlib.h>
#include <stdio.h>
#include <time.h>
#include <string.h>
#include <stdbool.h>
#include <getopt.h>
#include <limits.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>

#ifdef HAVE_PCRE_PCRE_H
#include <pcre/pcre.h>
#else
#include <pcre.h>
#endif

#define CONFIG_TMOUT      60000
#define FREE_TMOUT        300000
#define OVECTOR_SIZE      30
#define LOG_ROLL_INTERVAL 86400
#define LOG_ROLL_OFFSET   0

static const char *const PLUGIN_NAME = "regex_revalidate";
static const char *const DEFAULT_DIR = "var/trafficserver"; /* Not perfect, but no better API) */

static char const *const RESULT_MISS    = "MISS";
static char const *const RESULT_STALE   = "STALE";
static char const *const RESULT_UNKNOWN = "UNKNOWN";

static int               stat_id_stale   = TS_ERROR;
static char const *const stat_name_stale = "plugin.regex_revalidate.stale";
static int               stat_id_miss    = TS_ERROR;
static char const *const stat_name_miss  = "plugin.regex_revalidate.miss";

static DbgCtl dbg_ctl{PLUGIN_NAME};

static void
create_stats()
{
  if (TS_ERROR == stat_id_stale && TS_ERROR == TSStatFindName(stat_name_stale, &stat_id_stale)) {
    stat_id_stale = TSStatCreate(stat_name_stale, TS_RECORDDATATYPE_INT, TS_STAT_NON_PERSISTENT, TS_STAT_SYNC_COUNT);
    if (TS_ERROR != stat_id_stale) {
      Dbg(dbg_ctl, "Created stat '%s'", stat_name_stale);
    }
  }

  if (TS_ERROR == stat_id_miss && TS_ERROR == TSStatFindName(stat_name_miss, &stat_id_miss)) {
    stat_id_miss = TSStatCreate(stat_name_miss, TS_RECORDDATATYPE_INT, TS_STAT_NON_PERSISTENT, TS_STAT_SYNC_COUNT);
    if (TS_ERROR != stat_id_miss) {
      Dbg(dbg_ctl, "Created stat '%s'", stat_name_miss);
    }
  }
}

static void
increment_stat(TSCacheLookupResult const result)
{
  switch (result) {
  case TS_CACHE_LOOKUP_MISS:
    if (TS_ERROR != stat_id_miss) {
      TSStatIntIncrement(stat_id_miss, 1);
      Dbg(dbg_ctl, "Incrementing stat '%s'", stat_name_miss);
    }
    break;
  case TS_CACHE_LOOKUP_HIT_STALE:
    if (TS_ERROR != stat_id_stale) {
      TSStatIntIncrement(stat_id_stale, 1);
      Dbg(dbg_ctl, "Incrementing stat '%s'", stat_name_stale);
    }
    break;
  default:
    break;
  }
}

static const char *
strForResult(TSCacheLookupResult const result)
{
  switch (result) {
  case TS_CACHE_LOOKUP_MISS:
    return RESULT_MISS;
    break;
  case TS_CACHE_LOOKUP_HIT_STALE:
    return RESULT_STALE;
    break;
  default:
    return RESULT_UNKNOWN;
    break;
  }
}

typedef struct invalidate_t {
  const char          *regex_text;
  pcre                *regex;
  pcre_extra          *regex_extra;
  time_t               epoch;
  time_t               expiry;
  TSCacheLookupResult  new_result;
  struct invalidate_t *next;
} invalidate_t;

typedef struct {
  invalidate_t   *invalidate_list;
  char           *config_path;
  char           *match_header;
  time_t          last_load;
  TSTextLogObject log;
  char           *state_path;
} plugin_state_t;

static invalidate_t *
init_invalidate_t(invalidate_t *i)
{
  i->regex_text  = nullptr;
  i->regex       = nullptr;
  i->regex_extra = nullptr;
  i->epoch       = 0;
  i->expiry      = 0;
  i->new_result  = TS_CACHE_LOOKUP_HIT_STALE;
  i->next        = nullptr;
  return i;
}

static void
free_invalidate_t(invalidate_t *i)
{
  if (i->regex_extra) {
#ifndef PCRE_STUDY_JIT_COMPILE
    pcre_free(i->regex_extra);
#else
    pcre_free_study(i->regex_extra);
#endif
  }
  if (i->regex) {
    pcre_free(i->regex);
  }
  if (i->regex_text) {
    pcre_free_substring(i->regex_text);
  }
  TSfree(i);
}

static void
free_invalidate_t_list(invalidate_t *iptr)
{
  while (nullptr != iptr) {
    invalidate_t *const next = iptr->next;
    free_invalidate_t(iptr);
    iptr = next;
  }
}

static plugin_state_t *
init_plugin_state_t(plugin_state_t *pstate)
{
  pstate->invalidate_list = nullptr;
  pstate->config_path     = nullptr;
  pstate->match_header    = nullptr;
  pstate->last_load       = 0;
  pstate->log             = nullptr;
  pstate->state_path      = nullptr;
  return pstate;
}

static void
free_plugin_state_t(plugin_state_t *pstate)
{
  if (pstate->invalidate_list) {
    free_invalidate_t_list(pstate->invalidate_list);
  }
  if (pstate->config_path) {
    TSfree(pstate->config_path);
  }
  if (pstate->match_header) {
    TSfree(pstate->match_header);
  }
  if (pstate->log) {
    TSTextLogObjectDestroy(pstate->log);
  }
  if (pstate->state_path) {
    TSfree(pstate->state_path);
  }
  TSfree(pstate);
}

static invalidate_t *
copy_invalidate_t(invalidate_t *i)
{
  invalidate_t *iptr;
  const char   *errptr;
  int           erroffset;

  iptr              = (invalidate_t *)TSmalloc(sizeof(invalidate_t));
  iptr->regex_text  = TSstrdup(i->regex_text);
  iptr->regex       = pcre_compile(iptr->regex_text, 0, &errptr, &erroffset, nullptr); // There is no pcre_copy :-(
  iptr->regex_extra = pcre_study(iptr->regex, 0, &errptr); // Assuming no errors since this worked before :-/
  iptr->epoch       = i->epoch;
  iptr->expiry      = i->expiry;
  iptr->new_result  = i->new_result;
  iptr->next        = nullptr;
  return iptr;
}

static invalidate_t *
copy_config(invalidate_t *old_list)
{
  invalidate_t *new_list = nullptr;
  invalidate_t *iptr_old, *iptr_new;

  if (old_list) {
    new_list = copy_invalidate_t(old_list);
    iptr_old = old_list->next;
    iptr_new = new_list;
    while (iptr_old) {
      iptr_new->next = copy_invalidate_t(iptr_old);
      iptr_new       = iptr_new->next;
      iptr_old       = iptr_old->next;
    }
  }

  return new_list;
}

static bool
prune_config(invalidate_t **i)
{
  invalidate_t *iptr, *ilast;
  time_t        now;
  bool          pruned = false;

  now = time(nullptr);

  if (*i) {
    iptr  = *i;
    ilast = nullptr;
    while (iptr) {
      if (iptr->expiry <= now) {
        Dbg(dbg_ctl, "Removing %s expiry: %jd type: %s now: %jd", iptr->regex_text, (intmax_t)iptr->expiry,
            strForResult(iptr->new_result), (intmax_t)now);
        if (ilast) {
          ilast->next = iptr->next;
          free_invalidate_t(iptr);
          iptr = ilast->next;
        } else {
          *i = iptr->next;
          free_invalidate_t(iptr);
          iptr = *i;
        }
        pruned = true;
      } else {
        ilast = iptr;
        iptr  = iptr->next;
      }
    }
  }
  return pruned;
}

static bool
load_state(plugin_state_t *pstate, invalidate_t **ilist)
{
  if (NULL == *ilist) {
    return true;
  }

  FILE *const fs = fopen(pstate->state_path, "r");
  if (NULL == fs) {
    Dbg(dbg_ctl, "Could not open state %s for reading", pstate->state_path);
    return false;
  }

  time_t const now = time(nullptr);

  const char *errptr;
  int         erroffset;
  int         ovector[OVECTOR_SIZE];
  pcre *const config_re = pcre_compile("^([^#].+?)\\s+(\\d+)\\s+(\\d+)\\s+(\\w+)\\s*$", 0, &errptr, &erroffset, nullptr);
  TSReleaseAssert(nullptr != config_re);

  char line[LINE_MAX];
  int  ln = 0;
  while (fgets(line, LINE_MAX, fs) != nullptr) {
    Dbg(dbg_ctl, "state: processing: %d %s", ln, line);
    ++ln;
    int const rc = pcre_exec(config_re, nullptr, line, strlen(line), 0, 0, ovector, OVECTOR_SIZE);

    if (5 == rc) {
      invalidate_t *const inv = (invalidate_t *)TSmalloc(sizeof(invalidate_t));
      init_invalidate_t(inv);

      pcre_get_substring(line, ovector, rc, 1, &(inv->regex_text));
      inv->epoch  = atoi(line + ovector[4]);
      inv->expiry = atoi(line + ovector[6]);

      if (inv->expiry < now) {
        Dbg(dbg_ctl, "state: skipping expired : '%s'", inv->regex_text);
        free_invalidate_t(inv);
        continue;
      }

      int const         len  = ovector[9] - ovector[8];
      char const *const type = line + ovector[8];

      if (0 == strncasecmp(type, RESULT_STALE, len)) {
        Dbg(dbg_ctl, "state: regex line set to result type %s: '%s'", RESULT_STALE, inv->regex_text);
      } else if (0 == strncasecmp(type, RESULT_MISS, len)) {
        Dbg(dbg_ctl, "state: regex line set to result type %s: '%s'", RESULT_MISS, inv->regex_text);
        inv->new_result = TS_CACHE_LOOKUP_MISS;
      } else {
        Dbg(dbg_ctl, "state: unknown regex line result type '%.*s', skipping '%s'", len, type, inv->regex_text);
      }

      // iterate through the loaded config and try to merge
      invalidate_t *iptr = *ilist;
      do {
        if (0 == strcmp(inv->regex_text, iptr->regex_text)) {
          if (iptr->expiry == inv->expiry && iptr->new_result == inv->new_result) {
            Dbg(dbg_ctl, "state: restoring epoch for %s", iptr->regex_text);
            iptr->epoch = inv->epoch;
          }
          break;
        }

        if (nullptr == iptr->next) {
          break;
        }
        iptr = iptr->next;
      } while (nullptr != iptr);

      free_invalidate_t(inv);
    } else {
      Dbg(dbg_ctl, "state: invalid line '%s'", line);
    }
  }

  pcre_free(config_re);
  fclose(fs);
  return true;
}

static bool
load_config(plugin_state_t *pstate, invalidate_t **ilist)
{
  size_t path_len;
  char  *path;

  if (pstate->config_path[0] != '/') {
    path_len = strlen(TSConfigDirGet()) + strlen(pstate->config_path) + 2;
    path     = static_cast<char *>(alloca(path_len));
    snprintf(path, path_len, "%s/%s", TSConfigDirGet(), pstate->config_path);
  } else {
    path = pstate->config_path;
  }

  int const fd = open(path, O_RDONLY);
  if (fd < 0) {
    Dbg(dbg_ctl, "Could not open %s for reading", path);
    return false;
  }

  struct stat s;
  if (fstat(fd, &s) < 0) {
    Dbg(dbg_ctl, "Could not stat %s", path);
    close(fd);
    return false;
  }

  // Don't load if mod time is older than our copy
  if (pstate->last_load < s.st_mtime) {
    time_t const now = time(nullptr);

    FILE *const fs = fdopen(fd, "r");
    if (NULL == fs) {
      Dbg(dbg_ctl, "Could not open %s for reading", path);
      close(fd);
      return false;
    }

    Dbg(dbg_ctl, "Attempting to load rules from: '%s'", path);
    const char *errptr;
    int         erroffset;
    int         ovector[OVECTOR_SIZE];
    pcre *const config_re = pcre_compile("^([^#].+?)\\s+(\\d+)(\\s+(\\w+))?\\s*$", 0, &errptr, &erroffset, nullptr);
    TSReleaseAssert(nullptr != config_re);

    char          line[LINE_MAX];
    int           ln = 0;
    invalidate_t *iptr, *i;

    while (fgets(line, LINE_MAX, fs) != nullptr) {
      Dbg(dbg_ctl, "Processing: %d %s", ln, line);
      ++ln;
      int const rc = pcre_exec(config_re, nullptr, line, strlen(line), 0, 0, ovector, OVECTOR_SIZE);

      if (3 <= rc) {
        i = (invalidate_t *)TSmalloc(sizeof(invalidate_t));
        init_invalidate_t(i);
        pcre_get_substring(line, ovector, rc, 1, &i->regex_text);

        i->regex  = pcre_compile(i->regex_text, 0, &errptr, &erroffset, nullptr);
        i->epoch  = now;
        i->expiry = atoi(line + ovector[4]);

        if (5 == rc) {
          int const         len  = ovector[9] - ovector[8];
          char const *const type = line + ovector[8];
          if (0 == strncasecmp(type, RESULT_MISS, len)) {
            Dbg(dbg_ctl, "Regex line set to result type %s: '%s'", RESULT_MISS, i->regex_text);
            i->new_result = TS_CACHE_LOOKUP_MISS;
          } else if (0 != strncasecmp(type, RESULT_STALE, len)) {
            Dbg(dbg_ctl, "Unknown regex line result type '%s', using default '%s' '%s'", type, RESULT_STALE, i->regex_text);
          }
        }

        if (i->expiry <= i->epoch) {
          Dbg(dbg_ctl, "Rule is already expired!");
          free_invalidate_t(i);
          i = nullptr;
        } else if (i->regex == nullptr) {
          Dbg(dbg_ctl, "%s did not compile", i->regex_text);
          free_invalidate_t(i);
          i = nullptr;
        } else {
          i->regex_extra = pcre_study(i->regex, 0, &errptr);
          if (!*ilist) {
            *ilist = i;
            Dbg(dbg_ctl, "Created new list and Loaded %s %jd %jd %s", i->regex_text, (intmax_t)i->epoch, (intmax_t)i->expiry,
                strForResult(i->new_result));
          } else {
            iptr = *ilist;
            while (1) {
              if (strcmp(i->regex_text, iptr->regex_text) == 0) {
                if (iptr->expiry != i->expiry) {
                  Dbg(dbg_ctl, "Updating duplicate %s", i->regex_text);
                  iptr->epoch  = i->epoch;
                  iptr->expiry = i->expiry;
                }
                if (iptr->new_result != i->new_result) {
                  Dbg(dbg_ctl, "Resetting duplicate due to type change %s", i->regex_text);
                  iptr->new_result = i->new_result;
                  iptr->epoch      = now;
                }
                free_invalidate_t(i);
                i = nullptr;
                break;
              } else if (!iptr->next) {
                break;
              } else {
                iptr = iptr->next;
              }
            }
            if (i) {
              iptr->next = i;
              Dbg(dbg_ctl, "Loaded %s %jd %jd %s", i->regex_text, (intmax_t)i->epoch, (intmax_t)i->expiry,
                  strForResult(i->new_result));
            }
          }
        }
      } else {
        Dbg(dbg_ctl, "Skipping line %d, too few fields", ln);
      }
    }
    pcre_free(config_re);
    fclose(fs);
    pstate->last_load = s.st_mtime;
    return true;
  } else {
    Dbg(dbg_ctl, "File mod time is not newer: ftime: %jd <= last_load: %jd", (intmax_t)s.st_mtime, (intmax_t)pstate->last_load);
  }
  close(fd);
  return false;
}

static void
list_config(plugin_state_t *pstate, invalidate_t *i)
{
  invalidate_t *iptr;

  Dbg(dbg_ctl, "Current config:");
  if (pstate->log) {
    TSTextLogObjectWrite(pstate->log, "Current config:");
  }

  FILE *state_file = nullptr;
  if (pstate->state_path) {
    state_file = fopen(pstate->state_path, "w");
    if (nullptr == state_file) {
      Dbg(dbg_ctl, "Unable to open state file %s\n", pstate->state_path);
    }
  }

  if (i) {
    iptr = i;
    while (iptr) {
      char const *const typestr = strForResult(iptr->new_result);
      Dbg(dbg_ctl, "%s epoch: %jd expiry: %jd result: %s", iptr->regex_text, (intmax_t)iptr->epoch, (intmax_t)iptr->expiry,
          typestr);
      if (pstate->log) {
        TSTextLogObjectWrite(pstate->log, "%s epoch: %jd expiry: %jd result: %s", iptr->regex_text, (intmax_t)iptr->epoch,
                             (intmax_t)iptr->expiry, typestr);
      }
      if (state_file) {
        fprintf(state_file, "%s %jd %jd %s\n", iptr->regex_text, (intmax_t)iptr->epoch, (intmax_t)iptr->expiry, typestr);
      }
      iptr = iptr->next;
    }

  } else {
    Dbg(dbg_ctl, "EMPTY");
    if (pstate->log) {
      TSTextLogObjectWrite(pstate->log, "EMPTY");
    }
  }

  if (nullptr != state_file) {
    fclose(state_file);
  }
}

static int
free_handler(TSCont cont, TSEvent /* event ATS_UNUSED */, void * /* edata ATS_UNUSED */)
{
  invalidate_t *iptr;

  Dbg(dbg_ctl, "Freeing old config");
  iptr = (invalidate_t *)TSContDataGet(cont);
  free_invalidate_t_list(iptr);
  TSContDestroy(cont);
  return 0;
}

static int
config_handler(TSCont cont, TSEvent event, void * /* edata ATS_UNUSED */)
{
  plugin_state_t *pstate;
  invalidate_t   *i, *iptr;
  TSCont          free_cont;
  bool            updated;
  TSMutex         mutex;

  Dbg(dbg_ctl, "In config_handler");

  mutex = TSContMutexGet(cont);
  TSMutexLock(mutex);

  pstate = (plugin_state_t *)TSContDataGet(cont);
  i      = copy_config(pstate->invalidate_list);

  updated = prune_config(&i);
  updated = load_config(pstate, &i) || updated;

  if (updated) {
    list_config(pstate, i);
    iptr = __sync_val_compare_and_swap(&(pstate->invalidate_list), pstate->invalidate_list, i);

    if (iptr) {
      free_cont = TSContCreate(free_handler, TSMutexCreate());
      TSContDataSet(free_cont, (void *)iptr);
      TSContScheduleOnPool(free_cont, FREE_TMOUT, TS_THREAD_POOL_TASK);
    }
  } else {
    Dbg(dbg_ctl, "No Changes");
    if (i) {
      free_invalidate_t_list(i);
    }
  }

  TSMutexUnlock(mutex);

  // Don't reschedule for TS_EVENT_MGMT_UPDATE
  if (event == TS_EVENT_TIMEOUT) {
    TSContScheduleOnPool(cont, CONFIG_TMOUT, TS_THREAD_POOL_TASK);
  }
  return 0;
}

static time_t
get_date_from_cached_hdr(TSHttpTxn txn)
{
  TSMBuffer buf;
  TSMLoc    hdr_loc, date_loc;
  time_t    date = 0;

  if (TSHttpTxnCachedRespGet(txn, &buf, &hdr_loc) == TS_SUCCESS) {
    date_loc = TSMimeHdrFieldFind(buf, hdr_loc, TS_MIME_FIELD_DATE, TS_MIME_LEN_DATE);
    if (date_loc != TS_NULL_MLOC) {
      date = TSMimeHdrFieldValueDateGet(buf, hdr_loc, date_loc);
      TSHandleMLocRelease(buf, hdr_loc, date_loc);
    }
    TSHandleMLocRelease(buf, TS_NULL_MLOC, hdr_loc);
  }

  return date;
}

static void
add_header(TSHttpTxn txn, const char *const header, invalidate_t *const rule)
{
  TSMBuffer bufp     = NULL;
  TSMLoc    lochdr   = TS_NULL_MLOC;
  TSMLoc    locfield = TS_NULL_MLOC;
  char      rulestr[LINE_MAX];
  int       rulelen = 0;
  char      encstr[LINE_MAX];
  size_t    enclen = 0;

  TSReleaseAssert(header && rule);

  if (TS_SUCCESS != TSHttpTxnClientReqGet(txn, &bufp, &lochdr)) {
    Dbg(dbg_ctl, "Unable to get client request from transaction");
  }

  rulelen =
    snprintf(rulestr, sizeof(rulestr), "%s %jd %s", rule->regex_text, (intmax_t)rule->expiry, strForResult(rule->new_result));

  if (TS_SUCCESS != TSStringPercentEncode(rulestr, rulelen, encstr, sizeof(encstr), &enclen, NULL)) {
    Dbg(dbg_ctl, "Unable to get encode matching rule '%s'", rulestr);
    return;
  }

  locfield = TSMimeHdrFieldFind(bufp, lochdr, header, strlen(header));

  if (TS_NULL_MLOC == locfield) { // create header
    if (TS_SUCCESS == TSMimeHdrFieldCreateNamed(bufp, lochdr, header, strlen(header), &locfield)) {
      if (TS_SUCCESS == TSMimeHdrFieldValueStringSet(bufp, lochdr, locfield, -1, encstr, enclen)) {
        TSMimeHdrFieldAppend(bufp, lochdr, locfield);
        Dbg(dbg_ctl, "Added header %s: '%.*s'", header, (int)enclen, encstr);
      }
    }
    TSHandleMLocRelease(bufp, lochdr, locfield);
  } else { // replace header
    bool first = true;
    while (locfield) {
      const TSMLoc tmp = TSMimeHdrFieldNextDup(bufp, lochdr, locfield);
      if (first) {
        first = false;
        TSMimeHdrFieldValueStringSet(bufp, lochdr, locfield, -1, encstr, enclen);
        Dbg(dbg_ctl, "Added header '%s': '%.*s'", header, (int)enclen, encstr);
      } else {
        TSMimeHdrFieldDestroy(bufp, lochdr, locfield);
      }
      TSHandleMLocRelease(bufp, lochdr, locfield);
      locfield = tmp;
    }
  }
}

static int
main_handler(TSCont cont, TSEvent event, void *edata)
{
  TSHttpTxn       txn = (TSHttpTxn)edata;
  int             status;
  invalidate_t   *iptr   = NULL;
  plugin_state_t *pstate = NULL;

  time_t date = 0, now = 0;
  char  *url     = nullptr;
  int    url_len = 0;

  switch (event) {
  case TS_EVENT_HTTP_CACHE_LOOKUP_COMPLETE:
    if (TSHttpTxnCacheLookupStatusGet(txn, &status) == TS_SUCCESS) {
      if (status == TS_CACHE_LOOKUP_HIT_FRESH) {
        pstate = (plugin_state_t *)TSContDataGet(cont);
        iptr   = pstate->invalidate_list;
        while (iptr) {
          if (!date) {
            date = get_date_from_cached_hdr(txn);
            Dbg(dbg_ctl, "Cached Date header is: %jd", intmax_t(date));
            now = time(nullptr);
          }
          if (date <= iptr->epoch && now < iptr->expiry) {
            if (!url) {
              url = TSHttpTxnEffectiveUrlStringGet(txn, &url_len);
              Dbg(dbg_ctl, "Effective url is is '%.*s'", url_len, url);
            }
            if (pcre_exec(iptr->regex, iptr->regex_extra, url, url_len, 0, 0, nullptr, 0) >= 0) {
              Dbg(dbg_ctl, "Forced revalidate, Match with rule regex: '%s' epoch: %jd, expiry: %jd, result: '%s'", iptr->regex_text,
                  intmax_t(iptr->epoch), intmax_t(iptr->expiry), strForResult(iptr->new_result));
              TSHttpTxnCacheLookupStatusSet(txn, iptr->new_result);
              increment_stat(iptr->new_result);

              if (pstate->match_header) {
                add_header(txn, pstate->match_header, iptr);
              }
              iptr = nullptr;
            }
          }
          if (iptr) {
            iptr = iptr->next;
          }
        }
        if (url) {
          TSfree(url);
        }
      }
    }
    break;
  default:
    break;
  }

  TSHttpTxnReenable(txn, TS_EVENT_HTTP_CONTINUE);
  return 0;
}

static char *
make_state_path(const char *filename)
{
  if ('/' == *filename) {
    return TSstrdup(filename);
  } else {
    char        buf[8192];
    const char *dir = TSInstallDirGet();
    snprintf(buf, sizeof(buf), "%s/%s/%s", dir, DEFAULT_DIR, filename);
    return TSstrdup(buf);
  }

  return nullptr;
}

void
TSPluginInit(int argc, const char *argv[])
{
  TSPluginRegistrationInfo info;
  TSCont                   main_cont, config_cont;
  plugin_state_t          *pstate;
  invalidate_t            *iptr                 = nullptr;
  bool                     disable_timed_reload = false;

  Dbg(dbg_ctl, "Starting plugin init");

  pstate = (plugin_state_t *)TSmalloc(sizeof(plugin_state_t));
  init_plugin_state_t(pstate);

  int                        c;
  static const struct option longopts[] = {
    {"config",               required_argument, nullptr, 'c'},
    {"log",                  required_argument, nullptr, 'l'},
    {"disable-timed-reload", no_argument,       nullptr, 'd'},
    {"state-file",           required_argument, nullptr, 'f'},
    {"match-header",         required_argument, nullptr, 'm'},
    {nullptr,                0,                 nullptr, 0  }
  };

  while ((c = getopt_long(argc, (char *const *)argv, "c:l:f:m:", longopts, nullptr)) != -1) {
    switch (c) {
    case 'c':
      pstate->config_path = TSstrdup(optarg);
      break;
    case 'l':
      if (TS_SUCCESS == TSTextLogObjectCreate(optarg, TS_LOG_MODE_ADD_TIMESTAMP, &pstate->log)) {
        TSTextLogObjectRollingIntervalSecSet(pstate->log, LOG_ROLL_INTERVAL);
        TSTextLogObjectRollingOffsetHrSet(pstate->log, LOG_ROLL_OFFSET);
      }
      break;
    case 'd':
      disable_timed_reload = true;
      break;
    case 'f':
      pstate->state_path = make_state_path(optarg);
      break;
    case 'm':
      pstate->match_header = TSstrdup(optarg);
      break;
    default:
      break;
    }
  }

  if (nullptr == pstate->config_path) {
    TSError("[regex_revalidate] Plugin requires a --config option along with a config file name");
    free_plugin_state_t(pstate);
    return;
  }

  if (!load_config(pstate, &iptr)) {
    Dbg(dbg_ctl, "Problem loading config from file %s", pstate->config_path);
  } else {
    pstate->invalidate_list = iptr;

    /* Load and merge previous state if provided */
    if (nullptr != pstate->state_path) {
      if (!load_state(pstate, &iptr)) {
        Dbg(dbg_ctl, "Problem loading state from file %s", pstate->state_path);
      } else {
        Dbg(dbg_ctl, "Loaded state from file %s", pstate->state_path);
      }
    }

    list_config(pstate, iptr);
  }

  info.plugin_name   = PLUGIN_NAME;
  info.vendor_name   = "Apache Software Foundation";
  info.support_email = "dev@trafficserver.apache.org";

  if (TSPluginRegister(&info) != TS_SUCCESS) {
    TSError("[regex_revalidate] Plugin registration failed");

    free_plugin_state_t(pstate);
    return;
  } else {
    Dbg(dbg_ctl, "Plugin registration succeeded");
  }

  create_stats();

  main_cont = TSContCreate(main_handler, nullptr);
  TSContDataSet(main_cont, (void *)pstate);
  TSHttpHookAdd(TS_HTTP_CACHE_LOOKUP_COMPLETE_HOOK, main_cont);

  config_cont = TSContCreate(config_handler, TSMutexCreate());
  TSContDataSet(config_cont, (void *)pstate);

  TSMgmtUpdateRegister(config_cont, PLUGIN_NAME);

  if (!disable_timed_reload) {
    TSContScheduleOnPool(config_cont, CONFIG_TMOUT, TS_THREAD_POOL_TASK);
  }

  Dbg(dbg_ctl, "Plugin Init Complete");
}