package com.hdl.sdk.ttl_sdk.utlis;

import android.animation.ValueAnimator;
import android.content.Context;
import android.content.res.Resources;
import android.content.res.TypedArray;
import android.graphics.BlurMaskFilter;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.MaskFilter;
import android.graphics.Paint;
import android.graphics.Path;
import android.graphics.Point;
import android.graphics.RadialGradient;
import android.graphics.RectF;
import android.graphics.Region;
import android.graphics.Shader;
import android.graphics.SweepGradient;
import android.util.AttributeSet;
import android.util.DisplayMetrics;
import android.view.MotionEvent;
import android.view.View;

import androidx.annotation.ColorInt;
import androidx.annotation.Nullable;

import com.hdl.sdk.ttl_sdk.R;

import java.util.Locale;

/**
 * Created by Tong on 2021/10/27.
 * Rgb颜色圆环选择器
 */
public class RGBColorPicker extends View {

    private int mWidth, mHeight;

    //色
    private SweepGradient mHueShader;
    //饱和度
    private RadialGradient mSaturationShader;

    //色板画笔
    private Paint mPalettePaint;

    //圆盘范围
    private final Region mPaletteScopeRegion = new Region();

    private Paint paint;


    //指针半径
    private int markSize;
    private int markColor;

    private int mCurrentColor;

    private MaskFilter maskFilter;

    private float touchX = Float.MAX_VALUE;
    private float touchY = Float.MAX_VALUE;

    private ColorListener listener;

    private ValueAnimator mDelayAnim;

    public abstract static class DelayColorListener implements ColorListener {

        /**
         * 延迟500毫秒
         */
        private static final long DEF_DELAY = 500;

        private long lastTime = 0;

        private long delay = DEF_DELAY;

        public DelayColorListener(long delay) {
            this.delay = delay;
        }

        public DelayColorListener() {
        }

        public abstract void onDelayColorChanged(@ColorInt int color, boolean fromUser);


        @Override
        public void onColorSelected(int color, boolean fromUser) {
            onDelayColorChanged(color, fromUser);
        }

        @Override
        public void onColorChange(int color, boolean fromUser) {
            if (System.currentTimeMillis() - lastTime > delay) {
                onDelayColorChanged(color, fromUser);
                lastTime = System.currentTimeMillis();
            }
        }
    }

    public interface ColorListener {
        /**
         * 稳定
         */
        void onColorSelected(@ColorInt int color, boolean fromUser);

        /**
         * 颜色变化
         */
        void onColorChange(@ColorInt int color, boolean fromUser);
    }

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

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

    public RGBColorPicker(Context context, @Nullable AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
        if (attrs != null) {
            TypedArray a = getContext().getTheme().obtainStyledAttributes(attrs, R.styleable.RGBColorPicker, defStyleAttr, 0);
            markColor = a.getColor(R.styleable.RGBColorPicker_markColor, Color.WHITE);

            markSize = a.getDimensionPixelOffset(R.styleable.RGBColorPicker_markSize, 0);

            mCurrentColor = a.getColor(R.styleable.RGBColorPicker_markColor, Color.WHITE);

            a.recycle();
        }
        init();
    }

    private void init() {

        setLayerType(View.LAYER_TYPE_SOFTWARE, null);
        paint = new Paint(Paint.ANTI_ALIAS_FLAG);
        paint.setStyle(Paint.Style.FILL);
        paint.setStrokeCap(Paint.Cap.ROUND);


        mPalettePaint = new Paint();

    }

    @Override
    protected void onSizeChanged(int w, int h, int oldw, int oldh) {
        super.onSizeChanged(w, h, oldw, oldh);
        this.mWidth = getWidth();
        this.mHeight = getHeight();
        initPalette();

    }


    public void setColorListener(ColorListener listener) {
        this.listener = listener;
    }

    @Override
    protected void onDraw(Canvas canvas) {
        drawPalette(canvas);
        drawDropper(canvas);
    }

