/******************************************************\
* deck.java                                            *
* by Daniel Wedul                                      *
* Last Modified 5/27/02                                *
>******************************************************<
* This class describes a deck of playing cards         *
*  A deck is basically a stack of 52 cards             *
*  pile is the array of cards, cardsleft is the number *
*  of cards left in the deck                           *
* the "top" of the deck is the end of the array        *
* a joker may be added to the deck to make it 53 cards *
>******************************************************<
* The shuffle works as follows.                        *
* It goes through each entry in the deck               *
*  at each entry it picks another entry and the cards  *
*  are swapped. This is done up to 50 times.           *
\******************************************************/

import java.util.Random;

class deck
{
    private int cardsleft;
    private int numberofcards;
    private boolean joker;
    private card[] pile = new card[53];
    private Random generator = new Random();
    //note: if there is no joker, card pile[52] is not used

    /**************\
    * constructors *
    \**************/

    // just a regular 52 card deck
    public deck()
    {
      numberofcards = 52;
      joker = false;
      createdeck();
    } // end constructor/

    // a deck with a joker as long as j is true
    public deck(boolean j)
    {
      joker = j;
      numberofcards = 52;
      if (j)
      {
          numberofcards = 53;
          pile[52] = new card(15,5);
      }
      createdeck();
    }
    
    /******************\
    * end constructors *
    \******************/

    // get size, returns the number of cards left in the deck
    public int getsize()
    {
      return cardsleft;
    } // end getsize

    // a method to get the top card in the deck
    public card draw()
    {
      card retval = new card(0,0);
      if (cardsleft >= 1)
      {
          cardsleft--;
          retval = pile[cardsleft];
          pile[cardsleft] = new card(0,0);
      }
      return retval;
    } // end draw 

    // a method to put a card back in the deck
    public card returncard(card a)
    {
      card retval = new card(0,0);
      if (cardsleft < numberofcards)
      {
          pile[cardsleft] = a;
          cardsleft++;
      }
      return retval;
    } // end returncard
   
    // a method to test if there are no cards left
    public boolean isempty()
    {
      return (cardsleft < 1);
    } // end isempty 

    // a method to test if the deck is complete
    public boolean ismissingcards()
    {
      card tester;   //the card in question
      boolean found = false; //assume it isn't found
      int problems = 0;  //the number of cards missing
      //if there are less than numberofcards cards in the deck it isn't full
      if(cardsleft < numberofcards) return true;
   
      deck a = new deck(joker);   // create a good deck
   
          // go through each card in the good deck
      for (int i = 0;i<numberofcards;i++)    
      {
          tester = a.draw();  
          found = false;
          for (int j=0;j<numberofcards;j++)  // go through each card in the deck
          {
            if (tester.issameas(pile[j]) )   
            {
                found = true;
                j = numberofcards;   //exits for loop
            }
          }
   
          if (!found)
          {
            problems++;
            tester.printcard();
          }
      }

      if (problems != 0) System.out.println(" are missing");

      // if problems != 0 then the deck is short, return true.
      return (problems != 0);

    } // end ismissingcards 

    // a method to shuffle the deck
    public void shuffle()
    {
      Random generator = new Random();

      for(int i=0;i<cardsleft;i++)
      {
          for(int j=0; j<(Math.abs(generator.nextInt()%(numberofcards - 1)))+1;
		j++)
          {
            int swapindex = Math.abs(generator.nextInt() % cardsleft);
            card temp = pile[i];
            pile[i] = pile[swapindex];
            pile[swapindex] = temp;
          }
      }
    }

    // a method to cut the deck
    public boolean cut()
    {
      // find the pivot card
      int depth = cardsleft / 2 + (generator.nextInt() % 9)-4;
      card[] top = new card[depth];
   
      // copy all cards before the pivot to another array
      for (int i=0;i<depth;i++)
      {
          top[i] = pile[i];
      }
      // copy all cards after and including the pivot to
      //  the beginning of the array
      for (int i=0;i<cardsleft - depth;i++)
      {
          pile[i]=pile[depth+i];
      }
      // copy the cards from the temp array to the end of the array
      for (int i=0;i<depth;i++)
      {
          pile[cardsleft - depth+i]=top[i];
      }
      //return that it worked
      return true;
    } // end cut 

    // a method to print all cards in the deck
    public void printdeck()
    {
      for (int i=0;i<cardsleft;i++)
      {
          if ( (i%13 == 0) && (i != 0) )
          {
            System.out.println("");
          }
          else
          {
            if (i != 0) System.out.print (" ");
          }
          if (pile[i] != null)
             pile[i].printcard();
          else
            System.out.print ("Er");

      }
      System.out.println("");
    } // end printdeck 

    private void createdeck()
    {
          int i;
      int j;
      for (j=1;j<=4;j++)
      {
          for (i=1;i<=13;i++)
          {
            pile[13*(j-1)+i-1] = new card(i,j);
          }
      }
      cardsleft =  numberofcards;
    } // end creatdeck

} // end class deck


//end deck.java