import {
    NAVTYPE,
    Router,
    totalNextRoute,
    objectAny,
    routeRule,
    reNavMethodRule,
    rewriteMethodToggle,
    navtypeToggle,
    navErrorRule,
    uniBackApiRule,
    uniBackRule,
    navRoute
} from '../options/base'
import {
    queryPageToMap,
    resolveQuery,
    parseQuery
} from './query'
import {
    voidFun,
    paramsToQuery,
    getUniCachePage,
    routesForMapRoute,
    copyData,
    lockDetectWarn,
    getDataType,
    notRouteTo404,
    deepDecodeQuery
} from '../helpers/utils'
import { transitionTo } from './hooks';
import {createFullPath, createToFrom} from '../public/page'
import {HOOKLIST} from './hooks'

export function lockNavjump(
    to:string|totalNextRoute|navRoute,
    router:Router,
    navType:NAVTYPE,
    forceNav?:boolean,
    animation?:uniBackApiRule|uniBackRule
):void{
    lockDetectWarn(router, to, navType, () => {
        if (router.options.platform !== 'h5') {
            router.$lockStatus = true;
        }
        navjump(to as totalNextRoute, router, navType, undefined, forceNav, animation);
    }, animation);
}
export function navjump(
    to:string|totalNextRoute,
    router:Router,
    navType:NAVTYPE,
    nextCall?:{
        from:totalNextRoute;
        next:Function;
    },
    forceNav?:boolean,
    animation?:uniBackApiRule|uniBackRule,
    callHook:boolean|undefined = true
) :void|never|totalNextRoute {
    if (navType === 'back') {
        let level:number = 1;
        if (typeof to === 'string') {
            level = +to;
        } else {
            level = to.delta || 1;
        }
        if (router.options.platform === 'h5') {
            (router.$route as any).go(-level);

            // Fixe  https://github.com/SilurianYang/uni-simple-router/issues/266   2021年6月3日11:14:38
            // @ts-ignore
            const success = (animation || {success: voidFun}).success || voidFun;
            // @ts-ignore
            const complete = (animation || {complete: voidFun}).complete || voidFun;
            success({errMsg: 'navigateBack:ok'});
            complete({errMsg: 'navigateBack:ok'});
            return;
        } else {
            to = backOptionsBuild(router, level, animation);
        }
    }
    const {rule} = queryPageToMap(to, router);
    rule.type = navtypeToggle[navType];
    const toRule = paramsToQuery(router, rule);
    let parseToRule = resolveQuery(toRule as totalNextRoute, router);
    if (router.options.platform === 'h5') {
        if (navType !== 'push') {
            navType = 'replace';
        }
        if (nextCall != null) { // next 管道函数拦截时 直接next即可
            nextCall.next({
                replace: navType !== 'push',
                ...parseToRule
            })
        } else {
            // Fixe  https://github.com/SilurianYang/uni-simple-router/issues/240   2021年3月7日14:45:36
            if (navType === 'push' && Reflect.has(parseToRule, 'events')) {
                if (Reflect.has(parseToRule, 'name')) {
                    throw new Error(`在h5端上使用 'push'、'navigateTo' 跳转时，如果包含 events 不允许使用 name 跳转，因为 name 实现了动态路由。请更换为 path 或者 url 跳转！`);
                } else {
                    uni['navigateTo'](parseToRule, true, voidFun, forceNav);
                }
            } else {
                (router.$route as any)[navType](parseToRule, (parseToRule as totalNextRoute).success || voidFun, (parseToRule as totalNextRoute).fail || voidFun)
            }
        }
    } else {
        let from:totalNextRoute = {path: ''};
        if (nextCall == null) {
            let toRoute = routesForMapRoute(router, parseToRule.path, ['finallyPathMap', 'pathMap']);
            toRoute = notRouteTo404(router, toRoute, parseToRule, navType);
            parseToRule = { ...toRoute, ...{params: {}}, ...parseToRule, ...{path: toRoute.path} }
            from = createToFrom(parseToRule, router);
        } else {
            from = nextCall.from;
        }
        createFullPath(parseToRule, from);
        if (callHook === false) {
            return parseToRule;
        }
        transitionTo(router, parseToRule, from, navType, HOOKLIST, function(
            callOkCb:Function
        ):void {
            uni[navtypeToggle[navType]](parseToRule, true, callOkCb, forceNav);
        })
    }
}

