/// <summary>
 /// Initializes a new instance of the <see cref="TailChoppingRoutee"/> class.
 /// </summary>
 /// <param name="routees">The list of routees that the router uses to send messages.</param>
 /// <param name="within">The time within which at least one response is expected.</param>
 /// <param name="interval">The duration after which the next routee will be picked.</param>
 /// <param name="scheduler">The <see cref="IScheduler"/> used to force deadlines.</param>
 public TailChoppingRoutee(Routee[] routees, TimeSpan within, TimeSpan interval, IScheduler scheduler)
 {
     _routees = routees;
     _within = within;
     _interval = interval;
     _scheduler = scheduler;
 }

        private Routee SelectNext(Routee[] routees)
        {
            var winningScore = long.MaxValue;

            // round robin fallback
            var winner = routees[(Interlocked.Increment(ref _next) & int.MaxValue) %  routees.Length];

            for (int i = 0; i < routees.Length; i++)
            {
                var routee = routees[i];
                var cell = TryGetActorCell(routee);
                if (cell != null)
                {
                    // routee can be reasoned about it's mailbox size
                    var score = cell.NumberOfMessages;
                    if (score == 0)
                    {
                        // no messages => instant win    
                        return routee;
                    }

                    if (winningScore > score)
                    {
                        winningScore = score;
                        winner = routee;
                    }
                }
            }

            return winner;
        }

 /// <summary>
 /// Selects all routees and creates a TailChoppingRoutee.
 /// </summary>
 /// <param name="message">The message to use.</param>
 /// <param name="routees">The routees to select from.</param>
 /// <returns>A TailChoppingRoutee to handle the tail chopping routing.</returns>
 public override Routee Select(object message, Routee[] routees)
 {
     if(routees.IsNullOrEmpty())
     {
         return Routee.NoRoutee;
     }
     return new TailChoppingRoutee(routees, _within, _interval, _scheduler);
 }

 /// <summary>
 /// Selects the routee for the given message.
 /// </summary>
 /// <param name="message">The message.</param>
 /// <param name="routees">The routees.</param>
 /// <returns>Routee.</returns>
 public override Routee Select(object message, Routee[] routees)
 {
     if (routees == null || routees.Length == 0)
     {
         return Routee.NoRoutee;
     }
     return routees[rnd.Next(routees.Length - 1)%routees.Length];
 }

 /// <summary>
 /// Selects the routee for the given message.
 /// </summary>
 /// <param name="message">The message.</param>
 /// <param name="routees">The routees.</param>
 /// <returns>Routee.</returns>
 public override Routee Select(object message, Routee[] routees)
 {
     if (routees == null || routees.Length == 0)
     {
         return Routee.NoRoutee;
     }
     return routees[ThreadLocalRandom.Current.Next(routees.Length - 1)%routees.Length];
 }

 public override Routee Select(object message, Routee[] routees)
 {
     if (routees == null || routees.Length == 0)
     {
         return Routee.NoRoutee;
     }
     return new ScatterGatherFirstCompletedRoutees(routees,_within);
 }

 /// <summary>
 /// Picks the next <see cref="Routee"/> in the collection to receive the <paramref name="message"/>.
 /// </summary>
 /// <param name="message">The message that is being routed.</param>
 /// <param name="routees">A collection of routees to choose from when receiving the <paramref name="message"/>.</param>
 /// <returns>A <see cref="Routee" /> that is receives the <paramref name="message"/>.</returns>
 public override Routee Select(object message, Routee[] routees)
 {
     if (routees == null || routees.Length == 0)
     {
         return Routee.NoRoutee;
     }
     return routees[(Interlocked.Increment(ref _next) & int.MaxValue) % routees.Length];
 }

        public override Routee Select(object message, Routee[] routees)
        {
            if (message is ConsistentHashable)
            {
                var hashable = (ConsistentHashable) message;
                int hash = hashable.ConsistentHashKey.GetHashCode();
                return routees[hash%routees.Length];
            }

            throw new NotSupportedException("Only ConsistentHashable messages are supported right now");
        }

 protected void AddRoutees(Routee[] routees)
 {
     foreach(var routee in routees)
     {
         if(routee is ActorRefRoutee)
         {
             var @ref = ((ActorRefRoutee)routee).Actor;
             Watch(@ref);
         }
     }
     _router = _router.WithRoutees(_router.Routees.Concat(routees).ToArray());
 }

 private void AddRoutees(Routee[] routees)
 {
     foreach (var routee in routees)
     {
         if (routee is ActorRefRoutee)
         {
             var @ref = ((ActorRefRoutee)routee).Actor;
             Watch(@ref);
         }
     }
     Router = Router.WithRoutees(routees);
 }

 private ICell TryGetActorCell(Routee routee)
 {
     var refRoutee = routee as ActorRefRoutee;
     if (refRoutee != null)
     {
         var actorRef = refRoutee.Actor as ActorRefWithCell;
         if (actorRef != null)
         {
             return actorRef.Underlying;
         }
     }
     return null;
 }

 /// <summary>
 /// Picks the next <see cref="Routee"/> in the collection to receive the <paramref name="message"/>.
 /// </summary>
 /// <param name="message">The message that is being routed.</param>
 /// <param name="routees">A collection of routees to choose from when receiving the <paramref name="message"/>.</param>
 /// <returns>A <see cref="Routee" /> that is receives the <paramref name="message"/>.</returns>
 public override Routee Select(object message, Routee[] routees)
 {
     if (routees.Length > 0)
     {
         var size = routees.Length;
         int index = (Interlocked.Increment(ref _next) & int.MaxValue)%size;
         return routees[index < 0 ? size + index - 1 : index];
     }
     else
     {
         return Routee.NoRoutee;
     }
 }

        public void DefaultResizer_must_use_settings_to_evaluate_capacity()
        {
            var resizer = new DefaultResizer(2, 3);
            var c1 = resizer.Capacity(new Routee[] { });
            c1.ShouldBe(2);

            var current = new Routee[]
            {
                new ActorRefRoutee(Sys.ActorOf<ResizerTestActor>()),
                new ActorRefRoutee(Sys.ActorOf<ResizerTestActor>())
            };
            var c2 = resizer.Capacity(current);
            c2.ShouldBe(0);
        }

 public ScatterGatherFirstCompletedRoutees(Routee[] routees, TimeSpan within)
 {
     _routees = routees;
     _within = within;
 }

 public override Routee Select(object message, Routee[] routees)
 {
     if (routees == null || !routees.Any())
         return Routee.NoRoutee;
     return new SeveralRoutees(routees);
 }

 public abstract Routee Select(object message, Routee[] routees);

 public SeveralRoutees(Routee[] routees)
 {
     this.routees = routees;
 }

 internal void RemoveRoutee(Routee routee, bool stopChild)
 {
     RemoveRoutees(new[] { routee }, stopChild);
 }

 private void Unwatch(Routee routee)
 {
     var actorRef = routee as ActorRefRoutee;
     if (actorRef != null) Unwatch(actorRef.Actor);
 }

 /// <summary>
 /// Used to stop child routees - typically used in resizable <see cref="Pool"/> routers
 /// </summary>
 /// <param name="routee"></param>
 private void StopIfChild(Routee routee)
 {
     var actorRefRoutee = routee as ActorRefRoutee;
     IChildStats childActorStats;
     if (actorRefRoutee != null && TryGetChildStatsByName(actorRefRoutee.Actor.Path.Name, out childActorStats))
     {
         var childRef = childActorStats as ChildRestartStats;
         if (childRef != null && childRef.Child != null)
         {
             // The reason for the delay is to give concurrent
             // messages a chance to be placed in mailbox before sending PoisonPill,
             // best effort.
             System.Scheduler.ScheduleTellOnce(TimeSpan.FromMilliseconds(100), actorRefRoutee.Actor,
                 PoisonPill.Instance, Self);
         }
     }
 }