package racingcar;

import racingcar.controller.RacingController;

public class Application {
    public static void main(String[] args) {
        RacingController racingController = new RacingController();
        racingController.run();
    }
}

package racingcar.controller;

import camp.nextstep.edu.missionutils.Console;
import racingcar.exception.ErrorMessage;
import racingcar.view.InputView;
import racingcar.view.OutputView;
import racingcar.domain.RacingGame;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class RacingController {
    private static final int NAME_LENGTH_THRESHOLD = 5;
    private static final String SEPARATOR = ",";

    private final InputView inputView;
    private final OutputView outputView;
    private RacingGame racingGame; // RacingCar 클래스 사용, 1 Round 처리

    public RacingController() {
        this.inputView = new InputView();
        this.outputView = new OutputView();
    }

    public void run() {
        try {
            // 검증 및 파싱된 입력값
            List<String> parsedCarNamesList = parseCarNames(inputView.readCarNames());
            int roundCount = inputView.readRoundCount();

            racingGame = new RacingGame(parsedCarNamesList);

            loopGameRunner(roundCount);

            outputView.displayResult(racingGame.getWinner());
        } catch (IllegalArgumentException e) {
            System.out.println(e.getMessage());
            throw e;
        } finally {
            Console.close();
        }
    }

    private static List<String> parseCarNames(String input) {
        validateInputCarNameEmptyOrBlank(input);

        List<String> carNames = Arrays.stream(input.split(SEPARATOR, -1))
                .map(String::trim)
                .distinct() // 중복 제거
                .collect(Collectors.toList());

        validateSplitNamesCheck(carNames);

        return carNames;
    }

    // 기본 상태 입력 문자열 검증
    private static void validateInputCarNameEmptyOrBlank(String carNames) {
        if (carNames == null || carNames.isEmpty()) {
            throw new IllegalArgumentException(ErrorMessage.CAR_NAMES_INPUT_NULL_OR_EMPTY.getMessage());
        }
        if (carNames.isBlank()) {
            throw new IllegalArgumentException(ErrorMessage.CAR_NAMES_INPUT_BLANK.getMessage());
        }
    }

    // 스플릿한 문자열 개별 검증
    private static void validateSplitNamesCheck(List<String> carNames) {
        for (String carName : carNames) {
            if (carName == null || carName.isEmpty()) { // 앞선 trim 과정으로 isBlank() 해당 x
                throw new IllegalArgumentException(ErrorMessage.CAR_NAME_NULL_OR_EMPTY.getMessage());
            }
            if (carName.length() > NAME_LENGTH_THRESHOLD) {
                throw new IllegalArgumentException(ErrorMessage.CAR_NAME_TOO_LONG.getMessage());
            }
        }
    }

    private void loopGameRunner(int roundCount) {
        for (int i = 0; i < roundCount; i++) {
            if (i == 0) outputView.printInitOutputMessage();
            racingGame.run(); // 전체 차량 이동
        }
    }
}

package racingcar.domain;

import camp.nextstep.edu.missionutils.Randoms;
import racingcar.view.OutputView;

import java.util.ArrayList;
import java.util.List;

public class RacingGame {
    private static final int MAXIMUM_RANDOM_NUM = 9;
    private final OutputView outputView;
    private final List<RacingCar> racingCars;

    public RacingGame(List<String> carNames) {
        this.outputView = new OutputView();
        this.racingCars = new ArrayList<>();

        for (String carName : carNames) {
            this.racingCars.add(new RacingCar(carName));
        }
    }

    public void run() {
        for (RacingCar racingCar : this.racingCars) {
            int randomValue = Randoms.pickNumberInRange(0, MAXIMUM_RANDOM_NUM);
            racingCar.move(randomValue);

            outputView.displayOutput(racingCar.getName(), racingCar.getPosition());
        }

        outputView.printNewLine();
    }