    /**
     * 初始化调色板
     */
    private void initPalette() {
        float centerX = mWidth * 0.5f;
        float centerY = mHeight * 0.5f;
        float radius = Math.min(centerX, centerY);

        mHueShader =
                new SweepGradient(
                        mWidth * 0.5f,
                        mHeight * 0.5f,
                        new int[]{
                                Color.RED,
                                Color.MAGENTA,
                                Color.BLUE,
                                Color.CYAN,
                                Color.GREEN,
                                Color.YELLOW,
                                Color.RED,

                        },
                        new float[]{0.000f, 0.166f, 0.333f, 0.499f, 0.666f, 0.833f, 0.999f});


        mSaturationShader =
                new RadialGradient(
                        centerX, centerY, radius, Color.WHITE, Color.parseColor("#00FFFFFF"), Shader.TileMode.CLAMP);


        //色盘范围
        final Path mPaletteScopePath = new Path();
        mPaletteScopePath.addCircle(centerX, centerY, radius - markSize * 0.5f, Path.Direction.CW);

        final RectF bounds = new RectF();
        mPaletteScopePath.computeBounds(bounds, true);

        mPaletteScopeRegion.setPath(mPaletteScopePath, new Region((int) bounds.left, (int) bounds.top, (int) bounds.right, (int) bounds.bottom));

        maskFilter = new BlurMaskFilter(markSize * 0.1f, BlurMaskFilter.Blur.OUTER);

    }

    /**
     * 画取色器
     */
    private void drawDropper(Canvas canvas) {
        if (maskFilter == null) return;
        final float centerX = mWidth * 0.5f;
        final float centerY = mHeight * 0.5f;
        final float radius = Math.min(centerX, centerY);
        final Point point = getNearPoint(touchX, touchY, centerX, centerY, radius, markSize / 2);

        float x = point.x;
        float y = point.y;

        paint.reset();
        paint.setStyle(Paint.Style.STROKE);
        paint.setFlags(Paint.ANTI_ALIAS_FLAG);
        paint.setMaskFilter(maskFilter);
        paint.setColor(Color.BLACK);
        canvas.drawCircle(x, y, markSize * 0.5f, paint);

        paint.reset();
        paint.setStyle(Paint.Style.FILL);
        paint.setFlags(Paint.ANTI_ALIAS_FLAG);
        paint.setColor(markColor);
        paint.setStrokeWidth(dp2pxAdapt(0.5f));
        paint.setColor(Color.WHITE);
        paint.setStyle(Paint.Style.STROKE);
        canvas.drawCircle(x, y, markSize * 0.5f, paint);
    }

    /**
     * 画调色板
     */
    private void drawPalette(Canvas canvas) {
        final float centerX = mWidth * 0.5f;
        final float centerY = mHeight * 0.5f;
        final float radius = Math.min(centerX, centerY);

        mPalettePaint.reset();
        mPalettePaint.setFlags(Paint.ANTI_ALIAS_FLAG);
        mPalettePaint.setShader(mHueShader);
        canvas.drawCircle(centerX, centerY, radius, mPalettePaint);


        mPalettePaint.reset();
        mPalettePaint.setFlags(Paint.ANTI_ALIAS_FLAG);
        mPalettePaint.setShader(mSaturationShader);
        canvas.drawCircle(centerX, centerY, radius, mPalettePaint);


    }

    @Override
    public boolean onTouchEvent(MotionEvent event) {
        if (mDelayAnim != null) {
            mDelayAnim.cancel();
        }
        float x = event.getX();
        float y = event.getY();

        int color = getColorByPoint(x, y);
        this.mCurrentColor = color;
        switch (event.getAction()) {
            case MotionEvent.ACTION_DOWN:
            case MotionEvent.ACTION_MOVE:

                if (listener != null) {
                    listener.onColorChange(color, true);
                }
                touchX = x;
                touchY = y;
                invalidate();


                return true;
            case MotionEvent.ACTION_UP:

                if (listener != null) {
                    listener.onColorChange(color, true);
                    listener.onColorSelected(color, true);
                }
                touchX = x;
                touchY = y;
                invalidate();

                return true;

        }
        return super.onTouchEvent(event);

    }


    /**
     * 指定坐标是否在圆上,减了小圆圈半径
     */
    private boolean isPointInPalette(float x, float y) {
        return mPaletteScopeRegion.contains((int) x, (int) y);
    }


