package com.xw.common.custom

import android.content.Context
import android.graphics.*
import android.graphics.drawable.BitmapDrawable
import android.graphics.drawable.Drawable
import android.util.AttributeSet
import android.view.MotionEvent
import android.view.View
import android.view.animation.DecelerateInterpolator
import android.widget.Scroller
import androidx.core.content.ContextCompat
import com.xw.common.R
import kotlin.math.max
import kotlin.math.min

/**
 * 滑动按钮自定义 View
 */
class SlideButtonView @JvmOverloads constructor(
    context: Context,
    attrs: AttributeSet? = null,
    defStyleAttr: Int = 0
) : View(context, attrs, defStyleAttr) {

    companion object {
        const val DIRECTION_LEFT = 0
        const val DIRECTION_RIGHT = 1
        const val SHAPE_CIRCLE = 0
        const val SHAPE_SQUARE = 1
        const val SHAPE_ROUND_RECT = 2
    }

    // 固定间距 2dp
    private val fixedMargin = dpToPx(3f)

    private var slideDirection: Int = DIRECTION_RIGHT
    private var backgroundColor: Int = Color.parseColor("#2196F3")
    private var backgroundCornerRadius: Float = 0f
    private var text: String = "滑动"
    private var textColor: Int = Color.WHITE
    private var textSize: Float = 48f

    private var thumbDrawableRes: Int = -1
    private var thumbBitmap: Bitmap? = null
    private var thumbWidth: Float = 0f
    private var thumbHeight: Float = 0f
    private var thumbShape: Int = SHAPE_ROUND_RECT
    private var thumbCornerRadius: Float = 0f

    private val backgroundPaint = Paint(Paint.ANTI_ALIAS_FLAG)
    private val textPaint = Paint(Paint.ANTI_ALIAS_FLAG)
    private val thumbPaint = Paint(Paint.ANTI_ALIAS_FLAG)

    private var thumbX: Float = 0f
    private var maxThumbX: Float = 0f
    private var isDragging = false
    private var slideThreshold: Float = 0.7f
    //是否能够使用
    var enable: Boolean = true
        set(value) {
            field = value
            invalidate()
        }

    private val scroller = Scroller(context, DecelerateInterpolator())
    private var onSlideCompleteListener: (() -> Unit)? = null

    init {
        context.theme.obtainStyledAttributes(
            attrs,
            R.styleable.SlideButtonView,
            defStyleAttr,
            0
        ).apply {
            try {
                slideDirection = getInt(R.styleable.SlideButtonView_slideDirection, DIRECTION_RIGHT)
                backgroundColor = getColor(R.styleable.SlideButtonView_slideBackgroundColor, backgroundColor)
                backgroundCornerRadius = getDimension(R.styleable.SlideButtonView_backgroundCornerRadius, 0f)
                text = getString(R.styleable.SlideButtonView_slideText) ?: text
                textColor = getColor(R.styleable.SlideButtonView_slideTextColor, textColor)
                textSize = getDimension(R.styleable.SlideButtonView_slideTextSize, textSize)
                thumbDrawableRes = getResourceId(R.styleable.SlideButtonView_thumbDrawable, -1)
                thumbShape = getInt(R.styleable.SlideButtonView_thumbShape, SHAPE_ROUND_RECT)
                thumbCornerRadius = getDimension(R.styleable.SlideButtonView_thumbCornerRadius, 0f)
                slideThreshold = getFloat(R.styleable.SlideButtonView_slideThreshold, 0.7f)
                enable = getBoolean(R.styleable.SlideButtonView_enable, enable)
            } finally {
                recycle()
            }
        }

        initPaints()
        loadThumbDrawable()
    }

    private fun initPaints() {
        backgroundPaint.color = backgroundColor
        textPaint.apply {
            color = textColor
            textSize = this@SlideButtonView.textSize
            textAlign = Paint.Align.CENTER
            isFakeBoldText = true  // 粗体效果
//            typeface = Typeface.DEFAULT_BOLD
        }
        thumbPaint.apply {
            isFilterBitmap = true
            isAntiAlias = true
        }
    }

    private fun loadThumbDrawable() {
        if (thumbDrawableRes != -1) {
            val drawable = ContextCompat.getDrawable(context, thumbDrawableRes)
            drawable?.let {
                thumbBitmap = if (it is BitmapDrawable) {
                    it.bitmap
                } else {
                    drawableToBitmap(it)
                }
            }
        }
    }

    private fun drawableToBitmap(drawable: Drawable): Bitmap {
        val width = drawable.intrinsicWidth.coerceAtLeast(1)
        val height = drawable.intrinsicHeight.coerceAtLeast(1)
        val bitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888)
        val canvas = Canvas(bitmap)
        drawable.setBounds(0, 0, canvas.width, canvas.height)
        drawable.draw(canvas)
        return bitmap
    }

    override fun onSizeChanged(w: Int, h: Int, oldw: Int, oldh: Int) {
        super.onSizeChanged(w, h, oldw, oldh)

        if (backgroundCornerRadius == 0f) {
            backgroundCornerRadius = h / 2f
        }

        // 滑块高度 = 总高度 - 上下间距（各 5dp）
        thumbHeight = h - fixedMargin * 2
        thumbWidth = if (thumbBitmap != null) {
            val ratio = thumbBitmap!!.width.toFloat() / thumbBitmap!!.height
            thumbHeight * ratio
        } else {
            thumbHeight
        }

        maxThumbX = w - thumbWidth - fixedMargin * 2
        resetThumbPosition()
    }

    private fun resetThumbPosition() {
        thumbX = when (slideDirection) {
            DIRECTION_LEFT -> maxThumbX
            else -> 0f
        }
    }

    override fun onDraw(canvas: Canvas) {
        super.onDraw(canvas)

        val width = width.toFloat()
        val height = height.toFloat()

        // 绘制背景（全填充，无内边距）
        val backgroundRect = RectF(0f, 0f, width, height)
        canvas.drawRoundRect(backgroundRect, backgroundCornerRadius, backgroundCornerRadius, backgroundPaint)

        // 绘制文字
        val textX = width / 2
        val textY = height / 2 + textPaint.textSize / 3
        canvas.drawText(text, textX, textY, textPaint)

        // 绘制滑块（距离边缘 5dp）
        thumbBitmap?.let { bitmap ->
            val left = fixedMargin + thumbX
            val top = fixedMargin
            val right = left + thumbWidth
            val bottom = top + thumbHeight

            when (thumbShape) {
                SHAPE_CIRCLE -> {
                    val path = Path().apply {
                        val centerX = (left + right) / 2
                        val centerY = (top + bottom) / 2
                        val radius = min(thumbWidth, thumbHeight) / 2
                        addCircle(centerX, centerY, radius, Path.Direction.CW)
                    }
                    canvas.save()
                    canvas.clipPath(path)
                    canvas.drawBitmap(bitmap, null, RectF(left, top, right, bottom), thumbPaint)
                    canvas.restore()
                }
                SHAPE_ROUND_RECT -> {
                    val radius = if (thumbCornerRadius == 0f) {
                        min(thumbWidth, thumbHeight) / 2
                    } else {
                        thumbCornerRadius
                    }
                    val path = Path().apply {
                        addRoundRect(
                            RectF(left, top, right, bottom),
                            radius, radius,
                            Path.Direction.CW
                        )
                    }
                    canvas.save()
                    canvas.clipPath(path)
                    canvas.drawBitmap(bitmap, null, RectF(left, top, right, bottom), thumbPaint)
                    canvas.restore()
                }
                else -> {
                    canvas.drawBitmap(bitmap, null, RectF(left, top, right, bottom), thumbPaint)
                }
            }
        }
    }

    override fun onTouchEvent(event: MotionEvent): Boolean {
        if (!enable) {
            return super.onTouchEvent(event)
        }
        when (event.action) {
            MotionEvent.ACTION_DOWN -> {
                val touchX = event.x
                val thumbLeft = fixedMargin + thumbX
                val thumbRight = thumbLeft + thumbWidth
                if (touchX in thumbLeft..thumbRight) {
                    isDragging = true
                    parent.requestDisallowInterceptTouchEvent(true)
                    return true
                }
            }

            MotionEvent.ACTION_MOVE -> {
                if (isDragging) {
                    val rawX = event.x - thumbWidth / 2 - fixedMargin
                    thumbX = min(max(rawX, 0f), maxThumbX)
                    invalidate()
                    return true
                }
            }

            MotionEvent.ACTION_UP, MotionEvent.ACTION_CANCEL -> {
                if (isDragging) {
                    isDragging = false
                    parent.requestDisallowInterceptTouchEvent(false)

                    val progress = if (slideDirection == DIRECTION_LEFT) {
                        1 - (thumbX / maxThumbX)
                    } else {
                        thumbX / maxThumbX
                    }

                    if (progress >= slideThreshold) {
                        onSlideCompleteListener?.invoke()
                    } else {
                        animateReset()
                    }
                    return true
                }
            }
        }
        return super.onTouchEvent(event)
    }

    fun animateReset() {
        val startX = thumbX.toInt()
        val endX = when (slideDirection) {
            DIRECTION_LEFT -> maxThumbX.toInt()
            else -> 0
        }
        scroller.startScroll(startX, 0, endX - startX, 0, 300)
        invalidate()
    }

    override fun computeScroll() {
        if (scroller.computeScrollOffset()) {
            thumbX = scroller.currX.toFloat()
            invalidate()
            if (!scroller.isFinished) {
                postInvalidateOnAnimation()
            }
        }
    }

    private fun dpToPx(dp: Float): Float {
        return dp * resources.displayMetrics.density
    }

    // ==================== 公共 API ====================

    fun setOnSlideCompleteListener(listener: () -> Unit) {
        onSlideCompleteListener = listener
    }

    fun setSlideDirection(direction: Int) {
        slideDirection = direction
        resetThumbPosition()
        invalidate()
    }

    fun getSlideDirection() = slideDirection

    fun setSlideBackgroundColor(color: Int) {
        backgroundColor = color
        backgroundPaint.color = color
        invalidate()
    }

    fun setBackgroundCornerRadius(radius: Float) {
        backgroundCornerRadius = radius
        invalidate()
    }

    fun setSlideText(text: String) {
        this.text = text
        invalidate()
    }

    fun setSlideTextColor(color: Int) {
        textColor = color
        textPaint.color = color
        invalidate()
    }

    fun setSlideTextSize(size: Float) {
        textSize = size
        textPaint.textSize = size
        invalidate()
    }

    fun setThumbDrawable(resId: Int) {
        thumbDrawableRes = resId
        loadThumbDrawable()
        requestLayout()
        invalidate()
    }

    fun setThumbBitmap(bitmap: Bitmap?) {
        thumbBitmap = bitmap
        requestLayout()
        invalidate()
    }

    fun setThumbShape(shape: Int) {
        thumbShape = shape
        invalidate()
    }

    fun setThumbCornerRadius(radius: Float) {
        thumbCornerRadius = radius
        invalidate()
    }

    fun setSlideThreshold(threshold: Float) {
        slideThreshold = threshold.coerceIn(0f, 1f)
    }
}