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

import android.content.Context;
import android.content.res.TypedArray;
import android.graphics.Canvas;
import android.graphics.Paint;
import android.graphics.RectF;
import android.support.annotation.UiThread;
import android.util.AttributeSet;
import android.view.MotionEvent;

import com.mm.android.deviceaddmodule.R;
import com.mm.android.deviceaddmodule.mobilecommon.utils.LogUtil;
import com.mm.android.deviceaddmodule.mobilecommon.widget.linechart.adapter.IValueAdapter;
import com.mm.android.deviceaddmodule.mobilecommon.widget.linechart.animate.LAnimator;
import com.mm.android.deviceaddmodule.mobilecommon.widget.linechart.data.Entry;
import com.mm.android.deviceaddmodule.mobilecommon.widget.linechart.data.Line;
import com.mm.android.deviceaddmodule.mobilecommon.widget.linechart.data.Lines;
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.model.Axis;
import com.mm.android.deviceaddmodule.mobilecommon.widget.linechart.model.HighLight;
import com.mm.android.deviceaddmodule.mobilecommon.widget.linechart.model.XAxis;
import com.mm.android.deviceaddmodule.mobilecommon.widget.linechart.model.YAxis;
import com.mm.android.deviceaddmodule.mobilecommon.widget.linechart.render.GodRender;
import com.mm.android.deviceaddmodule.mobilecommon.widget.linechart.render.HighLightRender;
import com.mm.android.deviceaddmodule.mobilecommon.widget.linechart.render.LineRender;
import com.mm.android.deviceaddmodule.mobilecommon.widget.linechart.render.NoDataRender;
import com.mm.android.deviceaddmodule.mobilecommon.widget.linechart.render.XAxisRender;
import com.mm.android.deviceaddmodule.mobilecommon.widget.linechart.render.YAxisRender;
import com.mm.android.deviceaddmodule.mobilecommon.widget.linechart.touch.GodTouchListener;
import com.mm.android.deviceaddmodule.mobilecommon.widget.linechart.touch.TouchListener;
import com.mm.android.deviceaddmodule.mobilecommon.widget.linechart.utils.RectD;
import com.mm.android.deviceaddmodule.mobilecommon.widget.linechart.utils.SingleD_XY;
import com.mm.android.deviceaddmodule.mobilecommon.widget.linechart.utils.Utils;

import java.util.List;


public class LineChart extends Chart {

    MappingManager _MappingManager;

    Lines _lines;

    ////////////////////////////  listener  ///////////////////////////
    IDragListener _dragListener;

    ////////////////////////// function //////////////////////////
    boolean isHighLightEnabled = true;
    boolean isTouchEnabled = true;
    boolean isDragable = true;
    boolean isScaleable = true;
    ChartMode _ChartMode;

    ///////////////////////////////// parts ////////////////////////////////
    XAxis _XAxis;
    YAxis _YAxis;
    HighLight _HighLight;

    //////////////////////////////////  render  /////////////////////////////
    NoDataRender _NoDataRender;
    XAxisRender _XAxisRender;
    YAxisRender _YAxisRender;
    LineRender _LineRender;
    HighLightRender _HighLightRender;
    GodRender _GodRender;


    ////////////////////////////// touch  /////////////////////////////
    TouchListener _TouchListener;
    GodTouchListener _GodTouchListener;

    //////////////////////////// 区域 ///////////////////////////
    RectF _MainPlotRect;// 主要的绘图区域

    float _paddingLeft = 40;
    float _paddingRight = 5;
//    float _paddingTop = 17;
    float _paddingTop = 37;
//    float _paddingBottom = 15;
    float _paddingBottom = 25;

    RectF _GodRect;//

    //////////////////////////////  animator  ////////////////////////////
    LAnimator _LAnimator;


    public LineChart(Context context) {
        super(context);
    }

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

    public LineChart(Context context, AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
    }

