package com.xg.navigation.delegates;

import android.app.Activity;
import android.content.Context;
import android.os.Bundle;
import android.support.annotation.IdRes;
import android.support.annotation.NonNull;
import android.support.annotation.Nullable;
import android.support.v4.app.Fragment;
import android.support.v4.app.FragmentActivity;
import android.text.TextUtils;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.view.animation.Animation;

import com.xg.navigation.activities.ProxyActivity;
import com.xg.navigation.constants.NavigationConstants;
import com.xg.navigation.debug.DebugStackManager;
import com.xg.navigation.debug.FragmentLifeCycle;
import com.xg.navigation.util.RxBus;

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

import me.yokeyword.fragmentation.ExtraTransaction;
import me.yokeyword.fragmentation.ISupportFragment;
import me.yokeyword.fragmentation.SupportFragmentDelegate;
import me.yokeyword.fragmentation.anim.FragmentAnimator;

/**
 * 基础的Fragment，封装一些通用的接口，方法，处理一些生命周期监听
 */
public abstract class BaseDelegate extends Fragment implements ISupportFragment{
    private final SupportFragmentDelegate DELEGATE = new SupportFragmentDelegate(this);
    private static final FragmentLifeCycle mLifeCycle = DebugStackManager.getInstance().getFragmentLifeListener();
    private View mRootView = null;
    private String mPagePath;
    public abstract Object setLayout();

    public abstract void onBindView(@Nullable Bundle savedInstanceState, @NonNull View rootView);

    public <T extends View> T $(@IdRes int viewId) {
        if (mRootView != null) {
            return mRootView.findViewById(viewId);
        }
        throw new NullPointerException("rootView is null");
    }

    @Nullable
    @Override
    public View onCreateView(LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {
        if( null != mLifeCycle){
            mLifeCycle.onCreateView(mPagePath);
        }
        Object targetObject = setLayout();

        final View rootView;
        if (targetObject instanceof Integer) {
            rootView = inflater.inflate((int)targetObject, container, false);
        } else if (targetObject instanceof View) {
            rootView = (View) targetObject;
        } else {
            throw new ClassCastException("type of setLayout() mst be int or View!");
        }
        mRootView = rootView;
        onBindView(savedInstanceState, rootView);

        return rootView;
    }

    @Override
    public void onViewCreated(View view, @Nullable Bundle savedInstanceState) {
        super.onViewCreated(view, savedInstanceState);
        //发送创建成功通知
        RxBus.getInstance().post(true);
    }

    protected FragmentActivity _mActivity;

    public final ProxyActivity getProxyActivity() {
        return (ProxyActivity) _mActivity;
    }

    @Override
    public SupportFragmentDelegate getSupportDelegate() {
        return DELEGATE;
    }

    @Override
    public ExtraTransaction extraTransaction() {
        return DELEGATE.extraTransaction();
    }

    @Override
    public void onAttach(Context context) {
        super.onAttach(context);
        DELEGATE.onAttach((Activity) context);
        _mActivity = DELEGATE.getActivity();
        Bundle bundle = getArguments();
        if(null != bundle){
            mPagePath = bundle.getString("pagePath");
        }
        if( null != mLifeCycle){
            mLifeCycle.onAttach(mPagePath);
        }
    }

    @Override
    public void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        DELEGATE.onCreate(savedInstanceState);
        if( null != mLifeCycle){
            mLifeCycle.onCreate(mPagePath);
        }
    }

    @Override
    public Animation onCreateAnimation(int transit, boolean enter, int nextAnim) {
        return DELEGATE.onCreateAnimation(transit, enter, nextAnim);
    }

    @Override
    public void onActivityCreated(@Nullable Bundle savedInstanceState) {
        super.onActivityCreated(savedInstanceState);
        DELEGATE.onActivityCreated(savedInstanceState);
        if( null != mLifeCycle){
            mLifeCycle.onActivityCreated(mPagePath);
        }
    }

    @Override
    public void onSaveInstanceState(Bundle outState) {
        super.onSaveInstanceState(outState);
        DELEGATE.onSaveInstanceState(outState);
    }

    @Override
    public void onResume() {
        super.onResume();
        DELEGATE.onResume();
        if( null != mLifeCycle){
            mLifeCycle.onResume(mPagePath);
        }
    }

    @Override
    public void onDestroyView() {
        DELEGATE.onDestroyView();
        super.onDestroyView();
        if( null != mLifeCycle){
            mLifeCycle.onDestroyView(mPagePath);
        }
    }

    @Override
    public void onDestroy() {
        DELEGATE.onDestroy();
        super.onDestroy();
        if( null != mLifeCycle){
            mLifeCycle.onDestroy(mPagePath);
        }
    }

