package com.mytatvarnsdk.myView.progress;

import android.animation.ValueAnimator;
import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.LinearGradient;
import android.graphics.Paint;
import android.graphics.RectF;
import android.graphics.Shader;
import android.util.AttributeSet;
import android.view.View;
import android.view.animation.OvershootInterpolator;

import androidx.annotation.ColorRes;
import androidx.annotation.Nullable;
import androidx.core.content.ContextCompat;

import com.mytatvarnsdk.R;

public class CircularProgressView extends View {

    private Paint mBackPaint, mProgPaint;  // 绘制画笔
    private RectF mRectF = new RectF();    // 绘制区域
    private int[] mColorArray; // 圆环渐变色
    private int mProgress;   // 圆环进度(0-100)
    private int radius = 15;
    /**
     * 绘制弧线的画笔
     */
    private Paint progressPaint;

    /**
     * 圆弧圆心位置
     */
    private int centerX, centerY;

    /**
     * 圆弧的半径
     */
    private int circleRadius;

    public CircularProgressView(Context context) {
        this(context, null);
    }

    public CircularProgressView(Context context, @Nullable AttributeSet attrs) {
        this(context, attrs, 0);
    }

    public CircularProgressView(Context context, @Nullable AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
        // 初始化背景圆环画笔
        mBackPaint = new Paint();
        mBackPaint.setStyle(Paint.Style.STROKE);  // 只描边，不填充
        mBackPaint.setStrokeCap(Paint.Cap.ROUND);  // 设置圆角
        mBackPaint.setAntiAlias(true);       // 设置抗锯齿
        mBackPaint.setDither(true);         // 设置抖动
        mBackPaint.setStrokeWidth(5);
        mBackPaint.setColor(ContextCompat.getColor(context, R.color.colorPrimary));

        // 初始化进度圆环画笔
        mProgPaint = new Paint();
        mProgPaint.setStyle(Paint.Style.STROKE);  // 只描边，不填充
        mProgPaint.setStrokeCap(Paint.Cap.ROUND);  // 设置圆角
        mProgPaint.setAntiAlias(true);       // 设置抗锯齿
        mProgPaint.setDither(true);         // 设置抖动
        mProgPaint.setStrokeWidth(12);
        mProgPaint.setColor(ContextCompat.getColor(context,  R.color.count_down_gray));


        //初始化结束位置小圆点
        progressPaint = new Paint();
        progressPaint.setStyle(Paint.Style.FILL);  // 填充
        progressPaint.setStrokeCap(Paint.Cap.ROUND);  // 设置圆角
        progressPaint.setAntiAlias(true);       // 设置抗锯齿
        progressPaint.setDither(true);         // 设置抖动
        progressPaint.setStrokeWidth(10);
        progressPaint.setColor(ContextCompat.getColor(context, R.color.count_down_gray));

        // 初始化进度圆环渐变色
        mColorArray = null;
        // 初始化进度
        mProgress = 0;
    }

    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        super.onMeasure(widthMeasureSpec, heightMeasureSpec);
        int viewWide = getMeasuredWidth() - getPaddingLeft() - getPaddingRight();
        int viewHigh = getMeasuredHeight() - getPaddingTop() - getPaddingBottom();
        int mRectLength = (int) ((Math.min(viewWide, viewHigh)) - (Math.max(mBackPaint.getStrokeWidth(), mProgPaint.getStrokeWidth()))) - radius;
        int mRectL = getPaddingLeft() + (viewWide - mRectLength) / 2;
        int mRectT = getPaddingTop() + (viewHigh - mRectLength) / 2;
        mRectF.left = mRectL;
        mRectF.top = mRectT;
        mRectF.right = mRectL + mRectLength;
        mRectF.bottom = mRectT + mRectLength;

        centerX = getMeasuredWidth() / 2;
        centerY = getMeasuredHeight() / 2;

