#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 structure, without defining it
struct Deck;

struct Card
{
    Rank rank;
    Suit suit;

    Card (Suit s, Rank r);
    Card ();
    void print () const;
    bool isGreater (const Card& c2) const;
    int find (const Deck& deck) const;
    int findSorted (const Deck& deck) const;
    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.rank == c2.rank && c1.suit == c2.suit);
}

struct Deck {
    vector<Card> cards;

    Deck (int n); // create uninitialized deck of size n
    Deck (); // create a completed, sorted deck of cards
    void print () const;
    Deck subdeck (int low, int high) const;
    void shuffle ();
};

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

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

    int i = 0; // next vector element to initialize
    for (Suit suit = CLUBS; suit <= SPADES; suit = Suit(suit+1)) {
        for (Rank rank = ACE; rank <= KING; rank = Rank(rank+1)) {
            cards[i].suit = suit;
            cards[i].rank = rank;
            i++;
        }
    }
}

void Deck::print () const {
    for (int i = 0; i < cards.size(); i++) {
        cards[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;
    }
}

/*
int Card::find (const Deck& deck) const {
    for (int i = 0; i < deck.cards.size(); i++) {
        if (equals (deck.cards[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.cards[mid], *this)) return mid;
    if (deck.cards[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.cards.size()-1);
}

Deck merge (const Deck& d1, const Deck& d2) {
    // create a new deck big enough for all the cards
    Deck result (d1.cards.size() + d2.cards.size());

    // 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.cards.size(); k++) {

        // if d1 is empty, d2 wins; if d2 is empty, d1 wins;
        // otherwise, compare the two cards

        // add the winner to the new deck
    }
    return result;
}

int main () {
    Card card (DIAMONDS, JACK);
    card.print();
    Card c2;
    c2.print();
    cout << "Comparison " << c2.isGreater(card) << endl;

    Deck deck; // give me a new deck of cards
    Card AceSpades (SPADES, ACE);
    cout << AceSpades.findSorted (deck);

//    deck.print();
    /*
    cout << "Shuffled deck:\n";
    deck.shuffle();
    deck.print();
    Deck hand1 = deck.subdeck(0,4);
    Deck hand2 = deck.subdeck(5,9);
    cout << "\nHand 1:\n";
    hand1.print();
    cout << "\nHand 2:\n";
    hand2.print();
     */

    return 0;
}