import tkinter as tk
from tkinter import messagebox
import random
import time

class SnakeGame:
    def __init__(self, root):
        self.root = root
        self.root.title("Snake Game - Tkinter")
        self.root.resizable(False, False)
        
        # 游戏参数
        self.grid_size = 20
        self.grid_width = 30
        self.grid_height = 20
        self.cell_size = 25
        self.speed = 150  # 初始速度（毫秒）
        
        # 颜色定义
        self.bg_color = "#1a1a1a"
        self.grid_color = "#2a2a2a"
        self.snake_color = "#4CAF50"
        self.snake_head_color = "#388E3C"
        self.food_color = "#F44336"
        self.text_color = "#FFFFFF"
        self.score_color = "#FFC107"
        
        # 初始化游戏状态
        self.score = 0
        self.high_score = 0
        self.game_over = False
        self.paused = False
        self.direction = "Right"
        self.next_direction = "Right"
        
        # 创建UI
        self.create_widgets()
        self.setup_game()
        
        # 绑定按键事件
        self.root.bind("<KeyPress>", self.key_pressed)
        
        # 开始游戏循环
        self.game_loop()
    
    def create_widgets(self):
        # 创建主框架
        main_frame = tk.Frame(self.root, bg=self.bg_color)
        main_frame.pack(padx=20, pady=20)
        
        # 分数面板
        score_frame = tk.Frame(main_frame, bg=self.bg_color)
        score_frame.pack(fill="x", pady=(0, 10))
        
        self.score_label = tk.Label(score_frame, text=f"Score: 0", 
                                    font=("Arial", 16, "bold"), 
                                    fg=self.text_color, bg=self.bg_color)
        self.score_label.pack(side="left", padx=10)
        
        self.high_score_label = tk.Label(score_frame, text=f"High Score: 0", 
                                         font=("Arial", 16, "bold"), 
                                         fg=self.score_color, bg=self.bg_color)
        self.high_score_label.pack(side="right", padx=10)
        
        # 游戏区域
        canvas_width = self.grid_width * self.cell_size
        canvas_height = self.grid_height * self.cell_size
        
        self.canvas = tk.Canvas(main_frame, width=canvas_width, height=canvas_height, 
                                bg=self.bg_color, highlightthickness=2, 
                                highlightbackground=self.grid_color)
        self.canvas.pack()
        
        # 绘制网格
        self.draw_grid()
        
        # 控制面板
        control_frame = tk.Frame(main_frame, bg=self.bg_color)
        control_frame.pack(fill="x", pady=(10, 0))
        
        # 控制按钮
        button_style = {"font": ("Arial", 12), "width": 10, "height": 1, "bg": "#2196F3", "fg": "white"}
        
        self.start_btn = tk.Button(control_frame, text="Start Game", command=self.start_game, **button_style)
        self.start_btn.pack(side="left", padx=5)
        
        self.pause_btn = tk.Button(control_frame, text="Pause", command=self.toggle_pause, 
                                   state="disabled", **button_style)
        self.pause_btn.pack(side="left", padx=5)
        
        self.restart_btn = tk.Button(control_frame, text="Restart", command=self.restart_game, 
                                     state="disabled", **button_style)
        self.restart_btn.pack(side="left", padx=5)
        
        # 难度选择
        difficulty_frame = tk.Frame(control_frame, bg=self.bg_color)
        difficulty_frame.pack(side="right")
        
        tk.Label(difficulty_frame, text="Speed:", font=("Arial", 12), 
                fg=self.text_color, bg=self.bg_color).pack(side="left", padx=(0, 5))
        
        self.speed_var = tk.StringVar(value="Normal")
        speeds = [("Slow", 200), ("Normal", 150), ("Fast", 100), ("Very Fast", 70)]
        
        for speed_text, _ in speeds:
            tk.Radiobutton(difficulty_frame, text=speed_text, variable=self.speed_var, 
                          value=speed_text, command=self.change_speed,
                          font=("Arial", 10), fg=self.text_color, bg=self.bg_color,
                          selectcolor="#333333").pack(side="left", padx=2)
        
        # 控制说明
        instructions = tk.Label(main_frame, 
                               text="Controls: ↑ ↓ ← → or WASD to move | P: Pause | R: Restart", 
                               font=("Arial", 10), fg="#888888", bg=self.bg_color)
        instructions.pack(pady=(10, 0))
    
    def draw_grid(self):
        """绘制游戏网格"""
        for x in range(0, self.grid_width * self.cell_size, self.cell_size):
            self.canvas.create_line(x, 0, x, self.grid_height * self.cell_size, 
                                   fill=self.grid_color, width=1)
        for y in range(0, self.grid_height * self.cell_size, self.cell_size):
            self.canvas.create_line(0, y, self.grid_width * self.cell_size, y, 
                                   fill=self.grid_color, width=1)
    
    def setup_game(self):
        """初始化游戏"""
        # 清空画布
        self.canvas.delete("all")
        self.draw_grid()
        
        # 初始化蛇的位置（中间位置）
        center_x = self.grid_width // 2
        center_y = self.grid_height // 2
        self.snake = [
            (center_x, center_y),
            (center_x - 1, center_y),
            (center_x - 2, center_y)
        ]
        
        # 初始化食物
        self.food = None
        self.generate_food()
        
        # 初始化方向
        self.direction = "Right"
        self.next_direction = "Right"
        
        # 绘制初始状态
        self.draw_snake()
        self.draw_food()
        
        # 更新按钮状态
        self.start_btn.config(state="normal")
        self.pause_btn.config(state="disabled", text="Pause")
        self.restart_btn.config(state="disabled")
        
        # 重置游戏状态
        self.game_over = False
        self.paused = False
        self.score = 0
        self.update_score()
    
    def draw_snake(self):
        """绘制蛇"""
        for i, (x, y) in enumerate(self.snake):
            x1 = x * self.cell_size
            y1 = y * self.cell_size
            x2 = x1 + self.cell_size
            y2 = y1 + self.cell_size
            
            # 蛇头用不同颜色
            if i == 0:
                color = self.snake_head_color
                outline = "#81C784"
                # 绘制蛇眼睛
                eye_size = self.cell_size // 5
                eye_offset = self.cell_size // 3
                
                # 根据方向计算眼睛位置
                if self.direction == "Right":
                    self.canvas.create_oval(x1 + self.cell_size - eye_offset, y1 + eye_offset,
                                          x1 + self.cell_size - eye_offset + eye_size, y1 + eye_offset + eye_size,
                                          fill="white")
                    self.canvas.create_oval(x1 + self.cell_size - eye_offset, y2 - eye_offset - eye_size,
                                          x1 + self.cell_size - eye_offset + eye_size, y2 - eye_offset,
                                          fill="white")
                elif self.direction == "Left":
                    self.canvas.create_oval(x1 + eye_offset, y1 + eye_offset,
                                          x1 + eye_offset + eye_size, y1 + eye_offset + eye_size,
                                          fill="white")
                    self.canvas.create_oval(x1 + eye_offset, y2 - eye_offset - eye_size,
                                          x1 + eye_offset + eye_size, y2 - eye_offset,
                                          fill="white")
                elif self.direction == "Up":
                    self.canvas.create_oval(x1 + eye_offset, y1 + eye_offset,
                                          x1 + eye_offset + eye_size, y1 + eye_offset + eye_size,
                                          fill="white")
                    self.canvas.create_oval(x2 - eye_offset - eye_size, y1 + eye_offset,
                                          x2 - eye_offset, y1 + eye_offset + eye_size,
                                          fill="white")
                elif self.direction == "Down":
                    self.canvas.create_oval(x1 + eye_offset, y2 - eye_offset - eye_size,
                                          x1 + eye_offset + eye_size, y2 - eye_offset,
                                          fill="white")
                    self.canvas.create_oval(x2 - eye_offset - eye_size, y2 - eye_offset - eye_size,
                                          x2 - eye_offset, y2 - eye_offset,
                                          fill="white")
            else:
                color = self.snake_color
                outline = "#A5D6A7"
            
            # 绘制蛇身体
            self.canvas.create_rectangle(x1, y1, x2, y2, fill=color, 
                                        outline=outline, width=2, tags="snake")
            
            # 为身体节段添加圆角效果
            if i > 0:
                self.canvas.create_oval(x1 + 2, y1 + 2, x2 - 2, y2 - 2, 
                                      fill=color, outline=outline, width=1)
    
    def draw_food(self):
        """绘制食物"""
        if self.food:
            x, y = self.food
            x1 = x * self.cell_size
            y1 = y * self.cell_size
            x2 = x1 + self.cell_size
            y2 = y1 + self.cell_size
            
            # 绘制苹果形状的食物
            center_x = (x1 + x2) / 2
            center_y = (y1 + y2) / 2
            radius = self.cell_size // 2 - 2
            
            # 苹果主体
            self.canvas.create_oval(center_x - radius, center_y - radius,
                                  center_x + radius, center_y + radius,
                                  fill=self.food_color, outline="#D32F2F", width=2, tags="food")
            
            # 苹果茎
            stem_x = center_x
            stem_y = y1 + 2
            self.canvas.create_line(stem_x, stem_y, stem_x, stem_y - 6, 
                                   fill="#8D6E63", width=2)
            
            # 苹果叶子
            self.canvas.create_oval(stem_x - 3, stem_y - 8, stem_x + 7, stem_y - 2,
                                  fill="#388E3C", outline="")
    
    def generate_food(self):
        """生成新的食物位置"""
        while True:
            x = random.randint(0, self.grid_width - 1)
            y = random.randint(0, self.grid_height - 1)
            
            # 确保食物不在蛇身上
            if (x, y) not in self.snake:
                self.food = (x, y)
                break
    
    def move_snake(self):
        """移动蛇"""
        if self.game_over or self.paused:
            return
        
        # 更新方向
        self.direction = self.next_direction
        
        # 获取蛇头位置
        head_x, head_y = self.snake[0]
        
        # 根据方向计算新的头部位置
        if self.direction == "Up":
            new_head = (head_x, head_y - 1)
        elif self.direction == "Down":
            new_head = (head_x, head_y + 1)
        elif self.direction == "Left":
            new_head = (head_x - 1, head_y)
        elif self.direction == "Right":
            new_head = (head_x + 1, head_y)
        
        # 检查是否撞墙
        if (new_head[0] < 0 or new_head[0] >= self.grid_width or 
            new_head[1] < 0 or new_head[1] >= self.grid_height):
            self.game_over = True
            self.show_game_over()
            return
        
        # 检查是否撞到自己
        if new_head in self.snake:
            self.game_over = True
            self.show_game_over()
            return
        
        # 在头部添加新位置
        self.snake.insert(0, new_head)
        
        # 检查是否吃到食物
        if new_head == self.food:
            self.score += 10
            self.update_score()
            self.generate_food()
            
            # 每得50分增加速度
            if self.score % 50 == 0 and self.speed > 50:
                self.speed = max(50, self.speed - 20)
        else:
            # 如果没有吃到食物，移除尾部
            self.snake.pop()
        
        # 重绘游戏
        self.canvas.delete("all")
        self.draw_grid()
        self.draw_food()
        self.draw_snake()
    
    def update_score(self):
        """更新分数显示"""
        self.score_label.config(text=f"Score: {self.score}")
        
        if self.score > self.high_score:
            self.high_score = self.score
            self.high_score_label.config(text=f"High Score: {self.high_score}")
    
    def show_game_over(self):
        """显示游戏结束界面"""
        self.canvas.create_text(
            self.grid_width * self.cell_size / 2,
            self.grid_height * self.cell_size / 2 - 30,
            text="GAME OVER",
            font=("Arial", 36, "bold"),
            fill="#FF5252"
        )
        
        self.canvas.create_text(
            self.grid_width * self.cell_size / 2,
            self.grid_height * self.cell_size / 2 + 20,
            text=f"Final Score: {self.score}",
            font=("Arial", 20),
            fill="#FFC107"
        )
        
        self.canvas.create_text(
            self.grid_width * self.cell_size / 2,
            self.grid_height * self.cell_size / 2 + 60,
            text="Press 'R' to restart or click Restart button",
            font=("Arial", 12),
            fill="#BDBDBD"
        )
        
        # 更新按钮状态
        self.start_btn.config(state="disabled")
        self.pause_btn.config(state="disabled")
        self.restart_btn.config(state="normal")
    
    def key_pressed(self, event):
        """处理按键事件"""
        key = event.keysym
        
        # 方向控制
        if key in ("Up", "w", "W") and self.direction != "Down":
            self.next_direction = "Up"
        elif key in ("Down", "s", "S") and self.direction != "Up":
            self.next_direction = "Down"
        elif key in ("Left", "a", "A") and self.direction != "Right":
            self.next_direction = "Left"
        elif key in ("Right", "d", "D") and self.direction != "Left":
            self.next_direction = "Right"
        
        # 功能键
        elif key == "p" or key == "P":
            self.toggle_pause()
        elif key == "r" or key == "R":
            self.restart_game()
        elif key == "space":
            if not self.game_over:
                self.start_game()
    
    def start_game(self):
        """开始游戏"""
        if not self.game_over:
            self.paused = False
            self.start_btn.config(state="disabled")
            self.pause_btn.config(state="normal", text="Pause")
            self.restart_btn.config(state="normal")
    
    def toggle_pause(self):
        """暂停/继续游戏"""
        if not self.game_over:
            self.paused = not self.paused
            if self.paused:
                self.pause_btn.config(text="Resume")
                # 显示暂停文本
                self.canvas.create_text(
                    self.grid_width * self.cell_size / 2,
                    self.grid_height * self.cell_size / 2,
                    text="PAUSED",
                    font=("Arial", 36, "bold"),
                    fill="#2196F3"
                )
            else:
                self.pause_btn.config(text="Pause")
    
    def restart_game(self):
        """重新开始游戏"""
        self.setup_game()
        self.start_game()
    
    def change_speed(self):
        """改变游戏速度"""
        speed_map = {
            "Slow": 200,
            "Normal": 150,
            "Fast": 100,
            "Very Fast": 70
        }
        self.speed = speed_map[self.speed_var.get()]
    
    def game_loop(self):
        """游戏主循环"""
        if not self.game_over and not self.paused:
            self.move_snake()
        
        # 继续游戏循环
        self.root.after(self.speed, self.game_loop)

def main():
    root = tk.Tk()
    
    # 设置窗口位置在屏幕中央
    window_width = 850
    window_height = 650
    screen_width = root.winfo_screenwidth()
    screen_height = root.winfo_screenheight()
    x = (screen_width - window_width) // 2
    y = (screen_height - window_height) // 2
    root.geometry(f"{window_width}x{window_height}+{x}+{y}")
    
    # 创建游戏实例
    game = SnakeGame(root)
    
    # 运行主循环
    root.mainloop()

if __name__ == "__main__":
    main()