Racingcar.java

package racingcar;

import camp.nextstep.edu.missionutils.Console;
import camp.nextstep.edu.missionutils.Randoms;

import java.util.*;

public class Racingcar {

    public void run() {

        System.out.println("경주할 자동차 이름을 입력하세요.(이름은 쉼표(,) 기준으로 구분)");
        String carNameInput = Console.readLine();
        String carNames[] = parseAndValidateCarNames(carNameInput);

        System.out.println("시도할 횟수는 몇 회인가요?");
        String countInput = Console.readLine();
        int tryCount = validateCount(countInput);

        Map<String, String> racingMap = new LinkedHashMap<>();

        for(String name : carNames){
            racingMap.put(name, "");
        }

        System.out.println("\n실행 결과");
        for(int i=0; i<tryCount; i++){
            executeRound(carNames, racingMap);
            printRacing(racingMap);
        }

        printResult(racingMap);
    }

    private void printResult(Map<String, String> racingMap) {
        List<String> winners = new ArrayList<>();
        int maxDistance = findMaxDistance(racingMap);
        addWinner(winners, racingMap, maxDistance);

        System.out.println("최종 우승자 : " + String.join(", ", winners));
    }

    private void addWinner(List<String> winners, Map<String, String> racingMap, int maxDistance) {
        for(String key: racingMap.keySet() ){
            addIfWinner(winners, key, racingMap, maxDistance);
        }
    }

    private void addIfWinner(List<String> winners, String name, Map<String, String> racingMap, int maxDistance) {
        if(racingMap.get(name).length() == maxDistance){
            winners.add(name);
        }
    }

    private int findMaxDistance(Map<String, String> racingMap) {
        int max = 0;
        for(String key : racingMap.keySet()){
            max = Math.max(max, racingMap.get(key).length());
        }

        return max;
    }

    private void printRacing(Map<String, String> map) {
        for(String key : map.keySet()){
            System.out.printf("%s : %s\n", key, map.get(key));
        }
        System.out.println();
    }

    private void executeRound(String[] carNames, Map<String, String> racingMap) {
        for(String name : carNames){
            int rand = Randoms.pickNumberInRange(0, 9);
            boolean shouldMove = shouldMoveForward(rand);
            moveCar(name, shouldMove, racingMap);
        }
    }

    private void moveCar(String name, boolean shouldMove, Map<String, String> racingMap) {
        if(shouldMove){
            moveForward(name, racingMap);
        }
    }

    private void moveForward(String name, Map<String, String> racingMap) {
        racingMap.put(name, racingMap.getOrDefault(name, "")+"-");
    }

    private boolean shouldMoveForward(int rand) {
        return rand >= 4;
    }

    private int validateCount(String val) {
        int count = parseCount(val);
        validateCountIsPositive(count);
        return count;
    }

    private void validateCountIsPositive(int count) {
        if (count < 0) {
            throw new IllegalArgumentException();
        }
    }

    private int parseCount(String val) {
        try{
            return Integer.parseInt(val);
        } catch (NumberFormatException e){
            throw new IllegalArgumentException();
        }
    }

    private String[] parseAndValidateCarNames(String input) {
        String[] carNames = Arrays.stream(input.split(","))
                .map(String::trim)
                .toArray(String[]::new);

        for(String name : carNames) {
            validateCarName(name);
        }

        return carNames;
    }

    private void validateCarName(String name) {
        if(name.isEmpty()) {
            throw new IllegalArgumentException();
        }
        if(name.length() > 5) {
            throw new IllegalArgumentException();
        }
    }
}