import { Injectable } from '@angular/core';
import { pathToPageName } from '../utils/letter'
import { stringifyUrl as originStringifyUrl, parseUrl, hasHost } from '../utils/url'

const Pages = {};
const Menus = {};
const Routes = {};
const DeepLinks = {};
const NativeLinks = {};

let SConfig:any = {};
let defaultRouteName;
let defaultRoute;

export const Route:any = {};


import { Log } from "../utils/log";
const log = new Log('Route');

Route.init = function (config) {
  SConfig = config;
  defaultRouteName = pathToPageName(SConfig.route.index);
}

// 加载路由进路由数组
Route.load = function (...args) {
  for (let i = 0, n = args.length; i < n; i++) {
    let name, path, route;
    if(Array.isArray(args[i])){
      let routes = args[i];
      for (let j = 0, m = routes.length; j < m; j++) {
        route = routes[j];
        path = route.url;
        name = pathToPageName(path);
        if(name == defaultRouteName) defaultRoute = route;
        Route.loadRoute(name, route);
        Route.loadNativeLink(name, route);
        Route.loadDeepLink(name, route);
      }
    }else{
      //throw new Error('路由格式不对！')
    }
  }

  return Routes;
}

Route.pathToPageName = pathToPageName

// 加载age组件至Pages
Route.loadRoute = (name, route) => {
  if(Routes[name]) return Routes[name];
  Routes[name] = route;
  return Routes[name];
}

// 获取默认路由
Route.getDefaultRoute = () => {
  return defaultRoute;
}

// 登录路由名称
Route.getLoginRouteName = () => {
  return pathToPageName(SConfig.route.login);
}

// 登录路由
Route.getLoginRoute = () => {
  return Routes[Route.getLoginRouteName()];
}

// 获取Route
Route.getRoute = (name) => {
  return Routes[name];
}

// 获取Routes
Route.getRoutes =() => {
  return Routes;
}

// 判断是否是非授权页
Route.isNoneRoute = (route) => {
  return route && route.auth && route.auth == SConfig.auth.none;
}

// 判断是否是公共页面（含非授权页面）
Route.isPubRoute = (route) => {
  return route && route.auth && route.auth <= SConfig.auth.pub;
}

/**
 * 判断是否是Page
 * @param view
 */
Route.isPage = (view) => {
  if(typeof view === 'string'){
    const PageName = pathToPageName(view);
    return !!Pages[PageName];
  }else{
    return view && view._cssClass == "ion-page";
  }
}

// 获取Page
Route.getPage = (name) => {
  return Routes[name].page;
}

/**
 * 获取Pages
 * @param isArray 输出是否为数组形式
 * @returns {any}
 */
Route.getPages = (isArray = false):Array<any> | {} =>{
  if(isArray){
    let PagesArr = [];
    for (let key of Object.keys(Pages)) {
      PagesArr.push(Pages[key]);
    }
    return PagesArr;
  }else{
    return Pages;
  }
}

// 加载deepLink
Route.loadDeepLink = (name, route) => {
  if(DeepLinks[name]) return DeepLinks[name];
  DeepLinks[name] = {
    name,
    component: route.page,
    segment: route.url
  }
  // 设置默认路由，deeplink跳转内页时返回到此页面
  if(defaultRoute) DeepLinks[name].defaultHistory = [defaultRoute.page];
  return DeepLinks[name];
}

// 获取deepLinks
Route.getDeepLinks = (isArray = false) => {
  if(isArray){
    let DeepLinksArr = [];
    for (let key of Object.keys(DeepLinks)) {
      DeepLinksArr.push(DeepLinks[key]);
    }
    return DeepLinksArr;
  }else{
    return DeepLinks;
  }
}

// 加载原生链接供外部跳转使用
Route.loadNativeLink = (name,route) => {
  const key = route.url;
  if(NativeLinks[key]) return NativeLinks[key];
  NativeLinks[key] = route.page;
  return NativeLinks[key];
}

Route.getNativeLinks = () => {
  return NativeLinks;
}

/**
 * 匹配path至Route，遇到/a/b/c/123这样的路径进行递归,
 * 默认只递归到2层，即/a/b/c/123只递归到/a/b
 * @param path
 * @param level
 * @returns {any}
 */
Route.pathToRoute = (path:any,level=2) => {
  if(typeof path !== 'string' || hasHost(path)) return null;
  const name = pathToPageName(path);
  const Routes = Route.getRoutes();
  if(Routes[name]) {
    return Routes[name];
  }else{
    const arr = path.split('/');
    if(arr.length <= level){ // 只递归到2层
      log.info('Routes对象不存在' + name + '路由');
      return null;
    }else{
      arr.pop();
      path = arr.join('/');
      return Route.pathToRoute(path);
    }
  }
}