#include <stdio.h>
#include <iostream>
#include <math.h>
#include <time.h>
#include <stdlib.h>
#include <windows.h>

#define SIZE 52
#define HALF_SIZE 26

using namespace std;

typedef enum Suit { Diamonds, Hearts, Spades, Clubs } Suit_t;
typedef enum Power { Two = 2, Three, Four, Five, Six, Seven, Eight, Nine, Ten, Jack, Queen, King, Ace } Power_t;

typedef struct card {
	Suit_t suit;
	Power_t power;
}cards;

typedef struct deck {   // alokacja struktury
	cards* p_deck;
	int size;
}decks;

void Deck_Creator(cards* deck) {
	for (int i = 0; i < SIZE; i++) {
		deck[i].suit = (Suit)(i / 13);
		deck[i].power = (Power)(i % 13);
	}

}

void Display_Deck(cards* deck) {
	for (int i = 0; i < SIZE; i++) {

		if (deck[i].suit == Diamonds) {
			cout << "Diamond ";
		}
		else if (deck[i].suit == Hearts) {
			cout << "Heart ";
		}
		else if (deck[i].suit == Spades) {
			cout << "Spade ";
		}
		else {
			cout << "Club ";
		}
		cout << " " << deck[i].power << endl;
		cout << endl;
	}
}

void Deck_Shuffler(cards* deck) {
	int changer = 0;               // Index of changed card
	cards temp = {};             // Temporary holding place for changing
	srand(time(NULL));            // Function to get random numbers with current time
	for (int i = 0; i < SIZE; i++) {
		changer = rand() % SIZE;   // Generating random number from 0 to 51
		temp = deck[i];
		deck[i] = deck[changer];  // if changer = i
		deck[changer] = temp;
	}
}

void Deck1_Creator(cards* deck1, cards* deck, decks* q_deck1) {
	for (int i = 0; i < HALF_SIZE; i++) {
		memcpy(&deck1[i], &deck[i], sizeof(cards));  // Copying content using memcpy function
	}
	q_deck1->p_deck = deck1;
	q_deck1->size = HALF_SIZE;
}

void Deck2_Creator(cards* deck, cards* deck2, decks* q_deck2) {
	int i = HALF_SIZE;
	for (int i = 26; i < SIZE; i++) {
		deck2[i - HALF_SIZE] = deck[i];   // Simple copying struct array content into another array
	}
	q_deck2->p_deck = deck2;
	q_deck2->size = HALF_SIZE;
}

void table_creator(decks* q_deck, cards* array) {

	q_deck->p_deck = array;
	q_deck->size = 0;
}

void enqueue(decks* q_deck, cards card) {

	// decks* p_deck = (decks*)malloc(sizeof(*p_deck)); <- Taki malloc nie pomaga
	q_deck->p_deck[q_deck->size] = card;        // ADDING CARD ON THE TOP
	q_deck->size++;
}

cards dequeue(decks* q_deck) {
	cards tmp_card;
	tmp_card = q_deck->p_deck[0];
	for (int i = 0; i < q_deck->size - 1; i++) {    // TAKING CARD FROM THE BOTTOM
		q_deck->p_deck[i] = q_deck->p_deck[i + 1];
	}
	q_deck->size--;

	return tmp_card;
}

void disp_queue(decks* q_deck) {
	for (int i = 0; i < q_deck->size; i++) {
		cout << q_deck->p_deck[i].suit <<" ";
		cout << q_deck->p_deck[i].power << endl;
	}
}

