import random
import time

class Point:
    """Класс для представления точки на окружности"""
    def __init__(self, index):
        self.index = index
        self.color = None  # None - не окрашена, 'red' - красная, 'blue' - синяя

    def is_colored(self):
        """Проверяет, окрашена ли точка"""
        return self.color is not None

    def set_color(self, color):
        """Устанавливает цвет точки"""
        if color not in ['red', 'blue']:
            raise ValueError("Цвет должен быть 'red' или 'blue'")
        self.color = color

class Game:
    """Основной класс игры"""
    def __init__(self, num_points=9, player_vs_computer=True):
        self.num_points = num_points
        self.points = [Point(i) for i in range(num_points)]
        self.current_player = "Петя"  # Петя ходит первым
        self.player_vs_computer = player_vs_computer
        self.last_colored_points = []  # Список последних окрашенных точек для отслеживания

    def get_available_moves(self):
        """Возвращает список доступных ходов"""
        if all(point.is_colored() for point in self.points):
            return []  # Нет доступных ходов, если все точки окрашены

        # Для первого хода Пети доступны все точки
        if not any(point.is_colored() for point in self.points):
            return list(range(self.num_points))

        available_moves = []
        for i in range(self.num_points):
            if not self.points[i].is_colored():
                # Проверяем, есть ли окрашенные соседние точки
                left_neighbor = (i - 1) % self.num_points
                right_neighbor = (i + 1) % self.num_points

                if self.points[left_neighbor].is_colored() or self.points[right_neighbor].is_colored():
                    available_moves.append(i)

        return available_moves

    def make_move(self, point_index, color):
        """Выполняет ход - окрашивает выбранную точку в указанный цвет"""
        if point_index not in self.get_available_moves():
            return False, "Недопустимый ход!"

        self.points[point_index].set_color(color)
        self.last_colored_points.append(point_index)

        # Меняем текущего игрока
        self.current_player = "Вася" if self.current_player == "Петя" else "Петя"

        return True, f"Точка {point_index} окрашена в {color} цвет"

    def check_equilateral_triangles(self):
        """Проверяет наличие равносторонних треугольников одного цвета"""
        # В окружности с 9 равноотстоящими точками равносторонний треугольник
        # образуют точки, индексы которых отличаются на 3
        # (например, 0, 3, 6 или 1, 4, 7 или 2, 5, 8)
        triangles = []

        for start in range(3):
            points_indices = [start, (start + 3) % 9, (start + 6) % 9]
            colors = [self.points[i].color for i in points_indices]

            # Проверяем, что все точки окрашены и имеют один цвет
            if colors[0] is not None and colors[0] == colors[1] == colors[2]:
                triangles.append((points_indices, colors[0]))

        return triangles

    def is_game_over(self):
        """Проверяет, закончилась ли игра"""
        # Игра заканчивается, когда все точки окрашены
        if not all(point.is_colored() for point in self.points):
            return False, None

        # Проверяем наличие равносторонних треугольников одного цвета
        triangles = self.check_equilateral_triangles()

        if triangles:
            # Вася выигрывает, если есть равносторонний треугольник одного цвета
            return True, "Вася"
        else:
            # Петя выигрывает, если нет равностороннего треугольника одного цвета
            return True, "Петя"

    def computer_move(self):
        """Реализует ход компьютера"""
        available_moves = self.get_available_moves()
        if not available_moves:
            return False, "Нет доступных ходов"

        # Проверяем, является ли компьютер Петей или Васей
        is_computer_petya = self.current_player == "Петя"

        # Простая стратегия для компьютера
        best_move = None
        best_color = None

        # Перебираем все возможные ходы и цвета
        for point_index in available_moves:
            for color in ['red', 'blue']:
                # Временно делаем ход
                self.points[point_index].set_color(color)

                # Проверяем наличие треугольников
                triangles = self.check_equilateral_triangles()

                # Если компьютер играет за Васю и может выиграть
                if not is_computer_petya and triangles:
                    best_move = point_index
                    best_color = color
                    self.points[point_index].color = None  # Отменяем временный ход
                    break

                # Если компьютер играет за Петю и может предотвратить победу Васи
                if is_computer_petya:
                    # Проверяем, может ли следующий ход Васи привести к победе
                    will_vasya_win = False
                    temp_current_player = self.current_player
                    self.current_player = "Вася" if self.current_player == "Петя" else "Петя"

                    next_available_moves = self.get_available_moves()
                    for next_move in next_available_moves:
                        for next_color in ['red', 'blue']:
                            self.points[next_move].set_color(next_color)
                            if self.check_equilateral_triangles():
                                will_vasya_win = True
                            self.points[next_move].color = None
                            if will_vasya_win:
                                break
                        if will_vasya_win:
                            break

                    self.current_player = temp_current_player

                    if not will_vasya_win and (best_move is None or random.random() < 0.3):
                        best_move = point_index
                        best_color = color

                # Отменяем временный ход
                self.points[point_index].color = None

        # Если нет хорошего хода, выбираем случайный
        if best_move is None:
            best_move = random.choice(available_moves)
            best_color = random.choice(['red', 'blue'])

        # Делаем ход
        success, message = self.make_move(best_move, best_color)
        return success, f"Компьютер ({self.current_player if not success else ('Петя' if self.current_player == 'Вася' else 'Вася')}): {message}"

    def display_board(self):
        """Отображает текущее состояние игрового поля"""
        print("\nСостояние игры:")
        print("  ", end="")
        for i in range(self.num_points):
            if self.points[i].color == 'red':
                print("R", end=" ")
            elif self.points[i].color == 'blue':
                print("B", end=" ")
            else:
                print("○", end=" ")
        print("\n  ", end="")
        for i in range(self.num_points):
            print(i, end=" ")
        print("\n")

        # Показываем последний ход
        if self.last_colored_points:
            last_point = self.last_colored_points[-1]
            print(f"Последний ход: точка {last_point} окрашена в {self.points[last_point].color}")

        # Показываем текущего игрока
        print(f"Сейчас ходит: {self.current_player}")

        # Показываем доступные ходы
        available_moves = self.get_available_moves()
        if available_moves:
            print(f"Доступные ходы: {available_moves}")

