/* Copyright (c) 2011-2013 Tang Ke
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.wpc.library.widget.SlideMenu;

import android.content.Context;
import android.content.res.Resources;
import android.content.res.TypedArray;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Rect;
import android.graphics.drawable.Drawable;
import android.graphics.drawable.GradientDrawable;
import android.graphics.drawable.GradientDrawable.Orientation;
import android.os.Parcel;
import android.os.Parcelable;
import androidx.core.view.ViewCompat;
import android.util.AttributeSet;
import android.util.TypedValue;
import android.view.KeyEvent;
import android.view.MotionEvent;
import android.view.VelocityTracker;
import android.view.View;
import android.view.ViewConfiguration;
import android.view.ViewDebug.ExportedProperty;
import android.view.ViewGroup;
import android.view.animation.AnimationUtils;
import android.view.animation.Interpolator;
import android.widget.Scroller;

import com.wpc.lcjianlibrary.R;
import com.wpc.library.widget.SlideMenu.utils.ScrollDetectors;

/**
 * Swipe left/right to show the hidden menu behind the content view, Use
 * {@link ScrollDetectors} to custom the rule of MotionEvent intercept
 *
 * @author Tank
 */
public class SlideMenu extends ViewGroup {
    private final static int MAX_DURATION = 500;
    private static int STATUS_BAR_HEIGHT;

    public final static int FLAG_DIRECTION_LEFT = 1 << 0;
    public final static int FLAG_DIRECTION_RIGHT = 1 << 1;

    public final static int MODE_SLIDE_WINDOW = 1;
    public final static int MODE_SLIDE_CONTENT = 2;

    public final static int STATE_CLOSE = 1 << 0;
    public final static int STATE_OPEN_LEFT = 1 << 1;
    public final static int STATE_OPEN_RIGHT = 1 << 2;
    public final static int STATE_DRAG = 1 << 3;
    public final static int STATE_SCROLL = 1 << 4;
    public final static int STATE_OPEN_MASK = 6;

    private final static int POSITION_LEFT = -1;
    private final static int POSITION_MIDDLE = 0;
    private final static int POSITION_RIGHT = 1;
    private int mCurrentContentPosition;
    private int mCurrentState = STATE_CLOSE;

    private View mContent;
    private View mPrimaryMenu;
    private View mSecondaryMenu;

    private int mTouchSlop;

    private float mPressedX;
    private float mPressedY;
    private float mLastMotionX;
    private volatile int mCurrentContentOffset;

    private int mContentBoundsLeft;
    private int mContentBoundsRight;

    private boolean mIsTapInContent;
    private Rect mContentHitRect;

    @ExportedProperty
    private Drawable mPrimaryShadowDrawable;
    @ExportedProperty
    private Drawable mSecondaryShadowDrawable;
    @ExportedProperty
    private float mPrimaryShadowWidth;
    @ExportedProperty
    private float mSecondaryShadowWidth;
    private int mSlideDirectionFlag;
    private boolean mIsPendingResolveSlideMode;

    private int mSlideMode = MODE_SLIDE_CONTENT;

    private boolean mIsEdgeSlideEnable = true;
    private int mEdgeSlideWidth;
    private Rect mEdgeSlideDetectRect;
    private boolean mIsTapInEdgeSlide;

    private int mWidth;
    private int mHeight;

    private OnSlideStateChangeListener mSlideStateChangeListener;
    private OnContentTapListener mContentTapListener;

    private VelocityTracker mVelocityTracker;
    private Scroller mScroller;

    private Interpolator mInterpolator;
    public final static Interpolator DEFAULT_INTERPOLATOR = new Interpolator() {
        @Override
        public float getInterpolation(float t) {
            t -= 1.0f;
            return t * t * t * t * t + 1.0f;
        }
    };

