package com.bassbooster.soundeffects.equalizer.view.activity.edgelighting.customview

import android.animation.ArgbEvaluator
import android.animation.ValueAnimator
import android.annotation.SuppressLint
import android.content.Context
import android.graphics.Bitmap
import android.graphics.Canvas
import android.graphics.Color
import android.graphics.DashPathEffect
import android.graphics.Paint
import android.graphics.Path
import android.graphics.PathMeasure
import android.graphics.PorterDuff
import android.graphics.PorterDuffColorFilter
import android.graphics.RectF
import android.graphics.drawable.VectorDrawable
import android.util.AttributeSet
import android.view.View
import android.view.animation.AccelerateDecelerateInterpolator
import androidx.core.content.ContextCompat
import androidx.interpolator.view.animation.FastOutSlowInInterpolator
import com.bassbooster.equalizer.R
import kotlin.math.ceil


class ImageBorderView2(context: Context, attrs: AttributeSet?) : View(context, attrs) {
    private val borderPaint = Paint()
    private val paint = Paint()
    private val borderRect = RectF()

    private val borderWidth = 1f // Độ rộng của đường viền
    private var padding = 30f // Padding bên trong view

    private val startColor = ContextCompat.getColor(context, R.color.end)
    private val endColor = ContextCompat.getColor(context, R.color.start)
    private val center = ContextCompat.getColor(context, R.color.center)

    public var currentColor = startColor // Màu sắc hiện tại của đường viền

    private var path = Path()
    private var resizedAndColoredBitmap: Bitmap? = null
    public var colorAnimator: ValueAnimator? = null

    private var cornerRadiusTopLeft = 10f // Độ cong của góc trên trái,

    private var cornerRadiusTopRight = 10f // Độ cong của góc trên phải

    private var cornerRadiusBottomLeft = 10f // Độ cong của góc dưới trái

    private var cornerRadiusBottomRight = 10f // Độ cong của góc dưới phải

    private var widthOfEdge = 900 // Độ rộng điều chỉnh của biên
    // Số lần lặp (số lượng hình ảncanvas.drawPathh bitmap)
    var numberOfBitmaps = 46

    var duration = 1200

    var scaleFactor = 1.toDouble()

    init {
        paint.setColor(resources.getColor(android.R.color.black))
        paint.setStyle(Paint.Style.STROKE)
        paint.setStrokeWidth(5.toFloat()) // Độ dày của đường bao (có thể cấu hình)

        path = Path()
        borderPaint.style = Paint.Style.STROKE
        borderPaint.strokeWidth = borderWidth
        borderPaint.pathEffect = DashPathEffect(floatArrayOf(30f, 30f), 0f) // Định dạng line nét đứt

        val vectorDrawable =
            resources.getDrawable(R.drawable.ic_ess) as VectorDrawable
        val bitmap = Bitmap.createBitmap(
            vectorDrawable.intrinsicWidth,
            vectorDrawable.intrinsicHeight,
            Bitmap.Config.ARGB_8888
        )
        val canvas = Canvas(bitmap)
        vectorDrawable.setBounds(0, 0, canvas.width, canvas.height)
        vectorDrawable.draw(canvas)
        resizedAndColoredBitmap = bitmap

        val colors = listOf(Color.RED, Color.GREEN, Color.BLUE)
        val percentages = listOf(0.33f, 0.66f, 1.0f)

        // Khởi tạo và chạy ValueAnimator để thay đổi màu sắc
        colorAnimator = ValueAnimator.ofObject(
            ArgbEvaluator(),
            startColor,
            center,
            endColor
        )
        //colorAnimator = ValueAnimator.ofFloat(0.0f, 1.0f)
        colorAnimator?.addUpdateListener { animator ->
            currentColor = animator.animatedValue as Int
            invalidate()
        }
        //colorAnimator.interpolator = FastOutSlowInInterpolator()
        colorAnimator?.interpolator = AccelerateDecelerateInterpolator()
        //colorAnimator.interpolator = CycleInterpolator(2.toFloat())
        colorAnimator?.duration = duration.toLong() // Thời gian hoàn thành animation (ms)
        colorAnimator?.repeatCount = ValueAnimator.INFINITE
        colorAnimator?.repeatMode = ValueAnimator.RESTART
        colorAnimator?.start()
    }

