import tkinter as tk
from tkinter import ttk, colorchooser, filedialog, messagebox
from PIL import Image, ImageDraw, ImageTk
import os

class SimplePaintApp:
    def __init__(self, root):
        self.root = root
        self.root.title("简易画图板")
        
        # 窗口设置
        self.width = 1000
        self.height = 700
        self.root.geometry(f"{self.width}x{self.height}")
        
        # 创建主框架
        self.main_frame = tk.Frame(self.root)
        self.main_frame.pack(fill=tk.BOTH, expand=True)
        
        # 颜色设置
        self.colors = {
            'black': '#000000',
            'white': '#FFFFFF',
            'red': '#FF0000',
            'green': '#00FF00',
            'blue': '#0000FF',
            'yellow': '#FFFF00',
            'pink': '#FFC0CB',
            'purple': '#800080',
            'orange': '#FFA500',
            'brown': '#8B4513',
            'cyan': '#00FFFF',
            'gray': '#808080'
        }
        
        # 绘图变量
        self.pen_color = 'black'
        self.pen_size = 3
        self.eraser_color = 'white'
        self.current_tool = 'pen'
        self.last_x = None
        self.last_y = None
        self.start_x = None
        self.start_y = None
        self.drawing = False
        
        # 创建界面
        self.create_widgets()
        
        # 绑定事件
        self.bind_events()
        
    def create_widgets(self):
        """创建界面组件"""
        # 工具栏
        self.create_toolbar()
        
        # 画布区域
        self.create_canvas()
        
        # 状态栏
        self.create_statusbar()
        
    def create_toolbar(self):
        """创建工具栏"""
        # 工具栏框架
        toolbar_frame = tk.Frame(self.main_frame, bg='#f0f0f0', height=50)
        toolbar_frame.pack(side=tk.TOP, fill=tk.X)
        toolbar_frame.pack_propagate(False)
        
        # 工具按钮框架
        tools_frame = tk.Frame(toolbar_frame, bg='#f0f0f0')
        tools_frame.pack(side=tk.LEFT, padx=5)
        
        # 工具按钮
        tools = [
            ("画笔", 'pen', self.select_pen),
            ("橡皮", 'eraser', self.select_eraser),
            ("直线", 'line', self.select_line),
            ("矩形", 'rectangle', self.select_rectangle),
            ("圆形", 'oval', self.select_oval),
            ("填充", 'fill', self.select_fill)
        ]
        
        for name, tool, command in tools:
            btn = tk.Button(tools_frame, text=name, width=6,
                          command=lambda t=tool: command(),
                          bg='#4CAF50' if tool == 'pen' else '#f0f0f0',
                          fg='white' if tool == 'pen' else 'black',
                          relief=tk.RAISED)
            btn.pack(side=tk.LEFT, padx=2, pady=5)
            
        # 颜色选择框架
        color_frame = tk.Frame(toolbar_frame, bg='#f0f0f0')
        color_frame.pack(side=tk.LEFT, padx=20)
        
        tk.Label(color_frame, text="颜色:", bg='#f0f0f0').pack(side=tk.LEFT, padx=5)
        
        # 常用颜色按钮
        for name, color in self.colors.items():
            btn = tk.Button(color_frame, text="", bg=color, width=2, height=1,
                          command=lambda c=color: self.select_color(c))
            btn.pack(side=tk.LEFT, padx=1)
            
        # 自定义颜色按钮
        custom_color_btn = tk.Button(color_frame, text="自定义", width=6,
                                    command=self.choose_custom_color)
        custom_color_btn.pack(side=tk.LEFT, padx=10)
        
        # 当前颜色显示
        self.color_display = tk.Label(color_frame, text="◼", 
                                     font=("Arial", 20), fg=self.pen_color)
        self.color_display.pack(side=tk.LEFT, padx=5)
        
        # 粗细控制框架
        size_frame = tk.Frame(toolbar_frame, bg='#f0f0f0')
        size_frame.pack(side=tk.LEFT, padx=20)
        
        tk.Label(size_frame, text="粗细:", bg='#f0f0f0').pack(side=tk.LEFT, padx=5)
        
        # 粗细滑动条
        self.size_var = tk.IntVar(value=self.pen_size)
        size_scale = tk.Scale(size_frame, from_=1, to=20, orient=tk.HORIZONTAL,
                             variable=self.size_var, command=self.change_pen_size,
                             length=100, bg='#f0f0f0')
        size_scale.pack(side=tk.LEFT)
        
        # 粗细显示
        self.size_label = tk.Label(size_frame, text=f"{self.pen_size}px", 
                                  bg='#f0f0f0', width=6)
        self.size_label.pack(side=tk.LEFT, padx=5)
        
        # 文件操作框架
        file_frame = tk.Frame(toolbar_frame, bg='#f0f0f0')
        file_frame.pack(side=tk.RIGHT, padx=20)
        
        # 文件操作按钮
        file_buttons = [
            ("新建", self.new_canvas),
            ("打开", self.open_image),
            ("保存", self.save_image),
            ("清空", self.clear_canvas)
        ]
        
        for name, command in file_buttons:
            btn = tk.Button(file_frame, text=name, width=6, command=command,
                          bg='#2196F3', fg='white', relief=tk.RAISED)
            btn.pack(side=tk.LEFT, padx=2)
            
    def create_canvas(self):
        """创建画布区域"""
        # 画布框架
        canvas_frame = tk.Frame(self.main_frame, bg='white')
        canvas_frame.pack(fill=tk.BOTH, expand=True, padx=10, pady=10)
        
        # 创建画布
        self.canvas_width = 800
        self.canvas_height = 500
        self.canvas = tk.Canvas(canvas_frame, bg='white', 
                               width=self.canvas_width, height=self.canvas_height,
                               cursor="cross")
        
        # 添加滚动条
        v_scrollbar = tk.Scrollbar(canvas_frame, orient=tk.VERTICAL)
        h_scrollbar = tk.Scrollbar(canvas_frame, orient=tk.HORIZONTAL)
        
        v_scrollbar.pack(side=tk.RIGHT, fill=tk.Y)
        h_scrollbar.pack(side=tk.BOTTOM, fill=tk.X)
        
        self.canvas.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
        
        # 配置滚动条
        self.canvas.config(yscrollcommand=v_scrollbar.set,
                          xscrollcommand=h_scrollbar.set)
        v_scrollbar.config(command=self.canvas.yview)
        h_scrollbar.config(command=self.canvas.xview)
        
        # 设置画布可滚动区域
        self.canvas.config(scrollregion=self.canvas.bbox("all"))
        
    def create_statusbar(self):
        """创建状态栏"""
        status_frame = tk.Frame(self.main_frame, bg='#e0e0e0', height=30)
        status_frame.pack(side=tk.BOTTOM, fill=tk.X)
        status_frame.pack_propagate(False)
        
        # 状态信息
        self.status_label = tk.Label(status_frame, text="就绪 | 工具: 画笔 | 颜色: 黑色 | 粗细: 3px", 
                                    bg='#e0e0e0', anchor=tk.W)
        self.status_label.pack(side=tk.LEFT, padx=10)
        
        # 坐标显示
        self.coord_label = tk.Label(status_frame, text="坐标: (0, 0)", 
                                   bg='#e0e0e0')
        self.coord_label.pack(side=tk.RIGHT, padx=10)
        
    def bind_events(self):
        """绑定事件"""
        # 鼠标事件
        self.canvas.bind("<Button-1>", self.start_draw)
        self.canvas.bind("<B1-Motion>", self.drawing_motion)
        self.canvas.bind("<ButtonRelease-1>", self.stop_draw)
        
        # 鼠标移动事件（显示坐标）
        self.canvas.bind("<Motion>", self.show_coordinates)
        
    def start_draw(self, event):
        """开始绘图"""
        self.drawing = True
        self.last_x = event.x
        self.last_y = event.y
        self.start_x = event.x
        self.start_y = event.y
        
    def drawing_motion(self, event):
        """绘图过程中的移动"""
        if not self.drawing:
            return
            
        x, y = event.x, event.y
        
        if self.current_tool == 'pen':
            self.canvas.create_line(self.last_x, self.last_y, x, y,
                                   fill=self.pen_color,
                                   width=self.pen_size,
                                   capstyle=tk.ROUND, smooth=True)
            self.last_x = x
            self.last_y = y
            
        elif self.current_tool == 'eraser':
            self.canvas.create_line(self.last_x, self.last_y, x, y,
                                   fill=self.eraser_color,
                                   width=self.pen_size * 3,  # 橡皮更大
                                   capstyle=tk.ROUND, smooth=True)
            self.last_x = x
            self.last_y = y
            
        elif self.current_tool in ['line', 'rectangle', 'oval']:
            # 删除临时图形
            if hasattr(self, 'temp_shape'):
                self.canvas.delete(self.temp_shape)
                
            # 绘制临时图形
            if self.current_tool == 'line':
                self.temp_shape = self.canvas.create_line(self.start_x, self.start_y, x, y,
                                                         fill=self.pen_color,
                                                         width=self.pen_size)
            elif self.current_tool == 'rectangle':
                self.temp_shape = self.canvas.create_rectangle(self.start_x, self.start_y, x, y,
                                                              outline=self.pen_color,
                                                              width=self.pen_size)
            elif self.current_tool == 'oval':
                self.temp_shape = self.canvas.create_oval(self.start_x, self.start_y, x, y,
                                                         outline=self.pen_color,
                                                         width=self.pen_size)
                                                         
    def stop_draw(self, event):
        """停止绘图"""
        if not self.drawing:
            return
            
        x, y = event.x, event.y
        
        if self.current_tool == 'line':
            self.canvas.create_line(self.start_x, self.start_y, x, y,
                                   fill=self.pen_color,
                                   width=self.pen_size)
                                   
        elif self.current_tool == 'rectangle':
            self.canvas.create_rectangle(self.start_x, self.start_y, x, y,
                                        outline=self.pen_color,
                                        width=self.pen_size)
                                        
        elif self.current_tool == 'oval':
            self.canvas.create_oval(self.start_x, self.start_y, x, y,
                                   outline=self.pen_color,
                                   width=self.pen_size)
                                   
        elif self.current_tool == 'fill':
            # 简单的填充实现
            items = self.canvas.find_closest(x, y)
            if items:
                self.canvas.itemconfig(items[0], fill=self.pen_color)
                
        # 清除临时图形
        if hasattr(self, 'temp_shape'):
            self.canvas.delete(self.temp_shape)
            delattr(self, 'temp_shape')
            
        self.drawing = False
        
    def show_coordinates(self, event):
        """显示鼠标坐标"""
        x, y = event.x, event.y
        self.coord_label.config(text=f"坐标: ({x}, {y})")
        
    def select_pen(self):
        """选择画笔工具"""
        self.current_tool = 'pen'
        self.update_status()
        
    def select_eraser(self):
        """选择橡皮工具"""
        self.current_tool = 'eraser'
        self.update_status()
        
    def select_line(self):
        """选择直线工具"""
        self.current_tool = 'line'
        self.update_status()
        
    def select_rectangle(self):
        """选择矩形工具"""
        self.current_tool = 'rectangle'
        self.update_status()
        
    def select_oval(self):
        """选择圆形工具"""
        self.current_tool = 'oval'
        self.update_status()
        
    def select_fill(self):
        """选择填充工具"""
        self.current_tool = 'fill'
        self.update_status()
        
    def select_color(self, color):
        """选择颜色"""
        self.pen_color = color
        self.color_display.config(fg=color)
        self.update_status()
        
    def choose_custom_color(self):
        """选择自定义颜色"""
        color = colorchooser.askcolor(title="选择颜色", initialcolor=self.pen_color)
        if color[1]:  # 用户选择了颜色
            self.pen_color = color[1]
            self.color_display.config(fg=color[1])
            self.update_status()
            
    def change_pen_size(self, value):
        """改变画笔粗细"""
        self.pen_size = int(value)
        self.size_label.config(text=f"{self.pen_size}px")
        self.update_status()
        
    def new_canvas(self):
        """新建画布"""
        if messagebox.askyesno("新建", "确定要创建新的画布吗？当前内容将丢失。"):
            self.clear_canvas()
            
    def open_image(self):
        """打开图片"""
        file_path = filedialog.askopenfilename(
            title="打开图片",
            filetypes=[
                ("图片文件", "*.png *.jpg *.jpeg *.gif *.bmp"),
                ("所有文件", "*.*")
            ]
        )
        
        if file_path:
            try:
                # 清空当前画布
                self.clear_canvas()
                
                # 加载图片
                image = Image.open(file_path)
                
                # 调整图片大小以适应画布
                img_width, img_height = image.size
                scale = min(self.canvas_width/img_width, self.canvas_height/img_height)
                new_size = (int(img_width*scale), int(img_height*scale))
                image = image.resize(new_size, Image.Resampling.LANCZOS)
                
                # 显示图片
                self.tk_image = ImageTk.PhotoImage(image)
                self.canvas.create_image(self.canvas_width//2, self.canvas_height//2,
                                        anchor=tk.CENTER, image=self.tk_image)
                                        
            except Exception as e:
                messagebox.showerror("错误", f"无法打开图片: {str(e)}")
                
    def save_image(self):
        """保存图片"""
        file_path = filedialog.asksaveasfilename(
            title="保存图片",
            defaultextension=".png",
            filetypes=[
                ("PNG文件", "*.png"),
                ("JPEG文件", "*.jpg"),
                ("所有文件", "*.*")
            ]
        )
        
        if file_path:
            try:
                # 获取画布内容
                x = self.root.winfo_rootx() + self.canvas.winfo_x()
                y = self.root.winfo_rooty() + self.canvas.winfo_y()
                x1 = x + self.canvas_width
                y1 = y + self.canvas_height
                
                # 截屏保存
                from PIL import ImageGrab
                image = ImageGrab.grab(bbox=(x, y, x1, y1))
                image.save(file_path)
                
                messagebox.showinfo("成功", f"图片已保存到: {file_path}")
                
            except Exception as e:
                messagebox.showerror("错误", f"保存失败: {str(e)}")
                
    def clear_canvas(self):
        """清空画布"""
        if messagebox.askyesno("清空", "确定要清空画布吗？"):
            self.canvas.delete("all")
            
    def update_status(self):
        """更新状态栏"""
        tool_names = {
            'pen': '画笔',
            'eraser': '橡皮',
            'line': '直线',
            'rectangle': '矩形',
            'oval': '圆形',
            'fill': '填充'
        }
        
        # 获取颜色名称
        color_name = '自定义'
        for name, color in self.colors.items():
            if color == self.pen_color:
                color_name = name
                break
                
        status_text = f"就绪 | 工具: {tool_names[self.current_tool]} | 颜色: {color_name} | 粗细: {self.pen_size}px"
        self.status_label.config(text=status_text)

def main():
    """主函数"""
    root = tk.Tk()
    
    # 设置窗口位置居中
    screen_width = root.winfo_screenwidth()
    screen_height = root.winfo_screenheight()
    width = 1000
    height = 700
    x = (screen_width - width) // 2
    y = (screen_height - height) // 2
    root.geometry(f"{width}x{height}+{x}+{y}")
    
    app = SimplePaintApp(root)
    root.mainloop()

if __name__ == "__main__":
    main()