    public SlideMenu(Context context, AttributeSet attrs, int defStyle) {
        super(context, attrs, defStyle);
        // we want to draw drop shadow of content
        mTouchSlop = ViewConfiguration.get(context).getScaledTouchSlop();
        mVelocityTracker = VelocityTracker.obtain();
        mContentHitRect = new Rect();
        mEdgeSlideDetectRect = new Rect();
        STATUS_BAR_HEIGHT = (int) getStatusBarHeight(context);
        setWillNotDraw(false);

        TypedArray a = context.obtainStyledAttributes(attrs,
                R.styleable.SlideMenu, defStyle, 0);

        // Set the shadow attributes
        setPrimaryShadowWidth(a.getDimension(
                R.styleable.SlideMenu_primaryShadowWidth, 30));
        setSecondaryShadowWidth(a.getDimension(
                R.styleable.SlideMenu_secondaryShadowWidth, 30));

        Drawable primaryShadowDrawable = a
                .getDrawable(R.styleable.SlideMenu_primaryShadowDrawable);
        if (null == primaryShadowDrawable) {
            primaryShadowDrawable = new GradientDrawable(
                    Orientation.LEFT_RIGHT, new int[]{Color.TRANSPARENT,
                    Color.argb(99, 0, 0, 0)});
        }
        setPrimaryShadowDrawable(primaryShadowDrawable);

        Drawable secondaryShadowDrawable = a
                .getDrawable(R.styleable.SlideMenu_secondaryShadowDrawable);
        if (null == secondaryShadowDrawable) {
            secondaryShadowDrawable = new GradientDrawable(
                    Orientation.LEFT_RIGHT, new int[]{
                    Color.argb(99, 0, 0, 0), Color.TRANSPARENT});
        }
        setSecondaryShadowDrawable(secondaryShadowDrawable);

        int interpolatorResId = a.getResourceId(
                R.styleable.SlideMenu_interpolator, -1);
        setInterpolator(-1 == interpolatorResId ? DEFAULT_INTERPOLATOR
                : AnimationUtils.loadInterpolator(context, interpolatorResId));

        mSlideDirectionFlag = a.getInt(R.styleable.SlideMenu_slideDirection,
                FLAG_DIRECTION_LEFT | FLAG_DIRECTION_RIGHT);

        setEdgeSlideEnable(a.getBoolean(R.styleable.SlideMenu_edgeSlide, false));
        setEdgetSlideWidth(a.getDimensionPixelSize(
                R.styleable.SlideMenu_edgeSlideWidth, 100));
        a.recycle();

        setFocusable(true);
        setFocusableInTouchMode(true);
    }

    public SlideMenu(Context context, AttributeSet attrs) {
        this(context, attrs, R.attr.slideMenuStyle);
    }

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

    protected Drawable getDefaultContentBackground(Context context) {
        TypedValue value = new TypedValue();
        context.getTheme().resolveAttribute(android.R.attr.windowBackground,
                value, true);
        return context.getResources().getDrawable(value.resourceId);
    }

    /**
     * Retrieve the height of status bar that defined in system
     *
     * @param context
     * @return
     */
    public static float getStatusBarHeight(Context context) {
        Resources resources = context.getResources();
        int statusBarIdentifier = resources.getIdentifier("status_bar_height",
                "dimen", "android");
        if (0 != statusBarIdentifier) {
            return resources.getDimension(statusBarIdentifier);
        }
        return 0;
    }

    /**
     * Resolve the attribute slideMode
     */
    protected void resolveSlideMode() {
        final ViewGroup decorView = (ViewGroup) getRootView();
        final ViewGroup contentContainer = decorView
                .findViewById(android.R.id.content);
        final View content = mContent;
        if (null == decorView || null == content || 0 == getChildCount()) {
            return;
        }

        TypedValue value = new TypedValue();
        getContext().getTheme().resolveAttribute(
                android.R.attr.windowBackground, value, true);

        switch (mSlideMode) {
            case MODE_SLIDE_WINDOW: {
                // remove this view from parent
                removeViewFromParent(this);
                // copy the layoutparams of content
                LayoutParams contentLayoutParams = new LayoutParams(
                        content.getLayoutParams());
                // remove content view from this view
                removeViewFromParent(content);
                // add content to layout root view
                contentContainer.addView(content);

                // get window with ActionBar
                View decorChild = decorView.getChildAt(0);
                decorChild.setBackgroundResource(0);
                removeViewFromParent(decorChild);
                addView(decorChild, contentLayoutParams);

                // add this view to root view
                decorView.addView(this);
                setBackgroundResource(value.resourceId);
            }
            break;
            case MODE_SLIDE_CONTENT: {
                // remove this view from decor view
                setBackgroundResource(0);
                removeViewFromParent(this);
                // get the origin content view from the content wrapper
                View originContent = contentContainer.getChildAt(0);
                // this is the decor child remove from decor view
                View decorChild = mContent;
                LayoutParams layoutParams = (LayoutParams) decorChild
                        .getLayoutParams();
                // remove the origin content from content wrapper
                removeViewFromParent(originContent);
                // remove decor child from this view
                removeViewFromParent(decorChild);
                // restore the decor child to decor view
                decorChild.setBackgroundResource(value.resourceId);
                decorView.addView(decorChild);
                // add this view to content wrapper
                contentContainer.addView(this);
                // add the origin content to this view
                addView(originContent, layoutParams);
            }
            break;
        }
    }

    @Override
    public void addView(View child, int index,
                        ViewGroup.LayoutParams params) {
        if (!(params instanceof LayoutParams)) {
            throw new IllegalArgumentException(
                    "The parameter params must a instance of " + LayoutParams.class.getName());
        }

        if (null == params) {
            // Skip the view without LayoutParams
            return;
        }

        LayoutParams layoutParams = (LayoutParams) params;
        switch (layoutParams.role) {
            case LayoutParams.ROLE_CONTENT:
                removeView(mContent);
                mContent = child;
                break;
            case LayoutParams.ROLE_PRIMARY_MENU:
                removeView(mPrimaryMenu);
                mPrimaryMenu = child;
                break;
            case LayoutParams.ROLE_SECONDARY_MENU:
                removeView(mSecondaryMenu);
                mSecondaryMenu = child;
                break;
            default:
                // We will ignore the view without attribute layout_role
                return;
        }
        invalidateMenuState();
        super.addView(child, index, params);
    }

