public bool IsFlush(IHand hand)
        {
            var handCards = hand.Cards;

            if (!IsValidHand(hand))
            {
                return false;
            }

            for (var i = 0; i < handCards.Count; i += 5)
            {
                var firstCard = handCards[i];
                var secondCard = handCards[i + 1];
                var thirdCard = handCards[i + 2];
                var fourthCard = handCards[i + 3];
                var fifthCard = handCards[i + 4];
                if (firstCard.Suit == secondCard.Suit &&
                    secondCard.Suit == thirdCard.Suit &&
                    thirdCard.Suit == fourthCard.Suit &&
                    fourthCard.Suit == fifthCard.Suit)
                {
                    return true;
                }
            }

            return false;
        }

        public static int CompareHighCards(IHand firstHand, IHand secondHand)
        {
            List<CardFace> facesFirstHand = GetSortedFaces(firstHand);
            List<CardFace> facesSecondHand = GetSortedFaces(secondHand);

            return CompareFaceListsOfEqualLength(facesFirstHand, facesSecondHand);
        }

        /// <summary>
        /// Compares two objects and returns a value indicating whether one is less than, equal to, or greater than the other.
        /// </summary>
        /// <returns>
        /// A signed integer that indicates the relative values of <paramref name="x"/> and <paramref name="y"/>, as shown in the following table.Value Meaning Less than zero<paramref name="x"/> is less than <paramref name="y"/>.Zero<paramref name="x"/> equals <paramref name="y"/>.Greater than zero<paramref name="x"/> is greater than <paramref name="y"/>.
        /// </returns>
        /// <param name="x">The first object to compare.</param><param name="y">The second object to compare.</param>
        public int Compare(IHand x, IHand y)
        {
            Argument.IsNotNull(() => x);
            Argument.IsNotNull(() => y);
            if (x.Count != y.Count)
                throw new InvalidOperationException("Cannot compare hands with a different number of cards");

            if (x.Type != Hands.Straight &&
                y.Type != Hands.Straight)
                throw new InvalidOperationException("Cannot compare hands if neither hand is a Straight.");

            if (x.Type != Hands.Straight &&
                y.Type == Hands.Straight)
                return -1 * Constants.SortDirection;

            if (x.Type == Hands.Straight &&
                y.Type != Hands.Straight)
                return 1 * Constants.SortDirection;

            if (x.HighCard < y.HighCard)
                return -1 * Constants.SortDirection;
            if (x.HighCard > y.HighCard)
                return 1 * Constants.SortDirection;

            return 0;
        }

        public bool IsStraightFlush(IHand hand)
        {
            throw new NotImplementedException();
            //var faces = new List<int>(5);
            //if (!this.IsFlush(hand))
            //{
            //    return false;
            //}
            //else
            //{
            //    foreach (var card in hand.Cards)
            //    {
            //        faces.Add((int)card.Suit);
            //    }
            //}

            //faces.Sort();
            //for (int i = 0; i < faces.Count - 1; i++)
            //{
            //    if (faces[i] + 1 != faces[i+1])
            //    {
            //        return false;
            //    }
            //}

            //return true;
        }

        /// <summary>
        /// Compares the specified hand to determine if it is of the same type as this comparer.
        /// </summary>
        /// <param name="hand">The hand to be compared.</param>
        /// <returns>
        /// a tuple specifying information about the comparison.
        /// <para>The first value returns the type of this comparer if the specified hand matches, otherwise it returns <see cref="Hands.HighCard"/>.</para>
        /// <para>The second value indicates the high card of the hand if there was a match, otherwise it returns <see cref="Rank.Two"/>.</para>
        /// </returns>
        public Tuple<Hands, Rank> Compare(IHand hand)
        {
            Argument.IsNotNull(() => hand);
            if (hand.Count < 5)
                return Tuple.Create<Hands, Rank>(0, 0);

            // create a map of the rank and count for each card in the hand.
            var map = new Dictionary<Rank, int>(hand.Count);
            for (int i = 0; i < hand.Count; i++)
            {
                if (map.ContainsKey(hand[i].Rank))
                    map[hand[i].Rank]++;
                else
                    map[hand[i].Rank] = 1;
            }

            // If count does not have two elements, then we have more than 2 kinds of cards in the hand, can't be full house.
            if (map.Count != 2)
                return Tuple.Create<Hands, Rank>(0, 0);

            // Get the entry with 3
            foreach (var kvp in map)
            {
                if (kvp.Value == 3)
                    return Tuple.Create(Hands.FullHouse, kvp.Key);
            }

            // Should never get here, but compiler.
            return Tuple.Create<Hands, Rank>(0, 0);
        }

        public bool IsFourOfAKind(IHand hand)
        {
            if (!this.IsValidHand(hand))
            {
                return false;
            }

            for (int i = 0; i < ValidCardCount; i++)
            {
                int count = 0;
                for (int j = 0; j < ValidCardCount; j++)
                {
                    if (hand.Cards[i].Face == hand.Cards[j].Face)
                    {
                        count++;
                    }

                    if (count == 4)
                    {
                        return true;
                    }
                }
            }

            return false;
        }

        /// <summary>
        /// Compares two objects and returns a value indicating whether one is less than, equal to, or greater than the other.
        /// </summary>
        /// <returns>
        /// A signed integer that indicates the relative values of <paramref name="x"/> and <paramref name="y"/>, as shown in the following table.Value Meaning Less than zero<paramref name="x"/> is less than <paramref name="y"/>.Zero<paramref name="x"/> equals <paramref name="y"/>.Greater than zero<paramref name="x"/> is greater than <paramref name="y"/>.
        /// </returns>
        /// <param name="x">The first object to compare.</param><param name="y">The second object to compare.</param>
        public int Compare(IHand x, IHand y)
        {
            Argument.IsNotNull(() => x);
            Argument.IsNotNull(() => y);
            if (x.Count != y.Count)
                throw new InvalidOperationException("Cannot compare hands with a different number of cards");

            if (x.Type != Hands.ThreeOfAKind &&
                y.Type != Hands.ThreeOfAKind)
                throw new InvalidOperationException("Cannot compare hands if neither hand has Three-of-a-kind.");

            if (x.Type != Hands.ThreeOfAKind &&
                y.Type == Hands.ThreeOfAKind)
                return -1 * Constants.SortDirection;

            if (x.Type == Hands.ThreeOfAKind &&
                y.Type != Hands.ThreeOfAKind)
                return 1 * Constants.SortDirection;

            if (x.HighCard < y.HighCard)
                return -1 * Constants.SortDirection;
            if (x.HighCard > y.HighCard)
                return 1 * Constants.SortDirection;

            // compare kicker cards.
            return _comparer.Compare(x, y);
        }

        public bool IsFullHouse(IHand hand)
        {
            bool haveThreeOfAKind = this.IsRightTimesOfRepeat(hand, 3);
            bool haveOtherOnePair = false;

            int counter = 0;

            for (int i = 0; i < hand.Cards.Count; i++)
            {
                for (int j = 0; j < hand.Cards.Count; j++)
                {
                    if (hand.Cards[i].Face == hand.Cards[j].Face)
                    {
                        counter++;
                    }
                }

                if (counter == 2)
                {
                    haveOtherOnePair = true;
                    break;
                }

                counter = 0;
            }

            return haveThreeOfAKind && haveOtherOnePair;
        }

        /// <summary>
        /// Checks if <paramref name="hand"/> is a valid poker hand.
        /// </summary>
        /// <param name="hand">The hand to check.</param>
        /// <returns>True if the hand is valid, otherwise - false.</returns>
        public bool IsValid(IHand hand)
        {
            if (hand == null)
            {
                return false;
            }

            ICard[] cards = hand.Cards;

            if (cards.Length != HandSize)
            {
                return false;
            }

            for (int i = 0; i < cards.Length - 1; i++)
            {
                for (int j = i + 1; j < cards.Length; j++)
                {
                    if (cards[i].Equals(cards[j]))
                    {
                        return false;
                    }
                }
            }

            return true;
        }

        public bool IsFourOfAKind(IHand hand)
        {
            bool isHandValid = IsValidHand(hand);
            byte count = 1;
            for (int i = 0; i < hand.Cards.Count; i++)
            {
                for (int j = i+1; j < hand.Cards.Count; j++)
                {
                    if (hand.Cards[i].Face == hand.Cards[j].Face)
                    {
                        count++;
                    }
                }
                if (count == 4)
                {
                    break;
                }
                count = 0;
            }

            bool isFourCardsFromTheSameKind = false;
            if (isHandValid == true && count == 4)
            {
                isFourCardsFromTheSameKind = true;
            }

            return isFourCardsFromTheSameKind;
        }

        public bool IsHand(IHand hand)
        {
            var threeOfAKind = false;
            var pair = false;

            for (var i = Value.Two; i <= Value.Ace; i++)
            {
                IEnumerable<Card> cardsOfSameValue = hand.GetCards().Where(obj => obj.GetCardValue() == i);

                if (cardsOfSameValue.Count() > 2 && !threeOfAKind)
                {
                    threeOfAKind = true;

                }
                else if (cardsOfSameValue.Count() > 1 && !pair)
                {
                    pair = true;

                }
                if (threeOfAKind && pair)
                {
                    hand.SetRank(Rank.FullHouse);
                    return true;
                }
            }
            return false;
        }

        public bool IsFlush(IHand hand)
        {
            if (!IsValidHand(hand))
            {
                return false;
            }

            if (hand.Cards.Count != 5)
            {
                return false;
            }

            for (int i = 0; i < 5; i++)
            {
                if (hand.ToString().IndexOf(hand.Cards[i].ToString()) != hand.ToString().LastIndexOf(hand.Cards[i].ToString()))
                {
                    return false;
                }
            }
            CardSuit cardsSuit = hand.Cards[0].Suit;

            for (int j = 0; j < 5; j++)
            {
                if (hand.Cards[j].Suit != cardsSuit)
                {
                    return false;
                }
            }
            return true;
        }

 public bool IsFourOfAKind(IHand hand)
 {
     int counter = 1;
     if (IsValidHand(hand))
     {
         for (int i = 0; i < 2; i++)
         {
             for (int j = i+1; j < 5; j++)
             {
                 if (hand.Cards[i].Face == hand.Cards[j].Face)
                 {
                     counter++;
                 }
                 if (counter == 4)
                 {
                     return true;
                 }
             }
         }
         return false;
     }
     else
     {
         throw new ArgumentException("Hand is invalid", "hand");
     }
 }

        public bool IsHighCard(IHand hand)
        {
            bool isValidHand = this.IsValidHand(hand);
            bool isHighCard = !this.IsFlush(hand) && !this.IsStraight(hand) && !this.IsStraightFlush(hand) && !this.IsFullHouse(hand) && !this.IsOnePair(hand) && !this.IsTwoPair(hand) && !this.IsThreeOfAKind(hand) && !this.IsFourOfAKind(hand);

            return isValidHand && isHighCard;
        }

        public bool IsFourOfAKind(IHand hand)
        {
            if (!IsValidHand(hand))
            {
                return false;
            }

            int faceCounter = 1;
            int maxCounter = 0;
            String[] splitedHand = hand.ToString().Split(' ');

            for (int i = 0, len = splitedHand.Length; i < len; i++)
            {
                for (int j = i + 1; j < len; j++)
                {
                    if (splitedHand[i][0] == splitedHand[j][0])
                    {
                        faceCounter++;
                    }
                }

                if (faceCounter > maxCounter)
                {
                    maxCounter = faceCounter;
                    faceCounter = 1;
                }
            }

            if (maxCounter == 4)
                return true;
            else
                return false;
        }

        public bool IsFourOfAKind(IHand hand)
        {
            if (!IsValidHand(hand))
            {
                return false;
            }

            int equalCardFaceCount = 0;

            for (int i = 0; i < hand.Cards.Count - 1; i++)
            {
                for (int j = i + 1; j < hand.Cards.Count; j++)
                {
                    if (hand.Cards[i].Face == hand.Cards[j].Face)
                    {
                        equalCardFaceCount++;
                        if (equalCardFaceCount == FourOfAKindCount)
                        {
                            return true;
                        }
                    }
                }
            }

            return false;
        }

        public bool IsValidHand(IHand hand)
        {
            var handMaxLenght = 5;
            var cards = hand.Cards;
            if (cards.Count != handMaxLenght)
            {
                return false;
            }

            for (int i = 0; i < cards.Count; i++)
            {
                var checkerCard = cards[i];
                for (int j = 0; j < cards.Count; j++)
                {
                    if (i != j)
                    {
                        var currentCard = cards[j];
                        if (checkerCard.Face == currentCard.Face && checkerCard.Suit == currentCard.Suit)
                        {
                            return false;
                        }
                    }
                }
            }
            return true;
        }

 private void ValidExceptionHelper(IHand hand)
 {
     if (!this.IsValidHand(hand))
     {
         throw new ArgumentException("Hand is not valid!");
     }
 }

        public bool IsFourOfAKind(IHand hand)
        {
            var handCards = hand.Cards;
            if (handCards.Count != 5)
            {
                return false;
            }
            for (var i = 0; i < handCards.Count; i += 5)
            {
                var firstCard = handCards[i];
                var secondCard = handCards[i + 1];
                var thirdCard = handCards[i + 2];
                var fourthCard = handCards[i + 3];
                if (firstCard.Suit != secondCard.Suit &&
                    secondCard.Suit != thirdCard.Suit &&
                    thirdCard.Suit != fourthCard.Suit &&
                    secondCard.Face == firstCard.Face &&
                    thirdCard.Face == secondCard.Face &&
                    fourthCard.Face == thirdCard.Face)
                {
                    return true;
                }
            }

            return false;
        }

        /// <summary>
        /// Compares the specified hand to determine if it is of the same type as this comparer.
        /// </summary>
        /// <param name="hand">The hand to be compared.</param>
        /// <returns>
        /// a tuple specifying information about the comparison.
        /// <para>The first value returns the type of this comparer if the specified hand matches, otherwise it returns <see cref="Hands.HighCard"/>.</para>
        /// <para>The second value indicates the high card of the hand if there was a match, otherwise it returns <see cref="Rank.Two"/>.</para>
        /// </returns>
        public Tuple<Hands, Rank> Compare(IHand hand)
        {
            Argument.IsNotNull(() => hand);
            if (hand.Count < 5)
                return Tuple.Create<Hands, Rank>(0, 0);

            // create a map of the rank and count for each card in the hand.
            var map = new Dictionary<Rank, int>(hand.Count);
            for (int i = 0; i < hand.Count; i++)
            {
                if (map.ContainsKey(hand[i].Rank))
                    map[hand[i].Rank]++;
                else
                    map[hand[i].Rank] = 1;
            }

            // If the map has more than three entries, then we have more than 3 kinds of cards in the hand, can't be two pair
            if (map.Count > 3)
                return Tuple.Create<Hands, Rank>(0, 0);

            Rank high = Rank.Two;
            foreach (var kvp in map)
            {
                // Grab the highest pair.
                if (kvp.Value == 2 && high < kvp.Key)
                    high = kvp.Key;
            }

            return Tuple.Create(Hands.TwoPair, high);
        }