import { patternToPath, pathIsMatch, pathToPageName } from 'urlUtils';

import { BaseLog as Log } from 'base-log';
const log = new Log('Route');

let routes = {};
let routesForDeepLink = {};
let routesForNativeLink = {};

let authTypes;
let defaultPath;

// == 初始化配置
export const init = (option) => {
  authTypes = option.authTypes;
  defaultPath = option.defaultPath;
}

// == 是否为默认路由
export const isDefaultRoute = (route) => {
  const path = patternToPath(route.url);
  return path === defaultPath;
}

// == 加载路由配置
export const loadRoute = (route, name) => {
  const pattern = route.url;
  if(routes[pattern]) return routes[pattern];
  routes[pattern] = Object.assign({},route,{ name });
  return routes[pattern];
}

// == 加载deepLink
export const loadDeepLink = (route, name) => {
  const pattern = route.url;
  if(routesForDeepLink[pattern]) return routesForDeepLink[pattern];
  routesForDeepLink[pattern] = {
    name,
    component: route.page,
    segment: pattern
  }
  return routesForDeepLink[pattern];
}

// == 加载原生链接供外部跳转使用
export const loadNativeLink = (route) => {
  const pattern = route.url;
  if(routesForNativeLink[pattern]) return routesForNativeLink[pattern];
  routesForNativeLink[pattern] = route.page;
  return routesForNativeLink[pattern];
}

// == 处理路由子页面
export const handleChildsForRoutes = () => {
  for (let pattern  of Object.keys(routes)) {
    const route = routes[pattern];
    const parent = Object.assign({}, route);
    delete parent.childs;
    if(route.childs){
      for (let i = 0, n = route.childs.length; i < n; i++) {
        let child = route.childs[i];
        const cPattern = child.url;
        if(routes[cPattern]){
          // 每个子路由都挂载上父级配置
          routes[cPattern].parent = Object.assign({},parent, { index:i });
          // 如果子页面组件配置不存在则添加
          if(!child.page){
            routes[pattern].childs[i].page = routes[cPattern].page;
          }
        }else{
          log.warn(`无法为${pattern}匹配到名为${cPattern}的子路由组件`);
        }
      }
    }
  }
}

// == 加载路由
export const load = (routesGroup) => {
  for (let routeGroup of routesGroup) {
    if(Array.isArray(routeGroup)){
      for (let route of routeGroup) {
        const path = route.url;
        const name = pathToPageName(path);
        loadRoute(route, name);
        loadDeepLink(route, name);
        loadNativeLink(route);
      }
    }
  }
  handleChildsForRoutes();
}

/**
 * 获取全部配置（routes、routesForDeepLink、routesForNativeLink）
 * @param type route|deepLink|nativeLink
 * @param isArray
 * @returns {any}
 */
export const getAll = (isArray = false, type = 'route') => {
  let output;
  switch (type){
    case 'deepLink':
      output = routesForDeepLink;
      break;
    case 'nativeLink':
      output = routesForNativeLink;
      break;
    default:
      output = routes;
  }

  if(isArray){
    let arrOutput = [];
    for (let key of Object.keys(output)) {
      arrOutput.push(output[key]);
    }
    return arrOutput;
  }else{
    return output || {};
  }
}

/**
 * 获取单路径路由
 * @param pathOrName 真实路径或页面名称，如/a/b/1
 * @param type route|deepLink|nativeLink
 * @param pattern 路径匹配字符串，如/a/b/:id，默认为path
 */
export const get = (path, type = 'route') => {
  if(typeof path === 'object') return path;
  const allConfig = getAll(false, type);
  const patterns = Object.keys(allConfig);
  const pattern = patterns.filter((key) => {
    return pathIsMatch(path, key);
  })[0];
  return allConfig[pattern];
}

/**
 * 判断是否是page组件
 * @param view
 */
export const isPageComponent = (view) => {
  if(typeof view === 'string'){
    const route = get(view);
    return !!route;
  }else{
    return view && view._cssClass == "ion-page";
  }
}

// == 判断是否是无授权页面
export const isNone = (path) => {
  const route = get(path);
  const auth = authTypes[route.auth] || -1;
  return auth == authTypes.none;
}

// == 判断是否是公共页面
export const isPub = (path) => {
  const route = get(path);
  const auth = authTypes[route.auth];
  return auth == authTypes.pub;
}