package com.xg.navigation.util;

import android.app.Activity;
import android.os.Build;
import android.os.Bundle;
import android.support.v4.app.Fragment;
import android.support.v4.app.FragmentationMagician;
import android.text.TextUtils;
import android.util.Log;
import android.view.View;
import android.view.ViewGroup;
import android.widget.LinearLayout;

import com.facebook.react.BuildConfig;
import com.facebook.react.ReactApplication;
import com.facebook.react.ReactInstanceManager;
import com.facebook.react.ReactRootView;
import com.facebook.react.bridge.Arguments;
import com.facebook.react.bridge.ReactContext;
import com.facebook.react.bridge.ReadableMap;
import com.facebook.react.bridge.WritableArray;
import com.facebook.react.bridge.WritableMap;
import com.xg.navigation.AlertDialog;
import com.xg.navigation.CurrentActivityManager;
import com.xg.navigation.JSCallBack;
import com.xg.navigation.NativeNavigationEmitter;
import com.xg.navigation.NavigationActivity;
import com.xg.navigation.NavigationApplication;
import com.xg.navigation.R;
import com.xg.navigation.bridge.BundleConverter;
import com.xg.navigation.constants.NavigationConstants;
import com.xg.navigation.delegates.BaseDelegate;
import com.xg.navigation.delegates.NavigationDelegate;
import com.xg.navigation.delegates.ReactDelegate;
import com.xg.navigation.delegates.bottom.BaseBottomDelegate;
import com.xg.navigation.fragment.NavigationBottomDelegate;
import com.xg.navigation.fragment.ReactFragment;
import com.xg.navigation.fragment.ReactItem;
import com.xg.navigation.fragment.ReactItemContainer;

import java.util.List;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.TimeUnit;

import io.reactivex.Observable;
import io.reactivex.Observer;
import io.reactivex.disposables.Disposable;
import me.yokeyword.fragmentation.ExtraTransaction;
import me.yokeyword.fragmentation.ISupportFragment;
import me.yokeyword.fragmentation.SupportHelper;

public class NavigationUtil {
    private static final String TAG = "NavigationUtil";
    private static final String CALLBACK_ID = "callBackID";
    private static final String PARAMS = "params";
    private static final String CLICK_CALLBACK = "clickCallBack";
    private static final ConcurrentHashMap<String,AlertDialog> alertMap =
            new ConcurrentHashMap<>();

    private static final ConcurrentHashMap<String,View> alertViewMap =
            new ConcurrentHashMap<>();

    private static final ConcurrentHashMap<String,JSCallBack> callBackHashMap =
            new ConcurrentHashMap<>();

    public static void pushWithTransition(ExtraTransaction extraTransaction, String transitionConfig, BaseDelegate baseDelegate,
                                          boolean isAnimated, boolean isPop) {

        if (extraTransaction == null || TextUtils.isEmpty(transitionConfig) || baseDelegate == null) {
            return;
        }

        if (!isAnimated) {
            if (isPop) {
                extraTransaction
                        .setCustomAnimations(R.anim.pop_exit_no_anim, R.anim.pop_exit_no_anim,
                                R.anim.pop_exit_no_anim, R.anim.pop_exit_no_anim)
                        .startWithPop(baseDelegate);
            } else {
                extraTransaction
                        .setCustomAnimations(R.anim.pop_exit_no_anim, R.anim.pop_exit_no_anim,
                                R.anim.pop_exit_no_anim, R.anim.pop_exit_no_anim)
                        .start(baseDelegate);
            }
            return;
        }

        switch (transitionConfig) {
            case NavigationConstants.FROM_RIGHT:
                if (isPop) {
                    extraTransaction
                            .setCustomAnimations(R.anim.h_fragment_enter, R.anim.h_fragment_pop_exit,
                                    R.anim.h_fragment_pop_enter, R.anim.h_fragment_exit)
                            .startWithPop(baseDelegate);
                } else {
                    extraTransaction
                            .setCustomAnimations(R.anim.h_fragment_enter, R.anim.h_fragment_pop_exit,
                                    R.anim.h_fragment_pop_enter, R.anim.h_fragment_exit)
                            .start(baseDelegate);
                }
                break;
            case NavigationConstants.FROM_BOTTOM:
                if (isPop) {
                    extraTransaction
                            .setCustomAnimations(R.anim.v_fragment_enter, R.anim.v_fragment_pop_exit,
                                    R.anim.v_fragment_pop_enter, R.anim.v_fragment_exit)
                            .startWithPop(baseDelegate);
                } else {
                    extraTransaction
                            .setCustomAnimations(R.anim.v_fragment_enter, R.anim.v_fragment_pop_exit,
                                    R.anim.v_fragment_pop_enter, R.anim.v_fragment_exit)
                            .start(baseDelegate);
                }
                break;
            default:
                break;
        }
    }

