turma1076-desafio-bingo-rejane-avaliacao.java

turma1076-desafio-bingo-rejane-avaliacao.java

import java.util.Scanner;
import java.util.Set;
import java.util.HashSet;
import java.util.Random;
import java.util.Map;
import java.util.HashMap;
import java.util.Arrays;
import java.util.TreeMap;
import java.util.Collections;

public class Bingo {

    public static void main(String[] args) {
        Scanner read = new Scanner(System.in);
        System.out.println("******************************************************************");
        System.out.println("*                BEM-VINDOS AO BINGO DA ADA                      *");
        System.out.println("******************************************************************\n");

        // Etapa 1 - Informar os jogadores
        String[] players = playersName(read);

        // Etapa 2 - Escolher o método de geração de cartelas
        String choice = chooseCardGenerationMethod(read);
        int[][] playerCards = generatePlayerCards(players, choice, read);
        printPlayerCards(players, playerCards);

        // Etapa 3 - Iniciar as rodadas do jogo
        playRounds(players, playerCards, read);
    }

    private static String[] playersName(Scanner read) {
        System.out.println("Para começar, informe o nome dos jogadores separando-os por hífen:");
        System.out.print("> ");
        String[] players = read.nextLine().split("-");
        System.out.println("Há " + players.length + " pessoas participando deste Bingo.\n");
        return players;
    }

    private static String chooseCardGenerationMethod(Scanner read) {
        String choice;

        while (true) {
            System.out.println("Como você quer que as cartelas sejam geradas?");
            System.out.println("1 - Aleatoriamente");
            System.out.println("2 - Manualmente");
            System.out.print("> ");

            choice = read.nextLine();

            if (choice.equals("1") || choice.equals("2")) {
                break;  // Sai do loop se a escolha for válida
            } else {
                System.out.println("Opção inválida. Digite 1 para aleatório ou 2 para manual.");
            }
        }

        return choice;
    }

    private static int[][] generatePlayerCards(String[] players, String choice, Scanner read) {
        int[][] playerCards = new int[players.length][];

        if (choice.equals("1")) {
            Set<String> uniqueCardStrings = new HashSet<>();
            for (int i = 0; i < players.length; i++) {
                playerCards[i] = generateRandomCard(uniqueCardStrings);
            }
        } else if (choice.equals("2")) {
            System.out.println("Insira os números para as cartelas e tecle 'Enter'");
            System.out.print("> ");
            String[] inputArray = read.nextLine().split("-");
            Set<String> uniqueCardStrings = new HashSet<>();
            playerCards = parseManualInput(inputArray, uniqueCardStrings, read);
        } else {
            System.out.println("Opção inválida. Escolha 1 para aleatório ou 2 para manual.");
            System.exit(1);
            return null;
        }

        return playerCards;
    }

    private static int[] generateRandomCard(Set<String> uniqueCardStrings) {
        int[] card = new int[5];
        Set<Integer> uniqueNumbers = new HashSet<>();

        for (int i = 0; i < 5; i++) {
            int num;
            do {
                num = (int) (Math.random() * 60) + 1;
            } while (uniqueNumbers.contains(num));

            uniqueNumbers.add(num);
            card[i] = num;
        }

        Arrays.sort(card);
        String cardKey = Arrays.toString(card);

        while (uniqueCardStrings.contains(cardKey)) {
            uniqueNumbers.clear();

            for (int i = 0; i < 5; i++) {
                int num;
                do {
                    num = (int) (Math.random() * 60) + 1;
                } while (uniqueNumbers.contains(num));

                uniqueNumbers.add(num);
                card[i] = num;
            }

            Arrays.sort(card);
            cardKey = Arrays.toString(card);
        }

        uniqueCardStrings.add(cardKey);
        return card;
    }

    private static int[][] parseManualInput(String[] inputArray, Set<String> uniqueCardStrings, Scanner read) {
        int[][] playerCards = new int[inputArray.length][5];

        for (int i = 0; i < inputArray.length; i++) {
            String playerName = "Jogador " + (i + 1);
            int[] card = validateAndSortNumbers(inputArray[i].split(","), playerName, uniqueCardStrings, read);

            if (card == null) {
                System.out.println("Erro na inserção manual. Por favor, verifique os números e tente novamente.");
                System.exit(1);
            }

            playerCards[i] = card;
        }

        return playerCards;
    }

    private static int[] validateAndSortNumbers(String[] numbers, String playerName, Set<String> uniqueCardStrings, Scanner read) {
        int[] card = new int[5];

        while (true) {
            boolean valid = true;

            if (numbers.length != 5) {
                System.out.println("Erro: Forneça exatamente 5 números separados por vírgula para " + playerName + ".");
                valid = false;
            } else {
                Set<Integer> uniqueNumbers = new HashSet<>();

                for (int i = 0; i < 5; i++) {
                    int num;
                    try {
                        num = Integer.parseInt(numbers[i]);
                    } catch (NumberFormatException e) {
                        System.out.println("Erro: Forneça números válidos para " + playerName + ".");
                        valid = false;
                        break;
                    }

                    if (num < 1 || num > 60) {
                        System.out.println("Erro: Número inválido para " + playerName + ". Forneça números entre 1 e 60.");
                        valid = false;
                        break;
                    }

                    if (!uniqueNumbers.add(num)) {
                        System.out.println("Erro: Números duplicados não são permitidos em uma mesma cartela para " + playerName + ".");
                        valid = false;
                        break;
                    }

                    card[i] = num;
                }
            }

            if (valid) {
                Arrays.sort(card);
                String cardString = Arrays.toString(card);

                if (uniqueCardStrings.contains(cardString)) {
                    System.out.println("Erro: Não podem haver duas cartelas iguais. Digite novamente.");
                    valid = false;
                } else {
                    uniqueCardStrings.add(cardString);
                    break;  // Sai do loop se a validação for bem-sucedida
                }
            }

            // Se chegou até aqui, houve um erro, então solicitamos a entrada novamente
            System.out.print("Digite os números para " + playerName + " (separados por vírgula): ");
            String input = read.nextLine();
            numbers = input.split(",");
        }

        return card;
    }

