package com.wd.player.control;

import android.content.Context;
import android.graphics.drawable.Drawable;
import android.os.Handler;
import android.os.Message;
import android.util.AttributeSet;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.MotionEvent;
import android.view.View;
import android.widget.FrameLayout;
import android.widget.ImageView;
import android.widget.LinearLayout;
import android.widget.RelativeLayout;
import android.widget.SeekBar;
import android.widget.TextView;

import androidx.annotation.Nullable;
import androidx.appcompat.widget.AppCompatSeekBar;
import androidx.constraintlayout.widget.ConstraintLayout;
import androidx.core.content.ContextCompat;

import com.aliyun.player.nativeclass.MediaInfo;
import com.aliyun.svideo.wd.player.R;
import com.wd.common.viewclick.BaseClickListener;
import com.wd.foundation.bean.utils.TimeFormater;
import com.wd.foundation.bean.utils.TimeUtil;
import com.wd.foundation.wdkitcore.tools.ResUtils;
import com.wd.foundation.wdkitcore.tools.StringUtils;
import com.wd.player.interfaces.ViewAction;
import com.wd.player.listener.OnBackClickListener;
import com.wd.player.listener.OnScreenModeClickListener;
import com.wd.player.listener.OnSeekListener;
import com.wd.player.listener.OnShareClickListener;
import com.wd.player.widget.AliyunScreenMode;
import com.wd.player.widget.VideoAndLivePlayerView;

import java.lang.ref.WeakReference;

/**
 * 视频控制层，非直播
 * @author lvjinhui
 */
public class ControlView extends RelativeLayout implements ViewAction {

    private static final String TAG = ControlView.class.getSimpleName();
    private static final int WHAT_HIDE = 0;
    /**
     * 4秒后隐藏
     */
    private static final int DELAY_TIME = 4 * 1000;

    private final HideHandler mHideHandler = new HideHandler(this);

    private ConstraintLayout clControl, clbtmbar;

    private LinearLayout mControlBar;
    /**
     * 返回按钮
     */
    private LinearLayout ll_back;
    /**
     * 返回按钮
     */
    private ImageView iv_back;
    /**
     * 标题
     */
    private TextView mTitlebarText;
    /**
     * 竖屏顶部布局
     */
    private LinearLayout verticalTopLayout;

    /**
     * 竖屏顶部布局
     */
    private LinearLayout verticalTopLayoutReplay;

    /**
     * 竖屏顶部返回按钮
     */
    private ImageView verticalBackImg;
    /**
     * 视频播放状态
     */
    private PlayState mPlayState = PlayState.NotPlaying;
    /**
     * 播放按钮
     */
    private ImageView mPlayStateBtn;

    /**
     * 播放按钮(图文详情小屏用)
     */
    private ImageView mSpecialPlayStateBtn;

    /**
     * 播放按钮背景(图文详情小屏用)
     */
    private ImageView mSpecialPlayStateBtnBg;

    /**
     * 标题，控制条单独控制是否可显示
     */
    private boolean mTitleBarCanShow = true;

    private boolean mControlBarCanShow = true;
    /**
     * 底部控制按钮是否显示
     */
    private boolean mControlBarIsShow = false;
    /**
     * 屏幕方向是否锁定
     */
    private boolean mScreenLocked = false;
    /**
     * 切换大小屏相关
     */
    private AliyunScreenMode mCurrentScreenMode = AliyunScreenMode.Small;
    /**
     * 全屏/小屏按钮
     */
    private ImageView mScreenModeBtn;
    /**
     * 视频信息，info显示用。
     */
    private MediaInfo mAliyunMediaInfo;
    /**
     * 播放的进度
     */
    private int mVideoPosition = 0;
    /**
     * seekbar拖动状态
     */
    private boolean isSeekbarTouching = false;
    /**
     * 视频缓冲进度
     */
    private int mVideoBufferPosition;
    /**
     * 重播布局
     */
    private FrameLayout rePlayRootLayout;
    /**
     * 重播布局-可点击
     */
    private LinearLayout rePlayLayout;
    /**
     * 更多按钮
     */
    private ImageView iv_more;
    /**
     * 底部控制栏
     */
    private LinearLayout mInfoBar;
    /**
     * 当前位置文字
     */
    private TextView mPositionText;
    /**
     * 时长文字
     */
    private TextView mDurationText;
    /**
     * 正常seek进度条
     */
    private AppCompatSeekBar mNormalSeekbar;

    private LinearLayout ll_progress_time;

    private TextView tv_play_progress;

    private TextView tv_play_total_time;

    private RelativeLayout mTitleBar;

    /**
     * 缩放竖屏情况的进度条展示
     */
    private AppCompatSeekBar seekbarZoomVerticalScreen;

    /**
     * 文字直播封面图
     */
    private ImageView ivWallLive;

    // 整个view的显示控制：
    // 不显示的原因。如果是错误的，那么view就都不显示了。
    private HideType mHideType = null;

    // 分享点击监听
    private OnShareClickListener mOnShareClickListener;

    // 各种监听
    // 进度拖动监听
    private OnSeekListener mOnSeekListener;