    public static String getPageType(Fragment fragment) {
        if (fragment == null) {
            return "unknownPageType";
        }

        if (fragment instanceof NavigationBottomDelegate) {
            return NavigationConstants.NATIVE_TAB_PAGE;
        }

        if (fragment instanceof ReactDelegate) {
            return NavigationConstants.JS_PAGE;
        }

        if (fragment instanceof ReactItemContainer) {
            ISupportFragment topChild = SupportHelper.getTopFragment(fragment.getChildFragmentManager());
            if (topChild != null && (topChild instanceof ReactDelegate)) {
                return NavigationConstants.JS_PAGE;
            }
        }

        return NavigationConstants.NATIVE_PAGE;
    }

    public static String getPagePath(Fragment fragment) {

        if (fragment == null) {
            return "unknownPagePath";
        }

        if (!(fragment instanceof ReactItemContainer)) {
            return fragment.getTag();
        }

        ISupportFragment child = SupportHelper.getTopFragment(fragment.getChildFragmentManager());

        if (child == null) {
            return "unknownPagePath";
        }

        if (child instanceof ReactItem) {
            try {
                return (String) ((ReactItem) child).setNavigationParams().get("pagePath");
            } catch (Exception e) {
                String tag = ((ReactItem) child).getTag();
                return tag == null ? "" : tag;
            }
        } else {
            try {
                return ((Fragment) child).getTag();
            } catch (Exception e) {
                return "unknownPagePath";
            }
        }
    }

    /**
     * 仅js端调用：指定uuid对应的fragment是否为baseBottomDelegate的子标签页
     */
    public static Fragment matchTabs(BaseBottomDelegate baseBottomDelegate, String uuid) {
        if (baseBottomDelegate == null || TextUtils.isEmpty(uuid)) {
            return null;
        }
        List<Fragment> fragments = FragmentationMagician.getActiveFragments(baseBottomDelegate.getChildFragmentManager());
        int size = fragments.size();
        for (int i = size - 1; i >= 0; --i) {
            Fragment currentChild = fragments.get(i);
            if (currentChild == null) {
                continue;
            }

            if (!(currentChild instanceof ReactItemContainer)) {
                continue;
            }

            ISupportFragment child = SupportHelper.getTopFragment(currentChild.getChildFragmentManager());
            if (child == null) {
                continue;
            }

            if (!(child instanceof ReactItem)) {
                continue;
            }

            try {
                String childUUID = (String) ((ReactItem) child).setNavigationParams().get("uniqueId");
                if (uuid.equals(childUUID)) {
                    return baseBottomDelegate;
                }
            } catch (Exception ignored) {
            }
        }

        return null;
    }

    public static String getPageUniqueId(Fragment fragment) {
        if (fragment == null) {
            return "";
        }

        if (fragment instanceof NavigationBottomDelegate) {
            try {
                return (String) ((NavigationBottomDelegate) fragment).setNavigationParams().get("uniqueId");
            } catch (Exception e) {
                return "";
            }
        }

        if (fragment instanceof ReactDelegate) {
            try {
                return (String) ((ReactDelegate) fragment).setNavigationParams().get("uniqueId");
            } catch (Exception e) {
                return "";
            }
        }

        if (fragment instanceof ReactItemContainer) {
            ISupportFragment topChild = SupportHelper.getTopFragment(fragment.getChildFragmentManager());
            if (topChild != null && (topChild instanceof ReactDelegate)) {
                try {
                    return (String) ((ReactDelegate) topChild).setNavigationParams().get("uniqueId");
                } catch (Exception e) {
                    return "";
                }
            }
        }

        if (fragment instanceof NavigationDelegate) {
            return ((NavigationDelegate) fragment).getJsId();
        }

        return "";
    }