    private static void printPlayerCards(String[] players, int[][] playerCards) {
        System.out.println("\nCartelas dos Jogadores (números ordenados):");
        for (int i = 0; i < players.length; i++) {
            int[] sortedCard = Arrays.copyOf(playerCards[i], playerCards[i].length);
            Arrays.sort(sortedCard);
            System.out.println(players[i] + ": " + Arrays.toString(sortedCard));
        }
    }

    private static void playRounds(String[] players, int[][] playerCards, Scanner scanner) {
        Random random = new Random();
        Set<Integer> drawnNumbers = new HashSet<>();
        Map<String, Integer> totalMatchesMap = new HashMap<>();

        int round = 1;

        while (true) {
            System.out.println("\nPressione Enter para iniciar a Rodada " + round + "...");
            scanner.nextLine();

            int[] drawnNumbersArray = generateRandomDraw(drawnNumbers);
            System.out.println("Rodada " + round + " - Números Sorteados: " + Arrays.toString(drawnNumbersArray));

            checkBingoAndUpdateStats(players, playerCards, drawnNumbersArray, round, totalMatchesMap);

            displayTotalMatches(totalMatchesMap, round);

            if (hasBingo(playerCards, drawnNumbersArray, players)) {
                endGame(getWinner(totalMatchesMap)); // Chama endGame com o vencedor
                break;  // Encerra o programa após determinar o vencedor
            }

            round++;
        }
    }

    private static String getWinner(Map<String, Integer> totalMatchesMap) {
        return totalMatchesMap.entrySet().stream()
                .max(Map.Entry.comparingByValue())
                .map(Map.Entry::getKey)
                .orElse("Nenhum vencedor encontrado");
    }

    private static int[] generateRandomDraw(Set<Integer> drawnNumbers) {
        int[] drawnNumbersArray = new int[5];
        drawnNumbers.clear();

        Random random = new Random();
        Set<Integer> availableNumbers = new HashSet<>();

        for (int i = 1; i <= 60; i++) {
            availableNumbers.add(i);
        }

        for (int i = 0; i < 5; i++) {
            int randomIndex = random.nextInt(60 - i);
            int drawnNumber = 0;

            for (int num : availableNumbers) {
                if (randomIndex == 0) {
                    drawnNumber = num;
                    break;
                }
                randomIndex--;
            }

            drawnNumbersArray[i] = drawnNumber;
            availableNumbers.remove(drawnNumber);
            drawnNumbers.add(drawnNumber);
        }

        // Imprima os números sorteados aqui para verificar
        System.out.println("Números sorteados: " + Arrays.toString(drawnNumbersArray));

        return drawnNumbersArray;
    }

    private static void checkBingoAndUpdateStats(String[] players, int[][] playerCards, int[] drawnNumbers, int round, Map<String, Integer> totalMatchesMap) {
        Map<String, Integer> currentRoundMatches = new HashMap<>();

        for (int i = 0; i < players.length; i++) {
            int matches = countMatches(playerCards[i], drawnNumbers);
            totalMatchesMap.merge(players[i], matches, Integer::sum);
            currentRoundMatches.put(players[i], matches);

            if (matches == 5) {
                System.out.println("BINGO! " + players[i] + " acertou todos os números na Rodada " + round + "!");
            }
        }

        // Verificação de Bingo fora do loop
        for (String player : players) {
            if (currentRoundMatches.getOrDefault(player, 0) == 5) {
                endGame(player);
                break;
            }
        }
    }

    private static void displayTotalMatches(Map<String, Integer> totalMatchesMap, int round) {
        Map<Integer, String> positionMap = new TreeMap<>(Collections.reverseOrder());

        for (Map.Entry<String, Integer> entry : totalMatchesMap.entrySet()) {
            int position = entry.getValue();
            String playerName = entry.getKey();

            positionMap.merge(position, playerName, (existingPlayers, newPlayer) ->
                    existingPlayers + ", " + newPlayer);
        }

        System.out.println("\nQuantidade total de acertos após a Rodada " + round + ":");

        int positionCount = 0;
        for (Map.Entry<Integer, String> entry : positionMap.entrySet()) {
            int position = entry.getKey();
            String players = entry.getValue();

            positionCount++;
            System.out.println(positionCount + "º colocado: " + players + " - " + position + " acertos");

            if (positionCount >= 3) {
                break;
            }
        }
    }

    private static boolean hasBingo(int[][] playerCards, int[] drawnNumbers, String[] players) {
        for (int i = 0; i < playerCards.length; i++) {
            int matches = countMatches(playerCards[i], drawnNumbers);
            if (matches == 5) {
                System.out.println("BINGO! " + "O jogador " + players[i] + " acertou todos os números!");
                endGame(players[i]);
                return true;
            }
        }
        return false;
    }

    private static void endGame(String winner) {
        System.out.println("O jogador " + winner + " venceu o jogo com mais acertos! Parabéns!");
        System.out.println("Jogo encerrado. Obrigado por jogar!");
    }

    private static int countMatches(int[] playerCard, int[] drawnNumbers) {
        int matches = 0;
        for (int num : drawnNumbers) {
            if (Arrays.binarySearch(playerCard, num) >= 0) {
                matches++;
            }
        }
        return matches;
    }
}