    @Override
    protected void init(Context context, AttributeSet attributeSet) {
        super.init(context, attributeSet);

        TypedArray typedArray = context.obtainStyledAttributes(attributeSet,  R.styleable.LineChart);
            boolean isGodMode = typedArray.getBoolean(R.styleable.LineChart_god_mode, false);
            _ChartMode = isGodMode ? ChartMode.God : ChartMode.Normal;
            typedArray.recycle();

        // animator
        _LAnimator = new LAnimator(this);

        // init v
        _MainPlotRect = new RectF();
        _MappingManager = new MappingManager(_MainPlotRect);
        _GodRect = new RectF();

        // models
        _XAxis = new XAxis();
        _YAxis = new YAxis();
        _HighLight = new HighLight();

        // render
        _NoDataRender = new NoDataRender(_MainPlotRect, _MappingManager);
        _XAxisRender = new XAxisRender(_MainPlotRect, _MappingManager, _XAxis);
        _YAxisRender = new YAxisRender(_MainPlotRect, _MappingManager, _YAxis);
        _LineRender = new LineRender(_MainPlotRect, _MappingManager, _lines, this);
        _HighLightRender = new HighLightRender(context,_MainPlotRect, _MappingManager, _lines, _HighLight);
        _GodRender = new GodRender(_MainPlotRect, _MappingManager, _GodRect);

        // touch listener
        _TouchListener = new TouchListener(this);
        _GodTouchListener = new GodTouchListener(this);

        // other
        _paddingLeft = Utils.dp2px(_paddingLeft);
        _paddingRight = Utils.dp2px(_paddingRight);
        _paddingTop = Utils.dp2px(_paddingTop);
        _paddingBottom = Utils.dp2px(_paddingBottom);
    }


    @Override
    public void computeScroll() {
        super.computeScroll();

        if (_ChartMode == ChartMode.Normal) {
            _TouchListener.computeScroll();
        }
    }

    @Override
    public boolean onTouchEvent(MotionEvent event) {
        super.onTouchEvent(event);

        if (_lines == null) {
            return false;
        }
        if (!isTouchEnabled) {
            return false;
        }

        if (_ChartMode == ChartMode.Normal) {
            return _TouchListener.onTouch(this, event);
        } else if (_ChartMode == ChartMode.God) {
            return _GodTouchListener.onTouch(this, event);
        }

        return false;
    }

    @Override
    protected void onDraw(Canvas canvas) {
        super.onDraw(canvas);

        // 1. render no data
        if (_lines == null || _lines.getLines() == null || _lines.getLines().size() == 0) {
//            _NoDataRender.render(canvas);


            _XAxis.calValues(getVisiableMinX(), getVisiableMaxX(), null);
            _YAxis.calValues(getVisiableMinY(), getVisiableMaxY(), null);

            _YAxisRender.renderGridline(canvas);

            // render labels
            _XAxisRender.renderLabels(canvas);
            _YAxisRender.renderLabels(canvas);

            // render unit
            _XAxisRender.renderUnit(canvas);
            _YAxisRender.renderUnit(canvas);


            return;
        }

        // 计算轴线上的数值
        Line line = _lines.getLines().get(0);
        _XAxis.calValues(getVisiableMinX(), getVisiableMaxX(), line);
        _YAxis.calValues(getVisiableMinY(), getVisiableMaxY(), line);


        // render grid line
//        _XAxisRender.renderGridline(canvas);
        _YAxisRender.renderGridline(canvas);

        // render line
        _LineRender.render(canvas);

        // render god
        if (_ChartMode == ChartMode.God) {
            _GodRender.render(canvas);
        }


        // render high light,放到刻度虚线后面画，防止被Gridline遮挡
        _HighLightRender.render(canvas);


        // render warn line
        _XAxisRender.renderWarnLine(canvas);
        _YAxisRender.renderWarnLine(canvas);

        // render Axis
//        _XAxisRender.renderAxisLine(canvas);
//        _YAxisRender.renderAxisLine(canvas);

        // render labels
        _XAxisRender.renderLabels(canvas);
        _YAxisRender.renderLabels(canvas);

        // render unit
        _XAxisRender.renderUnit(canvas);
        _YAxisRender.renderUnit(canvas);

    }

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

