001package ball.game.card.poker;
002/*-
003 * ##########################################################################
004 * Game Applications and Utilities
005 * $Id: Ranking.java 5285 2020-02-05 04:23:21Z ball $
006 * $HeadURL: svn+ssh://svn.hcf.dev/var/spool/scm/repository.svn/ball-game/trunk/src/main/java/ball/game/card/poker/Ranking.java $
007 * %%
008 * Copyright (C) 2010 - 2020 Allen D. Ball
009 * %%
010 * Licensed under the Apache License, Version 2.0 (the "License");
011 * you may not use this file except in compliance with the License.
012 * You may obtain a copy of the License at
013 *
014 *      http://www.apache.org/licenses/LICENSE-2.0
015 *
016 * Unless required by applicable law or agreed to in writing, software
017 * distributed under the License is distributed on an "AS IS" BASIS,
018 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
019 * See the License for the specific language governing permissions and
020 * limitations under the License.
021 * ##########################################################################
022 */
023import ball.game.card.Card.Rank;
024import ball.game.card.Card.Suit;
025import ball.game.card.Card;
026import ball.util.Comparators;
027import java.util.Arrays;
028import java.util.Collection;
029import java.util.Comparator;
030import java.util.List;
031import java.util.Map;
032import java.util.Objects;
033import java.util.function.Predicate;
034import java.util.stream.Collectors;
035import java.util.stream.Stream;
036
037import static ball.game.card.Card.Rank.ACE;
038import static ball.game.card.Card.Rank.KING;
039import static ball.game.card.Card.Rank.SEQUENCE;
040
041/**
042 * Poker hand {@link Ranking} {@link Enum} and {@link Predicate}.
043 *
044 * @author {@link.uri mailto:ball@hcf.dev Allen D. Ball}
045 * @version $Revision: 5285 $
046 */
047public enum Ranking implements Predicate<List<Card>> {
048    Empty(0, null, Collection::isEmpty),
049        HighCard(1, t -> true, t -> true),
050        Pair(2, Rank.SAME, Rank.SAME),
051        TwoPair(4, holding(2, Rank.SAME), Pair.with(Pair)),
052        ThreeOfAKind(3, Rank.SAME, Rank.SAME),
053        Straight(5, SEQUENCE, SEQUENCE),
054        Flush(5, Suit.SAME, Suit.SAME),
055        FullHouse(5, holding(3, Rank.SAME), ThreeOfAKind.with(Pair)),
056        FourOfAKind(4, Rank.SAME, Rank.SAME),
057        StraightFlush(5,
058                      holding(ACE, KING).negate().and(SEQUENCE).and(Suit.SAME),
059                      holding(ACE, KING).negate().and(Straight).and(Flush)),
060        RoyalFlush(5,
061                   holding(ACE, KING).and(SEQUENCE).and(Suit.SAME),
062                   holding(ACE, KING).and(Straight).and(Flush)),
063        FiveOfAKind(5, Rank.SAME, Rank.SAME);
064
065    private final int required;
066    private final Predicate<List<Card>> possible;
067    private final Predicate<List<Card>> is;
068
069    private Ranking(int required,
070                    Predicate<List<Card>> possible, Predicate<List<Card>> is) {
071        this.required = required;
072        this.possible = possible;
073        this.is = Objects.requireNonNull(is);
074    }
075
076    /**
077     * Method to find the best possible {@link.this} {@link Ranking} hand in
078     * the {@link Collection}.
079     *
080     * @param   collection      The {@link Collection} of {@link Card}s to
081     *                          evaluate.
082     *
083     * @return  The best sorted hand as a {@link List} of {@link Card}s if
084     *          a combination matching {@link.this} {@link Ranking} is
085     *          found; the empty {@link List} otherwise.
086     */
087    public List<Card> find(Collection<Card> collection) {
088        Evaluator evaluator = new Evaluator(collection, this);
089        List<Card> hand =
090            evaluator.getScoring().isEmpty()
091                ? evaluator.getScoring()
092                : evaluator.getHand();
093
094        return hand;
095    }
096
097    /**
098     * Returns the number of {@link Card} for {@link.this} {@link Ranking}.
099     *
100     * @return  The number of {@link Card}s required.
101     */
102    public int required() { return required; }
103
104    /**
105     * Method to return a {@link Predicate} to test if the {@link List} of
106     * {@link Card} is a possible {@link Ranking}.
107     *
108     * @return  A {@link Predicate} that returns {@code false} if the hand
109     *          cannot be {@link.this} {@link Ranking}; {@code true}
110     *          otherwise.
111     */
112    public Predicate<List<Card>> possible() {
113        return t -> (possible == null
114                     || possible.test(subListTo(t, required())));
115    }
116
117    @Override
118    public boolean test(List<Card> list) {
119        return (list.size() >= required()
120                && is.test(subListTo(list, required())));
121    }
122
123    private Predicate<List<Card>> with(Predicate<List<Card>> that) {
124        return t -> test(t) && that.test(subListFrom(t, required()));
125    }
126
127    private static <T> Predicate<List<T>> holding(int count,
128                                                  Predicate<List<T>> predicate) {
129        return t -> (t.isEmpty() || predicate.test(subListTo(t, count)));
130    }
131
132    @SafeVarargs
133    @SuppressWarnings({ "varargs" })
134    private static <T> Predicate<List<T>> holding(Predicate<T>... array) {
135        return holding(Stream.of(array).collect(Collectors.toList()));
136    }
137
138    private static <T> Predicate<List<T>> holding(List<Predicate<T>> list) {
139        return t -> ((list.isEmpty() || t.isEmpty())
140                     || (list.get(0).test(t.get(0))
141                         && (holding(subListFrom(list, 1))
142                             .test(subListFrom(t, 1)))));
143    }
144
145    private static <T> List<T> subListTo(List<T> list, int to) {
146        return list.subList(0, Math.min(to, list.size()));
147    }
148
149    private static <T> List<T> subListFrom(List<T> list, int from) {
150        return list.subList(from, list.size());
151    }
152
153    /**
154     * {@link Comparator} that orders {@link Ranking}s weakest to
155     * strongest.
156     */
157    public static Comparator<Ranking> COMPARATOR =
158        Comparators.orderedBy(Arrays.asList(values()));
159}