    // 标题返回按钮监听
    private OnBackClickListener mOnBackClickListener;

    // 播放按钮点击监听
    private OnPlayStateClickListener mOnPlayStateClickListener;

    // 大小屏按钮点击监听
    private OnScreenModeClickListener mOnScreenModeClickListener;

    // 延迟隐藏监听
    private onHideDelayListener mOnHideDelayListener;

    // 原视频时长
    private long mSourceDuration;

    // 播放的数据类型
    private int playResourceType;

    /**
     * 是否监听visible后启动延时隐藏
     */
    private boolean enableVisibleHide = true;

    /**
     * 是否开启自动隐藏
     */
    private boolean isEnableAutoHide;
    private boolean mShareiSShow = true;
    boolean isDetail = false;
    /**
     * 控制是否可以拖动
     */
    private boolean controlCanSeek = true;

    private boolean rePlayShow;

    public ControlView(Context context) {
        super(context);
        init();
    }

    public ControlView(Context context, int playResourceType) {
        super(context);
        this.playResourceType = playResourceType;
        init();
    }

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

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

    private void init() {

        LayoutInflater.from(getContext()).inflate(R.layout.alivc_view_control, this, true);
        findAllViews();
        setViewListener();
        updateAllViews();
        updateSeekBarTheme();
    }

    private void findAllViews() {

        rePlayRootLayout = findViewById(R.id.layout_root_replay);
        rePlayLayout = findViewById(R.id.layout_replay);
        rePlayLayout.setOnClickListener(new OnClickListener() {
            @Override
            public void onClick(View v) {
                setRePlayVisible(false);
                if (mOnPlayStateClickListener != null) {
                    mOnPlayStateClickListener.onPlayStateClick();
                }
                showTitleBar();
            }
        });

        ivWallLive = findViewById(R.id.iv_wall_live);

        verticalTopLayout = findViewById(R.id.layout_top_vertical);
        verticalTopLayoutReplay = findViewById(R.id.layout_top_vertical_replay);
        verticalBackImg = findViewById(R.id.iv_back_vertical);

        mTitleBar = findViewById(R.id.titlebar);
        clControl = findViewById(R.id.cl_control);
        ll_back = findViewById(R.id.ll_back);
        iv_back = findViewById(R.id.iv_back);

        clbtmbar = findViewById(R.id.clbtmbar);
        mControlBar = findViewById(R.id.controlbar);
        mTitlebarText = findViewById(R.id.alivc_title_title);
        iv_more = findViewById(R.id.iv_more);
        mScreenModeBtn = findViewById(R.id.alivc_screen_mode);
        mPlayStateBtn = findViewById(R.id.alivc_player_state);
        mSpecialPlayStateBtn = findViewById(R.id.special_player_state);
        mSpecialPlayStateBtnBg = findViewById(R.id.special_player_state_bg);
        mInfoBar = findViewById(R.id.alivc_info_bar);
        mPositionText = findViewById(R.id.alivc_info_position);
        mDurationText = findViewById(R.id.alivc_info_duration);
        mNormalSeekbar = findViewById(R.id.alivc_info_normal_seekbar);
        ll_progress_time = findViewById(R.id.ll_progress_time);
        tv_play_progress = findViewById(R.id.tv_play_progress);
        tv_play_total_time = findViewById(R.id.tv_play_total_time);
        seekbarZoomVerticalScreen = (AppCompatSeekBar) findViewById(R.id.seekbar_zoom_vertical_screen);
        initTopViewWithChange();
    }

    public ImageView getScreenModeBtn() {
        return mScreenModeBtn;
    }

    /**
     * 设置顶部数据，标签、返回按钮
     */
    private void initTopViewWithChange() {

        showTitleBar();

    }

    /**
     * 是否监听visible后启动延时隐藏
     *
     * @param enableVisibleHide true or false
     */
    public void setEnableVisibleHide(boolean enableVisibleHide) {
        this.enableVisibleHide = enableVisibleHide;
    }

    /**
     * 控制大小屏切换按钮的可见性
     */
    public void setScreenModeBtnVisible(boolean visible) {
        mScreenModeBtn.setVisibility(visible ? View.VISIBLE : View.GONE);

    }

    /**
     * 在小屏时隐藏全屏按钮
     */
    public void hideScreenModeBtnInSmallScreenMode() {
        if (mCurrentScreenMode == AliyunScreenMode.Full) {
            return;
        }
        mScreenModeBtn.setVisibility(View.GONE);
    }


    /**
     * 更多按钮的可见性
     */
    public void setMoreBtnVisible(boolean visible) {
        if (!mShareiSShow) {
            iv_more.setVisibility(View.GONE);
            return;
        }
        iv_more.setVisibility(visible ? View.VISIBLE : View.GONE);
    }

