package com.hdl.widget.gesturelock;

import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.Path;
import android.os.Parcel;
import android.os.Parcelable;
import android.util.AttributeSet;
import android.view.MotionEvent;
import android.view.View;
import android.widget.RelativeLayout;

import com.hdl.widget.HDLUtlisXM;

import java.util.ArrayList;
import java.util.List;

/**
 * Created by JLChen on 2019/10/30
 */
public class GestureLockView extends RelativeLayout {

    private static final String TAG = "GestureLockView";
    public static int DEFAULT_SELECT_COLOR = 0xFFFC744B; //选中颜色
    public static int DEFAULT_BORDER_COLOR = 0xFF818181; //边框
//    public static int DEFAULT_BACK_TRUE_COLOR = 0x20FC744B; //抬起正确背景颜色
//    public static int DEFAULT_BACK_FALSE_COLOR = 0xFFEDACA7; //抬起错误背景颜色
    public static int DEFAULT_SELECT_FALSE_COLOR = 0xFFFF0000; //错误红颜色

    //模式选择，重置密码，设置密码模式
    public static final int RESET_MODE = 0;
    //验证密码模式
    public static final int VERIFY_MODE = 1;

    // 关于LockView的边长（n*n）： n * mLockViewWidth + ( n + 1 ) * mLockViewMargin = mWidth
    private int mLockViewWidth = 0;
    //mLockViewWidth * 0.25
    private int mLockViewMargin = 0;
    //LockView数组
    private ArrayList<ILockView> mILockViews = new ArrayList<>(1);

    private LockViewFactory mLockViewFactory = null;

    //x*x的手势解锁
    private int mDotCount = 3;

    //画笔
    private Paint mPaint;
    //路径
    private Path mPath;
    //连接线的宽度
    private float mStrokeWidth = 2;
    //手指触摸是，path颜色
    private int mFingerTouchColor = DEFAULT_SELECT_COLOR;
    //手指抬起时,密码匹配path颜色
    private int mFingerUpMatchedColor = DEFAULT_SELECT_COLOR;
    //手指抬起时,密码不匹配path颜色
    private int mFingerUpUnmatchedColor = DEFAULT_SELECT_FALSE_COLOR;

    //path上一次moveTo到的点坐标
    private float mLastPathX = 0;
    private float mLastPathY = 0;

    //指引线的终点坐标
    private float mLineX = 0;
    private float mLineY = 0;

    //保存选中的LockView id
    private ArrayList<Integer> mChooseList = new ArrayList<>(1);
    //答案list
    private ArrayList<Integer> mAnswerList = new ArrayList<>(1);

    //是否可以触摸
    private boolean mTouchable = true;

//    //允许的尝试次数
//    private int mTryTimes = 5;
//    //保存的尝试次数，因为模式切换的时候TryTimes可能不等于初始设置的值
//    private int mSavedTryTimes = 5;

    private OnLockVerifyListener mOnLockVerifyListener;
    private OnLockResetListener mOnLockResetListener;

    //当前模式
    private int mCurrentMode = VERIFY_MODE;
    //RESET_MODE下最少连接数
    private int mMinCount = 3;

    private int resetDelayMillis = 300;

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

    public GestureLockView(Context context, AttributeSet attrs) {
        super(context, attrs);
        init(context);
    }

    private void init(final Context context) {
        if (mLockViewFactory == null) {
            setLockView(new LockViewFactory() {
                @Override
                public ILockView newLockView() {
                    return new QQLockView(context);
                }
            });
        }

        mPaint = new Paint();
        mPaint.setAntiAlias(true);
        mPaint.setStyle(Paint.Style.STROKE);
        mPaint.setStrokeWidth(HDLUtlisXM.dp2px(context, mStrokeWidth));
        mPaint.setStrokeCap(Paint.Cap.ROUND);
        mPaint.setStrokeJoin(Paint.Join.ROUND);

        mPath = new Path();
    }

    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        super.onMeasure(widthMeasureSpec, heightMeasureSpec);
        int width = MeasureSpec.getSize(widthMeasureSpec);
        int height = MeasureSpec.getSize(heightMeasureSpec);

        width = width > height ? height : width;

