# screenshot_tool.py
import tkinter as tk
from tkinter import ttk, messagebox
import threading
import time
import json
import os
from datetime import datetime
from PIL import ImageGrab
import keyboard
import win32api
import ctypes
import sys

class ScreenshotTool:
    def __init__(self):
        self.root = tk.Tk()
        self.root.title("截图工具")
        self.root.geometry("300x450")
        self.root.resizable(False, False)
        
        # 配置文件路径
        self.config_file = "screenshot_config.json"
        
        # 截图相关变量
        self.screenshot_window = None
        self.start_x = None
        self.start_y = None
        self.end_x = None
        self.end_y = None
        self.rect_id = None
        self.drawing = False
        self.cancel_flag = False  # 取消标志
        
        # 加载配置
        self.load_config()
        
        # 设置快捷键
        self.setup_hotkeys()
        
        # 创建主界面
        self.create_ui()
        
        # 设置系统托盘
        self.setup_tray()
        
        # 绑定窗口关闭事件
        self.root.protocol("WM_DELETE_WINDOW", self.hide_window)
        
    def load_config(self):
        """加载配置文件"""
        default_config = {
            "hotkey_fullscreen": "ctrl+shift+a",
            "hotkey_area": "ctrl+shift+s",
            "save_path": "./screenshots",
            "auto_save": True,
            "image_format": "png",
            "quality": 95
        }
        
        if os.path.exists(self.config_file):
            try:
                with open(self.config_file, 'r', encoding='utf-8') as f:
                    config = json.load(f)
                    default_config.update(config)
            except:
                pass
        else:
            self.save_config(default_config)
        
        self.fullscreen_hotkey = default_config.get("hotkey_fullscreen")
        self.area_hotkey = default_config.get("hotkey_area")
        self.save_path = default_config.get("save_path")
        self.auto_save = default_config.get("auto_save")
        self.image_format = default_config.get("image_format")
        self.quality = default_config.get("quality")
        
        if not os.path.exists(self.save_path):
            os.makedirs(self.save_path)
    
    def save_config(self, config=None):
        """保存配置文件"""
        if config is None:
            config = {
                "hotkey_fullscreen": self.fullscreen_hotkey,
                "hotkey_area": self.area_hotkey,
                "save_path": self.save_path,
                "auto_save": self.auto_save,
                "image_format": self.image_format,
                "quality": self.quality
            }
        
        try:
            with open(self.config_file, 'w', encoding='utf-8') as f:
                json.dump(config, f, indent=4, ensure_ascii=False)
        except Exception as e:
            print(f"保存配置失败: {e}")
    
    def setup_hotkeys(self):
        """设置全局快捷键"""
        try:
            keyboard.add_hotkey(self.fullscreen_hotkey, self.fullscreen_screenshot)
            keyboard.add_hotkey(self.area_hotkey, self.area_screenshot)
            keyboard.add_hotkey("ctrl+shift+q", self.quit_app)
            print(f"快捷键注册成功:")
            print(f"  全屏截图: {self.fullscreen_hotkey}")
            print(f"  区域截图: {self.area_hotkey}")
            print(f"  退出程序: ctrl+shift+q")
        except Exception as e:
            print(f"快捷键注册失败: {e}")
    
    def create_ui(self):
        """创建主界面"""
        # 标题
        title_label = tk.Label(self.root, text="截图工具", font=("Arial", 16, "bold"))
        title_label.pack(pady=10)
        
        # 创建笔记本
        notebook = ttk.Notebook(self.root)
        notebook.pack(fill=tk.BOTH, expand=True, padx=10, pady=5)
        
        # 截图选项卡
        screenshot_frame = ttk.Frame(notebook)
        notebook.add(screenshot_frame, text="截图")
        
        # 快捷键设置选项卡
        hotkey_frame = ttk.Frame(notebook)
        notebook.add(hotkey_frame, text="快捷键设置")
        
        # 设置选项卡
        settings_frame = ttk.Frame(notebook)
        notebook.add(settings_frame, text="设置")
        
        # ========== 截图选项卡 ==========
        fullscreen_btn = tk.Button(screenshot_frame, text="全屏截图", 
                                  command=self.fullscreen_screenshot,
                                  bg="#4CAF50", fg="white", font=("Arial", 12),
                                  height=2, width=20)
        fullscreen_btn.pack(pady=20)
        
        area_btn = tk.Button(screenshot_frame, text="区域截图", 
                            command=self.area_screenshot,
                            bg="#2196F3", fg="white", font=("Arial", 12),
                            height=2, width=20)
        area_btn.pack(pady=20)
        
        hotkey_info = tk.Label(screenshot_frame, 
                              text=f"快捷键:\n全屏: {self.fullscreen_hotkey}\n区域: {self.area_hotkey}\n\n区域截图时按 ESC 取消",
                              font=("Arial", 10), fg="gray")
        hotkey_info.pack(pady=30)
        
        # ========== 快捷键设置选项卡 ==========
        tk.Label(hotkey_frame, text="全屏截图快捷键:").pack(anchor=tk.W, pady=(10, 5))
        self.fullscreen_hotkey_var = tk.StringVar(value=self.fullscreen_hotkey)
        fullscreen_entry = tk.Entry(hotkey_frame, textvariable=self.fullscreen_hotkey_var, 
                                   state='readonly', width=20)
        fullscreen_entry.pack(anchor=tk.W, pady=(0, 10))
        fullscreen_btn = tk.Button(hotkey_frame, text="设置", 
                                  command=lambda: self.set_hotkey("fullscreen"))
        fullscreen_btn.pack(anchor=tk.W, pady=(0, 10))
        
        tk.Label(hotkey_frame, text="区域截图快捷键:").pack(anchor=tk.W, pady=(10, 5))
        self.area_hotkey_var = tk.StringVar(value=self.area_hotkey)
        area_entry = tk.Entry(hotkey_frame, textvariable=self.area_hotkey_var, 
                             state='readonly', width=20)
        area_entry.pack(anchor=tk.W, pady=(0, 10))
        area_btn = tk.Button(hotkey_frame, text="设置", 
                            command=lambda: self.set_hotkey("area"))
        area_btn.pack(anchor=tk.W, pady=(0, 10))
        
        # ========== 设置选项卡 ==========
        tk.Label(settings_frame, text="保存路径:").pack(anchor=tk.W, pady=(10, 5))
        self.save_path_var = tk.StringVar(value=self.save_path)
        save_path_frame = tk.Frame(settings_frame)
        save_path_frame.pack(fill=tk.X, pady=(0, 10))
        save_path_entry = tk.Entry(save_path_frame, textvariable=self.save_path_var, width=30)
        save_path_entry.pack(side=tk.LEFT, padx=(0, 5))
        save_path_btn = tk.Button(save_path_frame, text="浏览", command=self.choose_save_path)
        save_path_btn.pack(side=tk.LEFT)
        
        self.auto_save_var = tk.BooleanVar(value=self.auto_save)
        auto_save_check = tk.Checkbutton(settings_frame, text="自动保存截图", 
                                        variable=self.auto_save_var,
                                        command=self.toggle_auto_save)
        auto_save_check.pack(anchor=tk.W, pady=5)
        
        tk.Label(settings_frame, text="图片格式:").pack(anchor=tk.W, pady=(10, 5))
        self.format_var = tk.StringVar(value=self.image_format)
        format_combo = ttk.Combobox(settings_frame, textvariable=self.format_var,
                                   values=["png", "jpg", "bmp"], state="readonly", width=10)
        format_combo.pack(anchor=tk.W, pady=(0, 10))
        format_combo.bind('<<ComboboxSelected>>', self.change_format)
        
        tk.Label(settings_frame, text="图片质量 (1-100):").pack(anchor=tk.W, pady=(10, 5))
        self.quality_var = tk.IntVar(value=self.quality)
        quality_scale = tk.Scale(settings_frame, from_=1, to=100, orient=tk.HORIZONTAL,
                                variable=self.quality_var, command=self.change_quality)
        quality_scale.pack(fill=tk.X, pady=(0, 10))
        
        # 底部按钮
        bottom_frame = tk.Frame(self.root)
        bottom_frame.pack(side=tk.BOTTOM, fill=tk.X, pady=10)
        
        hide_btn = tk.Button(bottom_frame, text="隐藏到托盘", command=self.hide_window, width=15)
        hide_btn.pack(side=tk.LEFT, padx=10)
        
        quit_btn = tk.Button(bottom_frame, text="退出程序", command=self.quit_app,
                            bg="red", fg="white", width=15)
        quit_btn.pack(side=tk.RIGHT, padx=10)
    
    def set_hotkey(self, hotkey_type):
        """设置快捷键"""
        setting_window = tk.Toplevel(self.root)
        setting_window.title("设置快捷键")
        setting_window.geometry("300x150")
        setting_window.transient(self.root)
        setting_window.grab_set()
        
        setting_window.update_idletasks()
        x = (setting_window.winfo_screenwidth() // 2) - (setting_window.winfo_width() // 2)
        y = (setting_window.winfo_screenheight() // 2) - (setting_window.winfo_height() // 2)
        setting_window.geometry(f"+{x}+{y}")
        
        label = tk.Label(setting_window, text="请按下组合键...", font=("Arial", 12))
        label.pack(pady=30)
        
        key_var = tk.StringVar()
        key_label = tk.Label(setting_window, textvariable=key_var, font=("Arial", 14, "bold"))
        key_label.pack(pady=10)
        
        def on_key(event):
            keys = []
            if event.state & 0x0004:
                keys.append("ctrl")
            if event.state & 0x0001:
                keys.append("shift")
            if event.state & 0x0002:
                keys.append("alt")
            
            key_name = event.keysym.lower()
            if key_name not in ["control", "shift", "alt", "ctrl"]:
                keys.append(key_name)
            
            hotkey = "+".join(keys)
            key_var.set(hotkey)
            
            def save():
                if hotkey_type == "fullscreen":
                    self.fullscreen_hotkey = hotkey
                    self.fullscreen_hotkey_var.set(hotkey)
                else:
                    self.area_hotkey = hotkey
                    self.area_hotkey_var.set(hotkey)
                
                keyboard.unhook_all()
                self.setup_hotkeys()
                setting_window.destroy()
                messagebox.showinfo("成功", f"快捷键已设置为: {hotkey}")
            
            setting_window.after(500, save)
        
        setting_window.bind("<Key>", on_key)
    
    def choose_save_path(self):
        """选择保存路径"""
        from tkinter import filedialog
        path = filedialog.askdirectory()
        if path:
            self.save_path = path
            self.save_path_var.set(path)
            if not os.path.exists(self.save_path):
                os.makedirs(self.save_path)
            self.save_config()
    
    def toggle_auto_save(self):
        self.auto_save = self.auto_save_var.get()
        self.save_config()
    
    def change_format(self, event=None):
        self.image_format = self.format_var.get()
        self.save_config()
    
    def change_quality(self, value):
        self.quality = self.quality_var.get()
        self.save_config()
    
    def fullscreen_screenshot(self):
        """全屏截图"""
        self.root.withdraw()
        time.sleep(0.2)
        screenshot = ImageGrab.grab()
        self.process_screenshot(screenshot)
    
    def area_screenshot(self):
        """区域截图"""
        self.root.withdraw()
        time.sleep(0.2)
        self.create_screenshot_window()
    
    def create_screenshot_window(self):
        """创建截图选择窗口"""
        self.cancel_flag = False
        self.screenshot_window = tk.Toplevel()
        self.screenshot_window.attributes('-fullscreen', True)
        self.screenshot_window.attributes('-alpha', 0.3)
        self.screenshot_window.attributes('-topmost', True)
        self.screenshot_window.configure(bg='black', cursor='cross')
        
        # 获取屏幕尺寸
        screen_width = self.screenshot_window.winfo_screenwidth()
        screen_height = self.screenshot_window.winfo_screenheight()
        
        # 创建画布
        self.canvas = tk.Canvas(self.screenshot_window, width=screen_width, 
                                height=screen_height, bg='black', highlightthickness=0)
        self.canvas.pack()
        
        # 绑定事件
        self.canvas.bind("<ButtonPress-1>", self.on_mouse_down)
        self.canvas.bind("<B1-Motion>", self.on_mouse_move)
        self.canvas.bind("<ButtonRelease-1>", self.on_mouse_up)
        
        # 绑定ESC - 直接绑定到窗口
        self.screenshot_window.bind("<Escape>", self.cancel_screenshot)
        
        # 显示提示
        self.show_info()
        
        # 确保窗口获得焦点
        self.screenshot_window.focus_force()
        
        # 显示ESC提示
        self.esc_label = tk.Label(self.screenshot_window, 
                                  text="✗ 按 ESC 键取消截图", 
                                  font=("Arial", 14, "bold"), 
                                  bg="black", 
                                  fg="red")
        self.esc_label.place(x=20, y=20)
    
    def show_info(self):
        """显示操作提示"""
        info_label = tk.Label(self.screenshot_window, 
                             text="拖动鼠标选择截图区域", 
                             font=("Arial", 14), 
                             bg="black", 
                             fg="white")
        info_label.pack(pady=20)
        self.screenshot_window.after(2000, info_label.destroy)
    
    def on_mouse_down(self, event):
        """鼠标按下"""
        self.start_x = event.x
        self.start_y = event.y
        self.drawing = True
        
        if self.rect_id:
            self.canvas.delete(self.rect_id)
    
    def on_mouse_move(self, event):
        """鼠标移动"""
        if self.drawing and self.start_x and self.start_y:
            if self.rect_id:
                self.canvas.delete(self.rect_id)
            self.rect_id = self.canvas.create_rectangle(
                self.start_x, self.start_y, event.x, event.y,
                outline='red', width=2, fill='blue', stipple='gray50'
            )
    
    def on_mouse_up(self, event):
        """鼠标释放"""
        if not self.drawing:
            return
        
        self.end_x = event.x
        self.end_y = event.y
        self.drawing = False
        
        # 计算截图区域
        x1 = min(self.start_x, self.end_x)
        y1 = min(self.start_y, self.end_y)
        x2 = max(self.start_x, self.end_x)
        y2 = max(self.start_y, self.end_y)
        
        # 关闭截图窗口
        if self.screenshot_window:
            self.screenshot_window.destroy()
            self.screenshot_window = None
        
        # 检查区域大小
        if (x2 - x1) < 5 or (y2 - y1) < 5:
            self.root.deiconify()
            messagebox.showinfo("提示", "选择的区域太小，已取消截图")
            return
        
        # 执行截图
        screenshot = ImageGrab.grab(bbox=(x1, y1, x2, y2))
        self.process_screenshot(screenshot)
    
    def cancel_screenshot(self, event=None):
        """取消截图 - ESC键处理"""
        print("ESC键按下，取消截图")  # 调试输出
        
        if self.screenshot_window:
            self.screenshot_window.destroy()
            self.screenshot_window = None
        
        self.root.deiconify()
        self.cancel_flag = True
    
    def process_screenshot(self, screenshot):
        """处理截图"""
        self.root.deiconify()
        
        if self.auto_save:
            self.save_screenshot(screenshot)
        else:
            self.show_save_dialog(screenshot)
    
    def save_screenshot(self, screenshot):
        """保存截图"""
        try:
            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S_%f")[:-3]
            filename = f"screenshot_{timestamp}.{self.image_format}"
            filepath = os.path.join(self.save_path, filename)
            
            if self.image_format == "jpg":
                screenshot.save(filepath, quality=self.quality)
            else:
                screenshot.save(filepath)
            
            result = messagebox.askyesno("成功", f"截图已保存至:\n{filepath}\n\n是否打开保存目录？")
            if result:
                os.startfile(self.save_path)
        except Exception as e:
            messagebox.showerror("错误", f"保存失败: {e}")
    
    def show_save_dialog(self, screenshot):
        """显示保存对话框"""
        from tkinter import filedialog
        
        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
        default_filename = f"screenshot_{timestamp}.{self.image_format}"
        
        filepath = filedialog.asksaveasfilename(
            defaultextension=f".{self.image_format}",
            filetypes=[("图片文件", f"*.{self.image_format}"), ("所有文件", "*.*")],
            initialfile=default_filename,
            initialdir=self.save_path
        )
        
        if filepath:
            try:
                if self.image_format == "jpg":
                    screenshot.save(filepath, quality=self.quality)
                else:
                    screenshot.save(filepath)
                messagebox.showinfo("成功", f"截图已保存至:\n{filepath}")
            except Exception as e:
                messagebox.showerror("错误", f"保存失败: {e}")
    
    def setup_tray(self):
        """设置系统托盘"""
        try:
            import pystray
            from PIL import Image as PILImage
            
            icon_image = PILImage.new('RGB', (64, 64), color='blue')
            
            def on_quit(icon, item):
                icon.stop()
                self.quit_app()
            
            def on_show(icon, item):
                self.root.deiconify()
            
            def on_fullscreen(icon, item):
                self.fullscreen_screenshot()
            
            def on_area(icon, item):
                self.area_screenshot()
            
            menu = pystray.Menu(
                pystray.MenuItem("显示主窗口", on_show),
                pystray.MenuItem("全屏截图", on_fullscreen),
                pystray.MenuItem("区域截图", on_area),
                pystray.MenuItem("退出", on_quit)
            )
            
            self.tray_icon = pystray.Icon("screenshot_tool", icon_image, "截图工具", menu)
            threading.Thread(target=self.tray_icon.run, daemon=True).start()
        except ImportError:
            print("提示: 安装 pystray 可支持系统托盘功能 (pip install pystray)")
        except Exception as e:
            print(f"托盘图标加载失败: {e}")
    
    def hide_window(self):
        """隐藏窗口到托盘"""
        self.root.withdraw()
        if hasattr(self, 'tray_icon'):
            self.tray_icon.notify("程序已在后台运行", "截图工具")
    
    def quit_app(self):
        """退出程序"""
        if messagebox.askyesno("确认", "确定要退出程序吗？"):
            keyboard.unhook_all()
            if hasattr(self, 'tray_icon'):
                self.tray_icon.stop()
            self.root.quit()
            self.root.destroy()
            sys.exit(0)
    
    def run(self):
        """运行程序"""
        self.root.mainloop()


def main():
    try:
        app = ScreenshotTool()
        app.run()
    except Exception as e:
        print(f"程序启动失败: {e}")
        messagebox.showerror("错误", f"程序启动失败: {e}")


if __name__ == "__main__":
    main()