    private void setViewListener() {

        // 标题的返回按钮监听
        iv_back.setOnClickListener(new BaseClickListener() {
            @Override
            public void onNoDoubleClick(View v) {

                // 视频详情页 点击返回按钮
                if (mCurrentScreenMode == AliyunScreenMode.AMPLIFY && playResourceType == VideoAndLivePlayerView.NORMAL) {
                    if (mOnScreenModeClickListener != null) {
                        mOnScreenModeClickListener.onClick();
                    }
                } else {
                    if (mOnBackClickListener != null) {
                        mOnBackClickListener.onClick();
                    }
                }

            }
        });

        verticalBackImg.setOnClickListener(new BaseClickListener() {
            @Override
            public void onNoDoubleClick(View v) {
                if (mOnScreenModeClickListener != null) {
                    mOnScreenModeClickListener.onClick();
                }
            }
        });

        verticalTopLayoutReplay.setOnClickListener(new BaseClickListener() {
            @Override
            public void onNoDoubleClick(View v) {
                if (mOnScreenModeClickListener != null) {
                    mOnScreenModeClickListener.onClick();
                }
            }
        });

        iv_more.setOnClickListener(new BaseClickListener() {
            @Override
            public void onNoDoubleClick(View view) {
                if (mOnShareClickListener != null) {
                    mOnShareClickListener.onShareClick();
                }
            }
        });

        // 控制栏的播放按钮监听
        mPlayStateBtn.setOnClickListener(new BaseClickListener() {
            @Override
            public void onNoDoubleClick(View v) {
                if (mOnPlayStateClickListener != null) {
                    mOnPlayStateClickListener.onPlayStateClick();
                }
            }
        });

        // 控制栏的播放按钮监听
        mSpecialPlayStateBtn.setOnClickListener(new BaseClickListener() {
            @Override
            public void onNoDoubleClick(View v) {
                if (mOnPlayStateClickListener != null) {
                    mOnPlayStateClickListener.onPlayStateClick();
                }
            }
        });

        // 大小屏按钮监听
        mScreenModeBtn.setOnClickListener(new BaseClickListener() {
            @Override
            public void onNoDoubleClick(View v) {
                if (mOnScreenModeClickListener != null) {
                    mOnScreenModeClickListener.onClick();
                }
            }
        });


        // seekbar的滑动监听
        SeekBar.OnSeekBarChangeListener seekBarChangeListener = new SeekBar.OnSeekBarChangeListener() {
            @Override
            public void onProgressChanged(SeekBar seekBar, int progress, boolean fromUser) {

                if (!fromUser) {
                    return;
                }

                Log.i(TAG, "onProgressChanged progress:" + progress);
                // 这里是用户拖动，直接设置文字进度就行，
                // 无需去updateAllViews() ， 因为不影响其他的界面。
                mPositionText.setText(TimeFormater.formatMs(progress));
                if (mOnSeekListener != null) {
                    mOnSeekListener.onProgressChanged(progress);
                }
                seekbarZoomVerticalScreen.setProgress(progress);
                tv_play_progress.setText(TimeFormater.formatMs(progress));
                tv_play_total_time.setText(TimeUtil.getTime(mSourceDuration));
            }

            @Override
            public void onStartTrackingTouch(SeekBar seekBar) {
                Log.i(TAG, "onStartTrackingTouch");
                isSeekbarTouching = true;
                mHideHandler.removeMessages(WHAT_HIDE);
                ll_progress_time.setVisibility(View.VISIBLE);
                // 清屏
                clbtmbar.setVisibility(VISIBLE);
                mControlBar.setVisibility(VISIBLE);
                mControlBarIsShow = false;

                if (mOnSeekListener != null) {
                    mOnSeekListener.onSeekStart(seekBar.getProgress());
                }
            }

            @Override
            public void onStopTrackingTouch(SeekBar seekBar) {
                Log.i(TAG, "onStopTrackingTouch");
                if (mOnSeekListener != null) {
                    mOnSeekListener.onSeekEnd(seekBar.getProgress());
                }
                setPlayState(PlayState.Playing);
                isSeekbarTouching = false;

                ll_progress_time.setVisibility(View.GONE);
                // 恢复
                clbtmbar.setVisibility(VISIBLE);
                mControlBar.setVisibility(View.VISIBLE);
                mControlBarIsShow = true;

                mHideHandler.removeMessages(WHAT_HIDE);
                if (isEnableAutoHide) {
                    mHideHandler.sendEmptyMessageDelayed(WHAT_HIDE, DELAY_TIME);
                }
            }
        };


        // seekbar的滑动监听
        mNormalSeekbar.setOnSeekBarChangeListener(seekBarChangeListener);
        // 增加seekbar垂直方向的滑动和点击区域监听
        setSeekBarParentOnTouchListener();
    }

    private void setSeekBarParentOnTouchListener() {

        //增加seekBar滑动范围
        mNormalSeekbar.setOnTouchListener(new OnTouchListener() {
            @Override
            public boolean onTouch(View v, MotionEvent event) {
                Log.i(TAG, "onTouch event:" + event.getAction());
                v.getParent().requestDisallowInterceptTouchEvent(true);
                return false;
            }
        });
    }


    /**
     * 设置是否显示标题栏。
     *
     * @param show false:不显示
     */
    public void setTitleBarCanShow(boolean show) {
        mTitleBarCanShow = show;
        updateAllTitleBar();
    }


    /**
     * 设置是否显示控制栏
     *
     * @param show fase：不显示
     */
    public void setControlBarCanShow(boolean show) {
        mControlBarCanShow = show;
        updateAllControlBar();
    }