        mLockViewWidth = (int) (4 * width * 1.0f / (5 * mDotCount + 1));
        //计算LockView的间距
        mLockViewMargin = (int) (mLockViewWidth * 0.25);

        if (mLockViewFactory != null) {
            setLockViewParams(mLockViewFactory);
        }
    }

    /**
     * 设置LockView的参数并添加到布局中
     *
     * @param lockViewFactory
     */
    private void setLockViewParams(LockViewFactory lockViewFactory) {
        if (mILockViews.size() > 0) {
            return;
        }
        for (int i = 0; i < mDotCount * mDotCount; i++) {
            ILockView iLockView = lockViewFactory.newLockView();
            iLockView.getView().setId(i + 1);
            mILockViews.add(iLockView);
            RelativeLayout.LayoutParams lockerParams = new LayoutParams(mLockViewWidth, mLockViewWidth);

            //不是每行的第一个，则设置位置为前一个的右边
            if (i % mDotCount != 0) {
                lockerParams.addRule(RelativeLayout.RIGHT_OF, mILockViews.get(i - 1).getView().getId());
            }
            //从第二行开始，设置为上一行同一位置View的下面
            if (i > mDotCount - 1) {
                lockerParams.addRule(RelativeLayout.BELOW, mILockViews.get(i - mDotCount).getView().getId());
            }

            //设置右下左上的边距
            int rightMargin = mLockViewMargin;
            int bottomMargin = mLockViewMargin;
            int leftMargin = 0;
            int topMargin = 0;

            //每个View都有右外边距和底外边距 第一行的有上外边距 第一列的有左外边距
            if (i >= 0 && i < mDotCount) {//第一行
                topMargin = mLockViewMargin;
            }

            if (i % mDotCount == 0) {//第一列
                leftMargin = mLockViewMargin;
            }

            lockerParams.setMargins(leftMargin, topMargin, rightMargin, bottomMargin);
            mILockViews.get(i).onNoFinger();
            mILockViews.get(i).getView().setLayoutParams(lockerParams);
            addView(mILockViews.get(i).getView());
        }
    }

    @Override
    protected void onSizeChanged(int w, int h, int oldw, int oldh) {
        super.onSizeChanged(w, h, oldw, oldh);
    }

    @Override
    protected void onFinishInflate() {
        super.onFinishInflate();
    }

    /**
     * 保存状态
     *
     * @return
     */
    @Override
    protected Parcelable onSaveInstanceState() {
        Parcelable superState = super.onSaveInstanceState();
        SavedState ss = new SavedState(superState);
//        ss.tryTimes = mTryTimes;
        return ss;
    }

    /**
     * 恢复状态
     *
     * @param state
     */
    @Override
    protected void onRestoreInstanceState(Parcelable state) {
        SavedState savedState = (SavedState) state;
        super.onRestoreInstanceState(savedState.getSuperState());
//        mTryTimes = savedState.tryTimes;
    }

    @Override
    public boolean onTouchEvent(MotionEvent event) {
        if (mTouchable) {
            int action = event.getAction();
            int x = (int) event.getX();
            int y = (int) event.getY();
            switch (action) {
                case MotionEvent.ACTION_DOWN:
                    handleDownEvent(x, y);
                    break;
                case MotionEvent.ACTION_MOVE:
                    handleMoveEvent(x, y);
                    break;
                case MotionEvent.ACTION_UP:
                    handleUpEvent();
                    break;
            }
            invalidate();
            return true;
        } else {
            return false;
        }
    }

    /**
     * 处理按下事件
     *
     * @param x
     * @param y
     */
    private void handleDownEvent(int x, int y) {
        reset();
        handleMoveEvent(x, y);
    }

    /**
     * 处理移动事件
     *
     * @param x
     * @param y
     */
    private void handleMoveEvent(int x, int y) {
        mPaint.setColor(mFingerTouchColor);
        ILockView lockView = getLockViewByPoint(x, y);
        if (lockView != null) {
            int childId = lockView.getView().getId();
            if (!mChooseList.contains(childId)) {
                mChooseList.add(childId);
                lockView.onFingerTouch();

                //手势解锁监听
                if (mOnLockVerifyListener != null) {
                    mOnLockVerifyListener.onGestureSelected(childId);
                }

                mLastPathX = lockView.getView().getLeft() / 2 + lockView.getView().getRight() / 2;
                mLastPathY = lockView.getView().getTop() / 2 + lockView.getView().getBottom() / 2;

                if (mChooseList.size() == 1) {
                    mPath.moveTo(mLastPathX, mLastPathY);
                } else {
                    mPath.lineTo(mLastPathX, mLastPathY);
                }
            }
        }
        //指引线终点坐标
        mLineX = x;
        mLineY = y;
    }

    /**
     * 处理抬起事件
     */
    private void handleUpEvent() {
        if (mCurrentMode == RESET_MODE) {
            handleResetMode();
        } else {
            handleVerifyMode();
        }
        //将指引线的终点坐标设置为最后一个Path的原点，即取消指引线
        mLineX = mLastPathX;
        mLineY = mLastPathY;
    }

    /**
     * 处理修改密码模式
     */
    private void handleResetMode() {
        if (mAnswerList.size() <= 0) {
            //如果AnswerList.size()==0则为第一次设置，验证连接数
            if (mChooseList.size() < mMinCount) {
                //连接数不符
                if (mOnLockResetListener != null) {
                    mOnLockResetListener.onConnectCountUnmatched(mChooseList.size(), mMinCount);
                }
                toggleLockViewMatchedState(false);
                return;
            } else {
                //连接数符合，将选择的答案赋值给mAnswerList
                for (Integer integer : mChooseList) {
                    //因为mAnswerList是从0开始，chooseList保存的是id从1开始，所以-1
                    mAnswerList.add(integer - 1);
                }
                if (mOnLockResetListener != null) {
                    mOnLockResetListener.onFirstPasswordFinished(mAnswerList);
                }
                toggleLockViewMatchedState(true);
            }
        } else {
            //mAnswerList已有答案，则验证密码，两次密码匹配保存密码
            boolean isAnswerRight = checkAnswer();
            if (isAnswerRight) {
                //两次密码正确，回调
                toggleLockViewMatchedState(true);
                if (mOnLockResetListener != null) {
                    mOnLockResetListener.onSetPasswordFinished(true, mAnswerList);
                }
            } else {
                //两次没密码不正确
                toggleLockViewMatchedState(false);
                if (mOnLockResetListener != null) {
                    mOnLockResetListener.onSetPasswordFinished(false, new ArrayList<Integer>(1));
                }
            }
        }
    }

