#include <numeric>
#include <set>


enum ResultHand {RoyalFlush, StraightFlush, FourOfAKind, FullHouse, Flush, Straight, ThreeOfAKind, TwoPair, OnePair, HighCard};

struct Card {
public:
  Card(char value, char suit) : value(value) , suit(suit) {};
  char value;
  char suit;
};

struct PokerHand {
  PokerHand (const char* pokerhand)
  {
    for(int i = 0; i < strlen(pokerhand) ; i=i+3)
    {
      cards.push_back(Card(pokerhand[i], pokerhand[i+1]));
    }
    fillMapWithCardValues();
    sum = sumOfValueCards();
    resultHand = checkResultHand();
  }

  void fillMapWithCardValues()
  {
    int value = 0;
    cardValues['2'] = ++value;
    cardValues['3'] = ++value;
    cardValues['4'] = ++value;
    cardValues['5'] = ++value;
    cardValues['6'] = ++value;
    cardValues['7'] = ++value;
    cardValues['8'] = ++value;
    cardValues['9'] = ++value;
    cardValues['T'] = ++value;
    cardValues['J'] = ++value;
    cardValues['Q'] = ++value;
    cardValues['K'] = ++value;
    cardValues['A'] = ++value;
  }
  bool isAllSameSuit(char color)
  {
    return std::all_of(cards.begin(), cards.end(), [color](Card card) {
      return card.suit == color;
    });
  }
  bool isFlush()
  {
    return (isAllSameSuit('S') || isAllSameSuit('H') || isAllSameSuit('D') || isAllSameSuit('C'));
  }

  bool isStraight()
  {
    std::vector<int> tmp;
    std::transform(cards.begin(), cards.end(), std::back_inserter(tmp),
    [this](const Card& card) {return cardValues.at(card.value);});
    std::sort(tmp.begin(), tmp.end());
    bool flag = true;
    for(int i=0; i<tmp.size() - 1; i++)
    {
      if((tmp[i]+1) != tmp[i+1])
      {
        flag = false;
      }
    }
//     std::cout << "FLAG: " << flag << std::endl;
    return isFiveHighStraight() || flag;
  }

  bool isFiveHighStraight()
  {
    int sum = cardValues.at('A') + cardValues.at('2') + cardValues.at('3') + cardValues.at('4') + cardValues.at('5');
    return sum == sumOfValueCards();
  }

  bool isStraightFlush()
  {
    return isStraight() & isFlush();
  }

  bool isRoyalFlush()
  {
    int sum = cardValues.at('T') + cardValues.at('J') + cardValues.at('Q') + cardValues.at('K') + cardValues.at('A');
    return sum == sumOfValueCards() && isFlush();
  }

  int sumOfValueCards()
  {
    int sum = 0;
    for(const auto& card : cards)
    {
      sum = sum + cardValues.at(card.value);
    }
    return sum;
  }

  std::set <char> sameCards(int value)
  {
    std::set<char> tmp;
    for(const auto& x : cardValues)
    {
      if(std::count_if(cards.begin(), cards.end(), [x, value](const Card& card) {return card.value == x.first;}) == value)
      {
        tmp.insert(x.first);
      }
    }
    sumOfResult = 0;
    for(const auto& x : tmp)
    {
      sumOfResult += cardValues.at(x);
    }
    return tmp;
  }

  bool isTheSameCard(int value)
  {
    auto theSameCards = sameCards(value);
    if(theSameCards.empty())
    {
      return false;
    }
    sumOfResult = 0;
    for(const auto& x : theSameCards)
    {
      sumOfResult += cardValues.at(x);
    }
    return true;
  }

  bool isFourOfAKind()
  {
    return isTheSameCard(4);
  }

  bool isFullHouse()
  {
    return isTheSameCard(3) && isTheSameCard(2);
  }

  bool isThreeOfAKind()
  {
    return isTheSameCard(3);
  }

  bool isTwoPairs()
  {
    return sameCards(2).size() == 2;
  }

  bool isOnePair()
  {
    return sameCards(2).size() == 1;
  }

  char theHighestCard()
  {
    auto max = cards.begin()->value;
    for(const auto& card : cards)
    {
      if(card.value > max)
      {
        max = card.value;
      }
    }
    return max;
  }

  ResultHand checkResultHand()
  {
    if(isRoyalFlush())
    {
      return ResultHand::RoyalFlush;
    }
    if(isStraightFlush())
    {
      return ResultHand::StraightFlush;
    }
    if(isFourOfAKind())
    {
      return ResultHand::FourOfAKind;
    }
    if(isFullHouse())
    {
      return ResultHand::FullHouse;
    }
    if(isFlush())
    {
      return ResultHand::Flush;
    }
    if(isStraight())
    {
      return ResultHand::Straight;
    }
    if(isThreeOfAKind())
    {
      return ResultHand::ThreeOfAKind;
    }
    if(isTwoPairs())
    {
      return ResultHand::TwoPair;
    }
    if(isOnePair())
    {
      return ResultHand::OnePair;
    }
    else
    {
      highestCard = theHighestCard();
      return ResultHand::HighCard;
    }
  }

    int sum;
    int highestCard;
    int sumOfResult{0};
    ResultHand resultHand;
      std::vector<Card> cards;

private:


  std::map<char, int> cardValues;
};

enum class Result { Win, Loss, Tie };

Result compare (const PokerHand &player, const PokerHand &opponent) {
    for(const auto& card : player.cards)
    {
      std::cout << card.value << card.suit << " ";
    }
    std::cout<<std::endl;
    for(const auto& card : opponent.cards)
    {
      std::cout << card.value << card.suit << " ";
    }
    std::cout << std::endl;
  std::cout << "PLAYER: " << player.resultHand;
  std::cout << "OPPONENT: " << opponent.resultHand << std::endl;

  if(player.resultHand > opponent.resultHand)
  {
    return Result::Loss;
  }
  if(player.resultHand < opponent.resultHand)
  {
    return Result::Win;
  }
  if(player.resultHand ==  ResultHand::HighCard && opponent.resultHand == ResultHand::HighCard)
  {
    if(player.highestCard > opponent.highestCard)
    {
      return Result::Win;
    }
    if(player.highestCard < opponent.highestCard)
    {
      return Result::Loss;
    }

  }
  if(player.sumOfResult > opponent.sumOfResult)
  {
    return Result::Win;
  }
  if(player.sumOfResult < opponent.sumOfResult)
  {
    return Result::Loss;
  }
  if(player.sum > opponent.sum)
  {
    return Result::Win;
  }
  if(player.sum < opponent.sum)
  {
    return Result::Loss;
  }
  return Result::Tie;
}