abstract class ChartData(points: List<ChartPoint>) : AnimationProvider, Filter {

    private val startTime: Long
    private val endTime: Long
    private val startValue: Double
    private val endValue: Double
    private val pointCount: Int
    private val sortedPoints: List<ChartPoint>
    private val turningPoints: List<ChartPoint>

    init {
        val sortedPoints = points.sortedBy { it.date }
        this.sortedPoints = sortedPoints
        this.turningPoints = findTurningPoints(sortedPoints)

        val firstPoint = sortedPoints.first()
        startTime = firstPoint.date
        startValue = firstPoint.amount

        val lastPoint = sortedPoints.last()
        endTime = lastPoint.date
        endValue = lastPoint.amount

        pointCount = sortedPoints.size
    }

    private fun findTurningPoints(points: List<ChartPoint>): List<ChartPoint> {
        val turningPoints = mutableListOf<ChartPoint>()
        var prevValue = 0.0

        for (i in 1..points.size - 1) {
            val point = points[i]
            val curValue = point.amount
            if (i > 0 && prevValue > curValue != prevValue < curValue) {
                turningPoints.add(point)
            }
            prevValue = curValue
        }

        return turningPoints
    }

    fun getStartValue() = startValue

    fun getEndValue() = endValue

    override fun applyFilter(start: Long, end: Long, range: AmountRange): Boolean {
        if (sortedPoints.isEmpty() || start > endTime || end < startTime) return false

        range.min = Double.MAX_VALUE
        range.max = Double.MIN_VALUE

        addValueToRange(applyAnimation(start), range)
        addValueToRange(applyAnimation(end), range)

        var startIndex = turningPoints.size - 1
        while (startIndex >= 0) {
            if (turningPoints[startIndex].date >= start) break
            startIndex--
        }

        for (i in startIndex + 1..turningPoints.size - 1) {
            val point = turningPoints[i]
            if (point.date > end) break
            addValueToRange(point.amount, range)
        }

        return true
    }

    protected fun getPoints() = sortedPoints

    fun getStartTime() = startTime

    fun getEndTime() = endTime

    private fun addValueToRange(value: Double, range: AmountRange) {
        if (value < range.min) range.min = value
        if (value > range.max) range.max = value
    }

}