//    /**
//     * 处理验证密码模式
//     */
//    private void handleVerifyMode() {
//        mTryTimes--;
//        boolean isAnswerRight = checkAnswer();
//        //手势解锁监听
//        if (mOnLockVerifyListener != null) {
//            mOnLockVerifyListener.onGestureFinished(isAnswerRight);
//            if (mTryTimes <= 0) {
//                mOnLockVerifyListener.onGestureTryTimesBoundary();
//            }
//        }
//        if (!isAnswerRight) {
//            toggleLockViewMatchedState(false);
//        } else {
//            toggleLockViewMatchedState(true);
//        }
//
////        resetGestureTimer();
//    }

    /**
     * 处理验证密码模式
     */
    private void handleVerifyMode() {
        //手势解锁监听
        if (mOnLockVerifyListener != null) {
            mOnLockVerifyListener.onGestureFinished(getAnswer(), mChooseList.size());
        }

    }


    private void resetGestureTimer(){
        postDelayed(new Runnable() {
            @Override
            public void run() {
                resetGesture();
            }
        }, resetDelayMillis);
    }

    /**
     * 检查x,y点是否在LockView中
     *
     * @param childView
     * @param x
     * @param y
     * @return
     */
    private boolean checkPointInChild(View childView, int x, int y) {
        //设置了内边距，即x,y必须落入下GestureLockView的内部中间的小区域中，可以通过调整padding使得x,y落入范围不变大，或者不设置padding
        int padding = (int) (mLockViewWidth * 0.1);
        if (x >= childView.getLeft() + padding && x <= childView.getRight() - padding
                && y >= childView.getTop() + padding
                && y <= childView.getBottom() - padding) {
            return true;
        }
        return false;
    }

    /**
     * 同过x，y点获取LockView对象
     *
     * @param x
     * @param y
     * @return
     */
    private ILockView getLockViewByPoint(int x, int y) {
        for (ILockView lockView : mILockViews) {
            if (checkPointInChild(lockView.getView(), x, y)) {
                return lockView;
            }
        }

        return null;
    }

    /**
     * 重置手势解锁
     */
    private void reset() {
        if (mChooseList == null || mPath == null || mILockViews == null) {
            return;
        }
        mChooseList.clear();
        mPath.reset();
        for (ILockView iLockView : mILockViews) {
            iLockView.onNoFinger();
        }
    }

    /**
     * 重置手势
     */
    public void resetGesture() {
        reset();
        invalidate();
    }


    /**
     * 检查答案是否正确
     *
     * @return
     */
    private boolean checkAnswer() {
        if (mAnswerList.size() != mChooseList.size()) {
            return false;
        }

        for (int i = 0; i < mAnswerList.size(); i++) {
            if (mAnswerList.get(i) != mChooseList.get(i) - 1) {
                return false;
            }
        }

        return true;
    }


    /**
     * 检查答案是否正确
     *
     * @return
     */
    private String getAnswer() {
        String pas = "";
        if(mChooseList != null) {
            for (int mChooseId : mChooseList) {
                pas += mChooseId;
            }
        }

        return pas;
    }

    /**
     * 切换LockView是否匹配状态
     *
     * @param isMatched
     */
    private void toggleLockViewMatchedState(boolean isMatched) {
        if (isMatched) {
            mPaint.setColor(mFingerUpMatchedColor);
        } else {
            mPaint.setColor(mFingerUpUnmatchedColor);
        }
        for (ILockView iLockView : mILockViews) {
            if (mChooseList.contains(iLockView.getView().getId())) {
                if (!isMatched) {
                    iLockView.onFingerUpUnmatched();
                } else {
                    iLockView.onFingerUpMatched();
                }
            }
        }
    }

    @Override
    protected void dispatchDraw(Canvas canvas) {
        super.dispatchDraw(canvas);
        //画Path
        canvas.drawPath(mPath, mPaint);
        //画指引线
        if (mChooseList.size() > 0) {
            canvas.drawLine(mLastPathX, mLastPathY, mLineX, mLineY, mPaint);
        }
    }

    /**
     * 设置LockView
     *
     * @param lockViewFactory
     */
    public void setLockView(LockViewFactory lockViewFactory) {
        if (lockViewFactory != null) {
            removeAllViewsInLayout();
            mILockViews.clear();
            mLockViewFactory = lockViewFactory;
            if (mLockViewWidth > 0) {
                setLockViewParams(mLockViewFactory);
                reset();
            }
        }
    }

    /**
     * 设置答案
     *
     * @param answer
     */
    public void setAnswer(int... answer) {
        mAnswerList.clear();
        for (int i = 0; i < answer.length; i++) {
            mAnswerList.add(answer[i]);
        }
    }

    /**
     * 将String类型的Answer设置到list
     * 必须时List的toString形式[x,x,x]
     *
     * @param answer
     */
    public void setAnswer(String answer) {
        if (answer.startsWith("[") && answer.endsWith("]")) {
            answer = answer.substring(1, answer.length() - 1);
            String[] answers = answer.split(",");
            mAnswerList.clear();
            for (int i = 0; i < answers.length; i++) {
                mAnswerList.add(Integer.parseInt(answers[i].trim()));
            }
        }
    }

    /**
     * 设置是否可以触摸
     *
     * @param touchable
     */
    public void setTouchable(boolean touchable) {
        this.mTouchable = touchable;
        reset();
        invalidate();
    }

    /**
     * 设置手势解锁监听器
     *
     * @param listener
     */
    public void setOnLockVerifyListener(OnLockVerifyListener listener) {
        this.mOnLockVerifyListener = listener;
    }

    public void setOnLockResetListener(OnLockResetListener listener) {
        this.mOnLockResetListener = listener;
    }

    /**
     * 设置路径宽度
     *
     * @param dp
     */
    public void setPathWidth(float dp) {
        mPaint.setStrokeWidth(HDLUtlisXM.dp2px(getContext(), dp));
    }

    /**
     * 设置每行点的个数
     *
     * @param count
     */
    public void setDotCount(int count) {
        this.mDotCount = count;
    }

    /**
     * 设置手指按下时Path颜色
     *
     * @param color
     */
    public void setTouchedPathColor(int color) {
        this.mFingerTouchColor = color;
        DEFAULT_SELECT_COLOR = color;

    }

    /**
     * 设置正确时的颜色
     *
     * @param color
     */
    public void setTruePathColor(int color) {
        this.mFingerTouchColor = color;
        this.mFingerUpMatchedColor = color;
        DEFAULT_SELECT_COLOR = color;
    }

    /**
     * 设置手指抬起时，密码匹配颜色
     *
     * @param color
     */
    public void setMatchedPathColor(int color) {
        this.mFingerUpMatchedColor = color;
        DEFAULT_SELECT_COLOR = color;
    }

    /**
     * 设置手指抬起时，密码不匹配的颜色
     *
     * @param color
     */
    public void setUnmatchedPathColor(int color) {
        this.mFingerUpUnmatchedColor = color;
        DEFAULT_SELECT_FALSE_COLOR = color;
    }

    /**
     * 切换LockView是否匹配状态
     *
     * @param isMatched
     */
    public void setLockViewMatchedState(Boolean isMatched){
        toggleLockViewMatchedState(isMatched);
        resetGestureTimer();
    }

    /**
     * 设置重置延时时间
     *
     * @param resetDelayMillis
     */
    public void setResetDelayMillis(int resetDelayMillis) {
        this.resetDelayMillis = resetDelayMillis;
    }

    //    /**