    /**
     * 设置当前屏幕模式：全屏还是小屏
     *
     * @param mode {@link AliyunScreenMode#Small}：小屏. {@link AliyunScreenMode#Full}:全屏
     */
    @Override
    public void setScreenModeStatus(AliyunScreenMode mode) {
        mCurrentScreenMode = mode;
        hideDelayed();
        updateNormalInfoBar();
        updateScreenModeBtn();
        updateTitle();
        setControlBarFull(mCurrentScreenMode);
        if(playResourceType == VideoAndLivePlayerView.DETAIL){
            //图文-竖屏-缩小模式
            if (mCurrentScreenMode == AliyunScreenMode.REDUCE){
                verticalTopLayoutReplay.setVisibility(GONE);
            }
        }
    }

    /**
     * 设置当前的播放状态
     *
     * @param playState 播放状态
     */
    public void setPlayState(PlayState playState) {
        setPlayState(playState, true);
    }

    /**
     * 设置当前的播放状态
     *
     * @param playState 播放状态
     */
    public void setPlayState(PlayState playState, boolean needUpdate) {
        mPlayState = playState;
        if (needUpdate) {
            updatePlayStateBtn();
        }
        showVerticalVideoSeekBar();// 更新竖屏视频小屏模式的进度条
    }

    /**
     * 设置视频信息
     *
     * @param aliyunMediaInfo 媒体信息
     * @param currentQuality  当前清晰度
     */
    public void setMediaInfo(MediaInfo aliyunMediaInfo, String currentQuality) {
        mAliyunMediaInfo = aliyunMediaInfo;
        setPositionTextViewLayoutParams();
    }


    public void setSourceDuration(long sourceDuration) {
        this.mSourceDuration = sourceDuration;
        setPositionTextViewLayoutParams();
    }

    /**
     * 设置PositionTextView宽度
     */
    private void setPositionTextViewLayoutParams() {
        if (mAliyunMediaInfo != null) {
            mSourceDuration = mAliyunMediaInfo.getDuration();
        }
        if (mSourceDuration != 0) {
            mDurationText.setText(TimeFormater.formatMs(mSourceDuration));
            mNormalSeekbar.setMax((int) mSourceDuration);
            seekbarZoomVerticalScreen.setMax((int) mSourceDuration);
            LinearLayout.LayoutParams mLayoutParamsNormal = (LinearLayout.LayoutParams) mPositionText.getLayoutParams();
            if (mSourceDuration > 59 * 60 * 1000) {
                mLayoutParamsNormal.width = (int) getContext().getResources().getDimension(R.dimen.rmrb_dp55);
            } else {
                mLayoutParamsNormal.width = (int) getContext().getResources().getDimension(R.dimen.rmrb_dp36);
            }
            mPositionText.setLayoutParams(mLayoutParamsNormal);
        } else {
            // 时间
            mDurationText.setText(TimeFormater.formatMs(0));
            mNormalSeekbar.setMax(0);
            seekbarZoomVerticalScreen.setMax(0);
        }
    }

    /**
     * 设置视频总时长
     *
     * @param duration 视频时长
     */
    public void setDurationText(String duration) {
        if (mDurationText != null) {
            mDurationText.setText(duration);
        }
    }

    /**
     * 是否锁屏。锁住的话，其他的操作界面将不会显示。
     *
     * @param screenLocked true：锁屏
     */
    public void setScreenLockStatus(boolean screenLocked) {
        mScreenLocked = screenLocked;
        updateAllTitleBar();
        updateAllControlBar();
    }

    /**
     * 更新视频进度
     *
     * @param position 位置，ms
     */
    public void setVideoPosition(int position) {
        mVideoPosition = position;
        updateNormalInfoBar();
    }

    /**
     * 获取视频进度
     *
     * @return 视频进度
     */
    public int getVideoPosition() {
        return mVideoPosition;
    }

    public void updateAllViews() {
        updatePlayStateBtn();// 更新播放状态
        updateNormalInfoBar();// 更新小屏的显示信息
        updateScreenModeBtn();// 更新大小屏信息
        updateAllTitleBar(); // 更新标题显示
        updateAllControlBar();// 更新控制栏显示
        updateTitle();// 更新标题
    }

    /**
     * 更新当前主题色
     */
    private void updateSeekBarTheme() {

        // 获取不同主题的图片
        Drawable mThumb = ContextCompat.getDrawable(getContext(), R.mipmap.player_info_seekbar);
        // 设置到对应控件中
        Drawable normalProgressDrawable = ContextCompat.getDrawable(getContext(), R.drawable.alivc_info_seekbar_bg);
        mNormalSeekbar.setProgressDrawable(normalProgressDrawable);
        mNormalSeekbar.setThumb(mThumb);

        // 设置到对应控件中
        Drawable mThumbDragDrawable = ContextCompat.getDrawable(getContext(), R.drawable.mglayoutnew_max_video_seekbar);

        seekbarZoomVerticalScreen.setProgressDrawable(mThumbDragDrawable);
    }

