import java.util.*;

public class Player extends User{

	private int chips;
	protected ArrayList<Card> cardsOnHand;
	
	public Player(String loginName, String password, int chips) {
		super(loginName, password);
		this.chips = chips;
		this.cardsOnHand = new ArrayList<Card>();
	}

	public void addCard(Card card) {
		this.cardsOnHand.add(card);
	}
	
	public void showCardsOnHand() {
		System.out.println(getLoginName());
		for(Card card:this.cardsOnHand) {
			System.out.print(card+" ");
		}
		System.out.println();
	}
	
	public int getChips() {
		return this.chips;
	}
	
	public void addChips(int amount) {
		this.chips+=amount; //no error check
	}
	
	public void deductChips(int amount) {
		this.chips-=amount; //no error check
	}
	
	public void showTotalCardsValue() {
		System.out.println("Value:"+getTotalCardsValue());
	}
	
	public int getTotalCardsValue() {
		int totalValue = 0;
		for(Card card:cardsOnHand) {
			totalValue+=card.getValue();
		}
		return totalValue;
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Player player = new Player("IcePeak","password",100);
		Deck deck = new Deck();
		deck.shuffle();
		Card card1 = deck.dealCard();
		Card card2 = deck.dealCard();
		player.addCard(card1);
		player.addCard(card2);
		player.showCardsOnHand();
		player.showTotalCardsValue();
		
		/*player.deductChips(10);
		System.out.println(player.getChips());
		player.addChips(20);
		System.out.println(player.getChips());
		*/
	}
}
public class Keyboard {

	public static String readString(String prompt) {
		System.out.print(prompt);
		return new java.util.Scanner(System.in).nextLine();
	}

	public static int readInt(String prompt) {
		int input = 0;
		boolean valid = false;
		while (!valid) {
			try {
				input = Integer.parseInt(readString(prompt));
				valid = true;
			} catch (NumberFormatException e) {
				System.out.println("*** Please enter an integer ***");
			}
		}
		return input;
	}

	public static double readDouble(String prompt) {
		double input = 0;
		boolean valid = false;
		while (!valid) {
			try {
				input = Double.parseDouble(readString(prompt));
				valid = true;
			} catch (NumberFormatException e) {
				System.out.println("*** Please enter a double ***");
			}
		}
		return input;
	}

	public static float readFloat(String prompt) {
		float input = 0;
		boolean valid = false;
		while (!valid) {
			try {
				input = Float.parseFloat(readString(prompt));
				valid = true;
			} catch (NumberFormatException e) {
				System.out.println("*** Please enter a float ***");
			}
		}
		return input;
	}

	public static long readLong(String prompt) {
		long input = 0;
		boolean valid = false;
		while (!valid) {
			try {
				input = Long.parseLong(readString(prompt));
				valid = true;
			} catch (NumberFormatException e) {
				e.printStackTrace();
				System.out.println("*** Please enter a long ***");
			}
		}
		return input;
	}

	public static char readChar(String prompt) {
		char input = 0;
		boolean valid = false;
		while (!valid) {
			String temp = readString(prompt);
			if (temp.length() != 1) {
				System.out.println("*** Please enter a character ***");
			} else {
				input = temp.charAt(0);
				valid = true;
			}
		}
		return input;
	}

	public static boolean readBoolean(String prompt) {
		boolean valid = false;
		while (!valid) {
			String input = readString(prompt);
			if (input.equalsIgnoreCase("yes") || input.equalsIgnoreCase("y") || input.equalsIgnoreCase("true")
					|| input.equalsIgnoreCase("t")) {
				return true;
			} else if (input.equalsIgnoreCase("no") || input.equalsIgnoreCase("n") || input.equalsIgnoreCase("false")
					|| input.equalsIgnoreCase("f")) {
				return false;
			} else {
				System.out.println("*** Please enter Yes/No or True/False ***");
			}
		}
		return false;
	}

	public static java.util.Date readDate(String prompt) {
		java.util.Date date = null;
		boolean valid = false;
		while (!valid) {
			try {
				String input = readString(prompt).trim();
				if (input.matches("\\d\\d/\\d\\d/\\d\\d\\d\\d")) {
					int day = Integer.parseInt(input.substring(0, 2));
					int month = Integer.parseInt(input.substring(3, 5));
					int year = Integer.parseInt(input.substring(6, 10));
					java.util.Calendar cal = java.util.Calendar.getInstance();
					cal.setLenient(false);
					cal.set(year, month - 1, day, 0, 0, 0);
					date = cal.getTime();
					valid = true;
				} else {
					System.out.println("*** Please enter a date (DD/MM/YYYY) ***");
				}
			} catch (IllegalArgumentException e) {
				System.out.println("*** Please enter a date (DD/MM/YYYY) ***");
			}
		}
		return date;
	}