        //计算圆弧半径和圆心点
        circleRadius = Math.min(getMeasuredWidth(), getMeasuredHeight()) / 2;
        circleRadius -= radius;
    }

    @Override
    protected void onDraw(Canvas canvas) {
        super.onDraw(canvas);
        canvas.drawArc(mRectF, 0, 360, false, mBackPaint);
        canvas.drawArc(mRectF, 270, 360 * mProgress / 100f, false, mProgPaint);

        //绘制结束位置小圆形
        progressPaint.setStrokeWidth(10);
        progressPaint.setStyle(Paint.Style.FILL);
        float swipe = 360 * mProgress / 100f;
        float radians = (float) (((swipe - 90) / 2) / 180 * 2 * Math.PI);
        float endX;
        float endY;

        endX = centerX + circleRadius * (float) Math.cos(radians);
        endY = centerY + circleRadius * (float) Math.sin(radians);

        if (mProgress != 0) {
            canvas.drawCircle(endX, endY, radius, progressPaint);
        }
    }

    /**
     * 获取当前进度
     *
     * @return 当前进度（0-100）
     */
    public int getProgress() {
        return mProgress;
    }

    /**
     * 设置当前进度
     *
     * @param progress 当前进度（0-100）
     */
    public void setProgress(int progress) {
        this.mProgress = progress;
        invalidate();
    }

    /**
     * 设置当前进度，并展示进度动画。如果动画时间小于等于0，则不展示动画
     *
     * @param progress 当前进度（0-100）
     * @param animTime 动画时间（毫秒）
     */
    public void setProgress(int progress, long animTime) {
        if (animTime <= 0) setProgress(progress);
        else {
            ValueAnimator animator = ValueAnimator.ofInt(mProgress, progress);
            animator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
                @Override
                public void onAnimationUpdate(ValueAnimator animation) {
                    mProgress = (int) animation.getAnimatedValue();
                    invalidate();
                }
            });
            animator.setInterpolator(new OvershootInterpolator());
            animator.setDuration(animTime);
            animator.start();
        }
    }

    /**
     * 设置背景圆环宽度
     *
     * @param width 背景圆环宽度
     */
    public void setBackWidth(int width) {
        mBackPaint.setStrokeWidth(width);
        invalidate();
    }

    /**
     * 设置背景圆环颜色
     *
     * @param color 背景圆环颜色
     */
    public void setBackColor(/*@ColorRes int color*/String color) {
        mBackPaint.setColor(Color.parseColor(color)); //画笔颜色
        invalidate();
    }

    /**
     * 设置进度圆环宽度
     *
     * @param width 进度圆环宽度
     */
    public void setProgWidth(int width) {
        mProgPaint.setStrokeWidth(width);
        invalidate();
    }

    /**
     * 设置进度圆环颜色
     *
     * @param color 景圆环颜色
     */
    public void setProgColor(/*@ColorRes int color*/String color) {
        mProgPaint.setColor(Color.parseColor(color)); //画笔颜色
        mProgPaint.setShader(null);
        invalidate();
    }

    /**
     * 设置进度圆环颜色(支持渐变色)
     *
     * @param startColor 进度圆环开始颜色
     * @param firstColor 进度圆环结束颜色
     */
    public void setProgColor(@ColorRes int startColor, @ColorRes int firstColor) {
        mColorArray = new int[]{ContextCompat.getColor(getContext(), startColor), ContextCompat.getColor(getContext(), firstColor)};
        mProgPaint.setShader(new LinearGradient(0, 0, 0, getMeasuredWidth(), mColorArray, null, Shader.TileMode.MIRROR));
        invalidate();
    }

    /**
     * 设置进度圆环颜色(支持渐变色)
     *
     * @param colorArray 渐变色集合
     */
    public void setProgColor(@ColorRes int[] colorArray) {
        if (colorArray == null || colorArray.length < 2) return;
        mColorArray = new int[colorArray.length];
        for (int index = 0; index < colorArray.length; index++)
            mColorArray[index] = ContextCompat.getColor(getContext(), colorArray[index]);
        mProgPaint.setShader(new LinearGradient(0, 0, 0, getMeasuredWidth(), mColorArray, null, Shader.TileMode.MIRROR));
        invalidate();
    }
}
