'use strict';
import * as utils from 'utils';
/**
 * 将类似/a/b/1?x=1&y=2 解析成 {path:/a/b, params:{id:1,x:1,y:2}}
 * @param url
 * @param pattern
 * @param merge 参数是否合并
 * @returns {*}
 */
export function parseUrl (url, pattern?, merge?):any {
  if(!url) return {};
  var arr = url ? url.split('?') : [];
  var originPath = arr[0];
  var query = parseQuery(arr[1]) || {};
  var pathObj = parsePath(originPath, pattern);
  var path = pathObj.path;
  var params = pathObj.params;
  if(merge){
    return {
      path: path,
      params: Object.assign({}, params, query)
    };
  }else{
    return {
      path: path,
      params: params,
      query: query
    }
  }
}

// 解析路径
// 将类似/a/b/1 解析成 {path:/a/b, params:{id:1}}
export function parsePath (path, pattern?) {
  pattern = pattern || path;
  pattern = pattern.split('?')[0];
  var patternArr = pattern.split('/:');
  var realPath = patternArr.shift();
  var regex = new RegExp(realPath + '(\/)?');
  var paramsPath = path.replace(regex,'');
  var paramsArr = paramsPath && paramsPath != '' ? paramsPath.split('/') : [];
  var params = {};
  for (var i = 0, n = patternArr.length; i < n; i++) {
    if(paramsArr[i]){
      var key = patternArr[i];
      params[key] = paramsArr[i];
    }
  }
  return {
    path: realPath,
    params: params
  };
}

// 解析查询字符串
export function parseQuery (query)  {
  if(!query) return {};
  query = query.replace('?','');
  var queryArr = query ? query.split('&') : [];
  var params = {};
  for (var i = 0, n = queryArr.length; i < n; i++) {
    var arr = queryArr[i].split('=');
    if(arr.length > 0){
      var key = decodeURIComponent(arr.shift());
      var value = decodeURIComponent(arr.join('=')); // 参数如果带=，在这里加上去
      params[key] = value;
    }
  }
  return params;
}

// 将类似/a/b {x:1}, /a/b/1 {y:2}这样的配置拼接为url
export function stringifyUrl (url, params, pattern?) {
  var urlObj = parseUrl(url, pattern); // 剔除参数，只留纯路径
  var path = urlObj.path;
  params = Object.assign({}, params, urlObj.params);
  if(pattern && pattern.indexOf('/:') > -1){
    var match = pattern.match(/\/:(.*)/);
    if(match){
      var key = match[1];
      var value = params[key];
      // 如果params有匹配的参数，则路径添加这个参数，并且从params中删除
      if(value || value == 0) {
        delete params[key];
        path = pattern.replace(':' + key, value);// 匹配到/:然后进行替换
      }
    }
  }
  var query = stringifyQuery(params, false);
  return path + query;
}

/**
 * 拼接query值
 * @param params 参数
 * @param isAdd 是否追加，即使用?续接还是&续接
 * @returns {string}
 */
export function stringifyQuery (params, isAdd?)  {
  var query = '';
  for (var key in params) {
    var value = params[key];
    if(value || value == 0) {
      key = encodeURIComponent(key);
      value = encodeURIComponent(value);
      query += ('&' + key + '=' + value);
    }
  }
  return isAdd ? query : query.replace(/&/,'?');
}

/**
 * 是否匹配
 * @param path
 * @param pattern
 * @param onlyRealPath 是否只匹配纯路径，忽略query参数匹配，即/a/b与/a/b/:id也匹配
 */
export function pathIsMatch (path, pattern, onlyRealPath?) {
  path = path.split('?')[0];
  pattern = pattern.split('?')[0];
  const patternArr = pattern.split('/:');
  const realPath = patternArr.shift();
  const regex = new RegExp(realPath + '(\/)?');
  const paramsStr = path.replace(regex,'');
  const hasParamsStr = paramsStr && paramsStr !== '';
  const paramsArr = hasParamsStr ? paramsStr.split('/') : [];
  if(onlyRealPath && !hasParamsStr){
    return true;
  }else{
    return patternArr.length == paramsArr.length;
  }
}

// url是否带有host
export function hasHost (url) {
  return url.indexOf('https') >- 1 || url.indexOf('http') >- 1;
}

export function patternToPath (pattern) {
  return pattern.split('/:')[0];
}

/**
 * 将类似/home/index/:id转化为HomeIndexPage
 * @param path 路由配置里的路径,类似/home/index/:id
 */
export function pathToPageName (path: string, suffix:string = 'Page') {
  // 隔离/:id类似的情况
  let tempArr = path ? path.split('/:') : [];
  if(tempArr.length > 1) tempArr.pop(); // 移除/:XX后的字符
  path = tempArr.join('');

  tempArr = path.split('?'); // 移除查询字符串
  if(tempArr.length > 1) tempArr.pop();
  path = tempArr.join('');

  if(path.indexOf('/') >-1 ) {
    return utils.letter.pathToCamelCase(path) + suffix;
  }else if(path.indexOf(suffix) === -1){
    return path + suffix;
  }else{
    return path;
  }
}