/*
 * eset_rtp (ESET Real-time file system protection module)
 * Copyright (C) 1992-2025 ESET, spol. s r.o.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 *
 * In case of any questions, you can contact us at ESET, spol. s r.o., Einsteinova 24, 851 01 Bratislava, Slovakia.
 */


#include "ertp_stats.h"

#include <linux/kernel.h>
#include <linux/ktime.h>
#include <linux/overflow.h>
#include <linux/spinlock.h>

#include "ertp_qos_queue.h"

#define TIME_CONVERSION_FACTOR 1000

static u64 last_reset_timestamp = 0;

struct event_processing_stats {
  u64 event_counter;
  u64 qos_duration;
  u64 scan_duration;
  u64 total_duration;

  u64 qos_duration_max;
  u64 scan_duration_max;
  u64 total_duration_max;
};
static struct event_processing_stats generic_stats = {0, 0, 0, 0, 0, 0, 0};
static struct event_processing_stats remove_stats = {0, 0, 0, 0, 0, 0, 0};
static DEFINE_SPINLOCK(event_stats_lock);

static size_t scanner_max = 0;
static DEFINE_SPINLOCK(scanner_max_lock);

static size_t qos_size_stats[N_ERTP_QOS_QUEUE_IDS] = {0, 0, 0};
static DEFINE_SPINLOCK(qos_size_stats_lock);

void ertp_event_stats_init(struct ertp_event_stats* stats) {
  stats->event_creation_time = ktime_get_ns();
  stats->scan_start_time = 0;
  stats->scan_end_time = 0;
}

void ertp_stats_init(void) {
  spin_lock(&event_stats_lock);
  last_reset_timestamp = ktime_get_ns();
  spin_unlock(&event_stats_lock);
}

static struct event_processing_stats process_stats_unlocked(
    struct event_processing_stats* stats) {
  struct event_processing_stats out = {0, 0, 0, 0, 0, 0, 0};

  if (stats) {
    if (stats->event_counter) {
      out.event_counter = stats->event_counter;
      out.total_duration =
          div64_u64(stats->total_duration, stats->event_counter);
      out.scan_duration = div64_u64(stats->scan_duration, stats->event_counter);
      out.qos_duration = div64_u64(stats->qos_duration, stats->event_counter);
      out.total_duration_max = stats->total_duration_max;
      out.scan_duration_max = stats->scan_duration_max;
      out.qos_duration_max = stats->qos_duration_max;
    }
  }

  return out;
}

static void reset_event_processing_stats_unlocked(
    struct event_processing_stats* stats) {
  *stats = (struct event_processing_stats){0, 0, 0, 0, 0, 0, 0};
}

ssize_t ertp_stats_print(char* buf, size_t size) {
  static const char STATS_FMT[] =
      "SecondsSinceStatsReset: %llu s\n"
      "GenericEventsScanned: %llu\n"
      "RemoveEventsScanned: %llu\n"
      "MaxConcurrentEventsScanned: %lu\n"
      "MaxRTQueueSize: %lu\n"
      "MaxBEQueueSize: %lu\n"
      "MaxIDLEQueueSize: %lu\n"
      "AvgGenericQueueDuration: %llu us\n"
      "AvgRemoveQueueDuration: %llu us\n"
      "MaxGenericQueueDuration: %llu us\n"
      "MaxRemoveQueueDuration: %llu us\n"
      "AvgGenericScanDuration: %llu us\n"
      "AvgRemoveScanDuration: %llu us\n"
      "MaxGenericScanDuration: %llu us\n"
      "MaxRemoveScanDuration: %llu us\n"
      "AvgGenericTotalDuration: %llu us\n"
      "AvgRemoveTotalDuration: %llu us\n"
      "MaxGenericTotalDuration: %llu us\n"
      "MaxRemoveTotalDuration: %llu us\n";

  struct event_processing_stats avg_generic_stats;
  struct event_processing_stats avg_remove_stats;
  size_t tmp_max_scanner_array_size = 0;
  size_t tmp_qos_size_stats[3];
  u64 seconds_since_last_stats_reset = 0;

  spin_lock(&event_stats_lock);
  seconds_since_last_stats_reset =
      div64_u64(ktime_get_ns() - last_reset_timestamp, 1000000000);

  avg_generic_stats = process_stats_unlocked(&generic_stats);
  avg_remove_stats = process_stats_unlocked(&remove_stats);

  spin_lock(&scanner_max_lock);
  tmp_max_scanner_array_size = scanner_max;
  spin_unlock(&scanner_max_lock);

  spin_lock(&qos_size_stats_lock);
  tmp_qos_size_stats[ERTP_QOS_QUEUE_RT] = qos_size_stats[ERTP_QOS_QUEUE_RT];
  tmp_qos_size_stats[ERTP_QOS_QUEUE_BE] = qos_size_stats[ERTP_QOS_QUEUE_BE];
  tmp_qos_size_stats[ERTP_QOS_QUEUE_IDLE] = qos_size_stats[ERTP_QOS_QUEUE_IDLE];
  spin_unlock(&qos_size_stats_lock);

  spin_unlock(&event_stats_lock);

  return snprintf(
      buf, size, STATS_FMT, seconds_since_last_stats_reset,
      avg_generic_stats.event_counter, avg_remove_stats.event_counter,
      tmp_max_scanner_array_size, tmp_qos_size_stats[ERTP_QOS_QUEUE_RT],
      tmp_qos_size_stats[ERTP_QOS_QUEUE_BE],
      tmp_qos_size_stats[ERTP_QOS_QUEUE_IDLE],
      div64_u64(avg_generic_stats.qos_duration, TIME_CONVERSION_FACTOR),
      div64_u64(avg_remove_stats.qos_duration, TIME_CONVERSION_FACTOR),
      div64_u64(avg_generic_stats.qos_duration_max, TIME_CONVERSION_FACTOR),
      div64_u64(avg_remove_stats.qos_duration_max, TIME_CONVERSION_FACTOR),
      div64_u64(avg_generic_stats.scan_duration, TIME_CONVERSION_FACTOR),
      div64_u64(avg_remove_stats.scan_duration, TIME_CONVERSION_FACTOR),
      div64_u64(avg_generic_stats.scan_duration_max, TIME_CONVERSION_FACTOR),
      div64_u64(avg_remove_stats.scan_duration_max, TIME_CONVERSION_FACTOR),
      div64_u64(avg_generic_stats.total_duration, TIME_CONVERSION_FACTOR),
      div64_u64(avg_remove_stats.total_duration, TIME_CONVERSION_FACTOR),
      div64_u64(avg_generic_stats.total_duration_max, TIME_CONVERSION_FACTOR),
      div64_u64(avg_remove_stats.total_duration_max, TIME_CONVERSION_FACTOR));
}