	private static String quit = "0";

	public static int getUserOption(String title, String[] menu) {
		displayMenu(title, menu);
		int choice = Keyboard.readInt("Enter Choice --> ");
		while (choice > menu.length || choice < 0) {
			choice = Keyboard.readInt("Invalid Choice, Re-enter --> ");
		}
		return choice;
	}

	private static void displayMenu(String title, String[] menu) {
		line(80, "=");
		System.out.println(title.toUpperCase());
		line(80, "-");
		for (int i = 0; i < menu.length; i++) {
			System.out.println("[" + (i + 1) + "] " + menu[i]);
		}
		System.out.println("[" + quit + "] Quit");
		line(80, "-");
	}

	public static void line(int len, String c) {
		System.out.println(String.format("%" + len + "s", " ").replaceAll(" ", c));
	}
	
}
public class GameModule {

	private Dealer dealer;
	private Player player;
	
	public GameModule() {
		dealer = new Dealer();
		player = new Player("IcePeak","password",100);
	}
	
	public void run() {
		//game machine
		System.out.println("High sum game!");
		dealer.shuffleCards();
		dealer.dealCardTo(player);
		dealer.dealCardTo(dealer);
		
		dealer.showCardsOnHand(); //override to hide card on dealer
		player.showCardsOnHand();
	}
	
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		GameModule app = new GameModule();
		app.run();
	}

}
public class Deck {

	private ArrayList<Card> cards;
	
	public Deck() {
		cards = new ArrayList<Card>();
		String [] suits = {"Heart", "Diamond", "Spade", "Club"};
		for(int i=0;i<suits.length;i++) {
			String suit = suits[i];
			Card card = new Card(suit,"Ace",1);
			cards.add(card);
			for(int n=2;n<=10;n++) {
				Card aCard = new Card(suit,n+"",n);
				cards.add(aCard);
			}
			Card jackCard = new Card(suit,"Jack",10);
			cards.add(jackCard);
			Card queenCard = new Card(suit,"Queen",10);
			cards.add(queenCard);
			Card kingCard = new Card(suit,"King",10);
			cards.add(kingCard);
		}
	}
	
	public void shuffle() {
		Random random = new Random();
		for(int i=0;i<1000;i++) {
			int indexA = random.nextInt(cards.size());
			int indexB = random.nextInt(cards.size());
			Card cardA = cards.get(indexA);
			Card cardB = cards.get(indexB);
			cards.set(indexA, cardB);
			cards.set(indexB, cardA);
		}
	}
	
	public void showCards() {
		for(Card card: cards) {
			System.out.println(card);
		}
	}
	
	public Card dealCard() {
		return cards.remove(0);
	}
	
	public void appendCard(Card card) {
		cards.add(card);
	}
	
	public void appendCard(ArrayList<Card> cards) {
		for(Card card: cards) {
			appendCard(card);
		}
	}
	
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Deck deck = new Deck();
		//deck.shuffle();
		deck.showCards();
		Card card1 = deck.dealCard();
		Card card2 = deck.dealCard();
		Card card3 = deck.dealCard();
		ArrayList<Card> cards = new ArrayList<Card>();
		cards.add(card1);
		cards.add(card2);
		cards.add(card3);
		deck.appendCard(cards);
		System.out.println();
		deck.showCards();
	}
}
public class Card {

	private String suit;
	private String name;
	private int value;
	
	public Card(String suit, String name, int value) {
		this.suit = suit;
		this.name = name;
		this.value = value;
	}
	
	public int getValue() {
		return value;
	}

	public String toString() {
		return "<"+this.suit+" "+this.name+">";
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Card card = new Card("Heart","Ace",1);
		System.out.println(card);
	}
}
public class Dealer extends Player{

	private Deck deck;
	
	public Dealer() {
		super("Dealer","",0);
		deck = new Deck();
	}
	
	public void shuffleCards() {
		System.out.println("Dealer shuffle deck");
		deck.shuffle();
	}
	
	public void dealCardTo(Player player) {
		Card card = deck.dealCard();
		player.addCard(card);
	}
	
	//Think of actions that a dealer need to do
	//conduct the game
	//implement those actions
}
public class User {