    /**
     * 更新控制条的显示
     */
    private void updateAllControlBar() {

        // 单独设置可以显示，并且没有锁屏的时候才可以显示
        boolean canShow = mControlBarCanShow && !mScreenLocked;
        if (mControlBar != null) {
            mControlBar.setVisibility(canShow ? View.VISIBLE : View.GONE);
            mControlBarIsShow = canShow;
        }
    }

    /**
     * 更新标题栏的显示
     */
    private void updateAllTitleBar() {

        // 动态视频详情页&&全屏 展示导航栏
        if (playResourceType == VideoAndLivePlayerView.NORMAL && mCurrentScreenMode == AliyunScreenMode.AMPLIFY) {
            showTitleBar();
        } else if (playResourceType == VideoAndLivePlayerView.DETAIL) {
            iv_more.setVisibility(View.GONE);
        }

    }

    /**
     * 更新小屏下的控制条信息
     */
    private void updateNormalInfoBar() {
        if (isSeekbarTouching) {
            // 用户拖动的时候，不去更新进度值，防止跳动。
        } else {
            if (playResourceType != VideoAndLivePlayerView.DETAIL) {
                //图文详情不需要缓冲条
                mNormalSeekbar.setSecondaryProgress(mVideoBufferPosition);
            }
            mNormalSeekbar.setProgress(mVideoPosition);
            seekbarZoomVerticalScreen.setProgress(mVideoPosition);
            mPositionText.setText(TimeFormater.formatMs(mVideoPosition));
        }
        if (mInfoBar.getVisibility() != View.VISIBLE) {
            mInfoBar.setVisibility(View.VISIBLE);
        }
    }

    /**
     * 更新切换大小屏按钮的信息
     */
    private void updateScreenModeBtn() {

        if (mCurrentScreenMode == AliyunScreenMode.Full) {
            mScreenModeBtn.setVisibility(GONE);
            if (playResourceType == VideoAndLivePlayerView.NORMAL) {
                iv_more.setVisibility(GONE);
            }else {
                iv_more.setVisibility(VISIBLE);
            }
        } else if (mCurrentScreenMode == AliyunScreenMode.Small) {
            mScreenModeBtn.setImageResource(R.mipmap.icon_full_screen);
            mScreenModeBtn.setVisibility(VISIBLE);
            iv_more.setVisibility(GONE);
        }
        initTopViewWithChange();
    }

    /**
     * 设置竖屏视频模式
     */
    public void setVerticalVideoScreenMode(AliyunScreenMode mode) {
        mCurrentScreenMode = mode;
        if (mCurrentScreenMode == AliyunScreenMode.AMPLIFY) {
            //放大模式
            mScreenModeBtn.setVisibility(GONE);
        } else {
            mScreenModeBtn.setImageResource(R.mipmap.icon_full_screen);
            mScreenModeBtn.setVisibility(VISIBLE);
        }
        showVerticalVideoSeekBar();
        showTitleBar();
        //底部播放和放大按钮的间距
        setSmallFullScreenUi(mode);
    }

    /**
     * 显示竖屏视频小屏模式进度条
     */
    private void showVerticalVideoSeekBar(){
        if (isDetail){
            return;
        }
        if (mCurrentScreenMode != AliyunScreenMode.REDUCE) {
            //放大模式
            seekbarZoomVerticalScreen.setVisibility(GONE);
        } else {
            if (rePlayShow){
                seekbarZoomVerticalScreen.setVisibility(GONE);
            }else {
                if (mPlayState == PlayState.Playing){
                    seekbarZoomVerticalScreen.setVisibility(VISIBLE);
                }else {
                    seekbarZoomVerticalScreen.setVisibility(GONE);
                }
            }
        }
    }

    /**
     * 显示横屏就不显示竖屏的，两者互斥
     */
    private void showTitleBar(){
        if (mCurrentScreenMode == AliyunScreenMode.AMPLIFY){
            //竖屏-全屏
            verticalTopLayout.setVisibility(VISIBLE);
            mTitleBar.setVisibility(GONE);
        }else if (mCurrentScreenMode == AliyunScreenMode.Full){
            //横屏视频-全屏
            verticalTopLayout.setVisibility(GONE);
            mTitleBar.setVisibility(VISIBLE);
        }else{
            //横屏视频-小屏
            verticalTopLayout.setVisibility(GONE);
            mTitleBar.setVisibility(GONE);
        }
//        hideDelayed();
    }

    /**
     * 动态视频的UI
     */
    private void setSmallFullScreenUi(AliyunScreenMode mode) {
        //竖屏小屏播放按钮和全屏按钮间距
        int dimension = (int) ResUtils.getDimension(R.dimen.rmrb_dp16);
        if (AliyunScreenMode.REDUCE == mode){
            dimension = (int) ResUtils.getDimension(R.dimen.rmrb_dp8);
        }
        LinearLayout.LayoutParams layoutParams = (LinearLayout.LayoutParams) mPlayStateBtn.getLayoutParams();
        layoutParams.leftMargin = dimension;
        LinearLayout.LayoutParams modeBtnLayoutParams = (LinearLayout.LayoutParams) mScreenModeBtn.getLayoutParams();
        modeBtnLayoutParams.rightMargin = dimension;
    }