    /**
     * 跳转到首页
     * @param animated  动画
     */
    public static void popToRoot(boolean animated){
        if (CurrentActivityManager.getInstance().isActivityDestroyed()){
            return;
        }
        NavigationActivity activity = CurrentActivityManager.getInstance().getActivity();
        try {
            List<Fragment> fragments = activity.getFragments();
            int size = fragments.size();
            if (size <= 1) {
                return;
            }

            Fragment iSupportFragment = fragments.get(0);
            if (null != iSupportFragment) {
                if (animated) {
                    activity.getSupportDelegate().extraTransaction().popTo(iSupportFragment.getTag(), false);
                } else {
                    activity.getSupportDelegate()
                            .extraTransaction()
                            .setCustomAnimations(R.anim.pop_exit_no_anim, R.anim.pop_exit_no_anim, R.anim.pop_exit_no_anim, R.anim.pop_exit_no_anim)
                            .popTo(iSupportFragment.getTag(), false);
                }
            }
        } catch (Exception ignored) {
            Log.e(TAG, "popToRoot: ",ignored );
        }
    }

    public static void pop(boolean animated) {
        if (CurrentActivityManager.getInstance().isActivityDestroyed()){
            return;
        }
        final NavigationActivity activity = CurrentActivityManager.getInstance().getActivity();
        if (animated) {
            activity.runOnUiThread(new Runnable() {
                @Override
                public void run() {
                    if (CurrentActivityManager.getInstance().isActivityDestroyed()){
                        return;
                    }
                    activity.invokeDefaultOnBackPressed();
                }
            });
        } else {
            List<Fragment> fragments = activity.getFragments();
            int size = fragments.size();
            activity.invokeDefaultOnBackPressed();
            if(size > 1) {
                activity.extraTransaction()
                        .setCustomAnimations(R.anim.pop_exit_no_anim, R.anim.pop_exit_no_anim, R.anim.pop_exit_no_anim, R.anim.pop_exit_no_anim)
                        .remove((ISupportFragment) fragments.get(size - 1), true);
            }
        }
    }

    public static WritableArray getFragments(){
        if(CurrentActivityManager.getInstance().isActivityDestroyed()){
            return null;
        }
        List<Fragment> fragments = CurrentActivityManager.getInstance().getActivity().getFragments();
        WritableArray writableArray = Arguments.createArray();
        int size = null == fragments ? 0 : fragments.size();

        for (int i = 0; i < size; ++i) {

            Fragment currentFragment = fragments.get(i);

            if (currentFragment == null) {
                continue;
            }

            WritableMap writableMap = Arguments.createMap();
            writableMap.putInt("index", i);
            writableMap.putString("pagePath", getPagePath(currentFragment));
            writableMap.putString("uniqueId", getPageUniqueId(currentFragment));
            writableMap.putString("pageType", getPageType(currentFragment));

            if (currentFragment instanceof NavigationBottomDelegate) {

                WritableArray currentArray = Arguments.createArray();

                List<Fragment> jsBridgeBottomFragments = ((NavigationBottomDelegate) currentFragment).getChildFragments();

                int jsBridgeBottomSize = jsBridgeBottomFragments.size();
                for (int j = 0; j < jsBridgeBottomSize; ++j) {
                    Fragment currentJsBridgeBottomFragment = jsBridgeBottomFragments.get(j);

                    WritableMap jsBridgeWritableMap = Arguments.createMap();
                    jsBridgeWritableMap.putInt("index", j);
                    jsBridgeWritableMap.putString("pagePath", getPagePath(currentJsBridgeBottomFragment));
                    jsBridgeWritableMap.putString("uniqueId", getPageUniqueId(currentJsBridgeBottomFragment));
                    jsBridgeWritableMap.putString("pageType", getPageType(currentJsBridgeBottomFragment));

                    currentArray.pushMap(jsBridgeWritableMap);
                }

                writableMap.putArray("tabs", currentArray);
            }

            writableArray.pushMap(writableMap);
        }
        return writableArray;
    }

    public static void setTabIndex(String uuid,final int newIndex){
        if (TextUtils.isEmpty(uuid)) {
            return;
        }

        if (CurrentActivityManager.getInstance().isActivityDestroyed()){
            return;
        }
        NavigationActivity activity = CurrentActivityManager.getInstance().getActivity();
        List<Fragment> fragments = activity.getFragments();
        final Fragment targetFragment = findFragmentById(fragments, uuid);

        if (targetFragment instanceof NavigationBottomDelegate) {
            activity.runOnUiThread(new Runnable() {
                @Override
                public void run() {
                    ((NavigationBottomDelegate) targetFragment).setNewIndex(newIndex);
                }
            });
        }
    }

