angular/modules/@angular/router/src/recognize.ts

import {RouteSegment, UrlSegment, Tree, TreeNode, rootNode, UrlTree, RouteTree, equalUrlSegments} from './segments';
import {RoutesMetadata, RouteMetadata} from './metadata/metadata';
import {Type, isBlank, isPresent, stringify} from './facade/lang';
import {ListWrapper, StringMapWrapper} from './facade/collection';
import {PromiseWrapper} from './facade/promise';
import {BaseException, ComponentFactory} from '@angular/core';
import {ComponentResolver} from '@angular/core';
import {DEFAULT_OUTLET_NAME} from './constants';
import {reflector} from '@angular/core';

export function recognize(componentResolver: ComponentResolver, rootComponent: Type,
                          url: UrlTree, existingTree: RouteTree): Promise<RouteTree> {
  let matched = new _MatchResult(rootComponent, [url.root], {}, rootNode(url).children, []);
  return _constructSegment(componentResolver, matched, rootNode(existingTree)).then(roots => new RouteTree(roots[0]));
}

function _recognize(componentResolver: ComponentResolver, parentComponent: Type,
                    url: TreeNode<UrlSegment>, existingSegments: TreeNode<RouteSegment>[]): Promise<TreeNode<RouteSegment>[]> {
  let metadata = _readMetadata(parentComponent);  // should read from the factory instead
  if (isBlank(metadata)) {
    throw new BaseException(
        `Component '${stringify(parentComponent)}' does not have route configuration`);
  }

  let match;
  try {
    match = _match(metadata, url);
  } catch (e) {
    return PromiseWrapper.reject(e, null);
  }

  let segmentsWithRightOutlet = existingSegments.filter(r => r.value.outlet == match.outlet);
  let segmentWithRightOutlet = segmentsWithRightOutlet.length > 0 ? segmentsWithRightOutlet[0] : null;

  let main = _constructSegment(componentResolver, match, segmentWithRightOutlet);
  let aux =
      _recognizeMany(componentResolver, parentComponent, match.aux, existingSegments).then(_checkOutletNameUniqueness);
  return PromiseWrapper.all([main, aux]).then(ListWrapper.flatten);
}

function _recognizeMany(componentResolver: ComponentResolver, parentComponent: Type,
                        urls: TreeNode<UrlSegment>[], existingSegments: TreeNode<RouteSegment>[]): Promise<TreeNode<RouteSegment>[]> {
  let recognized = urls.map(u => _recognize(componentResolver, parentComponent, u, existingSegments));
  return PromiseWrapper.all(recognized).then(ListWrapper.flatten);
}

function _constructSegment(componentResolver: ComponentResolver,
                           matched: _MatchResult, existingSegment: TreeNode<RouteSegment>): Promise<TreeNode<RouteSegment>[]> {
  return componentResolver.resolveComponent(matched.component)
      .then(factory => {
        let segment = _createOrReuseSegment(matched, factory, existingSegment);
        let existingChildren = isPresent(existingSegment) ? existingSegment.children : [];

        if (matched.leftOverUrl.length > 0) {
          return _recognizeMany(componentResolver, factory.componentType, matched.leftOverUrl, existingChildren)
              .then(children => [new TreeNode<RouteSegment>(segment, children)]);
        } else {
          return _recognizeLeftOvers(componentResolver, factory.componentType, existingChildren)
              .then(children => [new TreeNode<RouteSegment>(segment, children)]);
        }
      });
}

function _createOrReuseSegment(matched: _MatchResult, factory: ComponentFactory<any>, segmentNode: TreeNode<RouteSegment>): RouteSegment {
  let segment = isPresent(segmentNode) ? segmentNode.value : null;

  if (isPresent(segment) && equalUrlSegments(segment.urlSegments, matched.consumedUrlSegments)
    && StringMapWrapper.equals(segment.parameters, matched.parameters) &&
        segment.outlet == matched.outlet && factory.componentType == segment.type) {
    return segment;
  } else {
    return new RouteSegment(matched.consumedUrlSegments, matched.parameters, matched.outlet,
      factory.componentType, factory);
  }
}

