/**********************************************************
  File:          poker.cc                              
  Description:   A program that simulates a simple poker 
                 game to serve as an example of using the
                 Scatter and Gather functions from MPI.
                                                         
  Author:        Dana Vrajitoru                          
  Organization:  IUSB                                    
  Date:          October 14, 2004
***********************************************************/

#include <iostream>
using namespace std;
#include <mpi.h>
#include "poker.h"
#include "common.h"

// Main poker playing function.
void Poker_play(int proc_id, int nb_proc)
{
  int *all_cards=NULL, score, *all_scores=NULL;
  int my_hand[hand_size];
  int nb_cards = nb_proc * hand_size;
  if (proc_id == 0) {
    Draw_card(true);
    all_cards = new int[nb_cards];
    for (int i=0; i<nb_cards; i++)
      all_cards[i] = Draw_card();
  }

  // To be added by the student:

  // At this point the array all_cards is scattered among the
  // processes. The root or source process is 0. The receive array is
  // my_hand. The send array is all_cards.

  // MPI_Scatter();

  Print_hand(my_hand, proc_id);
  score = Score(my_hand);

  // To be added by the student:

  // Now the master must gather the scores from all the slaves into
  // the array all_scores which should be of size nb_proc. This will
  // be done by an MPI_Gather in which the send array is just the
  // variable score (address of...)  of size 1.

  // Allocate the memory for the array all_scores.
  // MPI_Gather();

  if (proc_id == 0)
    Find_winner(all_scores, nb_proc);
}

// Print all the cards in the hand and the process id.
void Print_hand(int *hand, int proc_id)
{
  cout << "Player " << proc_id << " has the following hand: ";
  for (int i=0; i<hand_size; i++)
    switch (hand[i]) {
    case 1:
      cout << " A "; break;
    case 10:
      cout << "10 "; break;
    case 11:
      cout << " J "; break;
    case 12:
      cout << " Q "; break;
    case 13:
      cout << " K "; break;
    default:
      cout << ' ' << hand[i] << ' ';
    }
  cout << endl;
}

// Find the id of the process that has the highest score and display
// it as the winner. If there's a tie, you should also report that.
void Find_winner(int *all_scores, int nb_proc)
{
  // Code to be supplied by the student.
}

// Generates a random card. The cards are identified by numbers
// between 0 and 13 and each of them can only appear 4 times in the
// game. The function should be called with the reset parameter being
// true once at the begining of a new game. The default value for the
// reset parameter is false.
int Draw_card(bool reset) 
{
  static int drawn[14];
  int card=-1;
  if (reset) 
    for (int i=1; i<14; i++)
      drawn[i] = 0;
  else {
    do 
      card = rand() % 13 + 1;
    while (drawn[card] >= 4);
    drawn[card]++;
  }
  return card;
}

// Computes the score of the hand by sorting the cards first and then
// calling the other functions bellow.
int Score(int *hand)
{
  // For only 5 elements it's not worth using the quicksort.
  Selection_sort(hand, hand_size);

  if (Four_of_a_kind(hand))
    return 60;
  else if (Full_house(hand))
    return 50;
  else if (Straight(hand))
    return 40;
  else if (Three_of_a_kind(hand))
    return 30;
  else if (Two_pairs(hand))
    return 20;
  else if (Pair(hand))
    return 15;
  else // If none of these applies, the score is the highest card.
    return hand[hand_size-1]; // hand is sorted at this point.
}

// For the following functions, the hand should have at least 5
// elements and only 5 will be used even if there are more. We will
// assume that the cards have been sorted before the functions are
// called. The functions should be called in decreasing order of
// importance, such that the function "Pair" for example should not
// worry if the hand is in fact a "3 of a kind".

// Verifies if the hand has 4 of a kind cards, meaning 4 cards with
// the same number. 
bool Four_of_a_kind(int *hand)
{
  // Code to be supplied by the student.
  // Statement for compilation.
  return false;
}

// Verifies if the hand is a full house, meaning 3 cards of a kind
// plus a pair of a different number.
bool Full_house(int *hand)
{
  if (hand[0] == hand[1] && hand[1] == hand[2] &&
      hand[3] == hand[4])
    return true;
  if (hand[0] == hand[1] && 
      hand[2] == hand[3] && hand[3] == hand[4])
    return true;
  return false;
}

// Verifies if the cards are in sequence.
bool Straight(int *hand)
{
  // Code to be supplied by the student.
  // Statement for compilation.
  return false;
}

// Verifies if the hand has 3 of a kind cards, meaning 3 cards with
// the same number.
bool Three_of_a_kind(int *hand)
{
  // Code to be supplied by the student.
  // Statement for compilation.
  return false;
}

// Verifies if there are 2 pairs of cards in the hand.
bool Two_pairs(int *hand)
{
  int i, j;
  bool pair = false;
  for (i=0; i<hand_size-1 && !pair; i++)
    if (hand[i] == hand[i+1])
      pair = true;
  if (pair)
    for (j=i+1; j<hand_size-1; j++)
      if (hand[j] == hand[j+1])
	return true;
  return false;  
}

// Verifies if there are 2 pairs of cards in the hand.
bool Pair(int *hand)
{
  for (int i=0; i<hand_size-1; i++)
    if (hand[i] == hand[i+1])
      return true;
  return false;
}