class PfpChartSegmentAnimator(
    animatorFactory: AnimatorFactory,
    observableWrapper: ObservableWrapper<List<AnimationFilter>, Payload>
) {
    private val animationWrapper: ObservableWrapper<List<AnimationFilter>, Payload> = observableWrapper
    private val animator: Animation = animatorFactory.createAnimator(0.5f, 0.0f, AccelerateDecelerateInterpolator())

    private val currentFilters: MutableList<AnimationFilter> = mutableListOf()
    private val targetFilters: MutableList<AnimationFilter> = mutableListOf()
    private val customFilters: MutableList<CustomAnimationFilter> = mutableListOf()

    private val animationData: ObservableData<List<AnimationFilter>, Unit> = ObservableData(emptyList())

    init {
        observableWrapper.registerObserver { filters, payload ->
            onDataSetChanged(filters, payload)
        }
    }

    private fun onDataSetChanged(filters: List<AnimationFilter>, payload: Payload) {
        if (!payload.animate) {
            animator.stop()
            updateAnimationData()
            return
        }

        currentFilters.clear()
        currentFilters.addAll(animationWrapper.getData())

        filters.sortedBy { it.startTime }

        targetFilters.clear()
        targetFilters.addAll(filters)

        if (currentFilters.size < targetFilters.size) {
            val firstFilter = targetFilters.first()
            val newFilter = createAnimationFilter(firstFilter.endTime, firstFilter.startValue)
            targetFilters.add(0, newFilter)
        } else {
            val lastFilter = currentFilters.last()
            val newFilter = createAnimationFilter(lastFilter.startTime, lastFilter.endValue)
            currentFilters.add(newFilter)
        }

        customFilters.clear()
        for (i in targetFilters.indices) {
            val currentFilter = currentFilters[i]
            val targetFilter = targetFilters[i]
            customFilters.add(CustomAnimationFilter(currentFilter, targetFilter))
        }

        animator.start(0.0f, 1.0f, payload.animate)
    }

    private fun createAnimationFilter(time: Long, value: Double): AnimationFilter {
        return AnimationFilter(time, value)
    }

    private fun updateAnimationData() {
        val data = if (animator.isRunning()) customFilters else animationWrapper.getData()
        animationData.updateData(data)
    }

    fun getAnimationData(): ObservableData<List<AnimationFilter>, Unit> {
        return animationData
    }

    fun isAnimating(): Boolean {
        return animator.isRunning()
    }

    fun onAnimationUpdate() {
        if (animator.isRunning()) {
            val progress = animator.getProgress()
            for (filter in customFilters) {
                filter.setProgress(progress)
            }
            updateAnimationData()
        }
    }
}