function _recognizeLeftOvers(componentResolver: ComponentResolver,
                             parentComponent: Type, existingSegments: TreeNode<RouteSegment>[]): Promise<TreeNode<RouteSegment>[]> {
  return componentResolver.resolveComponent(parentComponent)
      .then(factory => {
        let metadata = _readMetadata(factory.componentType);
        if (isBlank(metadata)) {
          return [];
        }

        let r = (<any[]>metadata.routes).filter(r => r.path == "" || r.path == "/");
        if (r.length === 0) {
          return PromiseWrapper.resolve([]);
        } else {
          let segmentsWithMatchingOutlet = existingSegments.filter(r => r.value.outlet == DEFAULT_OUTLET_NAME);
          let segmentWithMatchingOutlet = segmentsWithMatchingOutlet.length > 0 ? segmentsWithMatchingOutlet[0] : null;
          let existingChildren = isPresent(segmentWithMatchingOutlet) ? segmentWithMatchingOutlet.children : [];

          return _recognizeLeftOvers(componentResolver, r[0].component, existingChildren).then(children => {
                return componentResolver.resolveComponent(r[0].component)
                    .then(factory => {
                      let segment = _createOrReuseSegment(new _MatchResult(r[0].component, [], {}, [], []), factory, segmentWithMatchingOutlet);
                      return [new TreeNode<RouteSegment>(segment, children)];
                    });
              });
        }
      });
}

function _match(metadata: RoutesMetadata, url: TreeNode<UrlSegment>): _MatchResult {
  for (let r of metadata.routes) {
    let matchingResult = _matchWithParts(r, url);
    if (isPresent(matchingResult)) {
      return matchingResult;
    }
  }
  let availableRoutes = metadata.routes.map(r => `'${r.path}'`).join(", ");
  throw new BaseException(
      `Cannot match any routes. Current segment: '${url.value}'. Available routes: [${availableRoutes}].`);
}

function _matchWithParts(route: RouteMetadata, url: TreeNode<UrlSegment>): _MatchResult {
  let path = route.path.startsWith("/") ? route.path.substring(1) : route.path;

  if (path == "*") {
    return new _MatchResult(route.component, [], null, [], []);
  }

  let parts = path.split("/");
  let positionalParams = {};
  let consumedUrlSegments = [];

  let lastParent: TreeNode<UrlSegment> = null;
  let lastSegment: TreeNode<UrlSegment> = null;

  let current = url;
  for (let i = 0; i < parts.length; ++i) {
    if (isBlank(current)) return null;

    let p = parts[i];
    let isLastSegment = i === parts.length - 1;
    let isLastParent = i === parts.length - 2;
    let isPosParam = p.startsWith(":");

    if (!isPosParam && p != current.value.segment) return null;
    if (isLastSegment) {
      lastSegment = current;
    }
    if (isLastParent) {
      lastParent = current;
    }

    if (isPosParam) {
      positionalParams[p.substring(1)] = current.value.segment;
    }

    consumedUrlSegments.push(current.value);

    current = ListWrapper.first(current.children);
  }

  let p = lastSegment.value.parameters;
  let parameters = <{[key: string]: string}>StringMapWrapper.merge(p, positionalParams);
  let axuUrlSubtrees = isPresent(lastParent) ? lastParent.children.slice(1) : [];

  return new _MatchResult(route.component, consumedUrlSegments, parameters, lastSegment.children,
                          axuUrlSubtrees);
}

function _checkOutletNameUniqueness(nodes: TreeNode<RouteSegment>[]): TreeNode<RouteSegment>[] {
  let names = {};
  nodes.forEach(n => {
    let segmentWithSameOutletName = names[n.value.outlet];
    if (isPresent(segmentWithSameOutletName)) {
      let p = segmentWithSameOutletName.stringifiedUrlSegments;
      let c = n.value.stringifiedUrlSegments;
      throw new BaseException(`Two segments cannot have the same outlet name: '${p}' and '${c}'.`);
    }
    names[n.value.outlet] = n.value;
  });
  return nodes;
}

class _MatchResult {
  constructor(public component: Type|string, public consumedUrlSegments: UrlSegment[],
              public parameters: {[key: string]: string},
              public leftOverUrl: TreeNode<UrlSegment>[], public aux: TreeNode<UrlSegment>[]) {}

  get outlet():string {
    return this.consumedUrlSegments.length === 0 ||
     isBlank(this.consumedUrlSegments[0].outlet) ?
      DEFAULT_OUTLET_NAME :
      this.consumedUrlSegments[0].outlet;
  }
}

function _readMetadata(componentType: Type) {
  let metadata = reflector.annotations(componentType).filter(f => f instanceof RoutesMetadata);
  return ListWrapper.first(metadata);
}