void Compare(decks* q_table1, decks* q_table2, decks* q_deck1, decks* q_deck2) {
	int i = 0;
	int j = 0;
	{
		if (q_table1->p_deck[i].power > q_table2->p_deck[i].power) {
			cards tmp_card = dequeue(q_table2);                             // One way to take card from table 2 and put it into the deck 1
			enqueue(q_deck1, tmp_card);
			enqueue(q_deck1, dequeue(q_table1));                            // The other way, without temporary card (tmp_card)
		}
		else if (q_table1->p_deck[i].power < q_table2->p_deck[i].power) {
			cards tmp_card = dequeue(q_table1);
			enqueue(q_deck2, tmp_card);
			enqueue(q_deck2, dequeue(q_table2));
		}
		else if (q_table1->p_deck[i].power == q_table2->p_deck[i].power) {     // sprawdzic czy dodaje na spód, czy górę
			int j = 0;
			enqueue(q_table1, dequeue(q_deck1));
			enqueue(q_table2, dequeue(q_deck2));
			enqueue(q_table1, dequeue(q_deck1));
			enqueue(q_table2, dequeue(q_deck2));
			if (q_table1->p_deck[i + 2].power > q_table2->p_deck[i + 2].power) {
				while(q_table2->size != 0){
					enqueue(q_deck1, dequeue(q_table2));
				}
				while (q_table1->size != 0) {
					enqueue(q_deck1, dequeue(q_table1));
				}
			}
			else if (q_table1->p_deck[i + 2].power < q_table2->p_deck[i + 2].power) {
				while (q_table2->size != 0) {
					enqueue(q_deck2, dequeue(q_table1));
				}
				while (q_table1->size != 0) {
					enqueue(q_deck2, dequeue(q_table2));
				}
			}
			else if ((q_table1->p_deck[i + 2].power == q_table2->p_deck[i + 2].power)) {
				cout << "2nd draw in the row" << endl;

			}

		}
	}
	enqueue(q_table1, dequeue(q_deck1));
	enqueue(q_table2, dequeue(q_deck2));
}

int main() {
	cards deck[SIZE];
	cards deck1[SIZE];
	cards deck2[SIZE];
	cards table1[SIZE];
	cards table2[SIZE];
	decks q_deck1;            //Queues from struct decks. Containing size, and pointer to cards structure
	decks q_deck2;
	decks q_table1;
	decks q_table2;
	cards* p_deck;
	char choice;

	table_creator(&q_table1, table1);     //Gives addres for table 1 queue
	table_creator(&q_table2, table2);     //Gives addres for table 2 queue

	for(; ;) {  //Never ending loop
		cin >> choice;
		switch (choice) {
		case '1':
			cout << endl << "Unshuffled deck: " << endl;
			Deck_Creator(deck);
			Display_Deck(deck);
			break;
		case '2':
			cout << endl << "Shuffled deck: " << endl;
			Deck_Shuffler(deck);
			Display_Deck(deck);
			break;
		case '3':
			cout << endl << "Hand 1:" << endl;
			Deck1_Creator(deck1, deck, &q_deck1);
			disp_queue(&q_deck1);
			break;
		case '4':
			cout << endl << "Hand 2:" << endl;
			Deck2_Creator(deck, deck2, &q_deck2);
			disp_queue(&q_deck2);
            break;
		case '5':
			cards tmp_card = dequeue(&q_deck1); // Returns card taken from deck 1. That card is tmp_card
			enqueue(&q_table1, tmp_card);        // Gives our tmp_card to the table1
			tmp_card = dequeue(&q_deck2);       // Returns card taken from deck 2.
			enqueue(&q_table2, tmp_card);        // Gives tmp_card to the table2
            disp_queue(&q_table1);               // Shows table1
			disp_queue(&q_table2);               // Shows table2
			break;
		case '6':
			Compare(&q_table1, &q_table2, &q_deck1, &q_deck2);
			break;
		case '7':
			disp_queue(&q_deck1);
			break;
		case '8':
			disp_queue(&q_deck2);
			break;
		case '9':
			disp_queue(&q_table1);               // Shows table1
			disp_queue(&q_table2);               // table 2
			break;
		//case '10':
		//	while (&q_deck1)
		}
	}
	return 0;
}