import BaseFunc from "../base/func";
import BaseSupport from "../base/support";

import { IbaseFaceObject } from "../aim/face";
import { NavigationActions, NavigationNavigateAction } from 'react-navigation'




class CurlInfo {

    pageName: string = ''

    pageUrl: string = ''

    /**
     * 字段编号
     * 
     * @type {string}
     * @memberOf CurlInfo
     */
    baseKey: string

    /**
     * 操作类型
     * 
     * @type {string}
     * @memberOf CurlInfo
     */
    baseType: string
    /**
     * 跳转类型 取值push reset
     * 
     * @type {string}
     * @memberOf CurlInfo
     */
    baseJump: string
    /**
     * 基础父数据编号
     * 
     * @type {string}
     * @memberof CurlInfo
     */
    baseLeader: string
    /**
     * 展示类型标记 该标记优先级高于baseType的定义
     * 
     * @type {string}
     * @memberof CurlInfo
     */
    baseShow: string


    /**
     * 操作父页面的编号
     * 
     * @type {string}
     * @memberOf CurlInfo
     */
    baseField: string

    formParam: IbaseFaceObject = {}

    stateParam: IbaseFaceObject = {}

    parentParam: IbaseFaceObject = {}

    otherParam: IbaseFaceObject = {}

    paramSource: IbaseFaceObject = {}

}

let sTemplateUrl = '';

let oPageNavTemp = null;
let oPageRouteTemp = null;

export default class PlusOperatePage {


    static pageNavInit(navigator, RouteStack) {
        oPageNavTemp = navigator;
        oPageRouteTemp = RouteStack;
    }


    static pageNaviger(that, sPageUrl: string, oConfig?) {



        let urlInfo = this.upUrlInfo(sPageUrl);



        //reactnavigation的跳转

        if (that && that.props && that.props.navigation) {
            oPageNavTemp = that.props.navigation;

        }
        else if (that && that.navigation) {
            oPageNavTemp = that.navigation;
        }




        if (urlInfo.baseJump === "reset") {
            const resetAction = NavigationActions.reset({
                index: 0,
                actions: [
                    NavigationActions.navigate({ routeName: urlInfo.pageName, params: { url: sPageUrl } })
                ]
            })

            oPageNavTemp.dispatch(resetAction)


        }
        else if (urlInfo.baseJump === "replace") {

            let aAction = {
                type: 'CustomNav/replace',
                routeName: urlInfo.pageName,
                params: { url: sPageUrl }

            }



            oPageNavTemp.dispatch(aAction);

        } else if (urlInfo.baseJump == "back") {

            oPageNavTemp.goBack();

        }
        else {
            //if (sTemplateUrl !== sPageUrl) {
            sTemplateUrl = sPageUrl;
            oPageNavTemp.navigate(urlInfo.pageName, { url: sPageUrl });
            //}
        }



        /*
        let navigate = null;
        if (that.hasOwnProperty("navigate")) {
            navigate = that;
        } else {
            navigate = that.props.navigation;
        }

        navigate.setState({ params: { url: sPageUrl } });
        */
        //navigate.navigate(urlInfo.pageName, urlInfo);
        //oPageNavTemp.jump();
        /*
        if (urlInfo.baseJump === "reset") {
            oPageNavTemp.resetTo(oPageRouteTemp[urlInfo.pageName]);
        }
        else if (urlInfo.baseJump === "replace") {
            oPageNavTemp.replace(oPageRouteTemp[urlInfo.pageName]);
        } else if (urlInfo.baseJump == "back") {
            oPageNavTemp.pop();
        } else {
            oPageNavTemp.push(oPageRouteTemp[urlInfo.pageName]);
        }
        */

    }



    static onChangeUrl(oParams) {

        if (oParams != undefined && oParams.url) {
            sTemplateUrl = oParams.url;
        }

    }