    /**
     * Remove view child it's parent node, if the view does not have parent.
     * ignore
     *
     * @param view
     */
    public static void removeViewFromParent(View view) {
        if (null == view) {
            return;
        }
        ViewGroup parent = (ViewGroup) view.getParent();
        if (null == parent) {
            return;
        }
        parent.removeView(view);
    }

    /**
     * Set animation interpolator when SlideMenu scroll
     *
     * @param interpolator
     */
    public void setInterpolator(Interpolator interpolator) {
        mInterpolator = interpolator;
        mScroller = new Scroller(getContext(), interpolator);
    }

    /**
     * Get the animation interpolator
     *
     * @return
     */
    public Interpolator getInterpolator() {
        return mInterpolator;
    }

    /**
     * Set the shadow drawable of left side
     *
     * @param shadowDrawable
     */
    public void setPrimaryShadowDrawable(Drawable shadowDrawable) {
        mPrimaryShadowDrawable = shadowDrawable;
    }

    /**
     * Get the shadow drawable of left side
     *
     * @return
     */
    public Drawable getPrimaryShadowDrawable() {
        return mPrimaryShadowDrawable;
    }

    /**
     * Get the shadow drawable of right side
     *
     * @return
     */
    public Drawable getSecondaryShadowDrawable() {
        return mSecondaryShadowDrawable;
    }

    /**
     * Set the shadow drawable of right side
     *
     * @param secondaryShadowDrawable
     */
    public void setSecondaryShadowDrawable(Drawable secondaryShadowDrawable) {
        this.mSecondaryShadowDrawable = secondaryShadowDrawable;
    }

    /**
     * Get the slide mode current specified
     *
     * @return
     */
    public int getSlideMode() {
        return mSlideMode;
    }

    /**
     * Set the slide mode:<br/>
     * {@link #MODE_SLIDE_CONTENT} {@link #MODE_SLIDE_WINDOW}
     *
     * @param slideMode
     */
    public void setSlideMode(int slideMode) {
        if (isAttacthedInContentView()) {
            throw new IllegalStateException(
                    "SlidingMenu must be the root of layout");
        }

        if (mSlideMode == slideMode) {
            return;
        }
        mSlideMode = slideMode;
        if (0 == getChildCount()) {
            mIsPendingResolveSlideMode = true;
        } else {
            resolveSlideMode();
        }
    }

    /**
     * Toggle the edge slide
     *
     * @param enable
     */
    public void setEdgeSlideEnable(boolean enable) {
        mIsEdgeSlideEnable = enable;
    }

    /**
     * Indicate user can only open SlideMenu from the edge
     *
     * @return
     */
    public boolean isEdgeSlideEnable() {
        return mIsEdgeSlideEnable;
    }

    /**
     * Set edge slide width next left and right side of SlideMenu
     *
     * @param width
     */
    public void setEdgetSlideWidth(int width) {
        if (width < 0) {
            throw new IllegalArgumentException("Edge slide width must above 0");
        }
        mEdgeSlideWidth = width;
    }

    /**
     * Get the edge slide width
     *
     * @return
     */
    public float getEdgeSlideWidth() {
        return mEdgeSlideWidth;
    }

    /**
     * Indicate this SlideMenu is open
     *
     * @return true open, otherwise false
     */
    public boolean isOpen() {
        return (STATE_OPEN_MASK & mCurrentState) != 0;
    }

    /**
     * Open the SlideMenu
     *
     * @param isSlideLeft
     * @param isAnimated
     */
    public void open(boolean isSlideLeft, boolean isAnimated) {
        if (isOpen()) {
            return;
        }

        int targetOffset = isSlideLeft ? mContentBoundsLeft
                : mContentBoundsRight;

        if (isAnimated) {
            smoothScrollContentTo(targetOffset);
        } else {
            mScroller.abortAnimation();
            setCurrentOffset(targetOffset);
            setCurrentState(isSlideLeft ? STATE_OPEN_LEFT : STATE_OPEN_RIGHT);
        }
    }

    /**
     * Close the SlideMenu
     *
     * @param isAnimated
     */
    public void close(boolean isAnimated) {
        if (STATE_CLOSE == mCurrentState) {
            return;
        }

        if (isAnimated) {
            smoothScrollContentTo(0);
        } else {
            mScroller.abortAnimation();
            setCurrentOffset(0);
            setCurrentState(STATE_CLOSE);
        }
    }

    /**
     * Get current slide direction, {@link #FLAG_DIRECTION_LEFT},
     * {@link #FLAG_DIRECTION_RIGHT} or {@link #FLAG_DIRECTION_LEFT}|
     * {@link #FLAG_DIRECTION_RIGHT}
     *
     * @return
     */
    public int getSlideDirection() {
        return mSlideDirectionFlag;
    }

