package com.wpc.library.widget.TitleBar;

import android.content.Context;
import android.content.res.TypedArray;
import android.util.AttributeSet;
import android.util.Log;
import android.view.Gravity;
import android.view.MotionEvent;
import android.view.View;
import android.view.ViewConfiguration;
import android.view.ViewGroup;
import android.widget.Scroller;
import android.widget.TextView;

import com.wpc.lcjianlibrary.R;

public class MaterialHeaderLayout extends ViewGroup {

    final boolean DEBUG = true;
    final boolean DEBUG_LAYOUT = true;
    final String LOG_TAG = "HeaderLayout";

    ContentHandler mContentHandler;
    HeaderHandler mHeaderHandler;
    MotionEventIndicator mIndicator;

    View mHeaderView;
    View mContent;
    ScrollChecker mScrollChecker;
    int mHeaderId;
    int mContainerId;

    int mHeaderMaxHeight;
    int mHeaderMinHeight;
    int mOriginHeaderMinHeight; // 不带margin的高度，可直接设置

    MotionEvent mLastMoveEvent;
    private boolean mHasSendCancelEvent;
    private boolean mPreventForHorizontal;
    private boolean mDisableWhenHorizontalMove;
    private float mPagingTouchSlop;

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

    public MaterialHeaderLayout(Context context, AttributeSet attrs) {
        this(context, attrs, 0);
    }

    public MaterialHeaderLayout(Context context, AttributeSet attrs, int defStyle) {
        super(context, attrs, defStyle);

        TypedArray arr = context.obtainStyledAttributes(attrs, R.styleable.MaterialHeaderLayout, 0, 0);
        if (arr != null) {

            //mHeaderId = arr.getResourceId(R.styleable.MaterialHeaderLayout_header, mHeaderId);
            mContainerId = arr.getResourceId(R.styleable.MaterialHeaderLayout_content, mContainerId);
            mOriginHeaderMinHeight = arr.getDimensionPixelOffset(R.styleable.MaterialHeaderLayout_minHeight, 0);

            if (DEBUG) {
                Log.d(LOG_TAG, "attr: minHeight: " + mHeaderMinHeight);
            }
            arr.recycle();
        }
        mScrollChecker = new ScrollChecker();
        mIndicator = new MotionEventIndicator();
    }

    @Override
    protected void onFinishInflate() {
        final int childCount = getChildCount();
        if (childCount > 2) {
            throw new IllegalStateException("PtrFrameLayout only can host 2 elements");
        } else if (childCount == 2) {
            if (mHeaderId != 0 && mHeaderView == null) {
                mHeaderView = findViewById(mHeaderId);
            }
            if (mContainerId != 0 && mContent == null) {
                mContent = findViewById(mContainerId);
            }
            // not specify header or content
            if (mContent == null || mHeaderView == null) {

                View child1 = getChildAt(0);
                View child2 = getChildAt(1);
                if (child1 instanceof HeaderHandler) {
                    mHeaderView = child1;
                    mContent = child2;
                } else if (child2 instanceof HeaderHandler) {
                    mHeaderView = child2;
                    mContent = child1;
                } else {
                    // both are not specified
                    if (mContent == null && mHeaderView == null) {
                        mHeaderView = child1;
                        mContent = child2;
                    }
                    // only one is specified
                    else {
                        if (mHeaderView == null) {
                            mHeaderView = mContent == child1 ? child2 : child1;
                        } else {
                            mContent = mHeaderView == child1 ? child2 : child1;
                        }
                    }
                }
            }
        } else if (childCount == 1) {
            mContent = getChildAt(0);
        } else {
            TextView errorView = new TextView(getContext());
            errorView.setClickable(true);
            errorView.setTextColor(0xffff6600);
            errorView.setGravity(Gravity.CENTER);
            errorView.setTextSize(20);
            errorView.setText("The content view in PtrFrameLayout is empty. Do you forget to specify its id in xml layout file?");
            mContent = errorView;
            addView(mContent);
        }
        if (mContent instanceof ContentHandler) {
            mContentHandler = (ContentHandler) mContent;
        }
        if (mHeaderView != null) {
            mHeaderView.bringToFront();
            if (mHeaderView instanceof HeaderHandler) {
                mHeaderHandler = (HeaderHandler) mHeaderView;
            }
        }
        super.onFinishInflate();
    }

/*    void lpTransfer(View view){
        LayoutParams lp = view.getLayoutParams();
        MarginLayoutParams mlp = new MarginLayoutParams(lp.width,lp.height);
    }*/

    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        super.onMeasure(widthMeasureSpec, heightMeasureSpec);
        if (DEBUG && DEBUG_LAYOUT) {
            Log.d(LOG_TAG, String.format("onMeasure frame: width: %s, height: %s, padding: %s %s %s %s",
                    getMeasuredHeight(), getMeasuredWidth(),
                    getPaddingLeft(), getPaddingRight(), getPaddingTop(), getPaddingBottom()));

        }

