package com.guozg.wheelview.views;

import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Paint;
import android.graphics.Rect;
import android.graphics.drawable.Drawable;
import android.graphics.drawable.GradientDrawable;
import android.graphics.drawable.GradientDrawable.Orientation;
import
 
 android.os.Handler;
import android.os.Message;
import android.text.Layout;
import android.text.StaticLayout;
import android.text.TextPaint;
import android.util.AttributeSet;
import android.util.FloatMath;
import android.view.GestureDetector;
import android.view.GestureDetector.SimpleOnGestureListener;
import
 
 android.view.MotionEvent;
import android.view.View;
import android.view.animation.Interpolator;
import android.widget.Scroller;

import com.guozg.wheelview.R;

import java.util.LinkedList;
import java.util.List;

/**
 * Numeric wheel view.
 */
public class WheelView extends View {
    /**
     * Scrolling duration
     */
 

    private static final int SCROLLING_DURATION = 400;

    /**
     * Minimum delta for scrolling
     */
    private static final int MIN_DELTA_FOR_SCROLLING = 1; //判斷是否需要滾動調整的誤差值

    /**
     * 選中項的顏色值
     */
    private static final int VALUE_TEXT_COLOR = 0xFFFF0000;

    /**
     * 未選中項的顏色值
     */
    private static final int ITEMS_TEXT_COLOR = 0xFF000000;

    /**
     * 頂部和底部的陰影
     */
    private static final int[] SHADOWS_COLORS = new int[]{0xFF111111, 0x00AAAAAA, 0x00AAAAAA};

    /**
     * 額外的列表項 高度 是加到標準的列表項高度上去的
     */
    private static final int ADDITIONAL_ITEM_HEIGHT = 15;

    /**
     * Text size
     */
    private static final int TEXT_SIZE = 24;

    /**
     * 頂部和底部的偏移量 用來隱藏
     */
    private static final int ITEM_OFFSET = TEXT_SIZE / 5;

    /**
     * item 額外新增的高度
     */
    private static final int ADDITIONAL_ITEMS_SPACE = 10;

    /**
     * Label offset
     */
    private static final int LABEL_OFFSET = 8;

    /**
     * 左右兩邊的padding值
     */
    private static final int PADDING = 10;

    /**
     * 預設的可見item個數
     */
    private static final int DEF_VISIBLE_ITEMS = 5;
    // Messages
    private final int MESSAGE_SCROLL = 0; //滾動
    private final int MESSAGE_JUSTIFY = 1; //調整
    // Cyclic
    boolean isCyclic = false;
    // Wheel Values
    private WheelAdapter adapter = null;
    private int currentItem = 0;
    // Widths
    private int itemsWidth = 0;
    private int labelWidth = 0;
    // Count of visible items
    private int visibleItems = DEF_VISIBLE_ITEMS;

