/*
 * Copyright (c) Wondertek Technologies Co., Ltd. 2019-2022. All rights reserved.
 */

package com.wd.common.base;

import android.annotation.TargetApi;
import android.app.Activity;
import android.app.Dialog;
import android.content.Context;
import android.os.Build;
import android.os.Bundle;
import android.util.Log;
import android.view.KeyEvent;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.FrameLayout;

import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.fragment.app.Fragment;
import androidx.fragment.app.FragmentManager;
import androidx.lifecycle.ViewModel;
import androidx.lifecycle.ViewModelProviders;

import com.wd.base.log.Logger;
import com.wd.common.dialog.DialogUtils;
import com.wd.common.utils.ToolsUtil;
import com.wd.common.widget.DefaultView;
import com.wd.fastcoding.base.R;
import com.wd.foundation.wdkit.statusbar.StatusBarStyleEnum;

import java.util.List;

/**
 * fragment基类<BR>
 *
 * @author zhangbo
 * @version [V1.0.0, 2021/12/8]
 * @since V1.0.0
 */
public abstract class BaseFragment extends Fragment {
    private boolean isUserVisible = true;

    private boolean isViewCreated = false;

    private Dialog mLoadingDialog;

    protected Activity activity;
    /**
     * true java布局，false xml布局
     */
    private boolean isjava;

    private Activity mActivity;

