package com.mm.android.deviceaddmodule.mobilecommon.widget.linechart.touch;

import android.view.GestureDetector;
import android.view.MotionEvent;
import android.view.VelocityTracker;
import android.view.View;
import android.view.ViewParent;
import android.widget.Scroller;

import com.mm.android.deviceaddmodule.mobilecommon.widget.linechart.charts.LineChart;
import com.mm.android.deviceaddmodule.mobilecommon.widget.linechart.listener.IDragListener;
import com.mm.android.deviceaddmodule.mobilecommon.widget.linechart.manager.MappingManager;
import com.mm.android.deviceaddmodule.mobilecommon.widget.linechart.utils.RectD;

public class TouchListener implements View.OnTouchListener {

    ViewParent viewParent;

    GestureDetector _GestureDetector;
    Zoomer _Zoomer;
    Scroller _Scroller;

    LineChart _LineChart;
    MappingManager _MappingManager;

    VelocityTracker _VelocityTracker;
    TouchMode _TouchMode = TouchMode.NONE;

    ///////////////////////////////////  平滑的缩放  ///////////////////////////////////
    double _zoom_w, _zoom_h;
    float _zoom_cx, _zoom_cy;

    public TouchListener(LineChart lineChart) {
        this._LineChart = lineChart;

        _GestureDetector = new GestureDetector(_LineChart.getContext(), new GestureListener());
        _MappingManager = lineChart.get_MappingManager();

        _Zoomer = new Zoomer();
        _Scroller = new Scroller(lineChart.getContext());
    }


    float _lastX, _lastY;
    float _disX = 1, _disY = 1, _disXY = 1, _cX, _cY;

    @Override
    public boolean onTouch(View v, MotionEvent event) {

        viewParent = v.getParent();

        // 速度跟踪
        if (_VelocityTracker == null) {
            _VelocityTracker = VelocityTracker.obtain();
        }
        _VelocityTracker.addMovement(event);

        boolean hit = _GestureDetector.onTouchEvent(event);
        if (hit) {
            _LineChart.invalidate();
            return true;
        }

        float x = event.getX();
        float y = event.getY();

        switch (event.getActionMasked()) {
            case MotionEvent.ACTION_DOWN:
                stopAll();
                iNeedTouch(true);
                _lastX = x;
                _lastY = y;
                break;
            case MotionEvent.ACTION_POINTER_DOWN:
                if (event.getPointerCount() >= 2) {
                    _disX = getXDist(event);
                    _disY = getYDist(event);
                    _disXY = getABSDist(event);
                    float tmpX = event.getX(0) + event.getX(1);
                    float tmpY = event.getY(0) + event.getY(1);
                    _cX = (tmpX / 2f);
                    _cY = (tmpY / 2f);

                    _TouchMode = TouchMode.PINCH_ZOOM;
                }
                break;
            case MotionEvent.ACTION_MOVE:
                float dx = x - _lastX;
                float dy = y - _lastY;
                if (_TouchMode == TouchMode.DRAG) {
                    _VelocityTracker.computeCurrentVelocity(1000);
                    float vx = _VelocityTracker.getXVelocity();// 得到当前手指在这一点移动的速度
                    float vy = _VelocityTracker.getYVelocity();// 速度分为了x和y轴两个方向的速度
                    int direction = judgeDir(vx, vy);
                    doDrag(dx, dy, direction);
                } else if (_TouchMode == TouchMode.PINCH_ZOOM) {
                    doPinch(event);
                } else if (_TouchMode == TouchMode.NONE) {
                    _TouchMode = TouchMode.DRAG;
                }

                _lastX = x;
                _lastY = y;
                break;
            case MotionEvent.ACTION_POINTER_UP:
                _TouchMode = TouchMode.NONE;
                break;
            case MotionEvent.ACTION_UP:
                if (_TouchMode == TouchMode.DRAG) {
                    _TouchMode = TouchMode.FLING;

                    _VelocityTracker.computeCurrentVelocity(1000, 5000);
                    int vx = (int) _VelocityTracker.getXVelocity();
                    int vy = (int) _VelocityTracker.getYVelocity();
                    if (vx > 20 || vy > 20) {
                        doFling(event.getX(), event.getY(), vx, vy);
                    }

                    IDragListener listener = _LineChart.get_dragListener();
                    if (listener != null) {
                        listener.onDrag(_LineChart.getVisiableMinX(), _LineChart.getVisiableMaxX());
                    }
                }
                _TouchMode = TouchMode.NONE;
                break;
            case MotionEvent.ACTION_CANCEL:
                if (_VelocityTracker != null) {
                    _VelocityTracker.recycle();
                    _VelocityTracker = null;
                }

                _TouchMode = TouchMode.NONE;
                break;
        }

        return true;
    }

