#include <iostream>
#include <vector>
#include <string>
using namespace std;

enum Suit { CLUBS, DIAMONDS, HEARTS, SPADES };

enum Rank { ACE=1, TWO, THREE, FOUR, FIVE, SIX, SEVEN, EIGHT, NINE,
    TEN, JACK, QUEEN, KING };

// declare that Deck is a class, without defining it
class Deck;

class Card
{
    Suit suit;
    Rank rank;

public:
    // constructors
    Card ();
    Card (Suit s, Rank r);

    // accessor functions
    int getRank () const { return rank; }
    int getSuit () const { return suit; }
    void setRank (Rank r) { rank = r; }
    void setSuit (Suit s) { suit = s; }

    // other functions
    void print () const;
    bool isGreater (const Card& c2) const;
    int find (const Deck&) const;
    int findSorted (const Deck& deck) const;

private:
    int findBetween (const Deck& deck, int low, int high) const; //helper function

};

Card::Card (Suit s, Rank r) {
    suit = s;  rank = r;
}

Card::Card () {
    suit = CLUBS; rank = ACE;
}

void Card::print () const
{
    vector<string> suits (4);
    suits[CLUBS] = "Clubs";
    suits[DIAMONDS] = "Diamonds";
    suits[HEARTS] = "Hearts";
    suits[SPADES] = "Spades";

    vector<string> ranks (14);
    ranks[ACE] = "Ace";
    ranks[TWO] = "2";
    ranks[THREE] = "3";
    ranks[FOUR] = "4";
    ranks[FIVE] = "5";
    ranks[SIX] = "6";
    ranks[SEVEN] = "7";
    ranks[EIGHT] = "8";
    ranks[NINE] = "9";
    ranks[TEN] = "10";
    ranks[JACK] = "Jack";
    ranks[QUEEN] = "Queen";
    ranks[KING] = "King";

    cout << ranks[rank] << " of " << suits[suit] << endl;
}

bool Card::isGreater (const Card& c2) const
{
    // first check the suits
    if (suit > c2.suit) return true;
    if (suit < c2.suit) return false;

    // if the suits are equal, check the ranks
    if (rank > c2.rank) return true;
    if (rank < c2.rank) return false;

    // if the ranks are also equal, return false
    return false;
}

bool equals (const Card& c1, const Card& c2)
{
    return (c1.getRank() == c2.getRank() && c1.getSuit() == c2.getSuit() );
}

class Deck {
    vector<Card> cards;

public:
    // constructors
    Deck (int n); // create uninitialized deck of size n
    Deck (); // create a completed, sorted deck of cards

    // accessor function
    // D.getCards() returns a vector containing the Cards in Deck D.
    vector<Card> getCards () const { return cards; };

    // other functions
    void print () const;
    Deck subdeck (int low, int high) const;
    void shuffle ();
    void merge (const Deck& d1, const Deck& d2);
    void sort();
    void mergeSort();
};

Deck::Deck (int size)
{
    vector<Card> temp (size);
    cards = temp;
}

Deck::Deck ()
{
    vector<Card> temp (52);
    cards = temp;

    int i = 0;
    for (Suit suit = CLUBS; suit <= SPADES; suit = Suit(suit+1)) {
        for (Rank rank = ACE; rank <= KING; rank = Rank(rank+1)) {
            cards[i].setSuit (suit);
            cards[i].setRank (rank);
            i++;
        }
    }
}

// print() member function of Deck
void Deck::print () const {
    for (int i = 0; i < cards.size(); i++) {
        cards[i].print ();
    }
}

// stand-alone printDeck(D) to print a deck
void printDeck (const Deck& deck) {
    for (int i = 0; i < deck.getCards().size(); i++) {
        deck.getCards()[i].print();
    }
}

Deck Deck::subdeck (int low, int high) const {
    Deck sub (high-low+1);

    for (int i = 0; i<sub.cards.size(); i++) {
        sub.cards[i] = cards[low+i];
    }
    return sub;
}