        if (mHeaderView != null) {
            measureChildWithMargins(mHeaderView, widthMeasureSpec, 0, heightMeasureSpec, 0);
            MarginLayoutParams lp = (MarginLayoutParams) mHeaderView.getLayoutParams();
            mHeaderMaxHeight = mHeaderView.getMeasuredHeight() + lp.topMargin + lp.bottomMargin;
            mHeaderMinHeight = mOriginHeaderMinHeight + lp.topMargin + lp.bottomMargin;
            mIndicator.setHeight(mHeaderMaxHeight, mHeaderMinHeight);
            mIndicator.setCurrentPosIfFirst(mHeaderMaxHeight);
            if (DEBUG && DEBUG_LAYOUT) {
                Log.d(LOG_TAG, String.format("onMeasure, maxHeight: %s, minHeight: %s, margin: %s, %s, %s, %s", mHeaderMaxHeight, mHeaderMinHeight, lp.leftMargin, lp.topMargin, lp.rightMargin, lp.bottomMargin));
            }
            if (mContentHandler != null) {
                mContentHandler.onOffsetCalculated(mHeaderMaxHeight - mHeaderMinHeight);
            }
        }

        if (mContent != null) {
            measureContentView(mContent, widthMeasureSpec, heightMeasureSpec);
            MarginLayoutParams lp = (MarginLayoutParams) mContent.getLayoutParams();
            if (DEBUG && DEBUG_LAYOUT) {
                Log.d(LOG_TAG, String.format("onMeasure content, width: %s, height: %s, margin: %s %s %s %s",
                        getMeasuredWidth(), getMeasuredHeight(),
                        lp.leftMargin, lp.topMargin, lp.rightMargin, lp.bottomMargin));
            }
        }
    }

    private void measureContentView(View child,
                                    int parentWidthMeasureSpec,
                                    int parentHeightMeasureSpec) {
        final MarginLayoutParams lp = (MarginLayoutParams) child.getLayoutParams();

        final int childWidthMeasureSpec = getChildMeasureSpec(parentWidthMeasureSpec,
                getPaddingLeft() + getPaddingRight() + lp.leftMargin + lp.rightMargin, lp.width);
        final int childHeightMeasureSpec = getChildMeasureSpec(parentHeightMeasureSpec,
                getPaddingTop() + getPaddingBottom() + lp.topMargin + mHeaderMinHeight, lp.height);

        child.measure(childWidthMeasureSpec, childHeightMeasureSpec);
    }

    @Override
    protected void onLayout(boolean flag, int i, int j, int k, int l) {
        layoutChildren();
    }

    private void layoutChildren() {
        int offsetY = mIndicator.getCurrentPosY();
        int paddingLeft = getPaddingLeft();
        int paddingTop = getPaddingTop();

        if (mHeaderView != null) {
            MarginLayoutParams lp = (MarginLayoutParams) mHeaderView.getLayoutParams();
            final int left = paddingLeft + lp.leftMargin;
            final int top = paddingTop + lp.topMargin + offsetY - mHeaderMaxHeight;
            final int right = left + mHeaderView.getMeasuredWidth();
            final int bottom = top + mHeaderView.getMeasuredHeight();
            mHeaderView.layout(left, top, right, bottom);
            if (DEBUG && DEBUG_LAYOUT) {
                Log.d(LOG_TAG, String.format("onLayout header: %s %s %s %s", left, top, right, bottom));
            }
        }
        if (mContent != null) {
            MarginLayoutParams lp = (MarginLayoutParams) mContent.getLayoutParams();
            final int left = paddingLeft + lp.leftMargin;
            final int top = paddingTop + lp.topMargin + offsetY;
            final int right = left + mContent.getMeasuredWidth();
            final int bottom = top + mContent.getMeasuredHeight();
            if (DEBUG && DEBUG_LAYOUT) {
                Log.d(LOG_TAG, String.format("onLayout content: %s %s %s %s", left, top, right, bottom));
            }
            mContent.layout(left, top, right, bottom);
        }
    }

    @Override
    public boolean dispatchTouchEvent(MotionEvent e) {
        if (!isEnabled() || mContent == null || mHeaderView == null) {
            return super.dispatchTouchEvent(e);
        }
        int action = e.getAction();
        switch (action) {
            case MotionEvent.ACTION_UP:
            case MotionEvent.ACTION_CANCEL:
                mIndicator.onRelease();
                if (mIndicator.reachMinHeight()) {
                    if (DEBUG) {
                        Log.d(LOG_TAG, "call onRelease when user release");
                    }
                    if (mIndicator.hasMovedAfterPressedDown()) {
                        sendCancelEvent();
                        return true;
                    }
                    return super.dispatchTouchEvent(e);
                } else {
                    return super.dispatchTouchEvent(e);
                }

            case MotionEvent.ACTION_DOWN:
                mHasSendCancelEvent = false;
                mIndicator.onPressDown(e.getX(), e.getY(), e.getEventTime());

                mScrollChecker.abortIfWorking();

                mPreventForHorizontal = false;
                // The cancel event will be sent once the position is moved.
                // So let the event pass to children.
                // fix #93, #102
                super.dispatchTouchEvent(e);
                return true;

            case MotionEvent.ACTION_MOVE:
                mLastMoveEvent = e;
                mIndicator.onMove(e.getX(), e.getY(), e.getEventTime());
                float offsetX = mIndicator.getOffsetX();
                float offsetY = mIndicator.getOffsetY();

                if (mDisableWhenHorizontalMove && !mPreventForHorizontal && (Math.abs(offsetX) > mPagingTouchSlop && Math.abs(offsetX) > Math.abs(offsetY))) {
                    if (mIndicator.reachMinHeight()) {
                        mPreventForHorizontal = true;
                    }
                }
                if (mPreventForHorizontal) {
                    return super.dispatchTouchEvent(e);
                }

                boolean moveDown = offsetY > 0;
                boolean moveUp = !moveDown;
                boolean canMoveUp = !mIndicator.reachMinHeight();

                boolean canMoveDown = mContentHandler != null ? mContentHandler.checkCanDoRefresh(this, mContent, mHeaderView) : DefaultContentHandler.checkContentCanBePulledDown(this, mContent, mHeaderView);

                if (DEBUG) {
                    Log.v(LOG_TAG, String.format("ACTION_MOVE: offsetY:%s, currentPos: %s, moveUp: %s, canMoveUp: %s, moveDown: %s: canMoveDown: %s", offsetY, mIndicator.getCurrentPosY(), moveUp, canMoveUp, moveDown, canMoveDown));
                }

                // disable move when header not reach top
                if (moveDown && !canMoveDown) {
                    return super.dispatchTouchEvent(e);
                }

                if ((moveUp && canMoveUp) || moveDown) {
                    // has reached the top
                    if ((offsetY < 0 && mIndicator.reachMinHeight())) {
                        if (DEBUG) {
                            Log.v(LOG_TAG, String.format("has reached the top"));
                        }
                        return super.dispatchTouchEvent(e);
                    }
                    // has reached the top
                    if ((offsetY > 0 && mIndicator.reachMaxHeight())) {
                        if (DEBUG) {
                            Log.v(LOG_TAG, String.format("has reached the bottom"));
                        }
                        return super.dispatchTouchEvent(e);
                    }

                    Log.v(LOG_TAG, "move pos: " + offsetY + ", speed: " + offsetY / mIndicator.getOffsetTime());
                    if (Math.abs(offsetY / mIndicator.getOffsetTime()) > 2) {
                        if (offsetY > 0) {
                            mScrollChecker.tryToScrollTo(mHeaderMaxHeight, 300);
                        } else {
                            mScrollChecker.tryToScrollTo(mHeaderMinHeight, 300);
                        }
                    } else {
                        movePos(offsetY);
                    }
                    if (Math.abs(offsetY / offsetX) < Math.tan(Math.PI / 6)) {
                        MotionEvent event = MotionEvent.obtain(e);
                        event.setLocation(e.getX(), e.getY() - offsetY);
                        super.dispatchTouchEvent(event);
                    }
                    return true;
                }
                break;
        }
        return super.dispatchTouchEvent(e);
    }

    /**
     * if deltaY > 0, move the content down
     *
     * @param deltaY
     */
    private void movePos(float deltaY) {

        int to = mIndicator.getCurrentPosY() + (int) deltaY;

        // over top
        if (mIndicator.willOverTop(to)) {
            if (DEBUG) {
                Log.e(LOG_TAG, String.format("over top"));
            }
            to = mIndicator.getMinHeight();
        } else if (mIndicator.willOverBottom(to)) {
            if (DEBUG) {
                Log.e(LOG_TAG, String.format("over bottom"));
            }
            to = mIndicator.getMaxHeight();
        }

        mIndicator.setCurrentPos(to);
        int change = to - mIndicator.getLastPosY();
        updatePos(change);
    }

    private void updatePos(int change) {
        if (mHeaderHandler != null)
            mHeaderHandler.onChange(mIndicator.getCurrentPercent(), change);
        if (mContentHandler != null)
            mContentHandler.onChange(mIndicator.getCurrentPercent(), change);
        mHeaderView.offsetTopAndBottom(change);
        mContent.offsetTopAndBottom(change);
        invalidate();
    }

    private void sendCancelEvent() {
        if (DEBUG) {
            Log.d(LOG_TAG, "send cancel event");
        }
        // The ScrollChecker will update position and lead to send cancel event when mLastMoveEvent is null.
        // fix #104, #80, #92
        if (mLastMoveEvent == null) {
            return;
        }
        MotionEvent last = mLastMoveEvent;
        MotionEvent e = MotionEvent.obtain(last.getDownTime(), last.getEventTime() + ViewConfiguration.getLongPressTimeout(), MotionEvent.ACTION_CANCEL, last.getX(), last.getY(), last.getMetaState());
        super.dispatchTouchEvent(e);
    }

    public void setHeaderView(View header) {
        if (mHeaderView != null && header != null && mHeaderView != header) {
            removeView(mHeaderView);
        }
        ViewGroup.LayoutParams lp = header.getLayoutParams();
        if (lp == null) {
            lp = new LayoutParams(-1, -2);
            header.setLayoutParams(lp);
        }
        mHeaderView = header;
        addView(header);
    }

    @Override
    protected boolean checkLayoutParams(ViewGroup.LayoutParams p) {
        return p instanceof LayoutParams;
    }

    @Override
    protected ViewGroup.LayoutParams generateDefaultLayoutParams() {
        return new LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT);
    }

    @Override
    protected ViewGroup.LayoutParams generateLayoutParams(ViewGroup.LayoutParams p) {
        return new LayoutParams(p);
    }

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

    public static class LayoutParams extends MarginLayoutParams {

        public LayoutParams(Context c, AttributeSet attrs) {
            super(c, attrs);
        }

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

        @SuppressWarnings({"unused"})
        public LayoutParams(MarginLayoutParams source) {
            super(source);
        }

        public LayoutParams(ViewGroup.LayoutParams source) {
            super(source);
        }
    }

    class ScrollChecker implements Runnable {

        private int mLastFlingY;
        private Scroller mScroller;
        private boolean mIsRunning = false;
        private int mStart;
        private int mTo;

        public ScrollChecker() {
            mScroller = new Scroller(getContext());
        }

        public void run() {
            boolean finish = !mScroller.computeScrollOffset() || mScroller.isFinished();
            int curY = mScroller.getCurrY();
            int deltaY = curY - mLastFlingY;
            if (DEBUG) {
                if (deltaY != 0) {
                    Log.v(LOG_TAG,
                            String.format("scroll: %s, start: %s, to: %s, currentPos: %s, current :%s, last: %s, delta: %s",
                                    finish, mStart, mTo, mIndicator.getCurrentPosY(), curY, mLastFlingY, deltaY));
                }
            }
            if (!finish) {
                mLastFlingY = curY;
                movePos(deltaY);
                post(this);
            } else {
                finish();
            }
        }

        private void finish() {
            if (DEBUG) {
                Log.v(LOG_TAG, String.format("finish, currentPos:%s", mIndicator.getCurrentPosY()));
            }
            reset();
        }

        private void reset() {
            mIsRunning = false;
            mLastFlingY = 0;
            removeCallbacks(this);
        }

        public void abortIfWorking() {
            if (mIsRunning) {
                if (!mScroller.isFinished()) {
                    mScroller.forceFinished(true);
                }
                reset();
            }
        }

        public void tryToScrollTo(int to, int duration) {
            if (mIndicator.isAlreadyHere(to)) {
                return;
            }
            mStart = mIndicator.getCurrentPosY();
            mTo = to;
            int distance = to - mStart;
            if (DEBUG) {
                Log.d(LOG_TAG, String.format("tryToScrollTo: start: %s, distance:%s, to:%s", mStart, distance, to));
            }
            removeCallbacks(this);

            mLastFlingY = 0;

            // fix #47: Scroller should be reused, https://github.com/liaohuqiu/android-Ultra-Pull-To-Refresh/issues/47
            if (!mScroller.isFinished()) {
                mScroller.forceFinished(true);
            }
            mScroller.startScroll(0, 0, 0, distance, duration);
            post(this);
            mIsRunning = true;
        }
    }
}