make FragmentedLinearDistribution implement the SliderValueDistribution interface

Author: KamelMohamad

slider/src/main/java/io/monstarlab/mosaic/slider/SensitivityDistribution.kt renamed to slider/src/main/java/io/monstarlab/mosaic/slider/FragmentedLinearDistribution.kt

@@ -1,12 +1,13 @@
 package io.monstarlab.mosaic.slider
 
-public class SensitivityDistribution private constructor(
+public class FragmentedLinearDistribution private constructor(
     equationMap: Map<Float, LinearEquation>,
-) {
-    private var _equationList: MutableList<RangedLinearEquation> =
-        mutableListOf<RangedLinearEquation>()
+) : SliderValueDistribution {
+    private var _equationList: MutableList<RangedLinearEquation> = mutableListOf()
     public val equationList: List<RangedLinearEquation> get() = _equationList.toList()
 
+    private lateinit var valueRange: ClosedFloatingPointRange<Float>
+
     init {
         var previous: Pair<Float, LinearEquation>? = null
         // get the max range start value to help us identify the last equation
@@ -21,8 +22,17 @@ public class SensitivityDistribution private constructor(
             }
             previous = pair.toPair()
         }
+        valueRange = valueFromOffset(0f)..valueFromOffset(1f)
     }
 
+
+    override fun interpolate(value: Float): Float =
+        valueFromOffset(value).valueToFraction(valueRange)
+
+    override fun inverse(value: Float): Float = offsetFromValue(
+        value.fractionToValue(valueRange)
+    )
+
     private fun addEquation(equation: LinearEquation, rangeStart: Float, rangeEnd: Float) {
         val offsetRange = rangeStart..rangeEnd
         val valueRange =
@@ -36,45 +46,75 @@ public class SensitivityDistribution private constructor(
         )
     }
 
-    public fun valueFromOffset(offset: Float): Float? =
+    private fun valueFromOffset(offset: Float): Float =
         _equationList.firstOrNull { offset in it.offsetRange }?.equation?.valueFromOffset(offset)
+            ?: 0f
+
+    private fun offsetFromValue(value: Float): Float =
+        _equationList.firstOrNull { value in it.valueRange }?.equation?.offsetFromValue(value) ?: 0f
 
-    public fun offsetFromValue(value: Float): Float? =
-        _equationList.firstOrNull { value in it.valueRange }?.equation?.offsetFromValue(value)
 
     public class Builder {
         private var equationRangeStartMap = mutableMapOf<Float, LinearEquation>()
         private var maxRangeValue: Float = -1f
         private var lastEquation: LinearEquation? = null
+        private var rangeStart: Float = 0f
+        private var rangeEnd: Float = 1f
+
+
+        /**
+         * Create a distribution on a range with an initial sensitivity provided by [initialSensitivity]
+         * please note that the range is for the offset and not the value we get from the offset
+         *
+         * @param offsetRangeStart the start of the range that the offset values can start from
+         * @param offsetRangeEnd the end of the range  that the offset values can go up to
+         */
+        public fun createDistribution(
+            offsetRangeStart: Float,
+            offsetRangeEnd: Float,
+            initialSensitivity: Float
+        ) {
+            rangeStart = offsetRangeStart
+            rangeEnd = offsetRangeEnd
+            sliceAt(initialSensitivity, fractionalValue(rangeStart))
+        }
+
 
-        public fun add(sensitivity: Float, rangeStart: Float): Builder = apply {
-            if (equationRangeStartMap.isEmpty() && rangeStart != 0f) {
+        private fun fractionalValue(value: Float) = value.valueToFraction(rangeStart, rangeEnd)
+
+        public fun sliceAt(
+            sensitivity: Float,
+            position: Float,
+        ): Builder = apply {
+            val  relativePosition = fractionalValue(position)
+            if (equationRangeStartMap.isEmpty() && relativePosition != 0f) {
                 throw FirstValueNotZeroException()
             }
-            if (rangeStart !in 0.0f..1f) throw OutOfRangeException()
-            if (rangeStart < maxRangeValue) throw OverlappingRangeException()
+            if (position !in rangeStart..rangeEnd) throw OutOfRangeException()
+            if (position < maxRangeValue) throw OverlappingRangeException()
 
-            val equationRangeStartPair = calcNextEquation(sensitivity, rangeStart, lastEquation)
+            val equationRangeStartPair =
+                calcNextEquation(sensitivity, relativePosition, lastEquation)
             equationRangeStartMap[equationRangeStartPair.first] = equationRangeStartPair.second
             lastEquation = equationRangeStartPair.second
-            maxRangeValue = rangeStart
+            maxRangeValue = position
+        }
+
+        public fun build(): FragmentedLinearDistribution {
+            if (equationRangeStartMap.isEmpty()) {
+                sliceAt(1f, 0f)
+            }
+            return FragmentedLinearDistribution(equationRangeStartMap)
         }
 
         private fun calcNextEquation(
             slope: Float,
-            rangeStart: Float,
+            startPos: Float,
             previousEquation: LinearEquation?,
         ): Pair<Float, LinearEquation> {
-            val y0 = previousEquation?.valueFromOffset(rangeStart) ?: 0f
-            val c = y0 - slope * rangeStart
-            return Pair(rangeStart, LinearEquation(slope, c))
-        }
-
-        public fun build(): SensitivityDistribution {
-            if (equationRangeStartMap.isEmpty()) {
-                add(1f, 0f)
-            }
-            return SensitivityDistribution(equationRangeStartMap)
+            val y0 = previousEquation?.valueFromOffset(startPos) ?: 0f
+            val c = y0 - slope * startPos
+            return Pair(startPos, LinearEquation(slope, c))
         }
     }