    float _lastScrollX, _lastScrollY;

    public void computeScroll() {
        // 考虑滚动
        if (_Scroller.computeScrollOffset()) {

            int currX = _Scroller.getCurrX();
            int currY = _Scroller.getCurrY();

            float dx = currX - _lastScrollX;
            float dy = currY - _lastScrollY;

            doDrag(dx, dy, -1);

            _lastScrollX = currX;
            _lastScrollY = currY;
        }

        // 考虑缩放
        if (_Zoomer.computeZoom()) {

            float currentLevel = _Zoomer.getCurrentZoom();
            zoom(currentLevel, _zoom_w, _zoom_h, _zoom_cx, _zoom_cy);
        }
    }


    boolean hitStart = false;
    int hitCount = 0;

    /**
     * lchart 需要触摸事件
     */
    private void iNeedTouch(boolean need) {

        if (need) {
            viewParent.requestDisallowInterceptTouchEvent(true);
            hitStart = false;
        } else {
            hitCount++;

            if (!hitStart) {
                hitCount = 0;
                hitStart = true;
            } else {

                if (hitCount > 3) {
                    hitStart = false;
                    viewParent.requestDisallowInterceptTouchEvent(false);
                } else {
                    viewParent.requestDisallowInterceptTouchEvent(true);
                }
            }
        }

    }


    private void stopAll() {
        _Scroller.forceFinished(true);
        _Zoomer.stop();
    }


    private int judgeDir(float vx, float vy) {

        float x = Math.abs(vx);
        float y = Math.abs(vy);

        if (x > y) {
            // 方向是水平
            return 1;
        } else {
            // 方向是垂直
            return 2;
        }
    }

    /**
     * 双手缩放
     *
     * @param event
     */
    private void doPinch(MotionEvent event) {

        if (!_LineChart.isScaleable()) {
            return;
        }

        iNeedTouch(true);

        float absDist = getABSDist(event);
        float scale = _disXY / absDist;

        if (zoom_alone) {
            // 考虑独立缩放
            float xDis = getXDist(event);
            float yDis = getYDist(event);

            if (xDis > yDis) {
                zoom(scale, 1, _cX, _cY);
            } else {
                zoom(1, scale, _cX, _cY);
            }
        } else {
            zoom(scale, scale, _cX, _cY);
        }

        _disXY = absDist;
    }

    boolean canX_drag = true;
    boolean canY_drag = true;

    /**
     * 拖拽
     *
     * @param dx
     * @param dy
     */
    private void doDrag(float dx, float dy, int direction) {

        if (!_LineChart.isDragable()) {
            return;
        }

        if (direction != -1) {

            RectD current = _MappingManager.get_currentViewPort();
            RectD maxx = _MappingManager.get_constrainViewPort();

            boolean need = false;

            if (direction == 1) {
                // hor
                need = current.right < maxx.right;
                need &= current.left > maxx.left;

            } else {
                // ver
                need = current.bottom > maxx.bottom;
                need &= current.top < maxx.top;
            }

            iNeedTouch(need);
        }

        if (!canX_drag) {
            dx = 0;
        }
        if (!canY_drag) {
            dy = 0;
        }

        _MappingManager.translate(dx, dy);
        _LineChart.postInvalidate();
    }


    /**
     * 抛掷
     */
    private void doFling(float x, float y, int velocityX, int velocityY) {

        if (!_LineChart.isDragable()) {
            return;
        }

        _Scroller.forceFinished(true);

        _lastScrollX = x;
        _lastScrollY = y;

        _Scroller.fling(
                (int) x, (int) y,
                velocityX, velocityY,
                Integer.MIN_VALUE, Integer.MAX_VALUE,
                Integer.MIN_VALUE, Integer.MAX_VALUE);

        _LineChart.invalidate();
    }