    /**
     * Set slide direction
     *
     * @param slideDirectionFlag
     */
    public void setSlideDirection(int slideDirectionFlag) {
        this.mSlideDirectionFlag = slideDirectionFlag;
    }

    /**
     * Set the listener to listen the state change and offset change
     *
     * @return
     */
    public OnSlideStateChangeListener getOnSlideStateChangeListener() {
        return mSlideStateChangeListener;
    }

    /**
     * Get the current listener
     *
     * @param slideStateChangeListener
     */
    public void setOnSlideStateChangeListener(
            OnSlideStateChangeListener slideStateChangeListener) {
        this.mSlideStateChangeListener = slideStateChangeListener;
    }

    public void setOnContentTapListener(OnContentTapListener contentTapListener) {
        this.mContentTapListener = contentTapListener;
    }

    public OnContentTapListener getOnContentTapListener() {
        return this.mContentTapListener;
    }

    /**
     * Get current state
     *
     * @return
     */
    public int getCurrentState() {
        return mCurrentState;
    }

    /**
     * Set current state
     *
     * @param currentState
     */
    protected void setCurrentState(int currentState) {
        if (null != mSlideStateChangeListener && currentState != mCurrentState) {
            mSlideStateChangeListener.onSlideStateChange(currentState);
        }
        this.mCurrentState = currentState;
    }

    /**
     * Equals invoke {@link #smoothScrollContentTo(int, float)} with 0 velocity
     *
     * @param targetOffset
     */
    public void smoothScrollContentTo(int targetOffset) {
        smoothScrollContentTo(targetOffset, 0);
    }

    /**
     * Perform a smooth slide of content, the offset of content will limited to
     * menu width
     *
     * @param targetOffset
     * @param velocity
     */
    public void smoothScrollContentTo(int targetOffset, float velocity) {
        setCurrentState(STATE_SCROLL);
        int distance = targetOffset - mCurrentContentOffset;
        velocity = Math.abs(velocity);
        int duration = 400;
        if (velocity > 0) {
            duration = 3 * Math.round(1000 * Math.abs(distance / velocity));
        }
        duration = Math.min(duration, MAX_DURATION);
        mScroller.abortAnimation();
        mScroller.startScroll(mCurrentContentOffset, 0, distance, 0, duration);
        invalidate();
    }

    private boolean isTapInContent(float x, float y) {
        final View content = mContent;
        if (null != content) {
            content.getHitRect(mContentHitRect);
            return mContentHitRect.contains((int) x, (int) y);
        }
        return false;
    }

    private boolean isTapInEdgeSlide(float x, float y) {
        final Rect rect = mEdgeSlideDetectRect;
        boolean result = false;
        if (null != mPrimaryMenu) {
            getHitRect(rect);
            rect.right = mEdgeSlideWidth;
            result |= rect.contains((int) x, (int) y);
        }

        if (null != mSecondaryMenu) {
            getHitRect(rect);
            rect.left = rect.right - mEdgeSlideWidth;
            result |= rect.contains((int) x, (int) y);
        }
        return result;
    }

    @Override
    public boolean dispatchTouchEvent(MotionEvent ev) {
        if (MotionEvent.ACTION_UP == ev.getAction()) {
            requestDisallowInterceptTouchEvent(false);
        }
        return super.dispatchTouchEvent(ev);
    }

    @Override
    public boolean onInterceptTouchEvent(MotionEvent ev) {
        final float x = ev.getX();
        final float y = ev.getY();
        final int currentState = mCurrentState;
        if (STATE_DRAG == currentState || STATE_SCROLL == currentState) {
            return true;
        }
        switch (ev.getAction()) {
            case MotionEvent.ACTION_DOWN:
                mPressedX = mLastMotionX = x;
                mPressedY = y;
                mIsTapInContent = isTapInContent(x, y);
                mIsTapInEdgeSlide = isTapInEdgeSlide(x, y);
                return isOpen() && mIsTapInContent;
            case MotionEvent.ACTION_MOVE:
                float dx = x - mPressedX;
                float dy = y - mPressedY;

                if (mIsEdgeSlideEnable && !mIsTapInEdgeSlide
                        && mCurrentState == STATE_CLOSE) {
                    return false;
                }

                // Detect the vertical scroll
                if (Math.abs(dy) >= mTouchSlop && mIsTapInContent
                        && canScrollVertically(this, (int) dy, (int) x, (int) y)) {
                    // if the child can response the vertical scroll, we will not to
                    // steal the MotionEvent any more
                    requestDisallowInterceptTouchEvent(true);
                    return false;
                }

                if (Math.abs(dx) >= mTouchSlop && mIsTapInContent) {
                    if (!canScrollHorizontally(this, (int) dx, (int) x, (int) y)) {
                        setCurrentState(STATE_DRAG);
                        return true;
                    }
                }
        }

        return false;
    }