    /**
     * js 调 native 桥接
     * @param pageType
     * @param pagePath
     * @param bundle
     * @param transitionConfig
     * @param animated
     * @param isPop
     */
    public static void push(String pageType, String pagePath, Bundle bundle, String transitionConfig, boolean animated, boolean isPop){
        if (TextUtils.isEmpty(pageType) || TextUtils.isEmpty(pagePath)) {
            return;
        }
        if (CurrentActivityManager.getInstance().isActivityDestroyed()){
            return;
        }
        NavigationActivity activity = CurrentActivityManager.getInstance().getActivity();
        BaseDelegate baseDelegate = null;
        switch (pageType) {
            case NavigationConstants.JS_PAGE: {
                baseDelegate = ReactFragment.newInstance(bundle);
                break;
            }
            case NavigationConstants.NATIVE_PAGE: {
                NavigationDelegate targetDelegate;
                try {
                    Class targetClass = Class.forName(pagePath);
                    targetDelegate = (NavigationDelegate) targetClass.newInstance();
                } catch (Exception e) {
                    e.printStackTrace();
                    return;
                }
                if (targetDelegate == null) {
                    return;
                }
                targetDelegate.setArguments(bundle);

                baseDelegate = targetDelegate;
                break;
            }
            case NavigationConstants.NATIVE_TAB_PAGE: {
                baseDelegate = NavigationBottomDelegate.newInstance(bundle);
                break;
            }
        }
        if(null != baseDelegate) {
            ExtraTransaction extraTransaction = activity.extraTransaction()
                    .setTag(pagePath);
            pushWithTransition(extraTransaction, transitionConfig,
                    baseDelegate, animated, isPop);
        }
    }

    /**
     * 从原生跳转页面到Js页面，需要指定 JsCallBack
     *
     * @param pageType
     * @param pagePath
     * @param transitionsConfig
     * @param callBack
     * @param params
     */
    public static void push(String pageType, String pagePath, String transitionsConfig, JSCallBack callBack, String callBackName, Bundle params, boolean animated, boolean isPop) {
        if (TextUtils.isEmpty(pageType) || TextUtils.isEmpty(pagePath)) {
            return;
        }
        if (CurrentActivityManager.getInstance().isActivityDestroyed()){
            return;
        }
        Bundle bundle = new Bundle();
        bundle.putString("pageType", pageType);
        bundle.putString("pagePath", pagePath);
        bundle.putString("uniqueId", UUID.randomUUID().toString());
        bundle.putString("transitionsConfig", transitionsConfig);
        bundle.putBundle("params", params);
        if(null != callBack && !TextUtils.isEmpty(callBackName)) {
            String callBackID = generateJsCallBackId();
            Bundle value = new Bundle();
            value.putString("callBackID", callBackID);
            value.putString("valueType", "function");
            params.putBundle(callBackName, value);
            registerJsCallBack(callBackID, callBack);
        }
        push(pageType,pagePath,bundle,transitionsConfig,animated,isPop);
    }

    public static void push(String pageType, String pagePath, String transitionsConfig, boolean animated, Bundle params){
        push(pageType,pagePath,transitionsConfig,null,"",params,animated,false);
    }

    public static void registerJsCallBack(String callBackID, JSCallBack callBack) {
        callBackHashMap.put(callBackID, callBack);
    }

    public static void unregisterJsCallBack(String callBackID) {
        callBackHashMap.remove(callBackID);
    }

    public static JSCallBack getJsCallBackByID(String callBackID) {
        return callBackHashMap.get(callBackID);
    }

    public static String generateAlertId() {
        return "alertId#" + UUID.randomUUID() + System.nanoTime();
    }

    public static String generateJsCallBackId() {
        return "nativeCallBack#" + UUID.randomUUID() + System.nanoTime();
    }

    public static void pushToJsPage(String path) {
        pushToJsPage(path, true);
    }

    public static void pushToJsPage(String path, boolean animated) {

        pushToJsPage(path, animated, true, null);
    }

    public static void pushToJsPage(String path, boolean animated, boolean isFromRight, Bundle rawBundle) {

        if (TextUtils.isEmpty(path)) {
            return;
        }

        Bundle bundle = rawBundle == null ? (new Bundle()) : rawBundle;
        bundle.putString("uniqueId", UUID.randomUUID().toString());

        if (isFromRight) {
            bundle.putString("transitionsConfig", "FromRight");
        } else {
            bundle.putString("transitionsConfig", "FromBottom");
        }

        bundle.putString("pageType", "JSPage");
        bundle.putString("pagePath", path);
        if (CurrentActivityManager.getInstance().isActivityDestroyed()){
            return;
        }

        ExtraTransaction extraTransaction = CurrentActivityManager.getInstance().getActivity().extraTransaction()
                .setTag(path);
        pushWithTransition(extraTransaction, NavigationConstants.FROM_RIGHT,
                ReactFragment.newInstance(bundle), animated, false);
    }