    /**
     * RGB 0红 120 绿  240蓝
     */
    private int getColorByPoint(float x, float y) {
        final float centerX = mWidth * 0.5f;
        final float centerY = mHeight * 0.5f;
        final float radius = Math.min(centerX, centerY);

        x = x - centerX;
        y = y - centerY;

        //色调0-360，饱和度0-1，亮度范围0-1
        float[] hsv = {0, 0, 1};
        //色调计算角度
        hsv[0] = (float) (Math.atan2(y, -x) * 180f / Math.PI) + 180;
        //饱和度，从圆心出发0~1
        double r = Math.sqrt(x * x + y * y);
        hsv[1] = Math.max(0f, Math.min(1f, (float) (r / radius)));
        return Color.HSVToColor(hsv);
    }

    public void setCurrentColor(int mCurrentColor) {
        if (mDelayAnim != null) {
            mDelayAnim.cancel();
        }
        setCurrentColorInner(mCurrentColor);

    }

    private void setCurrentColorInner(int currentColor) {
        this.mCurrentColor = currentColor;
        post(new Runnable() {
            @Override
            public void run() {
                Point point = getPointByColor(mCurrentColor);
                touchX = point.x;
                touchY = point.y;
                invalidate();
            }
        });


    }

    public void setCurrentColorDelay(final int color) {
        if (mDelayAnim != null) {
            mDelayAnim.cancel();
        }

        //不相等才处理
        if (mCurrentColor != color) {

            mDelayAnim = ValueAnimator.ofFloat(0, 1);
            mDelayAnim.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
                @Override
                public void onAnimationUpdate(ValueAnimator animation) {
                    final float p = (float) animation.getAnimatedValue();
                    if (p == 1) {
                        setCurrentColorInner(color);
                    }
                }
            });
            mDelayAnim.setStartDelay(300);
            mDelayAnim.setDuration(100);
            mDelayAnim.start();
        }


    }


    public int getCurrentColor() {
        return mCurrentColor;
    }

    public static String getHexCode(@ColorInt int color) {
        int a = Color.alpha(color);
        int r = Color.red(color);
        int g = Color.green(color);
        int b = Color.blue(color);
        return String.format(Locale.getDefault(), "%02X%02X%02X%02X", a, r, g, b);
    }

    /**
     * 通过颜色获取坐标
     * 相对坐标
     */
    private Point getPointByColor(@ColorInt int color) {

        float[] hsv = {0, 0, 1};
        Color.colorToHSV(color, hsv);
        final float centerX = mWidth * 0.5f;
        final float centerY = mHeight * 0.5f;
        final float radius = Math.min(centerX, centerY);

        final float d = hsv[1] * radius;
        //转为弧度
        double radians = Math.toRadians(hsv[0]);


        int x = (int) (centerX + (float) (d * Math.cos(radians)));
        int y = (int) (centerY - (float) (d * Math.sin(radians)));

        return new Point(x, y);
    }

    /**
     * 获取最近距离坐标点
     */
    private Point getNearPoint(float x, float y, float centerX, float centerY, float parentRadius, float markRadius) {
        Point point = new Point();

        if (isPointInPalette(x, y)) {
            point.x = (int) x;
            point.y = (int) y;
        } else {
            //计算最近坐标
            x = x - parentRadius;
            y = y - parentRadius;
            int r = (int) (parentRadius - markRadius);
            //角度
            float angle = (float) (Math.atan2(y, -x) * 180f / Math.PI) + 180;
            //转为弧度
            double radians = Math.toRadians(angle);
            point.x = (int) (centerX + (float) (r * Math.cos(radians)));
            point.y = (int) (centerY - (float) (r * Math.sin(radians)));
        }
        return point;
    }


    public void setMarkColor(int markColor) {
        this.markColor = markColor;
    }

    private static final float WIDTH_DP_BASE = 360;

    //==================根据密度适配=========================
    public static int dp2pxAdapt(float dp) {
        return dp2pxAdapt(dp, WIDTH_DP_BASE);
    }

    public static int dp2pxAdapt(float dp, float widthDpBase) {
        DisplayMetrics dm = Resources.getSystem().getDisplayMetrics();
        float density = dm.density;
        float heightDP = dm.heightPixels / density;
        float widthDP = dm.widthPixels / density;
        float w = Math.min(widthDP, heightDP);
        return (int) (dp * w / widthDpBase * density + 0.5f);
    }
}