    static upUrlInfo(sPageUrl?: string, that?): CurlInfo {

        //如果spageURl没定义 则取临时值
        if (sPageUrl == undefined) {

            if (that && that.props && that.props.navigation && that.props.navigation.state.params) {

                sPageUrl = that.props.navigation.state.params.url;



            }
            else if (that && that.navigation) {
                //oPageNavTemp = that.navigation;
                sPageUrl = that.navigation.state.params.url;
            } else {
                sPageUrl = sTemplateUrl;
            }


            //sPageUrl = oPageNavTemp.state.params.url;
            //sPageUrl = sTemplateUrl;
        }



        let urlInfo = new CurlInfo();

        urlInfo.pageUrl = sPageUrl;

        if (sPageUrl != undefined && sPageUrl.indexOf('?') > -1) {
            urlInfo.pageName = sPageUrl.split('?')[0];

            let sParm = sPageUrl.substr(urlInfo.pageName.length + 1);

            sParm.split('&').forEach((fItem) => {

                if (!BaseFunc.stringIsEmpty(fItem)) {

                    let sKey = fItem.split('=')[0];
                    let sValue = fItem.substr(sKey.length + 1);

                    if (!BaseFunc.stringIsEmpty(sKey) && !BaseFunc.stringIsEmpty(sValue)) {



                        let sStart = sKey.split('_')[0];
                        let sEnd = sKey.substr(sStart.length + 1);

                        if (!BaseFunc.stringIsEmpty(sStart) && !BaseFunc.stringIsEmpty(sEnd)) {
                            if (sStart === "base") {
                                switch (sEnd) {
                                    case "key":
                                        urlInfo.baseKey = sValue;
                                        break;
                                    case "type":
                                        urlInfo.baseType = sValue;
                                        break;
                                    case "jump":
                                        urlInfo.baseJump = sValue;
                                        break;
                                    case "field":
                                        urlInfo.baseField = sValue;
                                        break;
                                    case "show":
                                        urlInfo.baseShow = sValue;
                                        break;
                                    case "leader":
                                        urlInfo.baseLeader = sValue;
                                        break;
                                    default:
                                        urlInfo.otherParam[sKey] = sValue;
                                        break;
                                }

                            }
                            else if (sStart === "form") {
                                urlInfo.formParam[sEnd] = sValue;
                            } else if (sStart === "state") {
                                urlInfo.stateParam[sEnd] = sValue;
                            }
                            else if (sStart === "parent") {
                                urlInfo.parentParam[sEnd] = sValue;
                            }
                            else {
                                urlInfo.otherParam[sKey] = sValue;
                            }
                        } else {
                            urlInfo.otherParam[sKey] = sValue;
                        }






                        urlInfo.paramSource[sKey] = sValue;
                    }

                }

            });


        }
        else {
            urlInfo.pageName = sPageUrl;
        }


        return urlInfo;
    }



    /**
     * 获取导航的参数
     * 
     * @static
     * @param {any} that 
     * @param {any} sPropName 
     * @returns 
     */
    static upNavigerValue(that, sPropName) {

        /*
        const { params } = that.props.navigation.state;

        let sReturn = null;

        if (params != undefined && params[sPropName] != undefined) {
            sReturn = params[sPropName];
        }

        return sReturn;
        */
        return sTemplateUrl;

    }

    /**
     * 延迟加载页面显示
     * 
     * @static
     * @param {any} that 
     */
    static asyncShowPage(that) {
        that.rootAsyncShow();
    }

    /**
     * 导航设置加载
     * 
     * @static
     * @param {any} defaultGetStateForAction 
     * @returns 
     * 
     * @memberof PlusOperatePage
     */
    static upNavAction(defaultGetStateForAction) {
        return (action, state) => {

            PlusOperatePage.onChangeUrl(action.params);

            if (state && action.type === 'CustomNav/replace') {

                const routes = [
                    ...state.routes
                ];

                routes[routes.length - 1] = { key: action.routeName, routeName: action.routeName, params: action.params };


                return {
                    ...state,
                    routes,
                    index: routes.length - 1,
                };
            }
            return defaultGetStateForAction(action, state);
        }
    }


}