    @Override
    public boolean onTouchEvent(MotionEvent event) {
        final float x = event.getX();
        final float y = event.getY();
        final int currentState = mCurrentState;

        final int action = event.getAction();
        switch (action) {
            case MotionEvent.ACTION_DOWN:
                mPressedX = mLastMotionX = x;
                mPressedY = y;
                mIsTapInContent = isTapInContent(x, y);
                mIsTapInEdgeSlide = isTapInEdgeSlide(x, y);

                if (mIsTapInContent) {
                    mScroller.abortAnimation();
                }
                break;
            case MotionEvent.ACTION_MOVE:
                mVelocityTracker.addMovement(event);

                if (mIsEdgeSlideEnable && !mIsTapInEdgeSlide
                        && mCurrentState == STATE_CLOSE) {
                    return false;
                }

                if (Math.abs(x - mPressedX) >= mTouchSlop && mIsTapInContent
                        && currentState != STATE_DRAG) {
                    getParent().requestDisallowInterceptTouchEvent(true);
                    setCurrentState(STATE_DRAG);
                }
                if (STATE_DRAG != currentState) {
                    mLastMotionX = x;
                    return false;
                }
                drag(mLastMotionX, x);
                mLastMotionX = x;
                break;
            case MotionEvent.ACTION_UP:
            case MotionEvent.ACTION_CANCEL:
            case MotionEvent.ACTION_OUTSIDE:
                if (STATE_DRAG == currentState) {
                    mVelocityTracker.computeCurrentVelocity(1000);
                    endDrag(x, mVelocityTracker.getXVelocity());
                } else if (mIsTapInContent && MotionEvent.ACTION_UP == action) {
                    performContentTap();
                }
                mVelocityTracker.clear();
                getParent().requestDisallowInterceptTouchEvent(false);
                mIsTapInContent = mIsTapInEdgeSlide = false;
                break;
        }
        return true;
    }

    @Override
    public boolean dispatchKeyEvent(KeyEvent event) {
        if (KeyEvent.ACTION_UP == event.getAction()) {
            final boolean isOpen = isOpen();
            switch (event.getKeyCode()) {
                case KeyEvent.KEYCODE_BACK:
                    if (isOpen) {
                        close(true);
                        return true;
                    }
                    break;
                case KeyEvent.KEYCODE_DPAD_LEFT:
                    if (STATE_OPEN_LEFT == mCurrentState) {
                        close(true);
                        return true;
                    } else if (!isOpen) {
                        open(true, true);
                        return true;
                    }
                    break;
                case KeyEvent.KEYCODE_DPAD_RIGHT:
                    if (STATE_OPEN_RIGHT == mCurrentState) {
                        close(true);
                        return true;
                    } else if (!isOpen) {
                        open(false, true);
                        return true;
                    }
                    break;
            }
        }
        return super.dispatchKeyEvent(event);
    }

    /**
     * Get current primary menu
     *
     * @return
     */
    public View getPrimaryMenu() {
        return mPrimaryMenu;
    }

    /**
     * Get current secondary menu
     *
     * @return
     */
    public View getSecondaryMenu() {
        return mSecondaryMenu;
    }

    /**
     * Perform click on the content
     */
    public void performContentTap() {
        if (isOpen()) {
            smoothScrollContentTo(0);
            return;
        }
        if (null != mContentTapListener) {
            mContentTapListener.onContentTap(this);
        }
    }

    protected void drag(float lastX, float x) {
        mCurrentContentOffset += (int) (x - lastX);
        setCurrentOffset(mCurrentContentOffset);
    }

    private void invalidateMenuState() {
        mCurrentContentPosition = mCurrentContentOffset < 0 ? POSITION_LEFT
                : (mCurrentContentOffset == 0 ? POSITION_MIDDLE
                : POSITION_RIGHT);
        switch (mCurrentContentPosition) {
            case POSITION_LEFT:
                invalidateViewVisibility(mPrimaryMenu, View.INVISIBLE);
                invalidateViewVisibility(mSecondaryMenu, View.VISIBLE);
                break;
            case POSITION_MIDDLE:
                invalidateViewVisibility(mPrimaryMenu, View.INVISIBLE);
                invalidateViewVisibility(mSecondaryMenu, View.INVISIBLE);
                break;
            case POSITION_RIGHT:
                invalidateViewVisibility(mPrimaryMenu, View.VISIBLE);
                invalidateViewVisibility(mSecondaryMenu, View.INVISIBLE);
                break;
        }
    }

    @Override
    public boolean shouldDelayChildPressedState() {
        return false;
    }

    private void invalidateViewVisibility(View view, int visibility) {
        if (null != view && view.getVisibility() != visibility) {
            view.setVisibility(visibility);
        }
    }

