#!/usr/bin/env python3
# -*- coding: utf-8 -*-

"""
================================================================================
Модуль: Морской бой
================================================================================
Классическая игра с умным ИИ и тремя уровнями сложности
================================================================================
"""

import sys
import random
from PyQt5.QtWidgets import (
    QApplication, QWidget, QVBoxLayout, QHBoxLayout, QLabel, 
    QPushButton, QFrame, QGridLayout, QMainWindow, QDialog,
    QDialogButtonBox, QTextBrowser, QComboBox
)
from PyQt5.QtCore import Qt, QTimer, pyqtSignal
from PyQt5.QtGui import QFont


# ========== КЛАСС МОДУЛЯ ==========

class SeaBattleModule:
    """Класс модуля для ModuleManager"""
    
    display_name = "🎯 Морской бой"
    description = "Классическая игра с тремя уровнями сложности"
    menu_category = "games"
    
    def __init__(self, main_window):
        self.main_window = main_window
        self.widget = None
        self.window = None
    
    def run(self):
        """Запуск модуля — открывает интерфейс в отдельном окне"""
        self.widget = SeaBattleWidget(self.main_window, self)
        
        self.window = QMainWindow()
        self.window.setWindowTitle(f"{self.display_name} - РейсМастер")
        self.window.setWindowIcon(self.main_window.windowIcon())
        self.window.setCentralWidget(self.widget)
        self.window.showMaximized()
        
        # Морской фон
        self.window.setStyleSheet("""
            QMainWindow {
                background: qlineargradient(x1:0, y1:0, x2:1, y2:1,
                    stop:0 #006994, stop:1 #003366);
            }
        """)
        
        self.window.show()


# ========== ОКНО ПРАВИЛ ==========

class HelpDialog(QDialog):
    """Диалог с правилами игры"""
    
    def __init__(self, parent=None):
        super().__init__(parent)
        self.setWindowTitle("📚 Правила Морского боя")
        self.setMinimumSize(600, 500)
        self.setup_ui()
    
    def setup_ui(self):
        layout = QVBoxLayout(self)
        layout.setSpacing(15)
        
        # Заголовок
        title = QLabel("🎯 ПРАВИЛА МОРСКОГО БОЯ")
        title.setStyleSheet("""
            font-size: 24px;
            font-weight: bold;
            color: white;
            background-color: #003366;
            padding: 15px;
            border-radius: 10px;
            border: 2px solid #FFD700;
        """)
        title.setAlignment(Qt.AlignCenter)
        layout.addWidget(title)
        
        # Текст правил
        text = QTextBrowser()
        text.setStyleSheet("""
            QTextBrowser {
                background-color: #E0F2FE;
                border: 3px solid #003366;
                border-radius: 15px;
                padding: 20px;
                font-size: 12pt;
                line-height: 1.6;
            }
        """)
        
        html = """
        <style>
            h2 { color: #003366; margin-top: 15px; border-bottom: 2px solid #003366; }
            .ship { 
                display: inline-block; 
                background: #2C3E50; 
                color: white;
                border-radius: 3px; 
                padding: 2px 8px; 
                margin: 2px; 
            }
        </style>
        
        <h2>🎯 ЦЕЛЬ ИГРЫ</h2>
        <p>Первым потопить все корабли противника.</p>
        
        <h2>🚢 КОРАБЛИ</h2>
        <p>У каждого игрока:</p>
        <ul>
            <li><span class='ship'>■■■■</span> 1 корабль (4 клетки)</li>
            <li><span class='ship'>■■■</span> 2 корабля (3 клетки)</li>
            <li><span class='ship'>■■</span> 3 корабля (2 клетки)</li>
            <li><span class='ship'>■</span> 4 корабля (1 клетка)</li>
        </ul>
        <p><b>Важно:</b> Между кораблями должна быть минимум 1 клетка.</p>
        
        <h2>🎮 ХОД ИГРЫ</h2>
        <ul>
            <li>Игроки ходят по очереди</li>
            <li>Нажмите на клетку поля противника, чтобы выстрелить</li>
            <li>Если попали — ходите еще раз</li>
            <li>Если промахнулись — ход переходит к компьютеру</li>
        </ul>
        
        <h2>🖱️ РАССТАНОВКА</h2>
        <ul>
            <li>Выберите корабль справа</li>
            <li>Кнопка "🔄 ПОВЕРНУТЬ" меняет ориентацию</li>
            <li>Кликните на свое поле, чтобы поставить корабль</li>
            <li>Кнопка "🎲 СЛУЧАЙНО" расставит автоматически</li>
        </ul>
        
        <h2>🎨 ОБОЗНАЧЕНИЯ</h2>
        <ul>
            <li><span style="color: #2C3E50;">🟦</span> Свой корабль</li>
            <li><span style="color: #C41E3A;">💥</span> Попадание</li>
            <li><span style="color: #8B0000;">💀</span> Потопленный корабль</li>
            <li><span style="color: #666;">•</span> Промах</li>
            <li><span style="color: #E0F2FE;">⬜</span> Пустая клетка</li>
        </ul>
        <p><b>Важно:</b> Корабли противника не видны!</p>
        
        <h2>🤖 УРОВНИ СЛОЖНОСТИ</h2>
        <ul>
            <li><b>🟢 Легкий:</b> Случайные выстрелы</li>
            <li><b>🟡 Сложный:</b> Ищет вокруг попаданий</li>
            <li><b>🔴 Супер-сложный:</b> Анализирует направление</li>
        </ul>
        """
        
        text.setHtml(html)
        layout.addWidget(text)
        
        # Кнопка закрытия
        btn = QDialogButtonBox(QDialogButtonBox.Ok)
        btn.accepted.connect(self.accept)
        btn.setStyleSheet("""
            QPushButton {
                background-color: #003366;
                color: white;
                border: 2px solid #FFD700;
                border-radius: 5px;
                padding: 8px 20px;
                font-size: 14px;
                font-weight: bold;
            }
            QPushButton:hover {
                background-color: #004488;
            }
        """)
        layout.addWidget(btn)


