class ChartAnimator(
    private val animatorFactory: AnimatorFactory,
    private val animationFilters: ObservableWrapper<List<AnimationFilter>, AnimatePayload>
) {

    private val animator = animatorFactory.createFloatAnimator(duration = 500L, valueStart = 0f, valueEnd = 1f)

    private val currentFilters = mutableListOf<AnimationFilter>()
    private val previousFilters = mutableListOf<AnimationFilter>()
    private val customFilters = mutableListOf<CustomAnimationFilter>()

    private val filteredData = ObservableData(emptyList<AnimationFilter>())

    init {
        animationFilters.registerObserver(::onAnimationFiltersChanged)
    }

    fun getFilteredData() = filteredData

    fun isAnimating() = animator.isRunning

    fun onAnimationFiltersChanged(filters: List<AnimationFilter>, payload: AnimatePayload) {
        if (!payload.animate) {
            animator.stopAnimation(1f)
            updateFilteredData()
            return
        }

        previousFilters.clear()
        previousFilters.addAll(filteredData.value)

        currentFilters.clear()
        currentFilters.addAll(filters.sortedBy { it.startTime })

        // Add start/end filters if sizes differ
        val (shorter, longer) = if (previousFilters.size < currentFilters.size) {
            previousFilters to currentFilters
        } else {
            currentFilters to previousFilters
        }

        val startFilter = if (shorter.isEmpty()) {
            createStartFilter(longer.first())
        } else {
            createEndFilter(shorter.last())
        }

        while (shorter.size < longer.size) {
            shorter.add(startFilter)
        }

        customFilters.clear()
        longer.forEachIndexed { i, filter ->
            customFilters.add(CustomAnimationFilter(previousFilters[i], currentFilters[i]))
        }

        animator.animate(0f, 1f, payload.animate)
    }

    fun updateAnimation() {
        if (animator.isRunning) {
            val progress = animator.progress
            customFilters.forEach { it.update(progress) }
            updateFilteredData()
        }
    }

    private fun updateFilteredData() {
        filteredData.value = customFilters
    }

    private fun createStartFilter(base: AnimationFilter) =
        ChartAnimationFilter(ChartData(listOf(ChartPoint(base.endTime, base.startValue))))

    private fun createEndFilter(base: AnimationFilter) =
        ChartAnimationFilter(ChartData(listOf(ChartPoint(base.startTime, base.endValue))))

}

data class AnimatePayload(val animate: Boolean)