    /**
     * 弹框显示
     */
    public static void alert(final ReadableMap alertConfig) {
        Log.d("alert", alertConfig.toString());

        final String alertId = alertConfig.hasKey("alertId") ?
                alertConfig.getString("alertId") : generateAlertId();
        String level = alertConfig.getString("level");
        final ReadableMap params = alertConfig.hasKey("params") ? alertConfig.getMap("params") : Arguments.createMap();

        if (CurrentActivityManager.getInstance().isActivityDestroyed()){
            return;
        }

        final NavigationActivity activity = CurrentActivityManager.getInstance().getActivity();

        if (TextUtils.equals(level, "PageLevel")) {
            activity.runOnUiThread(new Runnable() {
                @Override
                public void run() {
                    showPageLevelAlert(alertId, alertConfig, params);
                }
            });
        } else if (TextUtils.equals(level, "NavigationLevel") ||
                TextUtils.equals(level, "WindowLevel")) {
            activity.runOnUiThread(new Runnable() {
                @Override
                public void run() {
                    showWindowLevelAlert(alertId, alertConfig, params);
                }
            });
        }
    }

    public static void showPageLevelAlert(String alertId,ReadableMap alertConfig, ReadableMap params){
        if (CurrentActivityManager.getInstance().isActivityDestroyed()){
            return;
        }
        NavigationActivity activity = CurrentActivityManager.getInstance().getActivity();
        List<Fragment> fragments = activity.getFragments();
        ReadableMap bindRoute = alertConfig.getMap("bindRoute");
        String uuid = bindRoute.getString("uniqueId");
        Fragment toFragment = findFragmentById(fragments, uuid);
        if (toFragment == null) {
            return;
        }
        View view = toFragment.getView();
        if (view != null && view.getParent() != null){
            ReactRootView reactRootView = new ReactRootView(activity);
            ReactInstanceManager reactInstanceManager =
                    ((ReactApplication) activity.getApplication())
                            .getReactNativeHost().getReactInstanceManager();
            LinearLayout linearLayout = new LinearLayout(activity);
            LinearLayout.LayoutParams layoutParams = new LinearLayout.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT);
            reactRootView.setLayoutParams(layoutParams);
            linearLayout.addView(reactRootView);
            ((ViewGroup) view.getParent()).addView(linearLayout, new ViewGroup.LayoutParams(
                    ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT
            ));
            reactRootView.startReactApplication(reactInstanceManager,
                    "alert", BundleConverter.toBundle(alertConfig));
            alertViewMap.put(alertId, linearLayout);
        }else {
            showWindowLevelAlert(alertId, alertConfig, params);
        }
    }

    public static void showWindowLevelAlert(String alertId,ReadableMap alertConfig, ReadableMap params){
        if (CurrentActivityManager.getInstance().isActivityDestroyed()){
            return;
        }
        AlertDialog alertDialog = new AlertDialog(CurrentActivityManager.getInstance().getActivity());
        alertDialog.startReactNativeApplication(BundleConverter.toBundle(alertConfig));
        alertDialog.show();
        System.out.println("alertId add " + alertId);
        alertMap.put(alertId, alertDialog);
    }

    public static void removeAlert(String alertId) {
        if (alertMap.containsKey(alertId)) {
            AlertDialog dialog = alertMap.get(alertId);
            if(null != dialog && !CurrentActivityManager.getInstance().isActivityDestroyed()) {
                dialog.dismiss();
            }
            alertMap.remove(alertId);
        }

        if (alertViewMap.containsKey(alertId)) {
            final View target = alertViewMap.get(alertId);
            final ViewGroup parent = null == target ? null : (ViewGroup) target.getParent();
            if(null != parent) {
                parent.post(new Runnable() {
                    @Override
                    public void run() {
                        if (target instanceof LinearLayout) {
                            View view = ((LinearLayout) target).getChildAt(0);
                            if (view != null && view instanceof ReactRootView) {
                                ((ReactRootView) view).unmountReactApplication();
                            }
                        }
                        parent.removeView(target);
                    }
                });
            }
            alertViewMap.remove(alertId);
        }

    }

    public static Boolean alertIsShow(String alertId) {
        return alertMap.containsKey(alertId) || alertViewMap.containsKey(alertId);
    }

    public static Fragment findFragmentById(List<Fragment> fragments, String uuid) {
        if (fragments == null || TextUtils.isEmpty(uuid)) {
            return null;
        }
        int size = fragments.size();
        for (int i = size - 1; i >= 0; --i) {
            Fragment currentFragment = fragments.get(i);
            if (currentFragment == null) {
                continue;
            }

            if (currentFragment instanceof NavigationBottomDelegate) {
                try {
                    String uniqueId;
                    uniqueId = (String) ((NavigationBottomDelegate) currentFragment).setNavigationParams().get("uniqueId");
                    if (uuid.equals(uniqueId)) {
                        return currentFragment;
                    } else {
                        Fragment isMatchChild = findFragmentById(((BaseBottomDelegate) currentFragment).getChildFragments(), uuid);
                        if (isMatchChild != null) {
                            return currentFragment;
                        }
                    }
                } catch (Exception ignored) {
                    Log.e(TAG, "findFragmentById: ",ignored);
                }
            }

            if (currentFragment instanceof ReactItemContainer) {
                String uniqueId;
                ISupportFragment child = SupportHelper.getTopFragment(currentFragment.getChildFragmentManager());
                if (child instanceof ReactItem) {
                    try {
                        uniqueId = (String) ((ReactItem) child).setNavigationParams().get("uniqueId");
                        if (uuid.equals(uniqueId)) {
                            return currentFragment;
                        }
                    } catch (Exception ignored) {
                        Log.e(TAG, "findFragmentById: ",ignored);
                    }
                }
            }

            if (currentFragment instanceof NavigationDelegate) {
                String uniqueId = ((NavigationDelegate) currentFragment).getJsId();
                if (uuid.equals(uniqueId)) {
                    return currentFragment;
                }
            }

            if (currentFragment instanceof ReactDelegate) {
                try {
                    String uniqueId = (String) ((ReactDelegate) currentFragment).setNavigationParams().get("uniqueId");
                    if (uuid.equals(uniqueId)) {
                        return currentFragment;
                    }
                } catch (Exception ignored) {
                    Log.e(TAG, "findFragmentById: ",ignored);
                }
            }
        }

        return null;
    }


    /**
     * 处理从Js页面跳到Native页面 存在 需要传递回调函数的情况
     *
     * @param bundle
     */
    public static void processToNativeBundle(Bundle bundle) {

        if (bundle != null) {
            try {
                Bundle paramsBundle = bundle.getBundle(PARAMS);
                if (paramsBundle == null) {
                    return;
                }
                Bundle clickCallBackBundle = paramsBundle.getBundle(CLICK_CALLBACK);
                if (clickCallBackBundle == null){
                    return;
                }
                final String callBackID = clickCallBackBundle.getString(CALLBACK_ID);

                /**
                 * 测试使用的代码，延迟5秒弹出一个alert dialog
                 */
                if (BuildConfig.DEBUG) {
                    Observable.timer(5, TimeUnit.SECONDS)
                            .subscribe(new Observer<Long>() {
                                @Override
                                public void onSubscribe(Disposable d) {}

                                @Override
                                public void onNext(Long aLong) {
                                    ReactContext mReactCtx = NavigationApplication.instance.getReactContext();
                                    //mReactInstanceManager.getCurrentReactContext();
                                    WritableMap writableMap = Arguments.createMap();
                                    WritableMap params = Arguments.createMap();
                                    params.putString("xg", "fuck");
                                    writableMap.putMap(PARAMS, params);
                                    writableMap.putString(CALLBACK_ID, callBackID);
                                    NativeNavigationEmitter.sendEvent(mReactCtx, writableMap);
                                }

                                @Override
                                public void onError(Throwable e) {}

                                @Override
                                public void onComplete() {}
                            });
                }
            } catch (Exception e) {
                Log.e(TAG, "processToNativeBundle: ",e);
            }
        }
    }


    public static boolean isActivityDestroyed(Activity activity){
        if (activity != null && activity instanceof NavigationActivity){
            return CurrentActivityManager.getInstance().isActivityDestroyed();
        }
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) {
            return activity == null || activity.isFinishing() || activity.isDestroyed();
        }else {
            return activity == null || activity.isFinishing();
        }
    }
}