# ========== КЛАСС КЛЕТКИ ПОЛЯ ==========

class CellButton(QPushButton):
    """Кнопка-клетка игрового поля"""
    
    def __init__(self, x, y):
        super().__init__()
        self.x = x
        self.y = y
        self.state = "empty"  # empty, ship, hit, miss, sunk
        self.setFixedSize(45, 45)
        self.setFont(QFont("Arial", 16))
        self.update_style()
    
    def update_style(self):
        """Обновляет внешний вид клетки"""
        if self.state == "empty":
            self.setText("")
            self.setStyleSheet("""
                QPushButton {
                    background-color: #E0F2FE;
                    border: 1px solid #003366;
                }
                QPushButton:hover {
                    background-color: #B8E2F2;
                }
            """)
        
        elif self.state == "ship":
            self.setText("🟦")
            self.setStyleSheet("""
                QPushButton {
                    background-color: #2C3E50;
                    border: 1px solid #003366;
                    font-size: 20px;
                }
            """)
        
        elif self.state == "hit":
            self.setText("💥")
            self.setStyleSheet("""
                QPushButton {
                    background-color: #C41E3A;
                    color: white;
                    border: 1px solid #8B0000;
                    font-size: 20px;
                }
            """)
        
        elif self.state == "miss":
            self.setText("•")
            self.setStyleSheet("""
                QPushButton {
                    background-color: #E0F2FE;
                    color: #666;
                    border: 1px solid #003366;
                    font-size: 24px;
                }
            """)
        
        elif self.state == "sunk":
            self.setText("💀")
            self.setStyleSheet("""
                QPushButton {
                    background-color: #8B0000;
                    color: #FFD700;
                    border: 2px solid #FFD700;
                    font-size: 24px;
                    font-weight: bold;
                }
            """)
    
    def set_ship(self):
        """Устанавливает корабль"""
        self.state = "ship"
        self.update_style()
    
    def set_hit(self):
        """Устанавливает попадание"""
        self.state = "hit"
        self.update_style()
    
    def set_miss(self):
        """Устанавливает промах"""
        self.state = "miss"
        self.update_style()
    
    def set_sunk(self):
        """Устанавливает потопленный корабль"""
        self.state = "sunk"
        self.update_style()
    
    def reset(self):
        """Сбрасывает клетку"""
        self.state = "empty"
        self.update_style()


# ========== ИГРОВОЕ ПОЛЕ ==========

class GameBoard(QFrame):
    """Игровое поле с сеткой 10x10"""
    
    cell_clicked = pyqtSignal(int, int)
    
    def __init__(self, is_enemy=False):
        super().__init__()
        self.is_enemy = is_enemy
        self.cells = [[None for _ in range(10)] for _ in range(10)]
        self.setup_ui()
    
    def setup_ui(self):
        """Создает сетку 10x10"""
        layout = QGridLayout(self)
        layout.setSpacing(2)
        layout.setContentsMargins(5, 5, 5, 5)
        
        # Буквы (А-К)
        letters = ['А', 'Б', 'В', 'Г', 'Д', 'Е', 'Ж', 'З', 'И', 'К']
        for j, letter in enumerate(letters):
            label = QLabel(letter)
            label.setAlignment(Qt.AlignCenter)
            label.setStyleSheet("color: white; font-weight: bold; font-size: 14px;")
            layout.addWidget(label, 0, j + 1)
        
        # Цифры (1-10)
        for i in range(10):
            label = QLabel(str(i + 1))
            label.setAlignment(Qt.AlignCenter)
            label.setStyleSheet("color: white; font-weight: bold; font-size: 14px;")
            layout.addWidget(label, i + 1, 0)
        
        # Клетки
        for i in range(10):
            for j in range(10):
                cell = CellButton(i, j)
                cell.clicked.connect(lambda checked, x=i, y=j: self.on_cell_clicked(x, y))
                layout.addWidget(cell, i + 1, j + 1)
                self.cells[i][j] = cell
    
    def on_cell_clicked(self, x, y):
        """Обработка клика по клетке"""
        self.cell_clicked.emit(x, y)
    
    def set_ship(self, x, y):
        """Устанавливает корабль"""
        if 0 <= x < 10 and 0 <= y < 10:
            self.cells[x][y].set_ship()
    
    def set_hit(self, x, y):
        """Устанавливает попадание"""
        if 0 <= x < 10 and 0 <= y < 10:
            self.cells[x][y].set_hit()
    
    def set_miss(self, x, y):
        """Устанавливает промах"""
        if 0 <= x < 10 and 0 <= y < 10:
            self.cells[x][y].set_miss()
    
    def set_sunk(self, x, y):
        """Устанавливает потопленный корабль"""
        if 0 <= x < 10 and 0 <= y < 10:
            self.cells[x][y].set_sunk()
    
    def get_state(self, x, y):
        """Возвращает состояние клетки"""
        if 0 <= x < 10 and 0 <= y < 10:
            return self.cells[x][y].state
        return None
    
    def is_empty(self, x, y):
        """Проверяет, пуста ли клетка"""
        state = self.get_state(x, y)
        return state == "empty" or state == "ship"  # Для своего поля корабли считаем пустыми для выстрела
    
    def is_available_for_shot(self, x, y):
        """Проверяет, можно ли стрелять в клетку"""
        state = self.get_state(x, y)
        return state not in ["hit", "miss", "sunk"]
    
    def reset(self):
        """Сбрасывает поле"""
        for i in range(10):
            for j in range(10):
                self.cells[i][j].reset()