    public List<String> getWinner() {
        int winnerPosition = this.racingCars.getFirst().getPosition();

        // 공동 우승자 고려 List<String>으로 작성
        List<String> winnerNames = new ArrayList<>();
        winnerNames.add(this.racingCars.getFirst().getName());

        for (int i = 1; i < this.racingCars.size(); i++) {
            RacingCar racingCar = this.racingCars.get(i);
            int tmpPosition = racingCar.getPosition();

            if (tmpPosition == winnerPosition) winnerNames.add(racingCar.getName());
            if (tmpPosition > winnerPosition) {
                winnerPosition = tmpPosition;
                winnerNames.clear();
                winnerNames.add(racingCar.getName());
            }
        }

        return winnerNames;
    }
}

package racingcar.domain;

public class RacingCar {
    private static final int FORWARD_THRESHOLD = 4;

    private final String name;
    private int position;

    public RacingCar(String name) {
        this.name = name;
        this.position = 0;
    }

    public void move(int randomValue) {
        if (randomValue >= FORWARD_THRESHOLD) position++;
    }

    public String getName() {
        return this.name;
    }

    public int getPosition() {
        return this.position;
    }
}

package racingcar.view;

import camp.nextstep.edu.missionutils.Console;
import racingcar.exception.ErrorMessage;

public class InputView {
    private static final String CAR_NAME_PROMPT = "경주할 자동차 이름을 입력하세요.(이름은 쉼표(,) 기준으로 구분)";
    private static final String ROUND_COUNT_PROMPT = "시도할 횟수는 몇 회인가요?";

    public String readCarNames() {
        System.out.println(CAR_NAME_PROMPT);
        return Console.readLine(); // 입력값 검증 -> RacingController
    }

    public int readRoundCount() {
        System.out.println(ROUND_COUNT_PROMPT);
        return validateInputRoundCountFormat(Console.readLine());
    }

    private static int validateInputRoundCountFormat(String roundCount) {
        // 기본 입력 포맷 검증 로직 (숫자 포맷 일치 여부, 음이 아닌 정수)
        if (roundCount == null || roundCount.trim().isEmpty()) {
            throw new IllegalArgumentException(ErrorMessage.ROUND_COUNT_EMPTY.getMessage());
        }

        try {
            int num = Integer.parseInt(roundCount);
            checkPositive(num);

            return num;
        } catch (NumberFormatException e) {
            throw new IllegalArgumentException(ErrorMessage.ROUND_COUNT_INVALID_FORMAT.getMessage());
        }
    }

    private static void checkPositive(int roundCount) {
        if (roundCount <= 0) throw new IllegalArgumentException(ErrorMessage.ROUND_COUNT_NOT_POSITIVE.getMessage());
    }
}

package racingcar.view;

import java.util.List;

public class OutputView {
    private static final char MOVING_LINE = '-';

    public void printNewLine() {
        System.out.println();
    }

    public void printInitOutputMessage() {
        System.out.println("실행 결과");
    }

    public void displayOutput(String carName, int carPosition) {
        // 매 Round마다 호출될 결과 출력
        System.out.println(carName + " : " + String.valueOf(MOVING_LINE).repeat(carPosition));
    }

    public void displayResult(List<String> winnerNames) {
        // 최종 우승자 결과 출력
        System.out.print("최종 우승자 : " + String.join(", ", winnerNames));
    }
}

package racingcar.exception;

public enum ErrorMessage {
    CAR_NAME_NULL_OR_EMPTY("자동차 이름은 빈 값일 수 없습니다."),
    CAR_NAME_TOO_LONG("자동차 이름은 5글자를 초과할 수 없습니다."),

    CAR_NAMES_INPUT_NULL_OR_EMPTY("자동차 이름 입력은 빈 값일 수 없습니다."),
    CAR_NAMES_INPUT_BLANK("자동차 이름 입력은 공백만으로 구성될 수 없습니다."),

    ROUND_COUNT_EMPTY("시도 횟수는 빈 값일 수 없습니다."),
    ROUND_COUNT_INVALID_FORMAT("시도 횟수는 올바른 숫자 형식이어야 합니다."),
    ROUND_COUNT_NOT_POSITIVE("시도 횟수는 양수여야 합니다.");

    private static final String ERROR_PREFIX = "[ERROR] ";
    private final String message;

    ErrorMessage(String message) {
        this.message = message;
    }

    public String getMessage() {
        return ERROR_PREFIX + message;
    }
}