    /**
     * 更新标题信息的显示和隐藏
     */
    private void updateTitle() {

        if (isDetail) {
            mTitlebarText.setVisibility(GONE);
        } else {
            if (mCurrentScreenMode == AliyunScreenMode.Full) {
                mTitlebarText.setVisibility(VISIBLE);
            } else if (mCurrentScreenMode == AliyunScreenMode.Small) {
                mTitlebarText.setVisibility(GONE);
            }
        }
    }

    /**
     * 更新播放按钮的状态
     */
    private void updatePlayStateBtn() {
        if (mPlayState == PlayState.NotPlaying) {
            if(isSpecialPlayState){
                mSpecialPlayStateBtn.setImageResource(R.mipmap.icon_play_start);
                mSpecialPlayStateBtn.setVisibility(VISIBLE);
                mSpecialPlayStateBtnBg.setVisibility(VISIBLE);
                mPlayStateBtn.setVisibility(INVISIBLE);
            }else {
                mPlayStateBtn.setVisibility(VISIBLE);
            }
            mPlayStateBtn.setImageResource(R.mipmap.icon_play_start);
        } else if (mPlayState == PlayState.Playing) {
            if(isSpecialPlayState){
                mSpecialPlayStateBtn.setVisibility(GONE);
                mSpecialPlayStateBtnBg.setVisibility(GONE);
                mPlayStateBtn.setVisibility(INVISIBLE);
            }else {
                mPlayStateBtn.setVisibility(VISIBLE);
            }
            mPlayStateBtn.setImageResource(R.mipmap.icon_play_pause);
        }
    }

    /**
     * 监听view是否可见。从而实现5秒隐藏的功能
     */
    @Override
    protected void onVisibilityChanged(@Nullable View changedView, int visibility) {
        super.onVisibilityChanged(changedView, visibility);
        if (enableVisibleHide && visibility == VISIBLE) {
            // 如果变为可见了。启动4秒隐藏。
//            hideDelayed();
        }
    }

    public void setHideType(HideType hideType) {
        this.mHideType = hideType;
    }

    /**
     * 开启控制栏自动隐藏
     */
    public void openAutoHide() {
        if (mHideHandler != null) {
            isEnableAutoHide = true;
            hideDelayed();
        }
    }

    /**
     * 关闭控制栏自动隐藏，并且展示控制栏
     */
    public void closeAutoHide() {
        if (mHideHandler != null) {
            isEnableAutoHide = false;
            mHideHandler.removeMessages(WHAT_HIDE);
        }
        show();
    }

    public void setTitle(String title) {
        if (mTitlebarText == null) {
            return;
        }
        mTitlebarText.setText(StringUtils.isBlank(title) ? "" : title);
    }

    public void setPlayResourceType(int playResourceType, boolean isVR) {
        this.playResourceType = playResourceType;
        initTopViewWithChange();
    }

    public void setPlayResourceType(int playResourceType) {
        this.playResourceType = playResourceType;
        initTopViewWithChange();
    }

    /**
     * 隐藏类
     */
    private static class HideHandler extends Handler {

        private final WeakReference<ControlView> controlViewWeakReference;

        public HideHandler(ControlView controlView) {
            controlViewWeakReference = new WeakReference<ControlView>(controlView);
        }

        @Override
        public void handleMessage(Message msg) {

            ControlView controlView = controlViewWeakReference.get();
            if (controlView != null) {
                if (!controlView.isSeekbarTouching) {
                    controlView.hide(HideType.Normal);
                }
                if (controlView.getOnHideDelayListener() != null) {
                    controlView.getOnHideDelayListener().onHide();
                }
            }
            super.handleMessage(msg);
        }
    }

    private void hideDelayed() {
        mHideHandler.removeMessages(WHAT_HIDE);
        mHideHandler.sendEmptyMessageDelayed(WHAT_HIDE, DELAY_TIME);
    }

    /**
     * 隐藏自定义seekBar,展示原生seekBar
     */
    public void showNativeSeekBar() {
        if (mNormalSeekbar != null) {
            mNormalSeekbar.setVisibility(View.VISIBLE);
        }
    }

    /**
     * 重置状态
     */
    @Override
    public void reset() {
        mHideType = null;
        mAliyunMediaInfo = null;
        mVideoPosition = 0;
        mPlayState = PlayState.NotPlaying;
        isSeekbarTouching = false;
        updateAllViews();
    }

    /**
     * 显示画面
     */
    @Override
    public void show() {
        if (rePlayShow) {
            return;
        }
        if (mHideType == HideType.End) {
            // 如果是由于错误引起的隐藏，那就不能再展现了
            hideView(false);
        } else {
            updateAllViews();
            showView();
        }
    }

