Add Pristine Profit Tracker

1 files changed, 86 insertions, 0 deletions

diff --git a/src/main/kotlin/moe/nea/firmament/features/mining/Histogram.kt b/src/main/kotlin/moe/nea/firmament/features/mining/Histogram.kt
new file mode 100644
index 0000000..e897aaa
--- /dev/null
+++ b/src/main/kotlin/moe/nea/firmament/features/mining/Histogram.kt
@@ -0,0 +1,86 @@
+/*
+ * SPDX-FileCopyrightText: 2024 Linnea Gräf <nea@nea.moe>
+ *
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+package moe.nea.firmament.features.mining
+
+import java.util.*
+import kotlin.time.Duration
+import moe.nea.firmament.util.TimeMark
+
+class Histogram<T>(
+    val maxSize: Int,
+    val maxDuration: Duration,
+) {
+
+    data class OrderedTimestamp(val timestamp: TimeMark, val order: Int) : Comparable<OrderedTimestamp> {
+        override fun compareTo(other: OrderedTimestamp): Int {
+            val o = timestamp.compareTo(other.timestamp)
+            if (o != 0) return o
+            return order.compareTo(other.order)
+        }
+    }
+
+    val size: Int get() = dataPoints.size
+    private val dataPoints: NavigableMap<OrderedTimestamp, T> = TreeMap()
+
+    private var order = Int.MIN_VALUE
+
+    fun record(entry: T, timestamp: TimeMark = TimeMark.now()) {
+        dataPoints[OrderedTimestamp(timestamp, order++)] = entry
+        trim()
+    }
+
+    fun oldestUpdate(): TimeMark {
+        trim()
+        return if (dataPoints.isEmpty()) TimeMark.now() else dataPoints.firstKey().timestamp
+    }
+
+    fun latestUpdate(): TimeMark {
+        trim()
+        return if (dataPoints.isEmpty()) TimeMark.farPast() else dataPoints.lastKey().timestamp
+    }
+
+    fun averagePer(valueExtractor: (T) -> Double, perDuration: Duration): Double? {
+        return aggregate(
+            seed = 0.0,
+            operator = { accumulator, entry, _ -> accumulator + valueExtractor(entry) },
+            finish = { sum, beginning, end ->
+                val timespan = end - beginning
+                if (timespan > perDuration)
+                    sum / (timespan / perDuration)
+                else null
+            })
+    }
+
+    fun <V, R> aggregate(
+        seed: V,
+        operator: (V, T, TimeMark) -> V,
+        finish: (V, TimeMark, TimeMark) -> R
+    ): R? {
+        trim()
+        var accumulator = seed
+        var min: TimeMark? = null
+        var max: TimeMark? = null
+        dataPoints.forEach { (key, value) ->
+            max = key.timestamp
+            if (min == null)
+                min = key.timestamp
+            accumulator = operator(accumulator, value, key.timestamp)
+        }
+        if (min == null)
+            return null
+        return finish(accumulator, min!!, max!!)
+    }
+
+    private fun trim() {
+        while (maxSize < dataPoints.size) {
+            dataPoints.pollFirstEntry()
+        }
+        dataPoints.headMap(OrderedTimestamp(TimeMark.ago(maxDuration), Int.MAX_VALUE)).clear()
+    }
+
+
+}