    @SuppressLint("DrawAllocation")
    override fun onDraw(canvas: Canvas) {
        super.onDraw(canvas)

        val height = height.toFloat()
        //padding = (width.toFloat() - widthOfEdge)/2
        padding = 50.toFloat()
        val scaledWidth = resizedAndColoredBitmap!!.width * scaleFactor
        val scaledHeight = resizedAndColoredBitmap!!.height * scaleFactor

        val resizedBitmap = Bitmap.createScaledBitmap(resizedAndColoredBitmap!!, scaledWidth.toInt(), scaledHeight.toInt(), true)

        var coloredBitmap = changeBitmapColor(resizedBitmap!!, currentColor)

        path.reset()

        // Điểm bắt đầu ở góc trên bên trái
        path.moveTo(padding + cornerRadiusTopLeft, padding)
        // Đoạn đường ngang phía trên
        path.lineTo(width - padding - cornerRadiusTopRight, padding)
        // Góc trên phải
        path.arcTo(
            RectF(width -padding - 2 * cornerRadiusTopRight, padding, width - padding, padding + 2 * cornerRadiusTopRight),
            -90f,
            90f
        )
        // Đoạn đường dọc phía bên phải
        path.lineTo(width - padding, height - padding - cornerRadiusBottomRight)

        // Góc dưới phải
        path.arcTo(
            RectF(
                width - padding - 2 * cornerRadiusBottomRight, height -padding - 2 * cornerRadiusBottomRight,
                width - padding, height - padding
            ), 0f, 90f
        )
        // Đoạn đường ngang phía dưới
        path.lineTo(padding + cornerRadiusBottomLeft, height - padding)
        // Góc dưới trái
        path.arcTo(
            RectF(
                padding,
                height - padding - 2 * cornerRadiusBottomLeft,
                padding + 2 * cornerRadiusBottomLeft,
                height - padding
            ), 90f, 90f
        )
        // Đoạn đường dọc phía bên trái
        path.lineTo(padding, padding + cornerRadiusTopLeft)
        // Kết thúc ở góc trên trái
        path.arcTo(RectF(padding, padding, padding + 2 * cornerRadiusTopLeft, padding + 2 * cornerRadiusTopLeft), 180f, 90f)

        // Vẽ đường biên lên canvas
//        canvas.drawPath(path, paint)

        // Sử dụng PathMeasure để đo chiều dài của path
        val pathMeasure = PathMeasure(path, false)
        val pathLength = pathMeasure.length

        // Khoảng cách giữa các hình ảnh bitmap
        val distanceBetweenBitmaps = pathLength / numberOfBitmaps

        val bitmapWidth = coloredBitmap.getWidth().toFloat();
        val bitmapHeight = coloredBitmap.getHeight().toFloat();

        for (i in 0 until numberOfBitmaps) {
            val pos = FloatArray(2)
            val tan = FloatArray(2)

            // Tính toán vị trí và hướng tại điểm trên path
            val distance = i * distanceBetweenBitmaps
            pathMeasure.getPosTan(distance, pos, tan)

            // Vẽ hình ảnh bitmap tại vị trí và hướng tính toán
            canvas.save()
            canvas.translate(pos[0] - bitmapWidth / 2, pos[1] - bitmapHeight / 2)
            val rotationDegrees =
                Math.toDegrees(Math.atan2(tan[1].toDouble(), tan[0].toDouble())).toFloat()
            canvas.rotate(rotationDegrees, bitmapWidth / 2, bitmapHeight / 2)
            canvas.drawBitmap(coloredBitmap, 0.toFloat(), 0.toFloat(), null)
            canvas.restore()
        }

    }