    /**
     * 设置控制条高度
     * 竖屏横屏
     */
    public void setControlBarFull(AliyunScreenMode mAliyunScreenMode) {
        //底部进度条整体，播放/全屏控制距离
        LinearLayout.LayoutParams layoutParams = (LinearLayout.LayoutParams) mDurationText.getLayoutParams();
        if (AliyunScreenMode.Full == mAliyunScreenMode) {
            //横屏全屏放大
            if (clbtmbar != null) {
                int horizontalPadding = (int) getContext().getResources().getDimension(R.dimen.rmrb_dp24);
                clbtmbar.setPadding(horizontalPadding,0,horizontalPadding,0);
            }
            //总时长距离进度条间距-参考视频详情横屏16dp,进度条有个style间距有8dp,再加8dp就行
            layoutParams.leftMargin = (int) ResUtils.getDimension(R.dimen.rmrb_dp8);
        } else {
            if (clbtmbar != null) {
                if (isDetail){
                    clbtmbar.setPadding(0, 0, 0, 0);
                }else {
                    clbtmbar.setPadding(0, 0, 0, 0);
                }

            }
            //总时长距离进度条间距-参考视频详情横屏8dp,进度条有个style间距有8dp,再加0dp就行
            layoutParams.leftMargin = 0;
        }
        //竖屏小屏播放按钮和全屏按钮间距
        setSmallFullScreenUi(mAliyunScreenMode);

    }


    public void showView() {
        //全屏时显示标题
        if (isDetail) {
            mTitlebarText.setVisibility(GONE);
        } else {
            if (mCurrentScreenMode == AliyunScreenMode.Full) {
                mTitlebarText.setVisibility(VISIBLE);
            } else if (mCurrentScreenMode == AliyunScreenMode.Small) {
                mTitlebarText.setVisibility(GONE);
            }
        }
        mControlBar.setVisibility(mControlBarCanShow ? View.VISIBLE : View.GONE);
        mControlBarIsShow = true;
        //视频要显示播放按钮和进度条
        mPlayStateBtn.setVisibility(View.VISIBLE);
        mInfoBar.setVisibility(View.VISIBLE);

        showTitleBar();
    }

    public void hideView(boolean isRetry) {

        mControlBar.setVisibility(View.INVISIBLE);
        mControlBarIsShow = false;

        if (isRetry) {
            showTitleBar();
        }else {
            verticalTopLayout.setVisibility(GONE);
            mTitleBar.setVisibility(GONE);
            setMoreBtnVisible(false);
        }

    }

    /**
     * 获取底部控制按钮显示状态
     *
     * @return
     */
    public boolean getControlBarIsShow() {
        return mControlBarIsShow;
    }

    public PlayState getPlayState() {
        return mPlayState;
    }

    /**
     * 隐藏画面
     */
    @Override
    public void hide(HideType hideType) {
        if (mHideType != HideType.End) {
            mHideType = hideType;
        }
        hideView(false);
    }

    /**
     * 设置当前缓存的进度，给seekbar显示
     *
     * @param mVideoBufferPosition 进度，ms
     */
    public void setVideoBufferPosition(int mVideoBufferPosition) {
        this.mVideoBufferPosition = mVideoBufferPosition;
        updateNormalInfoBar();
    }

    public void setOnScreenModeClickListener(OnScreenModeClickListener l) {
        this.mOnScreenModeClickListener = l;
    }

    public void setOnBackClickListener(OnBackClickListener l) {
        this.mOnBackClickListener = l;
    }

    public void setOnSeekListener(OnSeekListener onSeekListener) {
        this.mOnSeekListener = onSeekListener;
    }

    public void setOnShareClickListener(OnShareClickListener onShareClickListener) {
        this.mOnShareClickListener = onShareClickListener;
    }

    /**
     * 播放状态枚举
     */
    public enum PlayState {
        // 正在播放
        Playing,
        // 停止播放
        NotPlaying,
    }

    public interface OnPlayStateClickListener {
        /**
         * 播放按钮点击事件
         */
        void onPlayStateClick();
    }

    public void setOnPlayStateClickListener(OnPlayStateClickListener onPlayStateClickListener) {
        mOnPlayStateClickListener = onPlayStateClickListener;
    }

    public interface onHideDelayListener {
        // 触发隐藏监听
        void onHide();
    }

    public void setOnHideDelayListener(onHideDelayListener onHideDelayListener) {
        this.mOnHideDelayListener = onHideDelayListener;
    }

    public onHideDelayListener getOnHideDelayListener() {
        return mOnHideDelayListener;
    }

    /**
     * 分享 view 展示隐藏
     */
    public void setIvMore(boolean isShow) {
        this.mShareiSShow = isShow;
        if (iv_more != null) {
            setMoreBtnVisible(isShow);
        }
    }

    /**
     * 设置重播是否可见
     * @param visible 是否展示重播视图
     */
    public void setRePlayVisible(boolean visible) {

        setSeekbarVisible(!visible);
        setPlayStateBtnVisible(visible);
        // 动态、图文视频&&缩小模式竖屏红色的进度条
        if (playResourceType == VideoAndLivePlayerView.NORMAL){
            if (mCurrentScreenMode == AliyunScreenMode.REDUCE ) {
                setSmallVertical(!visible);
            }
            if (mCurrentScreenMode == AliyunScreenMode.AMPLIFY){
                //竖屏放大模式
                setScreenModeBtnVisible(false);
            }else {
                //横屏视频
                setScreenModeBtnVisible(!visible);
            }
        }else if (playResourceType == VideoAndLivePlayerView.DETAIL){
            //图文
            if (mCurrentScreenMode == AliyunScreenMode.AMPLIFY){
                //竖屏放大模式
                setScreenModeBtnVisible(false);
            }else {
                setScreenModeBtnVisible(!visible);
            }
        }else {
            setScreenModeBtnVisible(!visible);
        }
        rePlayRootLayout.setVisibility(visible ? View.VISIBLE : View.GONE);
        // 播放结束
        if (visible) {
            hideView(true);
        } else {
            showView();
        }

        //竖屏-全屏
        if (mCurrentScreenMode == AliyunScreenMode.AMPLIFY){
            verticalTopLayoutReplay.setVisibility(VISIBLE);
        }else {
            verticalTopLayoutReplay.setVisibility(GONE);
        }

        rePlayShow = visible;
    }