	private String loginName;
	private String password; //plain password
	
	public User(String loginName, String password) {
		this.loginName = loginName;
		this.password = password;
	}

	public String getLoginName() {
		return loginName;
	}
	
	//should be done using HASH algorithm
	public boolean checkPassword(String password) {
		return this.password.equals(password);
	}
}

Write a program by filling in the classes above except Keyboard class. Keyboard class is not to be touched. The game is called high sum card game. The game starts with the dealer shuffles the deck of cards.
The dealer will deal (distribute) the cards to the players.
The dealer make two passes so that the players and the dealer have two cards each.
Two passes means that the dealer must distribute the cards in such a way that, the first card
belongs to the player, the second card belongs to the dealer, the third card belongs to the player
and the fourth card belows to the dealer. Round 1,The first card of the dealer and player are both hidden, that is face down.
The dealer and player can view their own hidden first card.
The second card is visible to both the dealer and player.
The player with the highest second visible card will make a “call” by stating the amount to bet.
The other player will need to place the same amount of bet.
Both the bet amount from dealer and player will be placed on the table.
The dealer is not allowed to quit the game. The dealer make one pass.
Dealer and player each have 3 cards now.
The player with the highest third visible card will make a “call” by stating the amount to bet.
The other player will need to place the same amount of bet or choose to quit the current game.
Dearler is not allowed to quit the game.
If the human player choose to quit at this round, all the chips on the table belongs to the dealer
and the current game ends here.
Both the bet amount from dealer and player will be placed on the table.
The dealer is not allowed to quit the game. Round 4
Similar to round 2 plus the following rule:
Each player compares the values of cards hold by other players at the end of each game to
determine the winner. The player with the highest accumulate values win the game.
The winner gets all the bet on the table.
Next Game
All the cards on the table are shuffled and placed at the end of the deck.

The game sample output is supposed to look something like this : 
"HighSum GAME
================================================================================
Enter Login name> IcePeak
Enter Password > password
Upon logging in, the player will enter the game.
(Below is a sample output of one game play)
HighSum GAME
================================================================================
IcePeak, You have 100 chips
--------------------------------------------------------------------------------
Game starts - Dealer shuffles deck.
--------------------------------------------------------------------------------
Dealer dealing cards - ROUND 1
--------------------------------------------------------------------------------
Dealer
<HIDDEN CARD> <Club 6>
IcePeak
<Diamond Ace> <Spade 6>

Value:7
Player call, state bet: 10
IcePeak, You are left with 90 chips
Bet on table : 20
--------------------------------------------------------------------------------
Dealer dealing cards - ROUND 2
--------------------------------------------------------------------------------
Dealer
<HIDDEN CARD> <Club 6> <Diamond 9>
IcePeak
<Diamond Ace> <Spade 6> <Heart 7>
Value:14
Dealer call, state bet: 10
Do you want to follow? [Y/N]: Y
IcePeak, You are left with 80 chips
Bet on table : 40
--------------------------------------------------------------------------------
Dealer dealing cards - ROUND 3
--------------------------------------------------------------------------------
Dealer
<HIDDEN CARD> <Club 6> <Diamond 9> <Heart Ace>
IcePeak
<Diamond Ace> <Spade 6> <Heart 7> <Spade 9>
Value:23
Page 4
Copyright SCIT, University of Wollongong, 2023
Do you want to [C]all or [Q]uit?: C
Player call, state bet: 10
You are left with 70 chips
Bet on table : 60
--------------------------------------------------------------------------------
Dealer dealing cards - ROUND 4
--------------------------------------------------------------------------------
Dealer
<HIDDEN CARD> <Club 6> <Diamond 9> <Heart Ace> <Spade 2>
IcePeak
<Diamond Ace> <Spade 6> <Heart 7> <Spade 9> <Heart King>
Value : 33
Do you want to [C]all or [Q]uit?: C
Player call, state bet: 10
You are left with 60 chips
Bet on table : 80
--------------------------------------------------------------------------------
Game End - Dealer reveal hidden cards
--------------------------------------------------------------------------------
Dealer
<Spade Ace> <Club 6> <Diamond 9> <Heart Ace> <Spade 2>
Value : 19
IcePeak
<Diamond Ace> <Spade 6> <Heart 7> <Spade 9> <Heart King>
Value : 33
IcePeak Wins
IcePeak, You have 140 chips
Dealer shuffles used cards and place behind the deck.
--------------------------------------------------------------------------------
Next Game? (Y/N) > Y"