using System;

using System.Collections.Generic;

using System.Linq;

​

// Assumptions

// Suit does not play a role in the scoring of a hand

// The deck is infinite, number of players are infinite

// flush > 3 of a kind > one pair > high card

​

namespace poker

{

  public class Program

  {

    public static void Main(string[] args)

    {

      Console.WriteLine("Hello World!");

      for (int i = 0; i < 5; i++) {

        Hand hand = new Hand();

        Console.WriteLine($"Hand: {hand}");

        Console.WriteLine($"Score: {hand.score()}");

      }

      Hand test = new Hand("2S","2C","2H","3H","4C");

      Console.WriteLine(test.score());

      Hand test2 = new Hand("2S","3C","4D","AS","AD");

      Console.WriteLine(test2.score());

    }

  }

​

  public class Card {

​

    // Class variables

    public static IDictionary<string, int> ranks = new Dictionary<string, int>() {

      { "2", 2 },

      { "3", 3 },

      { "4", 4 },

      { "5", 5 },

      { "6", 6 },

      { "7", 7 },

      { "8", 8 },

      { "9", 9 },

      { "10", 10 },

      { "J", 11 },

      { "Q", 12 },

      { "K", 13 },

      { "A", 14 }

    };

​

    public static List<char> suits = new List<char>() {

      'S',

      'C',

      'H',

      'D'

    };

    public static Random rnd = new Random();

​

    // Instance variables

    // rank is the value of the face

    public int rank;

    public char suit;

    // Face is the face of the card

    public string face;

​

    public Card(

      string cardValue

    ) {

      getCardValue(cardValue);

    }

​

    public Card() {

      int min_val = ranks.Values.Min();

      face = ranks.ElementAt(rnd.Next(ranks.Count)).Key;

      rank = ranks[face];

      suit = suits[rnd.Next(suits.Count)];

    }

​

    public void getCardValue(string card_value) {

      int length = card_value.Length;

      face = card_value.Substring(0, length - 1);

      rank = ranks[face];

      suit = card_value[1];

    }

​

    public override string ToString() {

      return face + suit;

    }

​

  }

​

  public class Hand {

    public IList<Card> cards = new List<Card>();

    public static Random rnd = new Random();

​

    public void generateCards() {

      for (int i=0; i<5; i++) {

        cards.Add(new Card());

      }

    }

​

    public Hand() => generateCards();

​

    public Hand(

      string card1,

      string card2,

      string card3,

      string card4,

      string card5

      ) {

        cards.Add(new Card(card1));

        cards.Add(new Card(card2));

        cards.Add(new Card(card3));

        cards.Add(new Card(card4));

        cards.Add(new Card(card5));

    }

​

    public int score() {

      // Consider a hand with only a high card, the highest being Ace

      // In the event two players both have a Ace, then the

      // second highest card wins and so on

      // Therefore the best hand a player can have without

      // any pair (including 3 of a kind) or flush is

      // A,K,Q,J,10

      // The sum of these values is 14+13+12+11+10 = 60

      // A pair, even the lowest pair possible (2,2) should beat

      // The highest high card you can get, therefore the lowest

      // pair should count for 61

      // e.g. 2,2,3,4,5 without pair bonus would be 16

      // v.s. the highest hand with only a high card A,K,Q,J,10 = 60

      // 60 - 16 = 44, so the lowest pair must be >= 45

      // A pair of 3s beats a pair of 2s, so a pair should be scored as

      // 43 + rank(pair)

      // i.e. for 2, it would be 43 + 2 = 45

      // for 3, 43 + 3 = 46

      // 3 of a kind beats one pair and high card, so the lowest

      // 3 of a kind must be better than the best pair

      // 2,2,2,3,4 > A,A,K,Q,J

      // A,A,K,Q,J = 14 + 14 + 13 + 12 + 11 + (43 + 14) = 121

      // 2,2,2,4,5 = 122

      // So 122 - 2 - 2 - 2 - 4 - 5 = 107

      // Therefore 3 of a kind is 105 + rank(trio)

      // Finally, a flush beats 3 of a kind

      // So the worst flush should beat the best 3 of a kind

      // All flushes are the same, therefore no rank dependent

      // on the card value is required

      // 2,3,4,5,6 (same suit) > A,A,A,K,Q

      // A,A,A,K,Q = 14 + 14 + 14 + 13 + 12 + (105 + 14) = 186

      // Therefore the worst flush must be worth >= 187 points

      // The worst flush 2,3,4,5,6 = 2 + 3 + 4 + 5 + 6 = 20

      // 187 - 20 = 167

​

      // Get hand information

      var info = getCounts();

      int score = 0;

      int bonus = 0;

      var suit_counts = info.Item1;

      var rank_counts = info.Item2;

      bool is_flush = false;

      bool is_threeofakind = false;

      bool is_onepair = false;

      foreach ( KeyValuePair<int, int> kvp in rank_counts ) {

        // Console.WriteLine($"k: {kvp.Key}, v: {kvp.Value}");

        if (kvp.Value == 2) {

          is_onepair = true;

          bonus = kvp.Key;

        }

        if (kvp.Value == 3) {

          is_threeofakind = true;

          bonus = kvp.Key;

        }

        score += (kvp.Key * kvp.Value);

      }

​

      // Console.WriteLine($"Bonus: {bonus}");

​

      // Compute bonuses

      int flush_bonus = 167;

      int threeofakind_bonus = 105 * (bonus * 3);

      int onepair_bonus = 43 * (bonus * 2);

      if (suit_counts.Count == 1) is_flush = true;

      if (is_flush) {

        score += flush_bonus;

      } else if (is_threeofakind) {

        score += threeofakind_bonus;

      } else if (is_onepair) {

        score += onepair_bonus;

      }

      // Console.WriteLine("Suit Counts");

      // foreach ( KeyValuePair<char, int> entry in suit_counts ) {

      //   Console.WriteLine($"Key: {entry.Key}, Val: {entry.Value}");

      // }

      // Console.WriteLine("Rank Counts");

      // foreach ( KeyValuePair<int, int> entry in rank_counts ) {

      //   Console.WriteLine($"Key: {entry.Key}, Val: {entry.Value}");

      // }

      return score;

    }

​

    public Tuple<IDictionary<char, int>, IDictionary<int, int>> getCounts() {

      IDictionary<char, int> suit_counts = new Dictionary<char, int>();

      IDictionary<int, int> rank_counts = new Dictionary<int, int>();

      foreach (Card card in cards) {

        if (suit_counts.ContainsKey(card.suit)) {

          suit_counts[card.suit] += 1;

        } else {

          suit_counts.Add(card.suit, 1);

        }

        if (rank_counts.ContainsKey(card.rank)) {

          rank_counts[card.rank] += 1;

        } else {

          rank_counts.Add(card.rank, 1);

        }

      }

      Tuple<IDictionary<char, int>, IDictionary<int, int>> results = Tuple.Create(suit_counts, rank_counts);

      // var results = (suit_counts, rank_counts);

      return results;

    }

​

    public override string ToString() {

      return string.Join(",", cards);

    }

​

  }

​

}

​