    fun changeColor(end:Int){
        colorAnimator?.cancel()
        colorAnimator=null
        colorAnimator = ValueAnimator.ofObject(
            ArgbEvaluator(),
            startColor,
            center,
            end
        )
        colorAnimator?.addUpdateListener { animator ->
            currentColor = animator.animatedValue as Int
            invalidate()
        }
        colorAnimator?.interpolator = FastOutSlowInInterpolator()
        colorAnimator?.duration = duration.toLong() // Thời gian hoàn thành animation (ms)
        colorAnimator?.repeatCount = ValueAnimator.INFINITE
        colorAnimator?.repeatMode = ValueAnimator.RESTART
        colorAnimator?.start()
        invalidate()
    }

    fun changeDurationTop(radiusTopLeft : Float,radiusTopRight: Float){
        cornerRadiusTopLeft  = radiusTopLeft
        cornerRadiusTopRight  = radiusTopRight
        invalidate()
    }

    fun changeDurationBottom(radiusTopLeft : Float,radiusTopRight: Float){
        cornerRadiusBottomLeft  = radiusTopLeft
        cornerRadiusBottomRight  = radiusTopRight
        invalidate()
    }

    fun changeWith(width : Int){
        widthOfEdge  = width+900
        invalidate()
    }

    fun changeScaleFactor(sf : Int){
        scaleFactor = 1+ ceil(sf.toFloat()*3/100)*0.8
        if (scaleFactor <= 0) {
            scaleFactor = 1.toDouble()
        }
        if (scaleFactor >= 2.5) {
            numberOfBitmaps = 35
        }
        invalidate()
    }

    fun changeDuration(durations : Int){
        colorAnimator?.cancel()
        duration = 1200 - durations  //Thời gian hoàn thành animation (ms)
        if (duration <= 0) {
            duration = 1
        }
        colorAnimator?.duration = duration.toLong()
        colorAnimator?.start()
        invalidate()
    }

    public fun createBitmapByShape(shape: Int) {
        val vectorDrawable =
            resources.getDrawable(shape) as VectorDrawable
        val bitmap = Bitmap.createBitmap(
            vectorDrawable.intrinsicWidth,
            vectorDrawable.intrinsicHeight,
            Bitmap.Config.ARGB_8888
        )
        val canvas = Canvas(bitmap)
        vectorDrawable.setBounds(0, 0, canvas.width, canvas.height)
        vectorDrawable.draw(canvas)
        resizedAndColoredBitmap = bitmap
        invalidate()

    }
    public fun changeColorAnimator(colors: IntArray) {
        // Lấy danh sách màu hiện tại từ colorAnimator
        val currentValues = (colorAnimator?.getValues() as? IntArray) ?: intArrayOf(startColor, center, endColor)

        // Tạo một danh sách màu mới bằng cách thêm màu mới vào danh sách cũ
        val newValues = currentValues.plus(colors)
        colorAnimator?.cancel()
        colorAnimator = null

        colorAnimator = ValueAnimator.ofObject(
            ArgbEvaluator(),
            startColor,
            Color.YELLOW,
            Color.CYAN
        )
        colorAnimator?.addUpdateListener { animator ->
            currentColor = animator.animatedValue as Int
            /*val fraction = animator.animatedValue as Float
            currentColor = calculateColor(colors, percentages, fraction)*/
            invalidate()
        }
        //colorAnimator.interpolator = FastOutSlowInInterpolator()
        colorAnimator?.interpolator = AccelerateDecelerateInterpolator()
        //colorAnimator.interpolator = CycleInterpolator(2.toFloat())
        colorAnimator?.duration = duration.toLong() // Thời gian hoàn thành animation (ms)
        colorAnimator?.repeatCount = ValueAnimator.INFINITE
        colorAnimator?.repeatMode = ValueAnimator.RESTART
        colorAnimator?.start()
        invalidate()
    }

    private fun changeBitmapColor(sourceBitmap: Bitmap, color: Int): Bitmap {
        val resultBitmap = sourceBitmap.copy(sourceBitmap.config, true)
        val paint = Paint()
        val filter = PorterDuffColorFilter(color, PorterDuff.Mode.SRC_IN)
        paint.colorFilter = filter

        val canvas = Canvas(resultBitmap)
        canvas.drawBitmap(resultBitmap, 0f, 0f, paint)

        return resultBitmap
    }

}
