Matcher

export interface RouterMatcher {
  addRoute: (record: RouteRecordRaw, parent?: RouteRecordMatcher) => () => void
  removeRoute: {
    (matcher: RouteRecordMatcher): void
    (name: RouteRecordName): void
  }
  getRoutes: () => RouteRecordMatcher[]
  getRecordMatcher: (name: RouteRecordName) => RouteRecordMatcher | undefined

  /**
   * @param location - MatcherLocationRaw to resolve to a url
   * @param currentLocation - MatcherLocation of the current location
   */
  resolve: (
    location: MatcherLocationRaw,
    currentLocation: MatcherLocation
  ) => MatcherLocation
}

/**
 * 添加路由记录
 * @param record 路由配置
 * @param parent 父级路由匹配器
 * @param originalRecord 原始匹配器
 */
function addRoute(record: RouteRecordRaw, parent?: RouteRecordMatcher, originalRecord?: RouteRecordMatcher) {
  const isRootAdd = !originalRecord
  // 调用 normalizeRouteRecord 标准化路由配置
  const mainNormalizedRecord = normalizeRouteRecord(record)
  if (__DEV__) {
    checkChildMissingNameWithEmptyPath(mainNormalizedRecord, parent)
  }
  mainNormalizedRecord.aliasOf = originalRecord && originalRecord.record
  const options: PathParserOptions = mergeOptions(globalOptions, record)

  const normalizedRecords: (typeof mainNormalizedRecord)[] = [mainNormalizedRecord]
  // 处理 record 的 alias 生成 normalizedRecords
  if ('alias' in record) {
    const aliases = typeof record.alias === 'string' ? [record.alias] : record.alias!
    for (const alias of aliases) {
      normalizedRecords.push(assign({}, mainNormalizedRecord, {
          components: originalRecord ? originalRecord.record.components : mainNormalizedRecord.components,
          path: alias,
          aliasOf: originalRecord ? originalRecord.record : mainNormalizedRecord,
        }) as typeof mainNormalizedRecord
      )
    }
  }

  let matcher: RouteRecordMatcher
  let originalMatcher: RouteRecordMatcher | undefined

  // 遍历 normalizedRecords 生成 matcher
  for (const normalizedRecord of normalizedRecords) {
    const { path } = normalizedRecord
    // 如果有 parent, 拼接子路由的路径
    if (parent && path[0] !== '/') {
      const parentPath = parent.record.path
      const connectingSlash = parentPath[parentPath.length - 1] === '/' ? '' : '/'
      normalizedRecord.path = parent.record.path + (path && connectingSlash + path)
    }

    if (__DEV__ && normalizedRecord.path === '*') {
      throw new Error('Catch all routes ("*") must now be defined using a param with a custom regexp.\n' + 'See more at https://next.router.vuejs.org/guide/migration/#removed-star-or-catch-all-routes.')
    }

    // 使用 createRouteRecordMatcher 生成 matcher
    matcher = createRouteRecordMatcher(normalizedRecord, parent, options)

    if (__DEV__ && parent && path[0] === '/')
      checkMissingParamsInAbsolutePath(matcher, parent)

    if (originalRecord) {
      originalRecord.alias.push(matcher)
      if (__DEV__) {
        checkSameParams(originalRecord, matcher)
      }
    } else {
      originalMatcher = originalMatcher || matcher
      if (originalMatcher !== matcher)
        originalMatcher.alias.push(matcher)

      if (isRootAdd && record.name && !isAliasRecord(matcher))
        removeRoute(record.name)
    }

    // 递归处理子路由记录
    if (mainNormalizedRecord.children) {
      const children = mainNormalizedRecord.children
      for (let i = 0; i < children.length; i++) {
        addRoute(children[i], matcher, originalRecord && originalRecord.children[i])
      }
    }

    originalRecord = originalRecord || matcher

    if ((matcher.record.components && Object.keys(matcher.record.components).length) || matcher.record.name || matcher.record.redirect) {
      insertMatcher(matcher)
    }
  }

  // 返回移除路由的函数
  return originalMatcher ? () => {
    removeRoute(originalMatcher!)
  } : noop
}