    @Override
    public void onDetach() {
        super.onDetach();
        if( null != mLifeCycle){
            mLifeCycle.onDetach(mPagePath);
        }
    }

    @Override
    public void onHiddenChanged(boolean hidden) {
        super.onHiddenChanged(hidden);
        DELEGATE.onHiddenChanged(hidden);
    }

    @Override
    public void setUserVisibleHint(boolean isVisibleToUser) {
        super.setUserVisibleHint(isVisibleToUser);
        DELEGATE.setUserVisibleHint(isVisibleToUser);
    }

    @Override
    public void onPause() {
        super.onPause();
        DELEGATE.onPause();
        if( null != mLifeCycle){
            mLifeCycle.onPause(mPagePath);
        }
    }

    @Override
    public void onStop() {
        super.onStop();
        if( null != mLifeCycle){
            mLifeCycle.onStop(mPagePath);
        }
    }

    @Override
    public void onStart() {
        super.onStart();
        if( null != mLifeCycle){
            mLifeCycle.onStart(mPagePath);
        }
    }

    @Override
    public void enqueueAction(Runnable runnable) {
        DELEGATE.enqueueAction(runnable);
    }

    @Override
    public void post(Runnable runnable) {
        DELEGATE.post(runnable);
    }

    @Override
    public void onEnterAnimationEnd(@Nullable Bundle savedInstanceState) {
        DELEGATE.onEnterAnimationEnd(savedInstanceState);
    }

    @Override
    public void onLazyInitView(@Nullable Bundle savedInstanceState) {
        DELEGATE.onLazyInitView(savedInstanceState);
    }

    @Override
    public void onSupportVisible() {
        DELEGATE.onSupportVisible();
    }

    @Override
    public void onSupportInvisible() {
        DELEGATE.onSupportInvisible();
    }

    @Override
    public boolean isSupportVisible() {
        return DELEGATE.isSupportVisible();
    }

    @Override
    public FragmentAnimator onCreateFragmentAnimator() {
        return DELEGATE.onCreateFragmentAnimator();
    }

    @Override
    public FragmentAnimator getFragmentAnimator() {
        return DELEGATE.getFragmentAnimator();
    }

    @Override
    public void setFragmentAnimator(FragmentAnimator fragmentAnimator) {
        DELEGATE.setFragmentAnimator(fragmentAnimator);
    }

    @Override
    public void setFragmentResult(int resultCode, Bundle bundle) {
        DELEGATE.setFragmentResult(resultCode, bundle);
    }

    @Override
    public void onFragmentResult(int requestCode, int resultCode, Bundle data) {
        DELEGATE.onFragmentResult(requestCode, resultCode, data);
    }

    @Override
    public void onNewBundle(Bundle args) {
        DELEGATE.onNewBundle(args);
    }

    @Override
    public void putNewBundle(Bundle newBundle) {
        DELEGATE.putNewBundle(newBundle);
    }

    @Override
    public boolean onBackPressedSupport() {
        return DELEGATE.onBackPressedSupport();
    }

    public void start(ISupportFragment toFragment) {
        if (toFragment == null) {
            return;
        }

        if (!(toFragment instanceof Fragment)) {
            return;
        }

        Bundle params = ((Fragment) toFragment).getArguments();
        ((Fragment) toFragment).setArguments(bindId(params));


        DELEGATE.start(toFragment);
    }

    public Map<String, String> getProps() {
        return new HashMap<>();
    }

    public Map<String, String> getPropsDesc() {
        return new HashMap<>();
    }

    public Map<String, String> getPageDesc() {
        return new HashMap<>();
    }

    public void start(final ISupportFragment toFragment, @LaunchMode int launchMode) {
        if (toFragment == null) {
            return;
        }

        if (!(toFragment instanceof Fragment)) {
            return;
        }

        Bundle params = ((Fragment) toFragment).getArguments();
        ((Fragment) toFragment).setArguments(bindId(params));

        DELEGATE.start(toFragment, launchMode);
    }

    private Bundle bindId(Bundle bundle) {
        if (bundle == null) {
            bundle = new Bundle();
        }
        bundle.putString(NavigationConstants.NativeNavigationId, String.valueOf(Math.random() * 10000000));
        return bundle;
    }

    public Map<String, Object> toMap() {

        HashMap<String, Object> result = new HashMap<>();
        Bundle bundle = getArguments();
        if (bundle == null) {
            return result;
        }

        Set<String> keys = bundle.keySet();
        for (String key: keys) {
            if (TextUtils.isEmpty(key)) {
                continue;
            }
            Object value = bundle.get(key);
            if (value == null) {
                continue;
            }

            result.put(key, value);
        }

        return result;
    }
}