def play_game():
    """Функция для запуска игры с пользовательским вводом"""
    print("Добро пожаловать в игру Strat17!")
    print("Правила:")
    print("- На окружности отмечено 9 точек, делящих окружность на 9 равных дуг")
    print("- Петя и Вася по очереди окрашивают точки в красный (R) или синий (B) цвет")
    print("- Первым ходит Петя, который может окрасить любую точку")
    print("- Далее можно окрашивать только неокрашенные точки, соседние с уже окрашенными")
    print("- Вася выигрывает, если после окрашивания всех точек найдётся равносторонний")
    print("  треугольник, все вершины которого окрашены в один цвет")
    print("- В окружности с 9 точками равносторонними треугольниками являются наборы точек:")
    print("  (0,3,6), (1,4,7), (2,5,8)")

    game_mode = input("\nВыберите режим игры:\n1. Против компьютера (вы - Петя)\n2. Против компьютера (вы - Вася)\n3. Два игрока\nВыбор: ")

    player_vs_computer = True
    player_is_petya = True

    if game_mode == "1":
        player_vs_computer = True
        player_is_petya = True
    elif game_mode == "2":
        player_vs_computer = True
        player_is_petya = False
    elif game_mode == "3":
        player_vs_computer = False
    else:
        print("Неверный выбор. Выбран режим против компьютера (вы - Петя)")

    game = Game(player_vs_computer=player_vs_computer)

    while True:
        game.display_board()

        game_over, winner = game.is_game_over()
        if game_over:
            print(f"\nИгра окончена! Победитель: {winner}")
            triangles = game.check_equilateral_triangles()
            if triangles:
                for triangle, color in triangles:
                    print(f"Треугольник с вершинами {triangle} окрашен в {color} цвет")
            break

        # Определяем, кто сейчас ходит - компьютер или игрок
        computer_turn = (player_vs_computer and
                        ((game.current_player == "Петя" and not player_is_petya) or
                        (game.current_player == "Вася" and player_is_petya)))

        if computer_turn:
            print("Компьютер думает...")
            time.sleep(1)  # Небольшая задержка для эффекта "размышления"
            success, message = game.computer_move()
            print(message)
        else:
            # Ход игрока
            available_moves = game.get_available_moves()
            if not available_moves:
                print("Нет доступных ходов!")
                break

            try:
                point_index = int(input(f"{game.current_player}, выберите точку для окрашивания {available_moves}: "))
                if point_index not in available_moves:
                    print("Недопустимый ход! Попробуйте снова.")
                    continue

                color = input("Выберите цвет (r - красный, b - синий): ").lower()
                if color == 'r':
                    color = 'red'
                elif color == 'b':
                    color = 'blue'
                else:
                    print("Неверный цвет! Используйте 'r' для красного или 'b' для синего.")
                    continue

                success, message = game.make_move(point_index, color)
                if not success:
                    print(message)
            except ValueError:
                print("Пожалуйста, введите корректное число!")

if __name__ == "__main__":
    play_game()