    /**
     * 进度条的可见性
     */
    public void setSeekbarVisible(boolean visible) {
        //竖屏模式
        if (mCurrentScreenMode == AliyunScreenMode.AMPLIFY || mCurrentScreenMode == AliyunScreenMode.REDUCE) {
            mPositionText.setVisibility(visible ? View.VISIBLE : View.GONE);
            mDurationText.setVisibility(visible ? View.VISIBLE : View.GONE);
            // 动态视频&&缩小模式不展示进度时间和总时间
            if (mCurrentScreenMode == AliyunScreenMode.REDUCE && playResourceType == VideoAndLivePlayerView.NORMAL) {
                mPositionText.setVisibility(View.GONE);
                mDurationText.setVisibility(View.GONE);
            }
            if (mCurrentScreenMode == AliyunScreenMode.AMPLIFY) {
                mNormalSeekbar.setVisibility(visible ? View.VISIBLE : View.GONE);
                //两者不同时存在
                if (visible){
                    seekbarZoomVerticalScreen.setVisibility(View.GONE);
                }
            } else {
                if (isDetail){
                    mNormalSeekbar.setVisibility(View.VISIBLE);
                }else {
                    mNormalSeekbar.setVisibility(View.GONE);
                }

            }
            return;
        }

        mNormalSeekbar.setVisibility(visible ? View.VISIBLE : View.INVISIBLE);
        mPositionText.setVisibility(visible ? View.VISIBLE : View.INVISIBLE);
        mDurationText.setVisibility(visible ? View.VISIBLE : View.INVISIBLE);
    }

    /**
     * 竖屏红色的进度条
     * @param visible
     */
    private void setSmallVertical(boolean visible){
        seekbarZoomVerticalScreen.setVisibility(visible ? View.VISIBLE : View.INVISIBLE);
    }

    /**
     * 竖屏的进度条不让拖拽
     *
     * @param control
     */
    public void setControlCanSeek(boolean control) {
        this.controlCanSeek = control;
        if (!controlCanSeek) {
            seekbarZoomVerticalScreen.setClickable(false);
            seekbarZoomVerticalScreen.setEnabled(false);
            seekbarZoomVerticalScreen.setSelected(false);
            seekbarZoomVerticalScreen.setFocusable(false);
        }
    }

    /**
     * 暂停播放按钮的可见性
     * @param visible 是否展示播放视图
     */
    public void setPlayStateBtnVisible(boolean visible) {

        // 小窗播放暂停按钮
        mSpecialPlayStateBtn.setVisibility(GONE);
        mSpecialPlayStateBtnBg.setVisibility(GONE);
        // 重播视图可见 || 小窗 非小窗播放暂停按钮
        if (visible || isSpecialPlayState) {
            mPlayStateBtn.setVisibility(View.INVISIBLE);
        }else {
            mPlayStateBtn.setVisibility(View.VISIBLE);
        }
    }

    /**
     * 是否是小窗
     */
    private boolean isSpecialPlayState = false;

    /**
     * 暂停播放按钮的可见性(特殊暂停按钮，图文小屏用)
     * @param visible 是否是小窗
     */
    public void setSpecialPlayStateBtnVisible(boolean visible) {

        // 是否是小窗
        isSpecialPlayState = visible;
        // 小窗 && 暂停播放，展示播放按钮
        if (visible && mPlayState == PlayState.NotPlaying) {
            // 小窗播放暂停按钮
            mSpecialPlayStateBtn.setVisibility(View.VISIBLE);
            mSpecialPlayStateBtnBg.setVisibility(View.VISIBLE);
        }else {
            mSpecialPlayStateBtn.setVisibility(View.INVISIBLE);
            mSpecialPlayStateBtnBg.setVisibility(View.INVISIBLE);
        }
        // 回放 || 小窗 非小窗播放暂停按钮
        if (rePlayShow || visible) {
            mPlayStateBtn.setVisibility(GONE);
        }else {
            mPlayStateBtn.setVisibility(VISIBLE);
        }
    }

    public void setIsDetail() {
        isDetail = true;
    }

    public void setVerticalVideoFullBtnClick(AliyunScreenMode mode) {
        setScreenModeStatus(mode);
        showTitleBar();
    }


    public void onScreenModeClick() {
        if (mOnScreenModeClickListener != null) {
            mOnScreenModeClickListener.onClick();
        }
    }

}