void ertp_stats_reset(void) {
  spin_lock(&event_stats_lock);
  last_reset_timestamp = ktime_get_ns();

  reset_event_processing_stats_unlocked(&generic_stats);
  reset_event_processing_stats_unlocked(&remove_stats);

  spin_lock(&scanner_max_lock);
  scanner_max = 0;
  spin_unlock(&scanner_max_lock);

  spin_lock(&qos_size_stats_lock);
  qos_size_stats[ERTP_QOS_QUEUE_RT] = 0;
  qos_size_stats[ERTP_QOS_QUEUE_BE] = 0;
  qos_size_stats[ERTP_QOS_QUEUE_IDLE] = 0;
  spin_unlock(&qos_size_stats_lock);

  spin_unlock(&event_stats_lock);
}

static void update_event_stats(struct event_processing_stats* stats,
                               struct ertp_event_stats* event_stats) {
  u64 qos_duration =
      event_stats->scan_start_time - event_stats->event_creation_time;
  u64 scan_duration = event_stats->scan_end_time - event_stats->scan_start_time;
  u64 total_duration =
      event_stats->scan_end_time - event_stats->event_creation_time;

  spin_lock(&event_stats_lock);

  if (check_add_overflow(stats->event_counter, (u64)1, &stats->event_counter)) {
    goto overflow;
  }
  if (check_add_overflow(stats->qos_duration, scan_duration,
                         &stats->qos_duration)) {
    goto overflow;
  }
  if (check_add_overflow(stats->scan_duration, scan_duration,
                         &stats->scan_duration)) {
    goto overflow;
  }
  if (check_add_overflow(stats->total_duration, total_duration,
                         &stats->total_duration)) {
    goto overflow;
  }

  if (qos_duration > stats->qos_duration_max) {
    stats->qos_duration_max = qos_duration;
  }
  if (scan_duration > stats->scan_duration_max) {
    stats->scan_duration_max = scan_duration;
  }
  if (total_duration > stats->total_duration_max) {
    stats->total_duration_max = total_duration;
  }

  spin_unlock(&event_stats_lock);
  return;

overflow:
  spin_unlock(&event_stats_lock);
  ertp_stats_reset();
}

void ertp_stats_report_scan_started(struct ertp_event_stats* event_stats,
                                    size_t scanner_array_size) {
  event_stats->scan_start_time = ktime_get_ns();

  spin_lock(&scanner_max_lock);
  if (scanner_array_size > scanner_max) {
    scanner_max = scanner_array_size;
  }
  spin_unlock(&scanner_max_lock);
}

void ertp_stats_report_scan_finished(struct ertp_event_stats* event_stats,
                                     uint32_t event_class) {
  event_stats->scan_end_time = ktime_get_ns();

  if (event_class == ERTP_EVENT_CLASS_GENERIC) {
    update_event_stats(&generic_stats, event_stats);
  }
  if (event_class == ERTP_EVENT_CLASS_REMOVE) {
    update_event_stats(&remove_stats, event_stats);
  }
}

void ertp_stats_report_qos_heap_size(size_t size, size_t type) {
  spin_lock(&qos_size_stats_lock);
  if (size > qos_size_stats[type]) {
    qos_size_stats[type] = size;
  }
  spin_unlock(&qos_size_stats_lock);
}