/*
 * ngtcp2
 *
 * Copyright (c) 2019 ngtcp2 contributors
 *
 * Permission is hereby granted, free of charge, to any person obtaining
 * a copy of this software and associated documentation files (the
 * "Software"), to deal in the Software without restriction, including
 * without limitation the rights to use, copy, modify, merge, publish,
 * distribute, sublicense, and/or sell copies of the Software, and to
 * permit persons to whom the Software is furnished to do so, subject to
 * the following conditions:
 *
 * The above copyright notice and this permission notice shall be
 * included in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
 * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */
#include "ngtcp2_pv.h"

#include <string.h>
#include <assert.h>

#include "ngtcp2_mem.h"
#include "ngtcp2_log.h"
#include "ngtcp2_macro.h"
#include "ngtcp2_addr.h"
#include "ngtcp2_str.h"

void ngtcp2_pv_entry_init(ngtcp2_pv_entry *pvent,
                          const ngtcp2_path_challenge_data *data,
                          ngtcp2_tstamp expiry, uint8_t flags) {
  *pvent = (ngtcp2_pv_entry){
    .expiry = expiry,
    .flags = flags,
    .data = *data,
  };
}

int ngtcp2_pv_new(ngtcp2_pv **ppv, const ngtcp2_dcid *dcid,
                  ngtcp2_duration timeout, uint8_t flags, ngtcp2_log *log,
                  const ngtcp2_mem *mem) {
  (*ppv) = ngtcp2_mem_malloc(mem, sizeof(ngtcp2_pv));
  if (*ppv == NULL) {
    return NGTCP2_ERR_NOMEM;
  }

  ngtcp2_static_ringbuf_pv_ents_init(&(*ppv)->ents);

  ngtcp2_dcid_copy(&(*ppv)->dcid, dcid);

  (*ppv)->mem = mem;
  (*ppv)->log = log;
  (*ppv)->timeout = timeout;
  (*ppv)->fallback_pto = 0;
  (*ppv)->started_ts = UINT64_MAX;
  (*ppv)->probe_pkt_left = NGTCP2_PV_NUM_PROBE_PKT;
  (*ppv)->round = 0;
  (*ppv)->flags = flags;

  return 0;
}

void ngtcp2_pv_del(ngtcp2_pv *pv) {
  if (pv == NULL) {
    return;
  }
  ngtcp2_mem_free(pv->mem, pv);
}

void ngtcp2_pv_add_entry(ngtcp2_pv *pv, const ngtcp2_path_challenge_data *data,
                         ngtcp2_tstamp expiry, uint8_t flags,
                         ngtcp2_tstamp ts) {
  ngtcp2_pv_entry *ent;

  assert(pv->probe_pkt_left);

  if (ngtcp2_ringbuf_len(&pv->ents.rb) == 0) {
    pv->started_ts = ts;
  }

  ent = ngtcp2_ringbuf_push_back(&pv->ents.rb);
  ngtcp2_pv_entry_init(ent, data, expiry, flags);

  pv->flags &= (uint8_t)~NGTCP2_PV_FLAG_CANCEL_TIMER;
  --pv->probe_pkt_left;
}

int ngtcp2_pv_validate(ngtcp2_pv *pv, uint8_t *pflags,
                       const ngtcp2_path_challenge_data *data) {
  size_t len = ngtcp2_ringbuf_len(&pv->ents.rb);
  size_t i;
  ngtcp2_pv_entry *ent;

  if (len == 0) {
    return NGTCP2_ERR_INVALID_STATE;
  }

  for (i = 0; i < len; ++i) {
    ent = ngtcp2_ringbuf_get(&pv->ents.rb, i);
    if (ngtcp2_cmemeq(ent->data.data, data->data, sizeof(ent->data.data))) {
      *pflags = ent->flags;
      ngtcp2_log_info(pv->log, NGTCP2_LOG_EVENT_PTV, "path has been validated");
      return 0;
    }
  }

  return NGTCP2_ERR_INVALID_ARGUMENT;
}

void ngtcp2_pv_handle_entry_expiry(ngtcp2_pv *pv, ngtcp2_tstamp ts) {
  ngtcp2_pv_entry *ent;

  if (ngtcp2_ringbuf_len(&pv->ents.rb) == 0) {
    return;
  }

  ent = ngtcp2_ringbuf_get(&pv->ents.rb, ngtcp2_ringbuf_len(&pv->ents.rb) - 1);

  if (ent->expiry > ts) {
    return;
  }

  ++pv->round;
  pv->probe_pkt_left = NGTCP2_PV_NUM_PROBE_PKT;
}

int ngtcp2_pv_should_send_probe(ngtcp2_pv *pv) {
  return pv->probe_pkt_left > 0;
}

int ngtcp2_pv_validation_timed_out(ngtcp2_pv *pv, ngtcp2_tstamp ts) {
  ngtcp2_tstamp t;
  ngtcp2_pv_entry *ent;

  if (pv->started_ts == UINT64_MAX) {
    return 0;
  }

  assert(ngtcp2_ringbuf_len(&pv->ents.rb));

  ent = ngtcp2_ringbuf_get(&pv->ents.rb, ngtcp2_ringbuf_len(&pv->ents.rb) - 1);

  t = pv->started_ts + pv->timeout;
  t = ngtcp2_max_uint64(t, ent->expiry);

  return t <= ts;
}

ngtcp2_tstamp ngtcp2_pv_next_expiry(ngtcp2_pv *pv) {
  ngtcp2_pv_entry *ent;

  if ((pv->flags & NGTCP2_PV_FLAG_CANCEL_TIMER) ||
      ngtcp2_ringbuf_len(&pv->ents.rb) == 0) {
    return UINT64_MAX;
  }

  ent = ngtcp2_ringbuf_get(&pv->ents.rb, ngtcp2_ringbuf_len(&pv->ents.rb) - 1);

  return ent->expiry;
}

void ngtcp2_pv_cancel_expired_timer(ngtcp2_pv *pv, ngtcp2_tstamp ts) {
  ngtcp2_tstamp expiry = ngtcp2_pv_next_expiry(pv);

  if (expiry > ts) {
    return;
  }

  pv->flags |= NGTCP2_PV_FLAG_CANCEL_TIMER;
}

void ngtcp2_pv_set_fallback(ngtcp2_pv *pv, const ngtcp2_dcid *dcid,
                            ngtcp2_duration pto) {
  pv->flags |= NGTCP2_PV_FLAG_FALLBACK_PRESENT;
  ngtcp2_dcid_copy(&pv->fallback_dcid, dcid);
  pv->fallback_pto = pto;
}