    //StaticLayout 解析 : 該元件用於顯示文字,
    // 一旦該文字被顯示後, 就不能再編輯, 如果想要修改文字, 使用 DynamicLayout 佈局即可;
    // Item height  item的高度
    private int itemHeight = 0;
    // Text paints
    private TextPaint itemsPaint; //普通文字畫筆
    private TextPaint valuePaint;//選中文字的畫筆  >>>>肯定是字型顏色突出一點咯 字型大一點什麼的
    //使用場景 : 一般情況下不會使用該元件, 當想要自定義元件 或者 想要使用 Canvas 繪製文字時 才使用該佈局;
    private StaticLayout itemsLayout; //普通條目佈局
    private StaticLayout labelLayout;//選中條目佈局
    private StaticLayout valueLayout;//標籤佈局  >>>>沒看作用 目前
    // Label & background
    private String label;
    private Drawable centerDrawable;  //選中條的背景
    // //漸變的Drawable 我們經常在 drawable是用的shape中gradient的屬性 >>相對應
    private GradientDrawable topShadow; //頭部的 >>這兩個應該是相反
    private GradientDrawable bottomShadow;//底部的
    // Scrolling
    private boolean isScrollingPerformed; //是否正在執行 滾動 動作
    private int scrollingOffset; //滾動中的偏移量
    // Scrolling animation
    private GestureDetector gestureDetector; //手勢
    private Scroller scroller; //用於 平滑滾動的
    private int lastScrollY;
    // Listeners >>>>>>>>>>>>>>>>>>  可以設定多個監聽器
    private List<OnWheelChangedListener> changingListeners = new LinkedList<OnWheelChangedListener>();
    private List<OnWheelScrollListener> scrollingListeners = new LinkedList<OnWheelScrollListener>();
    // animation handler
    private Handler animationHandler = new Handler() {
        public void handleMessage(Message msg) {
            scroller.computeScrollOffset(); //返回值為boolean，true說明滾動尚未完成，
            // false說明滾動已經完成。這是一個很重要的方法，通常放在View.computeScroll()中，用來判斷是否滾動是否結束。
            //

            int currY = scroller.getCurrY();
            int delta = lastScrollY - currY;
            lastScrollY = currY;
            if (delta != 0) {
                doScroll(delta);
            }

            //當滾動到對應的位置的時候 ,Scroller的狀態還沒有改變 所以需要我們去手動的結束 最後的滾動
            if (Math.abs(currY - scroller.getFinalY()) < MIN_DELTA_FOR_SCROLLING) {
                currY = scroller.getFinalY();
                scroller.forceFinished(true);
            }
            if (!scroller.isFinished()) { //如果還是沒有停止 繼續請求 >>>
                animationHandler.sendEmptyMessage(msg.what); //>>>繼續回撥 >>>完成動畫
            } else if (msg.what == MESSAGE_SCROLL) {
                justify(); //如果 動畫已經停止 就 微調一下 
            } else {
                finishScrolling();
            }
        }
    };
    // gesture listener
    private SimpleOnGestureListener gestureListener = new SimpleOnGestureListener() {
        public boolean onDown(MotionEvent e) {
            if (isScrollingPerformed) {
                scroller.forceFinished(true);
                clearMessages();
                return true;
            }
            return false;
        }

        public boolean onScroll(MotionEvent e1, MotionEvent e2, float distanceX, float distanceY) {
            startScrolling();
            doScroll((int) -distanceY);
            return true;
        }

        /**
         *
         * @param e1
         * @param e2
         * @param velocityX
         * @param velocityY
         * @return
         */
        public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX, float velocityY) {
            lastScrollY = currentItem * getItemHeight() + scrollingOffset;
            int maxY = isCyclic ? 0x7FFFFFFF : adapter.getItemsCount() * getItemHeight();
            int minY = isCyclic ? -maxY : 0;
            scroller.fling(0, lastScrollY, 0, (int) -velocityY / 2, 0, 0, minY, maxY);
            setNextMessage(MESSAGE_SCROLL);
            return true;
        }
    };

    /**
     * Constructor
     */
    public WheelView(Context context, AttributeSet attrs, int defStyle) {
        super(context, attrs, defStyle);
        initData(context);
    }

    /**
     * Constructor
     */
    public WheelView(Context context, AttributeSet attrs) {
        super(context, attrs);
        initData(context);
    }

    /**
     * Constructor
     */
    public WheelView(Context context) {
        super(context);
        initData(context);
    }

    /**
     * Initializes class data
     *
     * @param context the context
     */
    private void initData(Context context) {
        gestureDetector = new GestureDetector(context, gestureListener); //初始化手勢監聽器
        gestureDetector.setIsLongpressEnabled(false); //長按

        scroller = new Scroller(context); //初始化 滑動
    }

    /**
     * Gets wheel adapter
     *
     * @return the adapter
     */
    public WheelAdapter getAdapter() {
        return adapter;
    }

    /**
     * Sets wheel adapter
     *
     * @param adapter the new wheel adapter
     */
    public void setAdapter(WheelAdapter adapter) {
        this.adapter = adapter;
        invalidateLayouts(); //重新整理佈局
        invalidate(); //重繪
    }

    /**
     * Set the the specified scrolling interpolator
     * <p/>
     * 設定指定的滾動插值器
     *
     * @param interpolator the interpolator
     */
    public void setInterpolator(Interpolator interpolator) {
        scroller.forceFinished(true); //強制關閉當前的滾動  新建立一個有 插值器的
        scroller = new Scroller(getContext(), interpolator);
    }

    /**
     * Gets count of visible items
     *
     * @return the count of visible items
     */
    public int getVisibleItems() {
        return visibleItems;
    }

    /**
     * Sets count of visible items
     *
     * @param count the new count
     */
    public void setVisibleItems(int count) {
        visibleItems = count;
        invalidate();
    }

    /**
     * Gets label
     *
     * @return the label
     */
    public String getLabel() {
        return label;
    }

    /**
     * Sets label
     *
     * @param newLabel the label to set
     */
    public void setLabel(String newLabel) {
        if (label == null || !label.equals(newLabel)) {
            label = newLabel;
            labelLayout = null;
            invalidate();
        }
    }

    /**
     * Adds wheel changing listener
     *
     * @param listener the listener
     */
    public void addChangingListener(OnWheelChangedListener listener) {
        changingListeners.add(listener);
    }

    /**
     * Removes wheel changing listener
     *
     * @param listener the listener
     */
    public void removeChangingListener(OnWheelChangedListener listener) {
        changingListeners.remove(listener);
    }

    /**
     * Notifies changing listeners
     *
     * @param oldValue the old wheel value
     * @param newValue the new wheel value
     */
    protected void notifyChangingListeners(int oldValue, int newValue) {
        for (OnWheelChangedListener listener : changingListeners) {
            listener.onChanged(this, oldValue, newValue); //去通知 資料 改變
        }
    }

    /**
     * Adds wheel scrolling listener
     *
     * @param listener the listener
     */
    public void addScrollingListener(OnWheelScrollListener listener) {
        scrollingListeners.add(listener);
    }

    /**
     * Removes wheel scrolling listener
     *
     * @param listener the listener
     */
    public void removeScrollingListener(OnWheelScrollListener listener) {
        scrollingListeners.remove(listener);
    }

    /**
     * Notifies listeners about starting scrolling
     */
    protected void notifyScrollingListenersAboutStart() {
        for (OnWheelScrollListener listener : scrollingListeners) {
            listener.onScrollingStarted(this);
        }
    }

    /**
     * Notifies listeners about ending scrolling
     */
    protected void notifyScrollingListenersAboutEnd() {
        for (OnWheelScrollListener listener : scrollingListeners) {
            listener.onScrollingFinished(this); //通知滾動事件
        }
    }

    /**
     * Gets current value
     *
     * @return the current value
     */
    public int getCurrentItem() {
        return currentItem;
    }

    /**
     * Sets the current item w/o animation. Does nothing when index is wrong.
     *
     * @param index the item index
     */
    public void setCurrentItem(int index) {
        setCurrentItem(index, false);
    }

    /**
     * 設定當前選中項 如果 下標異常 直接不處理 如果下標 正常
     * 判斷是否需要動畫效果
     * 如果 需要 就使用scroller平滑的滑動過去
     * 如果 不需要就使介面失效 直接重繪 介面
     *
     * @param index    需要設定的下標
     * @param animated 是否需要動畫的標誌
     */
    public void setCurrentItem(int index, boolean animated) {
        if (adapter == null || adapter.getItemsCount() == 0) {
            return; // throw?
        }
        if (index < 0 || index >= adapter.getItemsCount()) {
            if (isCyclic) {  //如果 是迴圈 那麼 就不算 越界  做個 判斷 就能求出來 位置
                while (index < 0) {
                    index += adapter.getItemsCount();
                }
                index %= adapter.getItemsCount();
            } else { //如果是不能迴圈 那就是錯誤的下標
                return; // throw?
            }
        }
        if (index != currentItem) {  //如果 設定 不是 當前 一致  就需要跳轉 到  友好介面 滑過去
            if (animated) {  //是否是有動畫效果 有 就滑過去
                scroll(index - currentItem, SCROLLING_DURATION);
            } else {
                //沒有 直接使得介面失效 得了
                invalidateLayouts();

                //順便 通知一下 改變了 資料哦  把 就資料 和新資料的下標 傳遞過去
                int old = currentItem;
                currentItem = index;

                notifyChangingListeners(old, currentItem);

                invalidate(); //直接重繪
            }
        }
    }

    /**
     * Tests if wheel is cyclic. That means before the 1st item there is shown
     * the last one
     *
     * @return true if wheel is cyclic
     */
    public boolean isCyclic() {
        return isCyclic;
    }

    /**
     * Set wheel cyclic flag
     *
     * @param isCyclic the flag to set
     */
    public void setCyclic(boolean isCyclic) {
        this.isCyclic = isCyclic;

        invalidate();
        invalidateLayouts();
    }

    /**
     * Invalidates layouts
     */
    private void invalidateLayouts() {
        itemsLayout = null;
        valueLayout = null;
        scrollingOffset = 0;
    }

    /**
     * Initializes resources
     */
    private void initResourcesIfNecessary() {
        if (itemsPaint == null) { //普通項的畫筆
            itemsPaint = new TextPaint(Paint.ANTI_ALIAS_FLAG | Paint.FAKE_BOLD_TEXT_FLAG);
            // itemsPaint.density = getResources().getDisplayMetrics().density;
            itemsPaint.setTextSize(TEXT_SIZE);
        }

        if (valuePaint == null) { //選中項的畫筆
            valuePaint = new TextPaint(Paint.ANTI_ALIAS_FLAG | Paint.FAKE_BOLD_TEXT_FLAG | Paint.DITHER_FLAG);
            // valuePaint.density = getResources().getDisplayMetrics().density;
            valuePaint.setTextSize(TEXT_SIZE);
            valuePaint.setShadowLayer(0.1f, 0, 0.1f, 0xFFC0C0C0);
        }

        //獲取列表重心的 背景
        if (centerDrawable == null) {
            centerDrawable = getContext().getResources().getDrawable(R.drawable.wheel_val);
        }

        //恰好相反 >>>>為了 突出中心  中間 一個顏色 上下一一致
        if (topShadow == null) {
            topShadow = new GradientDrawable(Orientation.TOP_BOTTOM, SHADOWS_COLORS);
        }

        if (bottomShadow == null) {
            bottomShadow = new GradientDrawable(Orientation.BOTTOM_TOP, SHADOWS_COLORS);
        }

        setBackgroundResource(R.drawable.wheel_bg);
    }

    /**
     * 計算出 佈局想要的高度
     *
     * @param layout 傳入的是想要 進行計算的佈局
     * @return 返回該佈局想要的高度
     */
    private int getDesiredHeight(Layout layout) {
        if (layout == null) {
            return 0;
        }

        int desired = getItemHeight() * visibleItems - ITEM_OFFSET * 2 - ADDITIONAL_ITEM_HEIGHT;

        // Check against our minimum height
        desired = Math.max(desired, getSuggestedMinimumHeight());

        return desired;
    }

    /**
     * 根據下標返回文字資料
     *
     * @param index the item index
     * @return the item or null
     */
    private String getTextItem(int index) {
        if (adapter == null || adapter.getItemsCount() == 0) {
            return null;
        }
        int count = adapter.getItemsCount();
        if ((index < 0 || index >= count) && !isCyclic) {
            return null;
        } else {
            while (index < 0) {
                index = count + index;
            }
        }

        index %= count;
        return adapter.getItem(index);
    }

    /**
     * Builds text depending on current value
     *
     * @param useCurrentValue
     * @return the text
     */
    private String buildText(boolean useCurrentValue) {
        StringBuilder itemsText = new StringBuilder();
        int addItems = visibleItems / 2 + 1;

        for (int i = currentItem - addItems; i <= currentItem + addItems; i++) { //獲取 當前螢幕的所有顯示的文字
            if (useCurrentValue || i != currentItem) { //正在 滾動 或者 不是當前選中的View的時候 >>>>.這裡已經過濾掉了選中狀態下的當前Item的相應文字
                String text = getTextItem(i);
                if (text != null) {
                    itemsText.append(text);
                }
            }
            if (i < currentItem + addItems) {
                itemsText.append("\n");
            }
        }

        return itemsText.toString();
    }

    /**
     * 返回 最大的文字 寬度 是的 可以完整的呈現出來
     *
     * @return the max length
     */
    private int getMaxTextLength() {
        WheelAdapter adapter = getAdapter();
        if (adapter == null) {
            return 0;
        }

        int adapterLength = adapter.getMaximumLength();
        if (adapterLength > 0) { //如果是已經重寫了該方法的介面卡 應該是可以獲取的
            return adapterLength;
        }
        //下面是針對 沒有 重寫介面卡中的該方法的情況
        String maxText = null;
        int addItems = visibleItems / 2; //求出 課件項的重點
        //對所有 可見item 進行 便利 取出 最長字串
        for (int i = Math.max(currentItem - addItems, 0);  //第一個可見
             i < Math.min(currentItem + visibleItems,//最後一個課件
                     adapter.getItemsCount()); i++) { //遍歷
            String text = adapter.getItem(i); //獲取文字
            if (text != null && (maxText == null || maxText.length() < text.length())) {
                maxText = text;
            }
        }

        return maxText != null ? maxText.length() : 0; //返回最大高度
    }

    /**
     * Returns height of wheel item
     *
     * @return the item height
     */
    private int getItemHeight() {
        if (itemHeight != 0) {
            return itemHeight;
        } else if (itemsLayout != null && itemsLayout.getLineCount() > 2) {
            itemHeight = itemsLayout.getLineTop(2) - itemsLayout.getLineTop(1);
            return itemHeight;
        }

        return getHeight() / visibleItems;
    }

    /**
     * Calculates control width and creates text layouts
     *
     * @param widthSize the input layout width
     * @param mode      the layout mode
     * @return the calculated control width
     */
    private int calculateLayoutWidth(int widthSize, int mode) {
        initResourcesIfNecessary();

        int width = widthSize;

        int maxLength = getMaxTextLength();
        if (maxLength > 0) {
            float textWidth = FloatMath.ceil(Layout.getDesiredWidth("0", itemsPaint));
            itemsWidth = (int) (maxLength * textWidth);
        } else {
            itemsWidth = 0;
        }
        itemsWidth += ADDITIONAL_ITEMS_SPACE; // make it some more

        labelWidth = 0;
        if (label != null && label.length() > 0) {
            labelWidth = (int) FloatMath.ceil(Layout.getDesiredWidth(label, valuePaint));
        }

        boolean recalculate = false;
        if (mode == MeasureSpec.EXACTLY) {
            width = widthSize;
            recalculate = true;
        } else {
            width = itemsWidth + labelWidth + 2 * PADDING;
            if (labelWidth > 0) {
                width += LABEL_OFFSET;
            }

            // Check against our minimum width
            width = Math.max(width, getSuggestedMinimumWidth());

            if (mode == MeasureSpec.AT_MOST && widthSize < width) {
                width = widthSize;
                recalculate = true;
            }
        }

        if (recalculate) {
            // recalculate width
            int pureWidth = width - LABEL_OFFSET - 2 * PADDING;
            if (pureWidth <= 0) {
                itemsWidth = labelWidth = 0;
            }
            if (labelWidth > 0) {
                double newWidthItems = (double) itemsWidth * pureWidth / (itemsWidth + labelWidth);
                itemsWidth = (int) newWidthItems;
                labelWidth = pureWidth - itemsWidth;
            } else {
                itemsWidth = pureWidth + LABEL_OFFSET; // no label
            }
        }

        if (itemsWidth > 0) {
            createLayouts(itemsWidth, labelWidth);
        }

        return width;
    }

    /**
     * 建立佈局
     *
     * @param widthItems width of items layout
     * @param widthLabel width of label layout
     */
    private void createLayouts(int widthItems, int widthLabel) {
        //如果還沒有建立 或者是 當前的寬度 大於 所需要的 那麼就進行重新建立
        if (itemsLayout == null || itemsLayout.getWidth() > widthItems) {
            // 1 顯示文字
            // 2畫筆
            // 3 文字寬度 ,
            // 4對齊方式 ,
            // 5行間距, 1f 代表 1 倍字型高度
            // 6基礎行距上增加多少 , 真實行間距 等於 spacingmult 和 spacingadd 的和
            //7 不知道 false

            //需要指出的是這個layout是預設畫在Canvas的(0,0)點的，
            // 如果需要調整位置只能在draw之前移Canvas的起始座標canvas.translate(x, y);
            itemsLayout = new StaticLayout(buildText(isScrollingPerformed), itemsPaint, widthItems,
                    widthLabel > 0 ? Layout.Alignment.ALIGN_OPPOSITE : Layout.Alignment.ALIGN_CENTER, 1,
                    ADDITIONAL_ITEM_HEIGHT, false);
        } else {
            itemsLayout.increaseWidthTo(widthItems);
        }
        //下面畫的選中的Item 同理
        if (!isScrollingPerformed && (valueLayout == null || valueLayout.getWidth() > widthItems)) {//沒有在滾動的時候 才有會選中項
            String text = getAdapter() != null ? getAdapter().getItem(currentItem) : null;
            valueLayout = new StaticLayout(text != null ? text : "", valuePaint, widthItems,
                    widthLabel > 0 ? Layout.Alignment.ALIGN_OPPOSITE : Layout.Alignment.ALIGN_CENTER, 1,
                    ADDITIONAL_ITEM_HEIGHT, false);

        } else if (isScrollingPerformed) { //正在滾動 那麼顯示選中的佈局沒有必要顯示
            valueLayout = null;
        } else {
            valueLayout.increaseWidthTo(widthItems);
        }

        if (widthLabel > 0) {
            if (labelLayout == null || labelLayout.getWidth() > widthLabel) {
                labelLayout = new StaticLayout(label, valuePaint, widthLabel, Layout.Alignment.ALIGN_NORMAL, 1,
                        ADDITIONAL_ITEM_HEIGHT, false);
            } else {
                labelLayout.increaseWidthTo(widthLabel);
            }
        }
    }

    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        int widthMode = MeasureSpec.getMode(widthMeasureSpec);
        int heightMode = MeasureSpec.getMode(heightMeasureSpec);

        int widthSize = MeasureSpec.getSize(widthMeasureSpec);
        int heightSize = MeasureSpec.getSize(heightMeasureSpec);

        int width = calculateLayoutWidth(widthSize, widthMode);

        int height;
        if (heightMode == MeasureSpec.EXACTLY) { //精確模式
            height = heightSize; //直接是傳入的值
        } else {
            height = getDesiredHeight(itemsLayout); //獲取最大的

            if (heightMode == MeasureSpec.AT_MOST) { //傳入最大值 和 傳入值的最小值
                height = Math.min(height, heightSize);
            }
        }

        setMeasuredDimension(width, height);
    }

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

        if (itemsLayout == null) {
            if (itemsWidth == 0) {
                calculateLayoutWidth(getWidth(), MeasureSpec.EXACTLY);
            } else {
                createLayouts(itemsWidth, labelWidth);
            }
        }

        if (itemsWidth > 0) {
            canvas.save();
            // Skip padding space and hide a part of top and bottom items
            canvas.translate(PADDING, -ITEM_OFFSET); //平移畫布
            drawItems(canvas); //繪製 普通Item
            drawValue(canvas); //繪製 選中Item
            canvas.restore(); //把畫布恢復
        }

        drawCenterRect(canvas);
        drawShadows(canvas);
    }

    /**
     * 繪製 頂部和底部的陰影
     *
     * @param canvas the canvas for drawing
     */
    private void drawShadows(Canvas canvas) {
        topShadow.setBounds(0, 0, getWidth(), getHeight() / visibleItems);
        topShadow.draw(canvas);

        bottomShadow.setBounds(0, getHeight() - getHeight() / visibleItems, getWidth(), getHeight());
        bottomShadow.draw(canvas);
    }

    /**
     * Draws value and label layout
     *
     * @param canvas the canvas for drawing
     */
    private void drawValue(Canvas canvas) {
        valuePaint.setColor(VALUE_TEXT_COLOR);
        valuePaint.drawableState = getDrawableState();

        Rect bounds = new Rect();
        itemsLayout.getLineBounds(visibleItems / 2, bounds);

        // draw label
        if (labelLayout != null) {
            canvas.save();
            canvas.translate(itemsLayout.getWidth() + LABEL_OFFSET, bounds.top);
            labelLayout.draw(canvas);
            canvas.restore();
        }

        // 繪製選中的item
        if (valueLayout != null) {
            canvas.save();
            canvas.translate(0, bounds.top + scrollingOffset);
            valueLayout.draw(canvas);
            canvas.restore();
        }
    }

    /**
     * 繪製普通Item
     *
     * @param canvas the canvas for drawing
     */
    private void drawItems(Canvas canvas) {
        canvas.save();

        int top = itemsLayout.getLineTop(1); //得到普通佈局中的第一行的高度
        canvas.translate(0, -top + scrollingOffset); //將畫布平移上去之後 再空出一個新增的位置

        itemsPaint.setColor(ITEMS_TEXT_COLOR);
        itemsPaint.drawableState = getDrawableState();
        itemsLayout.draw(canvas);

        canvas.restore(); //恢復畫布
    }

    /**
     * 繪製空間中心的矩形局域
     *
     * @param canvas the canvas for drawing
     */
    private void drawCenterRect(Canvas canvas) {
        int center = getHeight() / 2; //畫布的中點
        int offset = getItemHeight() / 2;  //列表項的寬度一半
        centerDrawable.setBounds(0, center - offset, getWidth(), center + offset);
        centerDrawable.draw(canvas);
    }

    @Override
    public boolean onTouchEvent(MotionEvent event) {
        WheelAdapter adapter = getAdapter();
        if (adapter == null) {
            return true;
        }

        if (!gestureDetector.onTouchEvent(event) && event.getAction() == MotionEvent.ACTION_UP) {
            //手指鬆開時和手勢監聽器，沒有收到事件的時候
            justify();
        }
        return true;
    }

    /**
     * 滾動 這個 控制元件
     *
     * @param delta 需要滾動的距離
     */
    private void doScroll(int delta) {
        scrollingOffset += delta;  //0+199  ing 199

        int count = scrollingOffset / getItemHeight(); //需要滾動 的 item個數 因為 要恰好停在 item上 不能偏嘛 如果取證
        int pos = currentItem - count;  //需要到達的位置


        if (isCyclic && adapter.getItemsCount() > 0) {
            // fix position by rotating 因為存在一個 可以迴圈 滑動 所以處理一下這種情況 做一下 位置判斷
            while (pos < 0) {
                pos += adapter.getItemsCount();
            }
            pos %= adapter.getItemsCount();

        } else if (isScrollingPerformed) { //是否正在滾動呢
            //如果不是迴圈的
            if (pos < 0) {  //如果是負的  最多滾動 當前個數的距離 -> 滾動 到 0
                count = currentItem;
                pos = 0;
            } else if (pos >= adapter.getItemsCount()) { //如果要滾動的位置大於最多的位置
                count = currentItem - adapter.getItemsCount() + 1;
                pos = adapter.getItemsCount() - 1;
            }
        } else {
            // fix position  防止越界
            pos = Math.max(pos, 0); //保證 位置 大於0
            pos = Math.min(pos, adapter.getItemsCount() - 1); //保證 位置 小於 最大的
        }

        int offset = scrollingOffset;
        if (pos != currentItem) {
            setCurrentItem(pos, false);
        } else {
            invalidate();
        }


        // update offset
        scrollingOffset = offset - count * getItemHeight();  //恰好滾動的距離 可以使得 恰好在中間

        if (scrollingOffset > getHeight()) {  //去除了重複的次數
            scrollingOffset = scrollingOffset % getHeight() + getHeight();
        }
    }

    /**
     * 先清空訊息佇列的所有資訊 再將資訊傳遞過去
     *
     * @param message the message to set
     */
    private void setNextMessage(int message) {
        clearMessages();
        animationHandler.sendEmptyMessage(message);
    }

    /**
     * 將訊息佇列中過的資訊進行清空處理
     */
    private void clearMessages() {
        animationHandler.removeMessages(MESSAGE_SCROLL);
        animationHandler.removeMessages(MESSAGE_JUSTIFY);
    }

    /**
     * Justifies wheel  整理版面 >>>>>>>>>>>>>
     */
    private void justify() {
        if (adapter == null) {
            return;
        }

        lastScrollY = 0;
        int offset = scrollingOffset;
        int itemHeight = getItemHeight();
        //判斷是否 需要去 微調 使得恰好 落在中間

        boolean needToIncrease = offset > 0 ? currentItem < adapter.getItemsCount() : currentItem > 0;
        //如果是迴圈的或者是不迴圈但是也是可以調整的狀態
        if ((isCyclic || needToIncrease) && Math.abs((float) offset) > (float) itemHeight / 2) {
            if (offset < 0) //
                offset += itemHeight + MIN_DELTA_FOR_SCROLLING;
            else
                offset -= itemHeight + MIN_DELTA_FOR_SCROLLING;
        }

        if (Math.abs(offset) > MIN_DELTA_FOR_SCROLLING) {
            //最後 滾動一丟丟
            scroller.startScroll(0, 0, 0, offset, SCROLLING_DURATION);
            //通知一下 動畫控制器
            setNextMessage(MESSAGE_JUSTIFY);
        } else {
            //不需要調整 可以有
            finishScrolling();
        }
    }

    /**
     * 開始滾動呼叫 開始滾動的方法
     */
    private void startScrolling() {
        if (!isScrollingPerformed) {
            isScrollingPerformed = true;
            notifyScrollingListenersAboutStart();
        }
    }

    /**
     * 停止 滾動 呼叫停止滾動的方法
     */
    void finishScrolling() {
        if (isScrollingPerformed) {
            notifyScrollingListenersAboutEnd();
            isScrollingPerformed = false;
        }
        invalidateLayouts();
        invalidate();
    }

    /**
     * Scroll the wheel
     *
     * @param
     * @param time scrolling duration
     */
    public void scroll(int itemsToScroll, int time) {
        scroller.forceFinished(true); //強制關了

        lastScrollY = scrollingOffset;
        int offset = itemsToScroll * getItemHeight();

        scroller.startScroll(0, lastScrollY, 0, offset - lastScrollY, time); //平滑滾動
        setNextMessage(MESSAGE_SCROLL); //通知去微調

        startScrolling(); //通知一下 開始 滾動 相關的監聽器得知道吧

    }

}