# ========== КЛАСС КОРАБЛЯ ==========

class Ship:
    """Класс корабля (только для логики)"""
    
    def __init__(self, size):
        self.size = size
        self.cells = []  # Список координат (x, y)
        self.hits = 0
        self.is_placed = False
    
    def place(self, x, y, horizontal):
        """Размещает корабль"""
        self.cells = []
        self.hits = 0
        self.is_placed = True
        
        for i in range(self.size):
            if horizontal:
                self.cells.append((x, y + i))
            else:
                self.cells.append((x + i, y))
    
    def is_hit(self, x, y):
        """Проверяет, попали ли в корабль"""
        return (x, y) in self.cells
    
    def register_hit(self, x, y):
        """Регистрирует попадание"""
        self.hits += 1
    
    def is_sunk(self):
        """Проверяет, потоплен ли корабль"""
        return self.hits == self.size


# ========== ПАНЕЛЬ ВЫБОРА КОРАБЛЕЙ ==========

class ShipSelector(QFrame):
    """Панель для выбора и расстановки кораблей"""
    
    ship_selected = pyqtSignal(object)
    rotate_clicked = pyqtSignal()
    random_clicked = pyqtSignal()
    
    def __init__(self):
        super().__init__()
        self.ships = []
        self.selected_ship = None
        self.horizontal = True
        self.setup_ui()
    
    def setup_ui(self):
        """Создание интерфейса"""
        self.setStyleSheet("""
            QFrame {
                background: qlineargradient(x1:0, y1:0, x2:1, y2:1,
                    stop:0 #004488, stop:1 #002244);
                border: 3px solid #FFD700;
                border-radius: 15px;
                padding: 15px;
                min-width: 220px;
            }
        """)
        
        layout = QVBoxLayout(self)
        layout.setSpacing(10)
        
        # Заголовок
        title = QLabel("⚓ КОРАБЛИ")
        title.setStyleSheet("color: #FFD700; font-size: 20px; font-weight: bold;")
        title.setAlignment(Qt.AlignCenter)
        layout.addWidget(title)
        
        # Кнопка поворота
        self.rotate_btn = QPushButton("🔄 ПОВЕРНУТЬ")
        self.rotate_btn.setMinimumHeight(45)
        self.rotate_btn.setStyleSheet("""
            QPushButton {
                background-color: #FFA000;
                color: white;
                border: none;
                border-radius: 8px;
                padding: 10px;
                font-weight: bold;
                font-size: 14px;
            }
            QPushButton:hover {
                background-color: #FF8F00;
            }
        """)
        self.rotate_btn.clicked.connect(self.rotate_clicked)
        layout.addWidget(self.rotate_btn)
        
        # Индикатор ориентации
        self.orientation_label = QLabel("↔️ Горизонтально")
        self.orientation_label.setStyleSheet("""
            color: #FFD700;
            font-size: 14px;
            padding: 8px;
            background-color: rgba(0,0,0,0.3);
            border-radius: 5px;
        """)
        self.orientation_label.setAlignment(Qt.AlignCenter)
        layout.addWidget(self.orientation_label)
        
        # Разделитель
        line = QFrame()
        line.setFrameShape(QFrame.HLine)
        line.setStyleSheet("background-color: #FFD700; max-height: 2px;")
        layout.addWidget(line)
        
        # Список кораблей
        ships_label = QLabel("Доступные корабли:")
        ships_label.setStyleSheet("color: white; font-size: 14px; font-weight: bold;")
        layout.addWidget(ships_label)
        
        self.ships_layout = QVBoxLayout()
        self.ships_layout.setSpacing(5)
        layout.addLayout(self.ships_layout)
        
        # Кнопка случайной расстановки
        self.random_btn = QPushButton("🎲 СЛУЧАЙНО")
        self.random_btn.setMinimumHeight(45)
        self.random_btn.setStyleSheet("""
            QPushButton {
                background-color: #2E7D32;
                color: white;
                border: none;
                border-radius: 8px;
                padding: 10px;
                font-weight: bold;
                font-size: 14px;
            }
            QPushButton:hover {
                background-color: #1B5E20;
            }
        """)
        self.random_btn.clicked.connect(self.random_clicked)
        layout.addWidget(self.random_btn)
        
        layout.addStretch()
    
    def set_orientation(self, horizontal):
        """Устанавливает отображение ориентации"""
        self.horizontal = horizontal
        if horizontal:
            self.orientation_label.setText("↔️ Горизонтально")
        else:
            self.orientation_label.setText("↕️ Вертикально")
    
    def set_ships(self, ships):
        """Устанавливает список кораблей"""
        self.ships = ships
        
        # Очищаем layout
        while self.ships_layout.count():
            item = self.ships_layout.takeAt(0)
            if item.widget():
                item.widget().deleteLater()
        
        # Группируем по размерам
        sizes = {4: 0, 3: 0, 2: 0, 1: 0}
        for ship in ships:
            if not ship.is_placed:
                sizes[ship.size] += 1
        
        # Создаем кнопки для каждого размера
        for size in [4, 3, 2, 1]:
            if sizes[size] > 0:
                btn = QPushButton(f"🚢 {size}-палубный ({sizes[size]})")
                btn.setMinimumHeight(40)
                btn.setStyleSheet("""
                    QPushButton {
                        background-color: #FFD700;
                        color: #003366;
                        border: none;
                        border-radius: 5px;
                        padding: 8px;
                        font-weight: bold;
                        font-size: 13px;
                        text-align: left;
                    }
                    QPushButton:hover {
                        background-color: #FFC107;
                    }
                """)
                # Находим первый неразмещенный корабль этого размера
                for ship in ships:
                    if not ship.is_placed and ship.size == size:
                        btn.clicked.connect(lambda checked, s=ship: self.ship_selected.emit(s))
                        break
                self.ships_layout.addWidget(btn)