        _LineRender.onChartSizeChanged(w, h);
        notifyDataChanged();
    }

    @Override
    protected void onDetachedFromWindow() {
        super.onDetachedFromWindow();

        _lines = null;
    }

    /**
     * 通知数据改变
     */
    public void notifyDataChanged() {

        limitMainPlotArea();

        if (_lines == null) {
            return;
        }
        _lines.calMinMax();

        prepareMap();

        // 2. onDataChanged
        _LineRender.onDataChanged(_lines);
        _HighLightRender.onDataChanged(_lines);
    }

    /**
     * 限制 主绘图区域的边界
     */
    private void limitMainPlotArea() {

        _MainPlotRect.setEmpty();
        _MainPlotRect.right += _MainPlotRect.left + getWidth();
        _MainPlotRect.bottom += _MainPlotRect.top + getHeight();

        // 0. padding
        offsetPadding();
        // 1. 计算label,unit的宽高
        offsetArea();

        if (_ChartMode == ChartMode.God) {
            _GodRect.set(_MainPlotRect);
            _GodRect.right = _GodRect.right / 3;
        }
    }

    private void offsetPadding() {

        // 考虑图例
        if (_lines != null) {
            int h = 0;
            for (Line line : _lines.getLines()) {
                if (line.getLegendHeight() > h) {
                    h = line.getLegendHeight();
                }
            }

            if (h > 0) {
                _paddingTop = h;
            }
        }

        _MainPlotRect.left += _paddingLeft;
        _MainPlotRect.top += _paddingTop;
        _MainPlotRect.right -= _paddingRight;
        _MainPlotRect.bottom -= _paddingBottom;
    }

    private void offsetArea() {

        _YAxisRender.paint_label();
        _YAxisRender.paint_unit();
        Paint paintLabel = _YAxisRender.get_PaintLabel();
        Paint paintUnit = _YAxisRender.get_PaintUnit();

        /*******************************  取一堆label中的head middle tail 中的最大值  ***********************************/
        float labelDimen = _YAxis.getLabelDimen();

        if (_lines != null && _lines.getLines().size() > 0) {
            Line line = _lines.getLines().get(0);

            if (line.getEntries().size() > 0) {
                List<Entry> entryList = line.getEntries();

                Entry head = entryList.get(0);
                Entry tail = entryList.get(entryList.size() - 1);
                Entry middle = entryList.get(( entryList.size() - 1) / 2);

                IValueAdapter yAdapter = _YAxis.get_ValueAdapter();
                String s1 = yAdapter.value2String(head.getY());
                float w1 = Utils.textWidth(paintLabel, s1);
                if (labelDimen < w1) {
                    labelDimen = w1;
                }

                String s2 = yAdapter.value2String(middle.getY());
                float w2 = Utils.textWidth(paintLabel, s2);
                if (labelDimen < w2) {
                    labelDimen = w2;
                }

                String s3 = yAdapter.value2String(tail.getY());
                float w3 = Utils.textWidth(paintLabel, s3);
                if (labelDimen < w3) {
                    labelDimen = w3;
                }
            }

        }

        // 考虑y label和unit
        _MainPlotRect.left += _YAxis.offsetLeft(labelDimen, Utils.textHeight(paintUnit));
        // 考虑x label和unit
        _MainPlotRect.bottom -= _XAxis.offsetBottom(Utils.textHeight(paintLabel), Utils.textHeight(paintUnit));
    }


    /**
     * 准备映射关系
     */
    private void prepareMap() {
        double xMin = _lines.getmXMin();
        double xMax = _lines.getmXMax();
        double yMin = _lines.getmYMin();
        double yMax = _lines.getmYMax();

        if (yMin == 0 && yMax == 0){
            yMax = 10;
            yMin = 0;
        }

        if (_lines.getLines().size() == 0){
            yMax = 10;
            yMin = 0;

            Axis.CalWay calWay = get_XAxis().getCalWay();
            if (calWay == Axis.CalWay.lc_day){
                xMin = - 23.d/30;
                xMax = 23.d*31/30;
            }else if (calWay == Axis.CalWay.lc_week){
                xMin = - 6.d/30;
                xMax = 6.d*31/30;
            }else if (calWay == Axis.CalWay.lc_month){
                xMin = - 30.d/30;
                xMax = 30.d*31/30;
            }else if (calWay == Axis.CalWay.lc_year){
                xMin = - 11.d/30;
                xMax = 11.d*31/30;
            }

        }

        _MappingManager.prepareRelation(xMin, xMax, yMin, yMax);
    }

    /**
     * 设置数据源
     *
     * @param lines
     */
    public void setLines(Lines lines) {
        _lines = lines;

        notifyDataChanged();
        postInvalidate();
    }

    public Lines getlines() {
        return _lines;
    }

    /**
     * 清空数据
     */
    public void clearData() {
        _lines = null;
        invalidate();
    }


    private void A______________________________________________() {

    }

    /**
     * Y方向进行动画
     */
    @UiThread
    public void animateY() {
        _LAnimator.animateY(1000);
    }

    /**
     * Y方向进行动画
     */
    @UiThread
    public void animateY(long duration) {
        _LAnimator.animateY(duration);
    }

    /**
     * X方向进行动画
     */
    @UiThread
    public void animateX() {
        _LAnimator.animateX(1000);
    }

    /**
     * X方向进行动画
     */
    @UiThread
    public void animateX(long duration) {
        _LAnimator.animateX(duration);
    }

    /**
     * X,Y方向进行动画
     */
    @UiThread
    public void animateXY() {
        _LAnimator.animateXY(1000);
    }

    /**
     * X,Y方向进行动画
     */
    @UiThread
    public void animateXY(long duration) {
        _LAnimator.animateXY(duration);
    }

    public LAnimator get_LAnimator() {
        return _LAnimator;
    }

    public void set_LAnimator(LAnimator _LAnimator) {
        this._LAnimator = _LAnimator;
    }


    private void B_________________________________________________() {

    }

    private void a______________________________________________() {

    }

    public boolean isCanX_drag() {
        return _TouchListener.isCanX_drag();
    }

    /**
     * 设置x方向是否可拖动
     *
     * @param canX_drag
     */
    public void setCanX_drag(boolean canX_drag) {
        _TouchListener.setCanX_drag(canX_drag);
    }

    public boolean isCanY_drag() {
        return _TouchListener.isCanY_drag();
    }

    /**
     * 设置y方向是否可拖动
     *
     * @param canY_drag
     */
    public void setCanY_drag(boolean canY_drag) {
        _TouchListener.setCanY_drag(canY_drag);
    }

    public boolean isZoom_alone() {
        return _TouchListener.isZoom_alone();
    }

    /**
     * 设置x,y方向是否可以独立缩放
     *
     * @param zoom_independent
     */
    public void setZoom_alone(boolean zoom_independent) {
        _TouchListener.setZoom_alone(zoom_independent);
    }

    public boolean isCanX_zoom() {
        return _TouchListener.isCanX_zoom();
    }

    /**
     * 设置x方向是否可以缩放
     *
     * @param canX_zoom
     */
    public void setCanX_zoom(boolean canX_zoom) {
        _TouchListener.setCanX_zoom(canX_zoom);
    }

    public boolean isCanY_zoom() {
        return _TouchListener.isCanY_zoom();
    }

    /**
     * 设置y方向是否可以缩放
     *
     * @param canY_zoom
     */
    public void setCanY_zoom(boolean canY_zoom) {
        _TouchListener.setCanY_zoom(canY_zoom);
    }

    public boolean isDragable() {
        return isDragable;
    }

    public void setDragable(boolean dragable) {
        isDragable = dragable;
    }

    public boolean isScaleable() {
        return isScaleable;
    }

    public void setScaleable(boolean scaleable) {
        isScaleable = scaleable;
    }

    public IDragListener get_dragListener() {
        return _dragListener;
    }

    public void set_dragListener(IDragListener _dragListener) {
        this._dragListener = _dragListener;
    }

    private void b______________________________________________() {

    }

    public float get_paddingLeft() {
        return _paddingLeft;
    }

    public void set_paddingLeft(float _paddingLeft) {
        this._paddingLeft = _paddingLeft;
    }

    public float get_paddingRight() {
        return _paddingRight;
    }

    public void set_paddingRight(float _paddingRight) {
        this._paddingRight = _paddingRight;
    }

    public float get_paddingTop() {
        return _paddingTop;
    }

    public void set_paddingTop(float _paddingTop) {
        this._paddingTop = _paddingTop;
    }

    public float get_paddingBottom() {
        return _paddingBottom;
    }

    public void set_paddingBottom(float _paddingBottom) {
        this._paddingBottom = _paddingBottom;
    }

    private void c______________________________________________() {

    }

    public double getVisiableMinX() {
        float px = _MainPlotRect.left;
        SingleD_XY xy = _MappingManager.getValueByPx(px, 0);
        return xy.getX();
    }

    public double getVisiableMaxX() {
        float px = _MainPlotRect.right;
        SingleD_XY xy = _MappingManager.getValueByPx(px, 0);
        return xy.getX();
    }

    public double getVisiableMinY() {
        float py = _MainPlotRect.bottom;
        SingleD_XY xy = _MappingManager.getValueByPx(0, py);
        return xy.getY();
    }

    public double getVisiableMaxY() {
        float py = _MainPlotRect.top;
        SingleD_XY xy = _MappingManager.getValueByPx(0, py);
        return xy.getY();
    }

    public RectD get_currentViewPort() {
        return _MappingManager.get_currentViewPort();
    }

    public void set_currentViewPort(RectD currentViewPort) {
        _MappingManager.set_currentViewPort(currentViewPort);
    }

    /**
     * 设置y轴的范围
     *
     * @param yMin
     * @param yMax
     */
    public void setYMax_Min(double yMin, double yMax) {
        if (_lines != null) {
            _lines.setYCustomMaxMin(true);
            _lines.setmYMin(yMin);
            _lines.setmYMax(yMax);
            postInvalidate();
        } else {
            LogUtil.errorLog("setAxisMaxMin:", " 请在lines设置后，调用此方法！");
        }
    }

    /**
     * 设置轴线的范围
     *
     * @param xMin
     * @param xMax
     */
    public void setXAix_MaxMin(double xMin, double xMax) {
        if (_lines != null) {
            _lines.setXCustomMaxMin(true);
            _lines.setmXMin(xMin);
            _lines.setmXMax(xMax);
            postInvalidate();
        } else {
            LogUtil.errorLog("setAxisMaxMin:"," 请在lines设置后，调用此方法！");
        }
    }

    private void d______________________________________________() {

    }

    /**
     * 获取映射管家
     *
     * @return
     */
    public MappingManager get_MappingManager() {
        return _MappingManager;
    }


    ////////////////////////////////  便捷的方法  //////////////////////////////////

    public void highLight_PixXY(float px, float py) {
        SingleD_XY xy = _MappingManager.getValueByPx(px, py);
        highLight_ValueXY(xy.getX(), xy.getY());
    }

    public void highLight_ValueXY(double x, double y) {
        _HighLightRender.highLight_ValueXY(x, y);
        invalidate();
    }

    public void highLightLeft() {
        _HighLightRender.highLightLeft();
        invalidate();
    }

    public void highLightRight() {
        _HighLightRender.highLightRight();
        invalidate();
    }

    public HighLight get_HighLight() {
        return _HighLight;
    }

    public void set_HighLight(HighLight _HighLight) {
        this._HighLight = _HighLight;
    }

    public XAxis get_XAxis() {
        return _XAxis;
    }

    public YAxis get_YAxis() {
        return _YAxis;
    }

    public RectF get_GodRect() {
        return _GodRect;
    }

    public void set_GodRect(RectF _GodRect) {
        this._GodRect = _GodRect;
    }

    public RectF get_MainPlotRect() {
        return _MainPlotRect;
    }

    public void set_MainPlotRect(RectF _MainPlotRect) {
        this._MainPlotRect = _MainPlotRect;
    }

    public ChartMode get_ChartMode() {
        return _ChartMode;
    }

    public LineChart set_ChartMode(ChartMode _ChartMode) {
        this._ChartMode = _ChartMode;
        return this;
    }

    LineChart _ob_linechart;

    public void registObserver(LineChart lineChartOb) {
        this._ob_linechart = lineChartOb;

        notifyDataChanged_FromOb(lineChartOb);
    }

    public void notifyDataChanged_FromOb(LineChart lineChartOb) {

        // x,y轴上的单位
        XAxis xAxis = lineChartOb.get_XAxis();
        this.get_XAxis().set_unit(xAxis.get_unit());

        YAxis yAxis = lineChartOb.get_YAxis();
        this.get_YAxis().set_unit(yAxis.get_unit());

        this.setLines(lineChartOb.getlines());
    }

    public void notifyOB_ViewportChanged(RectD _currentViewPort) {
        _ob_linechart.set_CurrentViewPort(_currentViewPort);
        _ob_linechart.invalidate();
    }

    public LineChart set_CurrentViewPort(RectD _currentViewPort) {
        _MappingManager.set_currentViewPort(_currentViewPort);
        return this;
    }


    public enum ChartMode {
        Normal, God
    }


}