void Deck::shuffle () {
    // go trough the cards one at a time (i is the card)
    for (int i = 0; i < cards.size()-1; i++) {
        // choose a random number between i and the end of the deck
        int randCard = i + 1 + rand() % (cards.size() - i - 1);
        // swap the ith card and the randomly-chosen card
        Card temp = cards[i];
        cards[i] = cards[randCard];
        cards[randCard] = temp;
    }
}

void Deck::sort () {
    // loop through all the cards so that the first i are sorted
    for (int i=0; i < cards.size(); i++) {
    // find the lowest card to the right of card i
        int lowest = i;
        for (int j = i+1; j<cards.size(); j++) {
            // if card j is smaller than card lowest, set lowest = j
            if (cards[lowest] . isGreater(cards[j])) lowest = j;
        }
    // swap the i-th card and the lowest card (to the right)
        Card temp = cards[i];
        cards[i] = cards[lowest];
        cards[lowest] = temp;
    // loop invariant: the first i+1 cards are sorted
    }
}

int Card::find (const Deck& deck) const {
    for (int i = 0; i < deck.getCards().size(); i++) {
        if (equals (deck.getCards()[i], *this)) return i;
    }
    return -1;
}

int Card::findBetween (const Deck& deck, int low, int high) const {
    cout << "searching between " << low << " and " << high << endl;
    if (high < low) return -1;
    int mid = (high + low) / 2;
    if (equals(deck.getCards()[mid], *this)) return mid;
    if (deck.getCards()[mid].isGreater (*this)) {
        return findBetween (deck, low, mid-1);
    } else {
        return findBetween (deck, mid+1, high);
    }
}

int Card::findSorted (const Deck& deck) const {
    return findBetween (deck, 0, deck.getCards().size()-1);
}

void Deck::merge (const Deck& d1, const Deck& d2) {
    // create a new vector big enough for all the cards
    vector<Card> result (d1.getCards().size() + d2.getCards().size());
    if (d1.getCards().size() == 0 && d2.getCards().size() == 0) {
        cards = result;
        return;
    }
    // use the index i to keep track of where we are in
    // the first deck, and the index j for the second deck
    int i = 0;
    int j = 0;

    // the index k traverses the result deck
    for (int k = 0; k<result.size(); k++) {
        Card winner;
        // if d1 is empty, d2 wins; if d2 is empty, d1 wins;
        if (i >= d1.getCards().size()) {
            winner = d2.getCards()[j];
            j++;
        } else if (j >= d2.getCards().size()) {
            winner = d1.getCards()[i];
            i++;
        // otherwise, compare the two cards
        } else if (d1.getCards()[i].isGreater(d2.getCards()[j])) {
            winner = d2.getCards()[j];
            j++;
        } else {
            winner = d1.getCards()[i];
            i++;
        }
        // add the winner to the new deck
        result[k] = winner;
    }
    cards = result;
}

void Deck::mergeSort() {
    const int size = cards.size();
    // if the deck is 0 or 1 cards, we're done
    if (size <= 1) return;
    // find the midpoint of the deck
    const int mid = size / 2;
    // divide the deck into two subdecks
    Deck left(0), right(0);
    left = subdeck(0, mid-1);
    right = subdeck(mid, size-1);
    // sort the subdecks using mergeSort
    left.mergeSort();
    right.mergeSort();
    // merge the two halves to get the result
    merge (left, right);
}

int main () {

    Card AceOfSpades (SPADES, ACE);
    Deck deck;
    deck.shuffle();
    cout << "Shuffled deck:\n";
    deck.print();
    cout << "Ace of Spades in position " << AceOfSpades . find(deck) << endl;
    cout << "\nSorted deck:\n";
    deck.sort();
    printDeck(deck);
    cout << "Ace of Spades in position " << AceOfSpades . findSorted(deck) << endl;

    return 0;
}