/// <summary>
 /// Initializes a new instance of the <see cref="RouteMatch"/> class.
 /// </summary>
 /// <param name="success">if set to <c>true</c> [success].</param>
 /// <param name="route">The route.</param>
 /// <param name="parameterValues">The parameter values.</param>
 /// <param name="failReason">The fail reason.</param>
 private RouteMatch(bool success, IRoute route, IDictionary parameterValues, string failReason)
 {
     this.success = success;
     this.route = route;
     this.failReason = failReason;
     values = new RouteValueDictionary(parameterValues);
 }

 /// <summary>
 /// Given a path, attempts to match the next part of it to the current segment.
 /// </summary>
 /// <param name="route">The route.</param>
 /// <param name="path">The path.</param>
 /// <returns>
 /// An object that indicates whether the path was successfully matched.
 /// </returns>
 public override SegmentPathMatch MatchPath(IRoute route, PathIterator path)
 {
     var next = path.Next();
     return String.Equals(next, literal, StringComparison.InvariantCultureIgnoreCase)
         ? SegmentPathMatch.Successful()
         : SegmentPathMatch.Failure(string.Format("Expected segment '{0}'; got '{1}'", literal, next));
 }

        /// <summary>
        /// Returns the customer that least increases the length of the given route.
        /// </summary>
        /// <param name="problem"></param>
        /// <param name="route"></param>
        /// <returns></returns>
        public static TwoOptResult CalculateBestPlacement(
            IProblemWeights problem,
            IRoute route)
        {
            //int previous1 = -1;
            //foreach (int customer1 in route)
            //{
            //    if (previous1 >= 0)
            //    {
            //        int previous2 = -1;
            //        foreach (int customer2 in route)
            //        {
            //            if (previous1 != previous2)
            //            {
            //                // test the two opt move.

            //            }

            //            previous2 = customer2;
            //        }
            //    }

            //    previous1 = customer1;
            //}
            throw new NotImplementedException();
        }

        /// <summary>
        /// Given a path, attempts to match the next part of it to the current segment.
        /// </summary>
        /// <param name="route">The route.</param>
        /// <param name="path">The path.</param>
        /// <returns>
        /// An object that indicates whether the path was successfully matched.
        /// </returns>
        public override SegmentPathMatch MatchPath(IRoute route, PathIterator path)
        {
            var values = new RouteValueDictionary();
            var next = path.Next();
            
            if (next.Length == 0)
            {
                if (defaultValue != UrlParameter.NotSpecified)
                {
                    values[parameterName] = defaultValue;
                }
                else
                {
                    return SegmentPathMatch.Failure(string.Format("The path does not contain a segment for parameter '{0}'", parameterName));   
                }
            }
            else
            {
                values[parameterName] = next;

                if (constraint != null && !constraint.IsValid(route, next, parameterName))
                {
                    return SegmentPathMatch.Failure(string.Format("Segment '{0}' did not match the constraint on parameter '{1}'", next, parameterName));
                }
            }
            return SegmentPathMatch.Successful(values);
        }

 public void Log(IRoute route)
 {
     _routeLog.Add(route);
     Routes = _routeLog
         .OrderByDescending(r => r.End)
         .ToList();
 }

        public void Show(IRoute route, IEnumerable<IError> errors)
        {
            var view = route[KnownParameters.View] as UserControl;

            var adornerLayer = AdornerLayer.GetAdornerLayer(view);
            adornerLayer.Add(new ErrorsAdorner(view, errors));
        }

        public bool Matches(IRoute route, IPath path)
        {
            var routePath = route.Path;
            if (!routePath.IsLiteral)
                return false;

            return routePath.LiteralPath.Equals(path.LiteralPath);
        }

        public NancyEngineFixture()
        {
            this.resolver = A.Fake<IRouteResolver>();
            this.route = A.Fake<IRoute>();

            A.CallTo(() => resolver.GetRoute(A<IRequest>.Ignored.Argument)).Returns(route);
            this.engine = new NancyEngine(resolver);
        }

        public object CreateViewModel(IRoute route)
        {
            var type = GetTypeFor(route);

            if (type == null)
                return null;

            return IoC.Get(type);
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="PathMatch"/> class.
 /// </summary>
 /// <param name="success">if set to <c>true</c> [success].</param>
 /// <param name="route">The route.</param>
 /// <param name="routeValues">The route values.</param>
 /// <param name="leftOver">The left over.</param>
 /// <param name="segmentValues">The segment values.</param>
 /// <param name="failReason">The fail reason.</param>
 private PathMatch(bool success, IRoute route, RouteValueDictionary routeValues, RouteValueDictionary leftOver, List<object> segmentValues, string failReason)
 {
     this.success = success;
     this.route = route;
     this.routeValues = routeValues;
     this.leftOver = leftOver;
     this.segmentValues = segmentValues;
     this.failReason = failReason;
 }

        public IRouteResult Process(IRoute route)
        {
            var listener = route[KnownParameters.Listener] as IListener;

            var result = listener.Execute(route)
                .AddParameter(KnownParameters.ProcessedByListener, true);

            return result as IRouteResult;
        }

        public object CreateView(IRoute route)
        {
            var type = GetTypeFor(route);

            if (type == null)
                return null;

            return Activator.CreateInstance(type);
        }

        private static object CheckParameter(IRoute route, ParameterInfo parameterInfo)
        {
            if (parameterInfo.ParameterType == typeof(int))
            {
                return int.Parse(route.Parameters[parameterInfo.Name]);
            }

            return route.Parameters[parameterInfo.Name];
        }

        private static object[] MapParameters(IRoute route, MethodInfo action)
        {
            var result = action
                .GetParameters()
                .Select(parameterInfo =>
                    CheckParameter(route, parameterInfo)).ToArray();

            return result;
        }

        public static bool RouteEquals(this IRoute r1, IRoute r2)
        {
            if (r1.Resource != r2.Resource)
                return false;
            if (r1.Action != r2.Action)
                return false;

            return true;
        }

        /// <summary>
        /// Returns the customer that least increases the length of the given route.
        /// </summary>
        /// <param name="problem"></param>
        /// <param name="route"></param>
        /// <param name="customers"></param>
        /// <returns></returns>
        public static CheapestInsertionResult CalculateBestPlacement(
            IProblemWeights problem,
            IRoute route,
            ICollection<int> customers)
        {
            IInsertionCosts costs = new BinaryHeapInsertionCosts();

            return CheapestInsertionHelper.CalculateBestPlacement(problem, route, customers, costs);
        }

        public IRouteResult Execute(IRoute route)
        {
            var method = GetMethod(route);

            var parameters = GetParameters(route, method);

            object result = method.Invoke(this, parameters);

            return CreateRoute(result, route);
        }

        public IRouteResult Process(IRoute route)
        {
            var view = route[KnownParameters.View];
            var showAs = route[KnownParameters.ShowAs].ToString();

            var next = new Route("show", showAs)
                .AddParameter(KnownParameters.View, view);

            return new RouteResult(route).Next(next);
        }

 public IRouteTable AddRoute(IRoute route)
 {
     if (route == null)
     {
         throw new ArgumentNullException("route");
     }
     
     routes.Add(route);
     return this;
 }

 public void GetRouteReturnsCorrectRoute([Frozen]Mock<IRouteAlgorithmFactory> factoryStub, Mock<IRouteAlgorithm> routeAlgorithmStub, RouteSpecification specification, RouteType selectedAlgorithm, IRoute expectedResult, RouteController sut)
 {
     // Fixture setup
     factoryStub.Setup(f => f.CreateAlgorithm(selectedAlgorithm)).Returns(routeAlgorithmStub.Object);
     routeAlgorithmStub.Setup(a => a.CalculateRoute(specification)).Returns(expectedResult);
     // Exercise system
     var result = sut.GetRoute(specification, selectedAlgorithm);
     // Verify outcome
     Assert.Equal(expectedResult, result);
     // Teardown
 }