//     * 设置最大尝试次数
//     *
//     * @param tryTimes
//     */
//    public void setTryTimes(int tryTimes) {
//        this.mTryTimes = tryTimes;
//        this.mSavedTryTimes = tryTimes;
//    }

//    /**
//     * 获取最大尝试次数
//     *
//     * @return
//     */
//    public int getTryTimes() {
//        return mTryTimes;
//    }

//    /**
//     * 设置密码模式下，最小连接数
//     *
//     * @param minCount
//     */
//    public void setMinCount(int minCount) {
//        this.mMinCount = minCount;
//    }

//    public void setMode(int mode) {
//        this.mCurrentMode = mode;
//        reset();
//        //切换到验证模式的时候，还原最大尝试次数
//        if (mCurrentMode == VERIFY_MODE) {
////            mTryTimes = mSavedTryTimes;
//        } else if (mCurrentMode == RESET_MODE) {
//            //清除已有密码数据
//            mAnswerList.clear();
//        }
//    }

    public interface OnLockVerifyListener {

        /**
         * 移动过程中选中的id
         *
         * @param id
         */
        void onGestureSelected(int id);

//        /**
//         * 手势动作完成
//         *
//         * @param isMatched 是否和密码匹配
//         */
//        void onGestureFinished(boolean isMatched);


        /**
         * 手势动作完成
         *
         * @param selectPassword 选择的密码
         */
        void onGestureFinished(String selectPassword, int selectCount);

//        /**
//         * 超过尝试次数上限
//         */
//        void onGestureTryTimesBoundary();
    }

    public interface OnLockResetListener {

        /**
         * 连接数不符
         *
         * @param connectCount
         * @param minCount
         */
        void onConnectCountUnmatched(int connectCount, int minCount);

        /**
         * 连接数符合，第一次密码设置成功
         *
         * @param answerList
         */
        void onFirstPasswordFinished(List<Integer> answerList);

        /**
         * 设置密码成功
         *
         * @param isMatched  两次密码是否匹配
         * @param answerList 密码list
         */
        void onSetPasswordFinished(boolean isMatched, List<Integer> answerList);
    }

    /**
     * 保存状态bean
     */
    static class SavedState extends BaseSavedState {

        int tryTimes;

        public SavedState(Parcelable source) {
            super(source);
        }

        /**
         * Constructor called from {@link #CREATOR}
         */
        private SavedState(Parcel in) {
            super(in);
            tryTimes = in.readInt();
        }

        @Override
        public void writeToParcel(Parcel out, int flags) {
            super.writeToParcel(out, flags);
            out.writeValue(tryTimes);
        }

        public static final Parcelable.Creator<SavedState> CREATOR
                = new Parcelable.Creator<SavedState>() {
            public SavedState createFromParcel(Parcel in) {
                return new SavedState(in);
            }

            public SavedState[] newArray(int size) {
                return new SavedState[size];
            }
        };
    }
}