/**
 * 路由解析的核心方法
 * @param location 原始的location
 * @param currentLocation 当前位置
 */
function resolve(location: Readonly<MatcherLocationRaw>, currentLocation: Readonly<MatcherLocation>): MatcherLocation {
  let matcher: RouteRecordMatcher | undefined
  let params: PathParams = {}
  let path: MatcherLocation['path']
  let name: MatcherLocation['name']

  // 如果location有name, 从matcherMap获取对应matcher
  if ('name' in location && location.name) {
    matcher = matcherMap.get(location.name)

    if (!matcher)
      throw createRouterError<MatcherError>(ErrorTypes.MATCHER_NOT_FOUND, { location, })

    if (__DEV__) {
      const invalidParams: string[] = Object.keys(location.params || {}).filter(paramName => !matcher!.keys.find(k => k.name === paramName))

      if (invalidParams.length) {
        warn(`Discarded invalid param(s) "${invalidParams.join('", "')}" when navigating. See https://github.com/vuejs/router/blob/main/packages/router/CHANGELOG.md#414-2022-08-22 for more details.`)
      }
    }

    name = matcher.record.name
    // 合并参数
    params = assign(paramsFromLocation(currentLocation.params, matcher.keys.filter(k => !k.optional).map(k => k.name)), location.params && paramsFromLocation(location.params, matcher.keys.map(k => k.name)))
    // 生成路径path
    path = matcher.stringify(params)
  } else if ('path' in location) {
    // 没有name,有path
    path = location.path

    if (__DEV__ && !path.startsWith('/')) {
      warn(`The Matcher cannot resolve relative paths but received "${path}". Unless you directly called \`matcher.resolve("${path}")\`, this is probably a bug in vue-router. Please open an issue at https://github.com/vuejs/router/issues/new/choose.`)
    }

    // 用matchers匹配路径获取matcher
    matcher = matchers.find(m => m.re.test(path))
    if (matcher) {
      params = matcher.parse(path)!
      name = matcher.record.name
    }
  } else {
    // 如果两者都没有,以currentLocation匹配
    matcher = currentLocation.name ? matcherMap.get(currentLocation.name) : matchers.find(m => m.re.test(currentLocation.path))

    // 如果仍未匹配则报错
    if (!matcher)
      throw createRouterError<MatcherError>(ErrorTypes.MATCHER_NOT_FOUND, { location, currentLocation })
    name = matcher.record.name
    params = assign({}, currentLocation.params, location.params)
    path = matcher.stringify(params)
  }

  // 从matcher向上递归生成matched匹配链表
  const matched: MatcherLocation['matched'] = []
  let parentMatcher: RouteRecordMatcher | undefined = matcher
  while (parentMatcher) {
    matched.unshift(parentMatcher.record)
    parentMatcher = parentMatcher.parent
  }

  // 返回解析后的location对象
  return {
    name,
    path,
    params,
    matched,
    meta: mergeMetaFields(matched),
  }
}

/**
 * 删除已添加的路由记录
 * @param matcherRef
 */
function removeRoute(matcherRef: RouteRecordName | RouteRecordMatcher) {
  // 根据名称删除
  if (isRouteName(matcherRef)) {
    const matcher = matcherMap.get(matcherRef)
    if (matcher) {
      matcherMap.delete(matcherRef)
      matchers.splice(matchers.indexOf(matcher), 1)
      // 递归删除相关联的匹配器
      matcher.children.forEach(removeRoute)
      matcher.alias.forEach(removeRoute)
    }
  } else {
    // 根据匹配器索引删除
    const index = matchers.indexOf(matcherRef)
    if (index > -1) {
      matchers.splice(index, 1)
      if (matcherRef.record.name)
        matcherMap.delete(matcherRef.record.name)
      // 递归删除相关联的匹配器
      matcherRef.children.forEach(removeRoute)
      matcherRef.alias.forEach(removeRoute)
    }
  }
}

function getRoutes() {
  return matchers
}

function getRecordMatcher(name: RouteRecordName) {
  return matcherMap.get(name)
}