    protected void endDrag(float x, float velocity) {
        final int currentContentOffset = mCurrentContentOffset;
        final int currentContentPosition = mCurrentContentPosition;
        boolean velocityMatched = Math.abs(velocity) > 400;
        switch (currentContentPosition) {
            case POSITION_LEFT:
                if ((velocity < 0 && velocityMatched)
                        || (velocity >= 0 && !velocityMatched)) {
                    smoothScrollContentTo(mContentBoundsLeft, velocity);
                } else if ((velocity > 0 && velocityMatched)
                        || (velocity <= 0 && !velocityMatched)) {
                    smoothScrollContentTo(0, velocity);
                }
                break;
            case POSITION_MIDDLE:
                setCurrentState(STATE_CLOSE);
                break;
            case POSITION_RIGHT:
                if ((velocity > 0 && velocityMatched)
                        || (velocity <= 0 && !velocityMatched)) {
                    smoothScrollContentTo(mContentBoundsRight, velocity);
                } else if ((velocity < 0 && velocityMatched)
                        || (velocity >= 0 && !velocityMatched)) {
                    smoothScrollContentTo(0, velocity);
                }
                break;
        }
    }

    private void setCurrentOffset(int currentOffset) {
        final int slideDirectionFlag = mSlideDirectionFlag;
        final int currentContentOffset = mCurrentContentOffset = Math
                .min((slideDirectionFlag & FLAG_DIRECTION_RIGHT) == FLAG_DIRECTION_RIGHT ?
                        mContentBoundsRight : 0, Math.max(currentOffset, (slideDirectionFlag &
                        FLAG_DIRECTION_LEFT) == FLAG_DIRECTION_LEFT ? mContentBoundsLeft : 0));
        if (null != mSlideStateChangeListener) {
            float slideOffsetPercent = 0;
            if (0 < currentContentOffset) {
                slideOffsetPercent = currentContentOffset * 1.0f
                        / mContentBoundsRight;
            } else if (0 > currentContentOffset) {
                slideOffsetPercent = -currentContentOffset * 1.0f
                        / mContentBoundsLeft;
            }
            mSlideStateChangeListener.onSlideOffsetChange(slideOffsetPercent);
        }
        invalidateMenuState();
        invalidate();
        requestLayout();
    }

    @Override
    public void computeScroll() {
        if (STATE_SCROLL == mCurrentState || isOpen()) {
            if (mScroller.computeScrollOffset()) {
                setCurrentOffset(mScroller.getCurrX());
            } else {
                setCurrentState(mCurrentContentOffset == 0 ? STATE_CLOSE
                        : (mCurrentContentOffset > 0 ? STATE_OPEN_LEFT
                        : STATE_OPEN_RIGHT));
            }
        }
    }

    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        final int count = getChildCount();
        final int slideMode = mSlideMode;
        final int statusBarHeight = STATUS_BAR_HEIGHT;
        final int measureHeight = MeasureSpec.getSize(heightMeasureSpec);
        final int measureHeightMode = MeasureSpec.getMode(heightMeasureSpec);

        boolean needRemeasure = false;

        int maxChildWidth = 0, maxChildHeight = 0;
        for (int index = 0; index < count; index++) {
            View child = getChildAt(index);
            LayoutParams layoutParams = (LayoutParams) child.getLayoutParams();
            needRemeasure |= (MeasureSpec.EXACTLY != measureHeightMode && LayoutParams
                    .MATCH_PARENT == layoutParams.height);
            switch (layoutParams.role) {
                case LayoutParams.ROLE_CONTENT:
                    measureChildWithMargins(child, widthMeasureSpec, 0,
                            heightMeasureSpec, 0);
                    break;
                case LayoutParams.ROLE_PRIMARY_MENU:
                case LayoutParams.ROLE_SECONDARY_MENU:
                    measureChildWithMargins(
                            child,
                            widthMeasureSpec,
                            0,
                            slideMode == MODE_SLIDE_WINDOW ? MeasureSpec
                                    .makeMeasureSpec(measureHeight
                                                    - statusBarHeight,
                                            MeasureSpec.getMode(heightMeasureSpec))
                                    : heightMeasureSpec, 0);
                    break;
            }

            maxChildWidth = Math.max(maxChildWidth, child.getMeasuredWidth());
            maxChildHeight = Math
                    .max(maxChildHeight, child.getMeasuredHeight());
        }
        maxChildWidth += getPaddingLeft() + getPaddingRight();
        maxChildHeight += getPaddingTop() + getPaddingBottom();

        setMeasuredDimension(resolveSize(maxChildWidth, widthMeasureSpec),
                resolveSize(maxChildHeight, heightMeasureSpec));