export function backOptionsBuild(
    router:Router,
    level:number,
    animation:uniBackApiRule|uniBackRule|undefined = {},
):totalNextRoute {
    const toRule = createRoute(router, level, undefined, {NAVTYPE: 'back', ...animation});
    const navjumpRule:totalNextRoute = {
        ...animation,
        path: toRule.path,
        query: toRule.query,
        delta: level
    }
    if (getDataType<any>(animation) === '[object Object]') {
        const {animationDuration, animationType} = (animation as uniBackApiRule)
        if (animationDuration != null) {
            navjumpRule.animationDuration = animationDuration;
        }
        if (animationType != null) {
            navjumpRule.animationType = animationType;
        }

        const {from} = (animation as uniBackRule)
        if (from != null) {
            navjumpRule.BACKTYPE = from;
        }
    }
    return navjumpRule;
}

export function forceGuardEach(
    router:Router,
    navType:NAVTYPE|undefined = 'replaceAll',
    forceNav:undefined|boolean = false
):void|never {
    if (router.options.platform === 'h5') {
        throw new Error(`在h5端上使用：forceGuardEach 是无意义的，目前 forceGuardEach 仅支持在非h5端上使用`);
    }
    const currentPage = getUniCachePage<objectAny>(0);
    if (Object.keys(currentPage).length === 0) {
        (router.options.routerErrorEach as (error: navErrorRule, router:Router) => void)({
            type: 3,
            NAVTYPE: navType,
            uniActualData: {},
            level: 0,
            msg: `不存在的页面栈，请确保有足够的页面可用，当前 level:0`
        }, router);
    }
    const {route, options} = currentPage as objectAny;
    lockNavjump({
        path: `/${route}`,
        query: deepDecodeQuery(options || {})
    }, router, navType, forceNav);
}

export function createRoute(
    router:Router,
    level:number|undefined = 0,
    orignRule?:totalNextRoute,
    uniActualData:objectAny|undefined = {},
):routeRule|never {
    const route:routeRule = {
        name: '',
        meta: {},
        path: '',
        fullPath: '',
        NAVTYPE: '',
        query: {},
        params: {},
        BACKTYPE: (orignRule || {BACKTYPE: ''}).BACKTYPE || '' // v2.0.5 +
    };

    if (level === 19970806) { // 首次构建响应式 页面不存在 直接返回
        return route
    }
    if (router.options.platform === 'h5') {
        let vueRoute:totalNextRoute = {path: ''};
        if (orignRule != null) {
            vueRoute = orignRule;
        } else {
            vueRoute = (router.$route as objectAny).currentRoute;
        }
        const matRouteParams = copyData(vueRoute.params as objectAny);
        delete matRouteParams.__id__;
        const toQuery = parseQuery({...matRouteParams, ...copyData(vueRoute.query as objectAny)}, router);
        vueRoute = {...vueRoute, query: toQuery}
        route.path = vueRoute.path;
        route.fullPath = vueRoute.fullPath || '';
        route.query = deepDecodeQuery(vueRoute.query || {});
        route.NAVTYPE = rewriteMethodToggle[vueRoute.type as reNavMethodRule || 'reLaunch'];
    } else {
        let appPage:objectAny = {};
        if (orignRule != null) {
            appPage = {...orignRule, openType: orignRule.type};
        } else {
            const page = getUniCachePage<objectAny>(level);
            if (Object.keys(page).length === 0) {
                const {NAVTYPE: _NAVTYPE, ..._args} = uniActualData;
                const errorMsg:string = `不存在的页面栈，请确保有足够的页面可用，当前 level:${level}`;
                (router.options.routerErrorEach as (error: navErrorRule, router:Router) => void)({
                    type: 3,
                    msg: errorMsg,
                    NAVTYPE: _NAVTYPE,
                    level,
                    uniActualData: _args
                }, router);
                throw new Error(errorMsg);
            }
            // Fixes: https://github.com/SilurianYang/uni-simple-router/issues/196
            const pageOptions:objectAny = (page as objectAny).options || {};
            appPage = {
                ...(page as objectAny).$page || {},
                query: deepDecodeQuery(pageOptions),
                fullPath: decodeURIComponent(((page as objectAny).$page || {}).fullPath || '/' + (page as objectAny).route)
            }
            if (router.options.platform !== 'app-plus') {
                appPage.path = `/${(page as objectAny).route}`
            }
        }
        const openType:reNavMethodRule|'navigateBack' = appPage.openType;
        route.query = appPage.query;
        route.path = appPage.path;
        route.fullPath = appPage.fullPath;
        route.NAVTYPE = rewriteMethodToggle[openType || 'reLaunch'];
    }
    const tableRoute = routesForMapRoute(router, route.path, ['finallyPathMap', 'pathMap'])
    const perfectRoute = { ...route, ...tableRoute};
    perfectRoute.query = parseQuery(perfectRoute.query, router);
    return perfectRoute;
}