    FrameLayout layout;

    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
        this.perCreate();
        View rootView;
        if (isjava) {
            rootView = getJavaLayout();
        } else {
            rootView = inflater.inflate(getLayout(), container, false);
        }
        mActivity = getActivity();
        initView(rootView);
        return rootView;
    }

    @Override
    public void onViewCreated(@NonNull View view, @Nullable Bundle savedInstanceState) {
        super.onViewCreated(view, savedInstanceState);
        isViewCreated = true;
    }

    /**
     * 获取指定类型的VM实例<BR>
     * 获取Activity对象的vm
     *
     * @param viewModelClazz VM的类实例
     * @param <T>            VM类型
     * @return VM对象
     */
    protected <T extends ViewModel> T getViewModel(Class<T> viewModelClazz) {
        if (null != getActivity()) {
            return ViewModelProviders.of(getActivity()).get(viewModelClazz);
        } else {
            return ViewModelProviders.of(this).get(viewModelClazz);
        }
    }

    /**
     * 获取指定类型的VM实例<BR>
     * 获取fragment自己的vm
     *
     * @param viewModelClazz VM的类实例
     * @param <T>            VM类型
     * @return VM对象
     */
    protected <T extends ViewModel> T getViewModelThis(Class<T> viewModelClazz) {
        return ViewModelProviders.of(this).get(viewModelClazz);
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        // 在fragment destroy的时候重置isUserVisible
        isUserVisible = true;
    }

    /**
     * 获取日志tag
     *
     * @return 日志tag
     */
    protected abstract String getLogTag();

    /**
     * 获取当前Fragment布局
     *
     * @return 布局文件
     */
    protected abstract int getLayout();

    /**
     * 初始化View<BR>
     * 不要有耗时操作，否则页面加载慢
     *
     * @param rootView 布局根视图
     */
    protected abstract void initView(View rootView);

    /**
     * onKeyDown回调<BR>
     * 需要Activity主动触发
     *
     * @param keyCode 按键类型
     * @param event   按键事件
     * @return 是否消费事件
     */
    public boolean onKeyDown(int keyCode, KeyEvent event) {
        return false;
    }

    /**
     * onKeyUp 回调<BR>
     * 需要Activity主动触发
     *
     * @param keyCode 按键类型
     * @param event   按键事件
     * @return 是否消费事件
     */
    public boolean onKeyUp(int keyCode, KeyEvent event) {
        return false;
    }

    // 标记onResume是否被刚刚调用
    private boolean mResume = false;

    /**
     * 用于判断fragment真实展现，不要用其提供的isVisible()方法
     *
     * @return true 可见 false不可见
     */
    public boolean isRealVisible() {
        return getUserVisibleHint() && mResume;
    }

    @Override
    public void onResume() {
        super.onResume();
        mResume = true;
    }

    @Override
    public void onPause() {
        super.onPause();
        mResume = false;
    }

    @Override
    public void onStop() {
        super.onStop();
        mResume = false;
    }

    /**
     * 判断是否对用户可见
     */
    public boolean isUserVisible() {
        return /* isVisible() */ isAdded() && getUserVisibleHint() && isUserVisible && parentUserVisible(this);
    }

    @Override
    public void setUserVisibleHint(boolean isVisibleToUser) {
        super.setUserVisibleHint(isVisibleToUser);
        if (!isViewCreated) {
            isUserVisible = isVisibleToUser;
            return;
        }

        if (isVisibleToUser) {
            userVisible(false);
        } else {
            userInvisible(false);
        }

        Log.d("BaseFragment", this.getClass().getName());
    }

    /**
     * 判断父Fragment是否可见
     */
    private static boolean parentUserVisible(Fragment fragment) {
        Fragment f = fragment.getParentFragment();
        if (f instanceof BaseFragment) {
            return ((BaseFragment) f).isUserVisible();
        }

        while (f != null) {
            if (!f.isVisible() || !f.getUserVisibleHint()) {
                return false;
            }
            f = f.getParentFragment();
        }

        return true;
    }

    void userVisible(boolean fromActivity) {
        // 父Fragment不可见则不做处理
        if (isUserVisible || (fromActivity && (!getUserVisibleHint() || !parentUserVisible(this)))) {
            return;
        }

        isUserVisible = true;

        FragmentManager fragmentManager;
        try {
            fragmentManager = getChildFragmentManager();
        } catch (Exception e) {
            onUserVisible(fromActivity);
            return;
        }

        List<Fragment> fragments = fragmentManager.getFragments();
        if (fragments == null || fragments.isEmpty()) {
            onUserVisible(fromActivity);
            return;
        }

        for (Fragment f : fragments) {
            /*
             * if (!f.isVisible()) {
             * continue;
             * }
             */

            if (!(f instanceof BaseFragment)) {
                if (f.getUserVisibleHint() || (fromActivity && parentUserVisible(f))) {
                    f.setUserVisibleHint(true);
                }
                continue;
            }

            BaseFragment lazy = (BaseFragment) f;
            // 忽略子fragment中有对用户不可见的fragment
            if (!lazy.getUserVisibleHint()) {
                continue;
            }

            lazy.userVisible(fromActivity);
        }
        onUserVisible(fromActivity);
    }

    void userInvisible(boolean fromActivity) {
        // 已经不可见则无需再调用
        if (!isUserVisible) {
            return;
        }

        isUserVisible = false;

        FragmentManager fragmentManager;
        try {
            fragmentManager = getChildFragmentManager();
        } catch (Exception e) {
            onUserInvisible(getUserVisibleHint(), fromActivity);
            return;
        }

        List<Fragment> fragments = fragmentManager.getFragments();
        if (fragments == null || fragments.isEmpty()) {
            onUserInvisible(getUserVisibleHint(), fromActivity);
            return;
        }

        for (Fragment f : fragments) {
            /*
             * if (!f.isVisible()) {
             * continue;
             * }
             */

            if (!(f instanceof BaseFragment)) {
                f.setUserVisibleHint(false);
                continue;
            }

            BaseFragment lazy = (BaseFragment) f;
            // 忽略子fragment中有对用户不可见的fragment
            if (!lazy.getUserVisibleHint()) {
                continue;
            }

            lazy.userInvisible(fromActivity);
        }
        onUserInvisible(getUserVisibleHint(), fromActivity);
    }

    /**
     * 进入用户可见壮状态
     *
     * @param callFromActivity 是否是从activity层调用
     */
    protected void onUserVisible(boolean callFromActivity) {
        if (getLogTag() == null) {
            Logger.d("onUserVisible");
        } else {
            Logger.t(getLogTag()).d("onUserVisible");
        }
    }

    /**
     * 进入用户不可见状态, app进入后台，或者新的activity被启动时
     *
     * @param userVisibleHint  表示在进入不可见状态时，是否是对用户可见状态，一般情况下在ViewPager里才起作用
     * @param callFromActivity 是否是从activity层调用
     */
    protected void onUserInvisible(boolean userVisibleHint, boolean callFromActivity) {
        if (getLogTag() == null) {
            Logger.d("onUserInvisible");
        } else {
            Logger.t(getLogTag()).d("onUserInvisible");
        }
    }

    /**
     * loading 按返回键loading默认消失
     */
    public void startLoading() {
        startLoading(true);
    }

    /**
     * loading
     * @param allowCancel 按返回键loading是否消失
     */
    protected void startLoading(boolean allowCancel) {
        if (mActivity == null || mActivity.isFinishing() || mActivity.isDestroyed()) {
            return;
        }
        if (mLoadingDialog == null) {
            createLoadingDialog(allowCancel);
        }

        if (mLoadingDialog!=null&&!mLoadingDialog.isShowing()) {
            mLoadingDialog.show();
        }
    }

    protected void stopLoading() {
        if (mActivity == null || mActivity.isFinishing() || mActivity.isDestroyed()) {
            return;
        }
        if (mLoadingDialog != null && mLoadingDialog.isShowing()) {
            mLoadingDialog.dismiss();
        }
    }


    private void createLoadingDialog(boolean allowCancel) {
        mLoadingDialog = DialogUtils.createRequestDialog(mActivity, allowCancel);
    }

    /**
     * 增加空布局
     */
    protected View addEmptyView(int emptyType) {
        return addEmptyView(emptyType,null);
    }
    /**
     * 增加空布局
     *
     * @return
     */
    protected View addEmptyView(int type, DefaultView.RetryClickListener listener) {
        return addEmptyViewWithWeight(type,null,listener);
    }
    /**
     * 增加空布局
     *
     * @return
     */
    protected View addEmptyViewWithWeight(int type,Integer[] weight, DefaultView.RetryClickListener listener) {
        if(getContext() == null){
            return null;
        }
        View emptyView = LayoutInflater.from(getContext()).inflate(R.layout.empty_view_layout, null);
        DefaultView mDefaultView = emptyView.findViewById(R.id.default_view);
        if (listener != null) {
            mDefaultView.setRetryBtnClickListener(listener);
        }
        if(weight == null || weight.length != 2){
            mDefaultView.show(type);
        }else{
            mDefaultView.showWithWeight(type,weight[0],weight[1]);
        }
        return emptyView;
    }


    @SuppressWarnings({"deprecation"})
    @Override
    public void onAttach(@NonNull Activity activity) {
        super.onAttach(activity);
        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
            this.activity = activity;
        }
    }

    @TargetApi(23)
    @Override
    public void onAttach(@NonNull Context context) {
        super.onAttach(context);
        if (context instanceof Activity) {
            this.activity = (Activity) context;
        }
    }

    public void setStatusBarStyle(@NonNull StatusBarStyleEnum statusBarStyle) {
        ToolsUtil.setStatusBarStyle(statusBarStyle, getActivity());
    }

    protected void perCreate() {

    }

    protected View getJavaLayout() {
        return null;
    }

    /**
     * 设置java布局标识
     */
    public void setIsjava(boolean isjava) {
        this.isjava = isjava;
    }


    public void onUserLeaveHint() {

    }

}