        // we know the exactly size of SlideMenu, so we should use the new size
        // to remeasure the child
        if (needRemeasure) {
            for (int index = 0; index < count; index++) {
                View child = getChildAt(index);
                if (View.GONE != child.getVisibility()
                        && LayoutParams.MATCH_PARENT == child.getLayoutParams().height) {
                    measureChildWithMargins(child, widthMeasureSpec, 0,
                            MeasureSpec.makeMeasureSpec(getMeasuredHeight(),
                                    MeasureSpec.EXACTLY), 0);
                }
            }
        }

    }

    private boolean isAttacthedInContentView() {
        View parent = (View) getParent();
        return null != parent
                && (android.R.id.content == parent.getId() && MODE_SLIDE_CONTENT == mSlideMode)
                && (getRootView() == parent && MODE_SLIDE_WINDOW == mSlideMode);
    }

    @Override
    protected void onLayout(boolean changed, int l, int t, int r, int b) {
        final int count = getChildCount();
        final int paddingLeft = getPaddingLeft();
        final int paddingRight = getPaddingRight();
        final int paddingTop = getPaddingTop();
        final int statusBarHeight = mSlideMode == MODE_SLIDE_WINDOW ? STATUS_BAR_HEIGHT
                : 0;
        for (int index = 0; index < count; index++) {
            View child = getChildAt(index);
            final int measureWidth = child.getMeasuredWidth();
            final int measureHeight = child.getMeasuredHeight();
            LayoutParams layoutParams = (LayoutParams) child.getLayoutParams();
            switch (layoutParams.role) {
                case LayoutParams.ROLE_CONTENT:
                    // we should display the content in front of all other views
                    child.bringToFront();
                    child.layout(mCurrentContentOffset + paddingLeft, paddingTop,
                            paddingLeft + measureWidth + mCurrentContentOffset,
                            paddingTop + measureHeight);
                    break;
                case LayoutParams.ROLE_PRIMARY_MENU:
                    mContentBoundsRight = measureWidth;
                    child.layout(paddingLeft, statusBarHeight + paddingTop,
                            paddingLeft + measureWidth, statusBarHeight
                                    + paddingTop + measureHeight);
                    break;
                case LayoutParams.ROLE_SECONDARY_MENU:
                    mContentBoundsLeft = -measureWidth;
                    child.layout(r - l - paddingRight - measureWidth,
                            statusBarHeight + paddingTop, r - l - paddingRight,
                            statusBarHeight + paddingTop + measureHeight);
                    break;
                default:
                    continue;
            }
        }
    }

    /**
     * Detect whether the views inside content are slidable
     */
    protected final boolean canScrollHorizontally(View v, int dx, int x, int y) {
        if (v instanceof ViewGroup) {
            final ViewGroup viewGroup = (ViewGroup) v;
            final int scrollX = v.getScrollX();
            final int scrollY = v.getScrollY();

            final int childCount = viewGroup.getChildCount();
            for (int index = 0; index < childCount; index++) {
                View child = viewGroup.getChildAt(index);
                final int left = child.getLeft();
                final int top = child.getTop();
                if (x + scrollX >= left
                        && x + scrollX < child.getRight()
                        && y + scrollY >= top
                        && y + scrollY < child.getBottom()
                        && View.VISIBLE == child.getVisibility()
                        && (ScrollDetectors.canScrollHorizontal(child, dx) || canScrollHorizontally(
                        child, dx, x + scrollX - left, y + scrollY
                                - top))) {
                    return true;
                }
            }
        }

        return ViewCompat.canScrollHorizontally(v, -dx);
    }

    protected final boolean canScrollVertically(View v, int dy, int x, int y) {
        if (v instanceof ViewGroup) {
            final ViewGroup viewGroup = (ViewGroup) v;
            final int scrollX = v.getScrollX();
            final int scrollY = v.getScrollY();

            final int childCount = viewGroup.getChildCount();
            for (int index = 0; index < childCount; index++) {
                View child = viewGroup.getChildAt(index);
                final int left = child.getLeft();
                final int top = child.getTop();
                if (x + scrollX >= left
                        && x + scrollX < child.getRight()
                        && y + scrollY >= top
                        && y + scrollY < child.getBottom()
                        && View.VISIBLE == child.getVisibility()
                        && (ScrollDetectors.canScrollVertical(child, dy) || canScrollVertically(
                        child, dy, x + scrollX - left, y + scrollY
                                - top))) {
                    return true;
                }
            }
        }

        return ViewCompat.canScrollVertically(v, -dy);
    }

    public float getPrimaryShadowWidth() {
        return mPrimaryShadowWidth;
    }

    public void setPrimaryShadowWidth(float primaryShadowWidth) {
        this.mPrimaryShadowWidth = primaryShadowWidth;
        invalidate();
    }

    public float getSecondaryShadowWidth() {
        return mSecondaryShadowWidth;
    }

    public void setSecondaryShadowWidth(float secondaryShadowWidth) {
        this.mSecondaryShadowWidth = secondaryShadowWidth;
        invalidate();
    }

    @Override
    public void draw(Canvas canvas) {
        super.draw(canvas);
        drawShadow(canvas);
    }

    private void drawShadow(Canvas canvas) {
        if (null == mContent) {
            return;
        }

        final int left = mContent.getLeft();
        final int width = mWidth;
        final int height = mHeight;
        if (null != mPrimaryShadowDrawable) {
            mPrimaryShadowDrawable.setBounds(
                    (int) (left - mPrimaryShadowWidth), 0, left, height);
            mPrimaryShadowDrawable.draw(canvas);
        }

        if (null != mSecondaryShadowDrawable) {
            mSecondaryShadowDrawable.setBounds(left + width, 0, (int) (width
                    + left + mSecondaryShadowWidth), height);
            mSecondaryShadowDrawable.draw(canvas);
        }
    }

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

        if (mIsPendingResolveSlideMode) {
            resolveSlideMode();
        }
    }

    @Override
    public ViewGroup.LayoutParams generateLayoutParams(
            AttributeSet attrs) {
        LayoutParams layoutParams = new LayoutParams(getContext(), attrs);
        return layoutParams;
    }

    @Override
    protected Parcelable onSaveInstanceState() {
        SavedState savedState = new SavedState(super.onSaveInstanceState());
        savedState.primaryShadowWidth = mPrimaryShadowWidth;
        savedState.secondaryShadaryWidth = mSecondaryShadowWidth;
        savedState.slideDirectionFlag = mSlideDirectionFlag;
        savedState.slideMode = mSlideMode;
        savedState.currentState = mCurrentState;
        savedState.currentContentOffset = mCurrentContentOffset;
        return savedState;
    }

    @Override
    protected void onRestoreInstanceState(Parcelable state) {
        SavedState savedState = (SavedState) state;
        super.onRestoreInstanceState(savedState.getSuperState());
        mPrimaryShadowWidth = savedState.primaryShadowWidth;
        mSecondaryShadowWidth = savedState.secondaryShadaryWidth;
        mSlideDirectionFlag = savedState.slideDirectionFlag;
        setSlideMode(savedState.slideMode);
        mCurrentState = savedState.currentState;
        mCurrentContentOffset = savedState.currentContentOffset;

        invalidateMenuState();
        requestLayout();
        invalidate();
    }

    public static class SavedState extends BaseSavedState {
        public float primaryShadowWidth;
        public float secondaryShadaryWidth;
        public int slideDirectionFlag;
        public int slideMode;
        public int currentState;
        public int currentContentOffset;

        SavedState(Parcelable superState) {
            super(superState);
        }

        private SavedState(Parcel in) {
            super(in);
            primaryShadowWidth = in.readFloat();
            secondaryShadaryWidth = in.readFloat();
            slideDirectionFlag = in.readInt();
            slideMode = in.readInt();
            currentState = in.readInt();
            currentContentOffset = in.readInt();
        }

        @Override
        public void writeToParcel(Parcel out, int flags) {
            super.writeToParcel(out, flags);
            out.writeFloat(primaryShadowWidth);
            out.writeFloat(secondaryShadaryWidth);
            out.writeInt(slideDirectionFlag);
            out.writeInt(slideMode);
            out.writeInt(currentState);
            out.writeInt(currentContentOffset);
        }

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

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

    /**
     * Add view role for {@link #SlideMenu}
     *
     * @author Tank
     */
    public static class LayoutParams extends MarginLayoutParams {
        public final static int ROLE_CONTENT = 0;
        public final static int ROLE_PRIMARY_MENU = 1;
        public final static int ROLE_SECONDARY_MENU = 2;

        public int role;

        public LayoutParams(Context context, AttributeSet attrs) {
            super(context, attrs);

            TypedArray a = context.obtainStyledAttributes(attrs,
                    R.styleable.SlideMenu_Layout, 0, 0);

            final int indexCount = a.getIndexCount();
            for (int index = 0; index < indexCount; index++) {
                int attributeIndex = a.getIndex(index);
                if (R.styleable.SlideMenu_Layout_layout_role == attributeIndex) {
                    role = a.getInt(R.styleable.SlideMenu_Layout_layout_role, -1);
                }
            }

            switch (role) {
                // content should match whole SlidingMenu
                case ROLE_CONTENT:
                    width = MATCH_PARENT;
                    height = MATCH_PARENT;
                    break;
                case ROLE_SECONDARY_MENU:
                case ROLE_PRIMARY_MENU:
                    // add your custom layout rule here for menu
                    break;
                default:
                    throw new IllegalArgumentException(
                            "You must specified a layout_role for this view");
            }
            a.recycle();
        }

        public LayoutParams(int width, int height) {
            super(width, height);
        }

        public LayoutParams(int width, int height, int role) {
            super(width, height);
            this.role = role;
        }

        public LayoutParams(ViewGroup.LayoutParams layoutParams) {
            super(layoutParams);

            if (layoutParams instanceof LayoutParams) {
                role = ((LayoutParams) layoutParams).role;
            }
        }
    }

    public interface OnSlideStateChangeListener {
        /**
         * Invoked when slide state change
         *
         * @param slideState {@link SlideMenu#STATE_CLOSE},{@link SlideMenu#STATE_OPEN_LEFT},
         *                   {@link SlideMenu#STATE_OPEN_RIGHT},{@link SlideMenu#STATE_DRAG},
         *                   {@link SlideMenu#STATE_SCROLL}
         */
        void onSlideStateChange(int slideState);

        /**
         * Invoked when slide offset change
         *
         * @param offsetPercent negative means slide left, otherwise slide right
         */
        void onSlideOffsetChange(float offsetPercent);
    }

    public interface OnContentTapListener {
        void onContentTap(SlideMenu slideMenu);
    }
}