# ========== ГЛАВНЫЙ ВИДЖЕТ ИГРЫ ==========

class SeaBattleWidget(QWidget):
    """Основной виджет игры"""
    
    def __init__(self, main_window, module):
        super().__init__()
        self.main_window = main_window
        self.module = module
        
        # Поля
        self.player_board = GameBoard(is_enemy=False)
        self.enemy_board = GameBoard(is_enemy=True)
        self.ship_selector = ShipSelector()
        
        # Корабли
        self.player_ships = []
        self.computer_ships = []
        
        # Состояние игры
        self.current_player = "player"
        self.game_state = "placing"
        self.placing_horizontal = True
        
        # Статистика
        self.player_hits = 0
        self.player_misses = 0
        self.computer_hits = 0
        self.computer_misses = 0
        
        # Для ИИ
        self.ai_memory = []      # Все выстрелы
        self.ai_hits = []        # Попадания
        self.ai_current_ship = []  # Текущий корабль, который ищем
        self.ai_direction = None   # Направление поиска
        
        # Уровни сложности
        self.difficulty_levels = ["Легкий", "Сложный", "Супер-сложный"]
        self.current_difficulty = "Сложный"
        
        self.setup_ui()
        self.new_game()
    
    def setup_ui(self):
        """Создание интерфейса"""
        main_layout = QHBoxLayout(self)
        main_layout.setSpacing(15)
        main_layout.setContentsMargins(15, 15, 15, 15)
        
        # Левая панель (селектор кораблей)
        main_layout.addWidget(self.ship_selector)
        
        # Центр (поля)
        center_layout = QVBoxLayout()
        
        # Верхняя панель
        top_panel = QHBoxLayout()
        
        title = QLabel("🎯 МОРСКОЙ БОЙ")
        title.setStyleSheet("""
            font-size: 32px;
            font-weight: bold;
            color: white;
            background-color: #003366;
            padding: 10px 30px;
            border-radius: 20px;
            border: 3px solid #FFD700;
        """)
        top_panel.addWidget(title)
        
        top_panel.addStretch()
        
        # Выбор сложности
        difficulty_label = QLabel("🎮 Сложность:")
        difficulty_label.setStyleSheet("color: #FFD700; font-size: 16px; font-weight: bold;")
        top_panel.addWidget(difficulty_label)
        
        self.difficulty_combo = QComboBox()
        self.difficulty_combo.addItems(self.difficulty_levels)
        self.difficulty_combo.setCurrentText("Сложный")
        self.difficulty_combo.currentTextChanged.connect(self.change_difficulty)
        self.difficulty_combo.setStyleSheet("""
            QComboBox {
                background-color: #004488;
                color: white;
                border: 2px solid #FFD700;
                border-radius: 8px;
                padding: 8px;
                font-size: 14px;
                font-weight: bold;
                min-width: 130px;
            }
            QComboBox:hover {
                background-color: #0055AA;
            }
            QComboBox::drop-down {
                border: none;
            }
            QComboBox::down-arrow {
                image: none;
                border-left: 5px solid transparent;
                border-right: 5px solid transparent;
                border-top: 5px solid #FFD700;
                width: 0;
                height: 0;
            }
        """)
        top_panel.addWidget(self.difficulty_combo)
        
        top_panel.addSpacing(20)
        
        self.rules_btn = QPushButton("📚 ПРАВИЛА")
        self.rules_btn.setFixedSize(150, 50)
        self.rules_btn.setStyleSheet("""
            QPushButton {
                background-color: #003366;
                color: white;
                border: 3px solid #FFD700;
                border-radius: 10px;
                font-size: 16px;
                font-weight: bold;
            }
            QPushButton:hover {
                background-color: #004488;
            }
        """)
        self.rules_btn.clicked.connect(self.show_rules)
        top_panel.addWidget(self.rules_btn)
        
        center_layout.addLayout(top_panel)
        
        # Два поля
        boards_layout = QHBoxLayout()
        boards_layout.setSpacing(30)
        
        # Поле игрока
        player_frame = QFrame()
        player_frame.setStyleSheet("""
            QFrame {
                background: qlineargradient(x1:0, y1:0, x2:1, y2:1,
                    stop:0 #004488, stop:1 #002244);
                border: 3px solid #FFD700;
                border-radius: 15px;
                padding: 10px;
            }
        """)
        player_layout = QVBoxLayout(player_frame)
        
        player_label = QLabel("⚓ ВАШ ФЛОТ")
        player_label.setStyleSheet("color: #FFD700; font-size: 18px; font-weight: bold;")
        player_label.setAlignment(Qt.AlignCenter)
        player_layout.addWidget(player_label)
        
        player_layout.addWidget(self.player_board)
        boards_layout.addWidget(player_frame)
        
        # Поле компьютера
        enemy_frame = QFrame()
        enemy_frame.setStyleSheet("""
            QFrame {
                background: qlineargradient(x1:0, y1:0, x2:1, y2:1,
                    stop:0 #004488, stop:1 #002244);
                border: 3px solid #FFD700;
                border-radius: 15px;
                padding: 10px;
            }
        """)
        enemy_layout = QVBoxLayout(enemy_frame)
        
        enemy_label = QLabel("🎯 ФЛОТ ПРОТИВНИКА")
        enemy_label.setStyleSheet("color: #FFD700; font-size: 18px; font-weight: bold;")
        enemy_label.setAlignment(Qt.AlignCenter)
        enemy_layout.addWidget(enemy_label)
        
        enemy_layout.addWidget(self.enemy_board)
        boards_layout.addWidget(enemy_frame)
        
        center_layout.addLayout(boards_layout)
        
        main_layout.addLayout(center_layout, 1)
        
        # Нижняя панель
        bottom_panel = QHBoxLayout()
        
        # Статус
        self.status_label = QLabel("🎮 Расставьте корабли (выбирайте справа)")
        self.status_label.setStyleSheet("""
            font-size: 16px;
            font-weight: bold;
            color: white;
            background-color: #003366;
            padding: 10px 20px;
            border-radius: 10px;
            border: 2px solid #FFD700;
        """)
        bottom_panel.addWidget(self.status_label, 2)
        
        # Статистика
        self.stats_label = QLabel("🎯 0/0  |  🤖 0/0")
        self.stats_label.setStyleSheet("""
            font-size: 14px;
            color: #FFD700;
            background-color: #002244;
            padding: 5px 15px;
            border-radius: 8px;
        """)
        bottom_panel.addWidget(self.stats_label)
        
        # Кнопки
        self.ready_btn = QPushButton("✅ НАЧАТЬ")
        self.ready_btn.setFixedSize(150, 50)
        self.ready_btn.setStyleSheet("""
            QPushButton {
                background-color: #2E7D32;
                color: white;
                border: 2px solid #FFD700;
                border-radius: 10px;
                font-size: 16px;
                font-weight: bold;
            }
            QPushButton:hover {
                background-color: #1B5E20;
            }
            QPushButton:disabled {
                background-color: #666;
                border-color: #999;
            }
        """)
        self.ready_btn.clicked.connect(self.start_game)
        bottom_panel.addWidget(self.ready_btn)
        
        self.new_btn = QPushButton("🔄 НОВАЯ")
        self.new_btn.setFixedSize(150, 50)
        self.new_btn.setStyleSheet("""
            QPushButton {
                background-color: #8B0000;
                color: white;
                border: 2px solid #FFD700;
                border-radius: 10px;
                font-size: 16px;
                font-weight: bold;
            }
            QPushButton:hover {
                background-color: #B22222;
            }
        """)
        self.new_btn.clicked.connect(self.new_game)
        bottom_panel.addWidget(self.new_btn)
        
        center_layout.addLayout(bottom_panel)
        
        # Подключаем сигналы
        self.player_board.cell_clicked.connect(self.on_player_cell_clicked)
        self.enemy_board.cell_clicked.connect(self.on_enemy_cell_clicked)
        self.ship_selector.ship_selected.connect(self.on_ship_selected)
        self.ship_selector.rotate_clicked.connect(self.rotate_ship)
        self.ship_selector.random_clicked.connect(self.random_placement)
    
    def show_rules(self):
        """Показывает правила"""
        dialog = HelpDialog(self)
        dialog.exec_()
    
    def change_difficulty(self, level):
        """Меняет уровень сложности"""
        self.current_difficulty = level
        self.status_label.setText(f"🎮 Уровень сложности: {level}")
    
    def new_game(self):
        """Новая игра"""
        # Очищаем поля
        self.player_board.reset()
        self.enemy_board.reset()
        
        # Создаем корабли игрока
        self.player_ships = self.create_ships_list()
        
        # Создаем корабли компьютера
        self.computer_ships = self.create_ships_list()
        self.place_computer_ships()
        
        # Сбрасываем состояние
        self.current_player = "player"
        self.game_state = "placing"
        self.player_hits = 0
        self.player_misses = 0
        self.computer_hits = 0
        self.computer_misses = 0
        
        # Сбрасываем ИИ
        self.ai_memory = []
        self.ai_hits = []
        self.ai_current_ship = []
        self.ai_direction = None
        
        self.placing_horizontal = True
        
        # Обновляем интерфейс
        self.ship_selector.set_orientation(True)
        self.ship_selector.set_ships(self.player_ships)
        self.status_label.setText("🎮 Расставьте корабли (выбирайте справа)")
        self.ready_btn.setEnabled(True)
        self.update_stats()
    
    def create_ships_list(self):
        """Создает список кораблей"""
        ships = []
        # 1 четырехпалубный
        ships.append(Ship(4))
        # 2 трехпалубных
        ships.append(Ship(3))
        ships.append(Ship(3))
        # 3 двухпалубных
        ships.append(Ship(2))
        ships.append(Ship(2))
        ships.append(Ship(2))
        # 4 однопалубных
        ships.append(Ship(1))
        ships.append(Ship(1))
        ships.append(Ship(1))
        ships.append(Ship(1))
        return ships
    
    def place_computer_ships(self):
        """Размещает корабли компьютера (только в памяти)"""
        for ship in self.computer_ships:
            placed = False
            attempts = 0
            while not placed and attempts < 1000:
                attempts += 1
                x = random.randint(0, 9)
                y = random.randint(0, 9)
                horizontal = random.choice([True, False])
                
                if self.can_place_ship_memory(ship, x, y, horizontal):
                    ship.place(x, y, horizontal)
                    placed = True
    
    def can_place_ship_memory(self, ship, x, y, horizontal):
        """Проверяет возможность размещения корабля в памяти"""
        # Проверка границ
        if horizontal:
            if y + ship.size > 10:
                return False
        else:
            if x + ship.size > 10:
                return False
        
        # Проверка соседних клеток
        for i in range(-1, ship.size + 1):
            for dx in [-1, 0, 1]:
                for dy in [-1, 0, 1]:
                    if horizontal:
                        check_x = x + dx
                        check_y = y + i + dy
                    else:
                        check_x = x + i + dx
                        check_y = y + dy
                    
                    if 0 <= check_x < 10 and 0 <= check_y < 10:
                        for other_ship in self.computer_ships:
                            if other_ship.is_placed and (check_x, check_y) in other_ship.cells:
                                return False
        
        return True
    
    def can_place_player_ship(self, ship, x, y, horizontal):
        """Проверяет возможность размещения корабля игрока"""
        # Проверка границ
        if horizontal:
            if y + ship.size > 10:
                return False
        else:
            if x + ship.size > 10:
                return False
        
        # Проверка соседних клеток
        for i in range(-1, ship.size + 1):
            for dx in [-1, 0, 1]:
                for dy in [-1, 0, 1]:
                    if horizontal:
                        check_x = x + dx
                        check_y = y + i + dy
                    else:
                        check_x = x + i + dx
                        check_y = y + dy
                    
                    if 0 <= check_x < 10 and 0 <= check_y < 10:
                        for other_ship in self.player_ships:
                            if other_ship.is_placed and (check_x, check_y) in other_ship.cells:
                                return False
                        if not self.player_board.is_empty(check_x, check_y):
                            return False
        
        return True
    
    def place_player_ship(self, ship, x, y, horizontal):
        """Размещает корабль игрока"""
        ship.place(x, y, horizontal)
        for (cx, cy) in ship.cells:
            self.player_board.set_ship(cx, cy)
    
    def mark_ship_as_sunk(self, board, ship):
        """Отмечает потопленный корабль и клетки вокруг"""
        # Отмечаем сам корабль
        for (x, y) in ship.cells:
            board.set_sunk(x, y)
        
        # Отмечаем клетки вокруг
        for (x, y) in ship.cells:
            for dx in [-1, 0, 1]:
                for dy in [-1, 0, 1]:
                    nx, ny = x + dx, y + dy
                    if 0 <= nx < 10 and 0 <= ny < 10:
                        if board.get_state(nx, ny) == "empty":
                            board.set_miss(nx, ny)
    
    def on_ship_selected(self, ship):
        """Выбор корабля для расстановки"""
        self.ship_selector.selected_ship = ship
        self.status_label.setText(f"🎮 Ставьте {ship.size}-палубный корабль")
    
    def on_player_cell_clicked(self, x, y):
        """Обработка клика по своему полю (расстановка)"""
        if self.game_state != "placing":
            return
        
        if not self.ship_selector.selected_ship:
            self.status_label.setText("❌ Сначала выберите корабль справа")
            return
        
        ship = self.ship_selector.selected_ship
        
        # Проверяем, можно ли поставить
        if self.can_place_player_ship(ship, x, y, self.placing_horizontal):
            self.place_player_ship(ship, x, y, self.placing_horizontal)
            ship.is_placed = True
            self.ship_selector.selected_ship = None
            self.ship_selector.set_ships(self.player_ships)
            
            # Проверяем, все ли корабли расставлены
            placed_count = sum(1 for s in self.player_ships if s.is_placed)
            if placed_count == 10:
                self.status_label.setText("✅ Все корабли расставлены! Нажмите НАЧАТЬ")
            else:
                self.status_label.setText(f"✅ Корабль поставлен. Осталось: {10 - placed_count}")
        else:
            self.status_label.setText("❌ Нельзя поставить сюда")
    
    def rotate_ship(self):
        """Поворачивает корабль"""
        self.placing_horizontal = not self.placing_horizontal
        self.ship_selector.set_orientation(self.placing_horizontal)
        self.status_label.setText(f"🎮 Корабли теперь {'горизонтально' if self.placing_horizontal else 'вертикально'}")
    
    def random_placement(self):
        """Случайная расстановка кораблей игрока"""
        # Очищаем поле и корабли
        self.player_board.reset()
        for ship in self.player_ships:
            ship.is_placed = False
        
        # Расставляем случайно
        for ship in self.player_ships:
            placed = False
            attempts = 0
            while not placed and attempts < 1000:
                attempts += 1
                x = random.randint(0, 9)
                y = random.randint(0, 9)
                horizontal = random.choice([True, False])
                
                if self.can_place_player_ship(ship, x, y, horizontal):
                    self.place_player_ship(ship, x, y, horizontal)
                    placed = True
        
        self.ship_selector.set_ships(self.player_ships)
        self.ship_selector.selected_ship = None
        self.status_label.setText("🎮 Корабли расставлены случайно")
    
    def start_game(self):
        """Начинает игру"""
        # Проверяем, расставлены ли корабли игрока
        placed_count = sum(1 for ship in self.player_ships if ship.is_placed)
        
        if placed_count < 10:
            self.status_label.setText(f"❌ Расставьте все корабли! ({placed_count}/10)")
            return
        
        self.game_state = "playing"
        self.ready_btn.setEnabled(False)
        self.status_label.setText("🎮 Ваш ход! Стреляйте по полю противника")
    
    def on_enemy_cell_clicked(self, x, y):
        """Выстрел по врагу"""
        if self.game_state != "playing" or self.current_player != "player":
            return
        
        # Проверяем, можно ли стрелять в эту клетку
        if not self.enemy_board.is_available_for_shot(x, y):
            return
        
        # Проверяем попадание по кораблям компьютера
        hit = False
        sunk_ship = None
        
        for ship in self.computer_ships:
            if ship.is_hit(x, y):
                ship.register_hit(x, y)
                self.enemy_board.set_hit(x, y)
                self.player_hits += 1
                hit = True
                
                # Проверяем, потоплен ли корабль
                if ship.is_sunk():
                    sunk_ship = ship
                    self.mark_ship_as_sunk(self.enemy_board, ship)
                    self.status_label.setText(f"🎉 Корабль противника потоплен!")
                else:
                    self.status_label.setText(f"💥 Попадание! Еще выстрел!")
                
                break
        
        if not hit:
            self.enemy_board.set_miss(x, y)
            self.player_misses += 1
            self.status_label.setText(f"🌊 Промах! Ход компьютера")
            self.current_player = "computer"
            self.update_stats()
            
            # Ход компьютера
            QTimer.singleShot(500, self.computer_turn)
        else:
            self.update_stats()
            
            # Если потопили корабль, очищаем историю попаданий для этого корабля
            if sunk_ship:
                self.ai_hits = []
                self.ai_current_ship = []
                self.ai_direction = None
            
            # Проверяем победу
            if self.check_victory():
                return
    
    def computer_turn(self):
        """Ход компьютера с учетом сложности"""
        if self.game_state != "playing" or self.current_player != "computer":
            return
        
        # Выбираем клетку в зависимости от сложности
        if self.current_difficulty == "Легкий":
            x, y = self.get_ai_easy_target()
        elif self.current_difficulty == "Сложный":
            x, y = self.get_ai_hard_target()
        else:  # Супер-сложный
            x, y = self.get_ai_super_target()
        
        # Проверяем, можно ли стрелять
        if not self.player_board.is_available_for_shot(x, y):
            # Если клетка недоступна, ищем другую
            x, y = self.find_any_available()
        
        # Запоминаем выстрел
        self.ai_memory.append((x, y))
        
        # Проверяем попадание
        hit = False
        sunk_ship = None
        
        for ship in self.player_ships:
            if ship.is_hit(x, y):
                ship.register_hit(x, y)
                self.player_board.set_hit(x, y)
                self.computer_hits += 1
                hit = True
                
                # Запоминаем попадание
                self.ai_hits.append((x, y))
                self.ai_current_ship.append((x, y))
                
                # Проверяем, потоплен ли корабль
                if ship.is_sunk():
                    sunk_ship = ship
                    self.mark_ship_as_sunk(self.player_board, ship)
                    self.status_label.setText(f"💔 Компьютер потопил ваш корабль!")
                    
                    # Очищаем историю попаданий для этого корабля
                    self.ai_hits = []
                    self.ai_current_ship = []
                    self.ai_direction = None
                else:
                    # Определяем направление для продолжения поиска
                    if len(self.ai_current_ship) >= 2 and not self.ai_direction:
                        # Определяем направление по двум попаданиям
                        x1, y1 = self.ai_current_ship[0]
                        x2, y2 = self.ai_current_ship[1]
                        if x1 == x2:
                            self.ai_direction = (0, 1 if y2 > y1 else -1)
                        else:
                            self.ai_direction = (1 if x2 > x1 else -1, 0)
                    
                    self.status_label.setText(f"💥 Компьютер попал!")
                
                break
        
        if not hit:
            self.player_board.set_miss(x, y)
            self.computer_misses += 1
            self.status_label.setText(f"🎯 Компьютер промахнулся! Ваш ход")
            self.current_player = "player"
        else:
            # Если попал, ходит еще раз
            self.current_player = "computer"
            QTimer.singleShot(500, self.computer_turn)
        
        self.update_stats()
        self.check_victory()
    
    def find_any_available(self):
        """Находит любую доступную клетку"""
        for i in range(10):
            for j in range(10):
                if self.player_board.is_available_for_shot(i, j):
                    return i, j
        return 0, 0
    
    def get_ai_easy_target(self):
        """Легкий уровень - случайные выстрелы"""
        attempts = 0
        while attempts < 100:
            x = random.randint(0, 9)
            y = random.randint(0, 9)
            if self.player_board.is_available_for_shot(x, y):
                return x, y
            attempts += 1
        return self.find_any_available()
    
    def get_ai_hard_target(self):
        """Сложный уровень - ищет вокруг попаданий"""
        # Если есть активные попадания, ищем вокруг
        if self.ai_hits:
            # Берем последнее попадание
            last_x, last_y = self.ai_hits[-1]
            
            # Проверяем все соседние клетки
            directions = [(0, 1), (1, 0), (0, -1), (-1, 0)]
            random.shuffle(directions)
            
            for dx, dy in directions:
                nx, ny = last_x + dx, last_y + dy
                if 0 <= nx < 10 and 0 <= ny < 10:
                    if self.player_board.is_available_for_shot(nx, ny):
                        return nx, ny
        
        # Если нет попаданий, стреляем в шахматном порядке
        candidates = []
        for i in range(10):
            for j in range(10):
                if (i + j) % 2 == 0 and self.player_board.is_available_for_shot(i, j):
                    candidates.append((i, j))
        
        if candidates:
            return random.choice(candidates)
        
        return self.get_ai_easy_target()
    
    def get_ai_super_target(self):
        """Супер-сложный уровень - анализирует направление"""
        # Если есть направление, продолжаем в ту же сторону
        if self.ai_direction and self.ai_current_ship:
            last_x, last_y = self.ai_current_ship[-1]
            dx, dy = self.ai_direction
            
            # Пробуем в том же направлении
            nx, ny = last_x + dx, last_y + dy
            if 0 <= nx < 10 and 0 <= ny < 10:
                if self.player_board.is_available_for_shot(nx, ny):
                    return nx, ny
            
            # Пробуем в противоположном
            nx, ny = self.ai_current_ship[0][0] - dx, self.ai_current_ship[0][1] - dy
            if 0 <= nx < 10 and 0 <= ny < 10:
                if self.player_board.is_available_for_shot(nx, ny):
                    return nx, ny
        
        # Если есть попадания, ищем вокруг
        if self.ai_hits:
            return self.get_ai_hard_target()
        
        # Анализируем вероятности
        # Клетки в центре имеют больший вес
        heat_map = [[0 for _ in range(10)] for _ in range(10)]
        
        for i in range(10):
            for j in range(10):
                if not self.player_board.is_available_for_shot(i, j):
                    heat_map[i][j] = -1
                    continue
                
                # Вес на основе позиции (ближе к центру - выше вес)
                dist_from_center = abs(i - 4.5) + abs(j - 4.5)
                heat_map[i][j] += int(10 - dist_from_center)
                
                # Вес на основе соседних пустых клеток
                for di in [-1, 0, 1]:
                    for dj in [-1, 0, 1]:
                        ni, nj = i + di, j + dj
                        if 0 <= ni < 10 and 0 <= nj < 10:
                            if self.player_board.is_available_for_shot(ni, nj):
                                heat_map[i][j] += 1
        
        # Выбираем клетку с максимальным весом
        max_weight = -1
        best_target = None
        
        for i in range(10):
            for j in range(10):
                if heat_map[i][j] > max_weight:
                    max_weight = heat_map[i][j]
                    best_target = (i, j)
        
        if best_target:
            return best_target
        
        return self.get_ai_easy_target()
    
    def check_victory(self):
        """Проверяет, не закончилась ли игра"""
        player_ships_sunk = all(ship.is_sunk() for ship in self.player_ships)
        computer_ships_sunk = all(ship.is_sunk() for ship in self.computer_ships)
        
        if player_ships_sunk:
            self.game_state = "game_over"
            self.status_label.setText("🏆 КОМПЬЮТЕР ПОБЕДИЛ!")
            self.ready_btn.setEnabled(False)
            return True
        
        if computer_ships_sunk:
            self.game_state = "game_over"
            self.status_label.setText("🏆 ВЫ ПОБЕДИЛИ!")
            self.ready_btn.setEnabled(False)
            return True
        
        return False
    
    def update_stats(self):
        """Обновляет статистику"""
        self.stats_label.setText(
            f"🎯 {self.player_hits}/{self.player_misses}  |  "
            f"🤖 {self.computer_hits}/{self.computer_misses}"
        )


# ========== ТОЧКА ВХОДА ДЛЯ ТЕСТИРОВАНИЯ ==========

if __name__ == "__main__":
    app = QApplication(sys.argv)
    
    # Создаем тестовое окно
    window = QMainWindow()
    window.setWindowTitle("🎯 Морской бой - тест")
    window.showMaximized()
    
    # Создаем виджет игры
    class MockMainWindow:
        def windowIcon(self):
            return None
    
    widget = SeaBattleWidget(MockMainWindow(), None)
    window.setCentralWidget(widget)
    
    window.show()
    sys.exit(app.exec_())