    boolean canX_zoom = true;
    boolean canY_zoom = true;
    boolean zoom_alone = false;

    /**
     * 应用于指定的缩放
     *
     * @param scaleX
     * @param scaleY
     * @param cx
     * @param cy
     */
    private void zoom(float scaleX, float scaleY, float cx, float cy) {

        if (!_LineChart.isScaleable()) {
            return;
        }

        if (!canX_zoom) {
            scaleX = 1;
        }
        if (!canY_zoom) {
            scaleY = 1;
        }

        _MappingManager.zoom(scaleX, scaleY, cx, cy);
        _LineChart.postInvalidate();
    }


    /**
     * 应用于平滑的缩放
     *
     * @param level
     * @param startW
     * @param startH
     * @param cx
     * @param cy
     */
    private void zoom(float level, double startW, double startH, float cx, float cy) {

        if (!_LineChart.isScaleable()) {
            return;
        }

        _MappingManager.zoom(level, startW, startH, cx, cy, canX_zoom, canY_zoom);
        _LineChart.postInvalidate();
    }

    private static float getABSDist(MotionEvent event) {
        float x = event.getX(0) - event.getX(1);
        float y = event.getY(0) - event.getY(1);
        return (float) Math.sqrt(x * x + y * y);
    }

    private static float getXDist(MotionEvent e) {
        float x = Math.abs(e.getX(0) - e.getX(1));
        return x;
    }

    private static float getYDist(MotionEvent e) {
        float y = Math.abs(e.getY(0) - e.getY(1));
        return y;
    }


    public boolean isCanX_drag() {
        return canX_drag;
    }

    public void setCanX_drag(boolean canX_drag) {
        this.canX_drag = canX_drag;
    }

    public boolean isCanY_drag() {
        return canY_drag;
    }

    public void setCanY_drag(boolean canY_drag) {
        this.canY_drag = canY_drag;
    }

    public boolean isCanX_zoom() {
        return canX_zoom;
    }

    public void setCanX_zoom(boolean canX_zoom) {
        this.canX_zoom = canX_zoom;
    }

    public boolean isZoom_alone() {
        return zoom_alone;
    }

    public void setZoom_alone(boolean zoom_alone) {
        this.zoom_alone = zoom_alone;
    }

    public boolean isCanY_zoom() {
        return canY_zoom;
    }

    public void setCanY_zoom(boolean canY_zoom) {
        this.canY_zoom = canY_zoom;
    }

    class GestureListener extends GestureDetector.SimpleOnGestureListener {

        @Override
        public boolean onDoubleTap(MotionEvent e) {

            //禁用双击放大，以后有需求可以在这里打开
            if (true){
                return false;
            }

            _Zoomer.stop();

            _zoom_w = _MappingManager.get_currentViewPort().width();
            _zoom_h = _MappingManager.get_currentViewPort().height();

            _zoom_cx = e.getX();
            _zoom_cy = e.getY();

            _Zoomer.startZoom(0.6f);

            return true;
        }

        @Override
        public boolean onDown(MotionEvent e) {
            return super.onDown(e);
        }

        @Override
        public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX, float velocityY) {
            return super.onFling(e1, e2, velocityX, velocityY);
        }

        @Override
        public void onLongPress(MotionEvent e) {
            super.onLongPress(e);
        }

        @Override
        public boolean onScroll(MotionEvent e1, MotionEvent e2, float distanceX, float distanceY) {
            return super.onScroll(e1, e2, distanceX, distanceY);
        }

        @Override
        public boolean onSingleTapConfirmed(MotionEvent e) {

            _LineChart.highLight_PixXY(e.getX(), e.getY());
            return true;
        }
    }

    enum TouchMode {
        NONE, DRAG, X_ZOOM, Y_ZOOM, PINCH_ZOOM, ROTATE, SINGLE_TAP, DOUBLE_TAP, LONG_PRESS, FLING
    }
}