class SecureEncryptor:
    def __init__(self, password: str):
        self.password = password
        self.salt = None
        self.cipher = None
        self._initialize_encryption()

    def _initialize_encryption(self):
        kdf = PBKDF2HMAC(
            algorithm=hashes.SHA256(),
            length=32,
            salt=self.salt,
            iterations=480000,  # 遠超NIST建議的迭代次數(shù)
            backend=default_backend()
        )
        key = base64.urlsafe_b64encode(kdf.derive(self.password.encode()))
        self.cipher = Fernet(key)

PASSWORD_POLICY = PasswordPolicy.from_names(
    length=8,       # 最小長度
    uppercase=1,    # 至少1個大寫字母  
    numbers=1,      # 至少1個數(shù)字
    special=1,      # 至少1個特殊字符
    nonletters=1,   # 至少1個非字母字符
)

def _generate_autofill_page(self, entry):
    escaped_password = html.escape(entry['密碼'])
    return f"""
    <script>
    function autoFill() {{
        const userKeywords = ['user', 'login', 'account'];
        const passKeywords = ['pass', 'password', 'pwd'];
        // 智能識別表單元素...
    }}
    </script>
    """

def generate_strong_password(length=16):
    while True:
        # 強制包含四類字符
        uppercase = secrets.choice(string.ascii_uppercase)
        # ...其他字符生成邏輯...
        
        # 相鄰字符不重復(fù)檢查
        if not any(password[i] == password[i+1] for i in range(len(password)-1)):
            return password

def export_backup(self):
    # 要求單獨設(shè)置備份密碼
    backup_password = simpledialog.askstring("備份密碼", 
        "請輸入與主密碼不同的備份密碼：", show="*")

# 偽代碼示例
def enable_2fa():
    import pyotp
    totp = pyotp.TOTP(base32_secret)
    qrcode = totp.provisioning_uri(accountname)

# 使用安全字符串類型
from securestring import SecureString
password = SecureString()

import tkinter as tk
from tkinter import ttk, messagebox, filedialog, simpledialog
import json
import webbrowser
import os
import base64
import secrets
import string
import uuid
import shutil
import html
import bcrypt
from cryptography.fernet import Fernet
from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC
from cryptography.hazmat.backends import default_backend
from password_strength import PasswordPolicy

# 全局配置
CUSTOM_FONT = ("楷體", 10)
DEFAULT_DATA_DIR = os.path.join(os.path.expanduser("~"), "PasswordManager")
DATA_DIR = os.getenv("PASSWORD_MANAGER_DATA_DIR", DEFAULT_DATA_DIR)
ADMIN_FILE = os.path.join(DATA_DIR, "admin_password.enc")
DATA_FILE = os.path.join(DATA_DIR, "passwords.enc")
KEY_FILE = os.path.join(DATA_DIR, "secret.key")
COLORS = {
    "bg": "#F0F0F0",
    "button_bg": "#ADD8E6",
    "accent": "#4B8BBE",
    "text": "#333333"
}

# 確保數(shù)據(jù)目錄存在
os.makedirs(DATA_DIR, exist_ok=True)

# 密碼強度策略
PASSWORD_POLICY = PasswordPolicy.from_names(
    length=8,  # 最小長度
    uppercase=1,  # 至少一個大寫字母
    numbers=1,  # 至少一個數(shù)字
    special=1,  # 至少一個特殊字符
)

def center_window(window):
    """窗口居中顯示"""
    window.update_idletasks()
    width = window.winfo_width()
    height = window.winfo_height()
    x = (window.winfo_screenwidth() // 2) - (width // 2)
    y = (window.winfo_screenheight() // 2) - (height // 2)
    window.geometry(f'+{x}+{y}')

def hash_password(password):
    """使用 bcrypt 哈希密碼"""
    salt = bcrypt.gensalt()
    return bcrypt.hashpw(password.encode(), salt)

def verify_password(password, hashed_password):
    """驗證密碼"""
    return bcrypt.checkpw(password.encode(), hashed_password)

def is_password_strong(password):
    """檢查密碼強度"""
    return not bool(PASSWORD_POLICY.test(password))

class SecureEncryptor:
    def __init__(self, password: str):
        self.password = password
        self.salt = None
        self.cipher = None
        self._initialize_encryption()

    def _initialize_encryption(self):
        if not os.path.exists(KEY_FILE):
            self._generate_new_key()

        with open(KEY_FILE, "rb") as f:
            self.salt = f.read(16)

        kdf = PBKDF2HMAC(
            algorithm=hashes.SHA256(),
            length=32,
            salt=self.salt,
            iterations=480000,
            backend=default_backend()
        )
        key = base64.urlsafe_b64encode(kdf.derive(self.password.encode()))
        self.cipher = Fernet(key)

    def _generate_new_key(self):
        self.salt = os.urandom(16)
        with open(KEY_FILE, "wb") as f:
            f.write(self.salt)

    def encrypt_data(self, data):
        return self.cipher.encrypt(json.dumps(data).encode())

    def decrypt_data(self, encrypted_data):
        try:
            decrypted = self.cipher.decrypt(encrypted_data)
            return json.loads(decrypted.decode())
        except Exception as e:
            messagebox.showerror("解密錯誤", f"數(shù)據(jù)解密失敗: {str(e)}")
            return None

class LoginSystem:
    def __init__(self):
        self.login_window = tk.Tk()
        self.login_window.title("管理員登錄")
        self.login_window.geometry("380x220")
        self.login_window.configure(bg=COLORS["bg"])
        center_window(self.login_window)  # 調(diào)用此函數(shù)將登錄窗口居中
        self._init_styles()
        self.first_time_setup()
        self.create_login_ui()
        self.login_window.mainloop()

    def _init_styles(self):
        style = ttk.Style()
        style.theme_use("clam")
        style.configure("TButton",
                        background=COLORS["button_bg"],
                        foreground=COLORS["text"],
                        font=CUSTOM_FONT,
                        padding=8)
        style.map("TButton", background=[("active", COLORS["accent"])])
        style.configure("TLabel",
                        background=COLORS["bg"],
                        foreground=COLORS["text"])
        style.configure("TEntry",
                        fieldbackground="white",
                        foreground=COLORS["text"])

    def first_time_setup(self):
        """首次啟動時設(shè)置管理員密碼"""
        if not os.path.exists(ADMIN_FILE):
            self.show_set_password_dialog("首次啟動，請設(shè)置管理員密碼")

    def show_set_password_dialog(self, message):
        """顯示設(shè)置密碼對話框"""
        set_pass_win = tk.Toplevel(self.login_window)
        set_pass_win.title("設(shè)置管理員密碼")
        set_pass_win.configure(bg=COLORS["bg"])
        center_window(set_pass_win)

        ttk.Label(set_pass_win, text=message).grid(row=0, column=0, columnspan=2, pady=5)
        ttk.Label(set_pass_win, text="新密碼：").grid(row=1, column=0, padx=5, pady=5)
        new_pass_entry = ttk.Entry(set_pass_win, show="*")
        new_pass_entry.grid(row=1, column=1, padx=5, pady=5)

        ttk.Label(set_pass_win, text="確認密碼：").grid(row=2, column=0, padx=5, pady=5)
        confirm_pass_entry = ttk.Entry(set_pass_win, show="*")
        confirm_pass_entry.grid(row=2, column=1, padx=5, pady=5)

        def save_password():
            new_pass = new_pass_entry.get()
            confirm_pass = confirm_pass_entry.get()
            if new_pass != confirm_pass:
                messagebox.showerror("錯誤", "兩次輸入的密碼不一致！")
                return
            if not is_password_strong(new_pass):
                messagebox.showerror("錯誤", "密碼強度不足！請確保密碼包含大小寫字母、數(shù)字和特殊字符。")
                return

            hashed_password = hash_password(new_pass)
            with open(ADMIN_FILE, "wb") as f:
                f.write(hashed_password)
            set_pass_win.destroy()
            messagebox.showinfo("成功", "管理員密碼設(shè)置成功！")

        ttk.Button(set_pass_win, text="保存", command=save_password).grid(row=3, column=0, columnspan=2, pady=10)

    def create_login_ui(self):
        main_frame = ttk.Frame(self.login_window)
        main_frame.pack(padx=20, pady=20, fill=tk.BOTH, expand=True)

        # 鎖圖標(biāo)
        lock_icon = ttk.Label(main_frame,
                              text="??",
                              font=("Arial", 32),
                              anchor="center")
        lock_icon.grid(row=0, column=2, columnspan=2, pady=10)

        # 輸入?yún)^(qū)域
        input_frame = ttk.Frame(main_frame)
        input_frame.grid(row=1, column=2, columnspan=2, sticky="ew")

        ttk.Label(input_frame, text="管理員密碼：").grid(row=0, column=2, pady=10, sticky="w")
        self.password_entry = ttk.Entry(input_frame, show="*")
        self.password_entry.grid(row=0, column=7, pady=10, sticky="ew")

        # 登錄按鈕
        btn_frame = ttk.Frame(main_frame)
        btn_frame.grid(row=2, column=2, columnspan=2, pady=15)
        ttk.Button(btn_frame,
                   text="?? 登錄",
                   command=self.verify_password).pack(ipadx=20)

        self.password_entry.bind("<Return>", lambda e: self.verify_password())

    def verify_password(self):
        input_password = self.password_entry.get().strip()

        if not input_password:
            messagebox.showwarning("錯誤", "請輸入密碼！")
            return

        try:
            with open(ADMIN_FILE, "rb") as f:
                hashed_password = f.read()

            if verify_password(input_password, hashed_password):
                self.login_window.destroy()
                encryptor = SecureEncryptor(input_password)
                PasswordManagerGUI(encryptor)
            else:
                messagebox.showerror("錯誤", "密碼錯誤！")
        except Exception as e:
            messagebox.showerror("錯誤", f"登錄失敗: {str(e)}")

class PasswordManagerGUI:
    def __init__(self, encryptor):
        self.root = tk.Tk()
        self.root.title("密碼管理系統(tǒng)")
        self.root.configure(bg=COLORS["bg"])
        center_window(self.root)
        self._init_styles()
        self.encryptor = encryptor
        self.passwords = self.load_data()
        self.clipboard_timeout = 15  # 默認剪貼板清除時間
        self.settings_window = None  # 新增屬性，用于記錄系統(tǒng)設(shè)置子窗口
        self._setup_ui()
        self.root.mainloop()

    def _init_styles(self):
        style = ttk.Style()
        style.theme_use("clam")
        style.configure(".",
                        background=COLORS["bg"],
                        foreground=COLORS["text"],
                        font=CUSTOM_FONT)
        style.configure("TButton",
                        background=COLORS["button_bg"],
                        foreground=COLORS["text"],
                        padding=8,
                        borderwidth=0)
        style.map("TButton",
                  background=[("active", COLORS["accent"])])
        style.configure("Treeview",
                        rowheight=25,
                        fieldbackground="white",
                        foreground=COLORS["text"])
        style.configure("Treeview.Heading",
                        background=COLORS["accent"],
                        foreground="white",
                        font=("楷體", 10, "bold"))
        style.configure("TLabelframe",
                        background=COLORS["bg"],
                        foreground=COLORS["text"])
        style.configure("TLabelframe.Label",
                        background=COLORS["bg"],
                        foreground=COLORS["accent"])

    def _setup_ui(self):
        self._create_toolbar()
        self._create_input_area()
        self._create_buttons()
        self._create_treeview()
        self._create_context_menu()
        self.update_tree()

    def _create_toolbar(self):
        toolbar = ttk.Frame(self.root)
        toolbar.pack(side=tk.TOP, fill=tk.X, padx=5, pady=2)
        ttk.Button(toolbar,
                   text="?? 系統(tǒng)設(shè)置",
                   command=self.show_settings).pack(side=tk.RIGHT, padx=5)

    def _create_input_area(self):
        input_frame = ttk.LabelFrame(self.root, text="??; 密碼信息（*為必填項）")
        input_frame.pack(padx=10, pady=5, fill=tk.BOTH, expand=True)

        fields = [
            ("*名稱", True), ("*網(wǎng)址", True),
            ("*用戶名", True), ("*密碼", True),
            ("綁定手機號", False), ("綁定郵箱", False)
        ]

        self.entries = {}
        for row, (field, required) in enumerate(fields):
            lbl_text = field.replace("*", "")
            ttk.Label(input_frame, text=lbl_text).grid(row=row, column=0, padx=5, pady=2, sticky="e")

            if required:
                ttk.Label(input_frame, text="*", foreground="red").grid(row=row, column=1, sticky="w")

            entry = ttk.Entry(input_frame)
            entry.grid(row=row, column=2, padx=5, pady=2, sticky="ew")
            self.entries[lbl_text] = entry

            if not required:
                ttk.Label(input_frame, text="（選填）", foreground="gray").grid(row=row, column=3, padx=5)

        # 密碼生成器
        gen_frame = ttk.Frame(input_frame)
        gen_frame.grid(row=3, column=4, rowspan=2, padx=10)
        ttk.Button(gen_frame,
                   text="?? 生成密碼",
                   command=self.generate_password).pack(pady=2)
        self.generated_pw_entry = ttk.Entry(gen_frame, width=20)
        self.generated_pw_entry.pack(pady=2)
        ttk.Button(gen_frame,
                   text="?? 應(yīng)用密碼",
                   command=self.apply_generated_password).pack(pady=2)

    def _create_buttons(self):
        btn_frame = ttk.Frame(self.root)
        btn_frame.pack(pady=10, fill=tk.X, padx=10)

        buttons = [
            ("? 新增記錄", self.add_password),
            ("??? 刪除記錄", self.delete_password),
            ("?? 修改記錄", self.update_password),
            ("?? 搜索記錄", self.search_password),
            ("?? 打開網(wǎng)站", self.open_url)
        ]

        for text, cmd in buttons:
            ttk.Button(btn_frame,
                       text=text,
                       command=cmd).pack(side=tk.LEFT, padx=3, ipadx=5)

    def _create_treeview(self):
        tree_frame = ttk.Frame(self.root)
        tree_frame.pack(padx=10, pady=5, fill=tk.BOTH, expand=True)

        # 水平滾動條
        tree_scroll_x = ttk.Scrollbar(tree_frame, orient="horizontal")
        self.tree = ttk.Treeview(
            tree_frame,
            columns=("name", "username", "url"),
            show="headings",
            selectmode="browse",
            xscrollcommand=tree_scroll_x.set
        )
        tree_scroll_x.config(command=self.tree.xview)
        tree_scroll_x.pack(side=tk.BOTTOM, fill=tk.X)

        columns = [
            ("name", "名稱", 250),
            ("username", "用戶名", 180),
            ("url", "網(wǎng)址", 400)
        ]

        for col_id, text, width in columns:
            self.tree.heading(col_id, text=text, anchor="center")
            self.tree.column(col_id, width=width, anchor="w", stretch=True)

        self.tree.pack(fill=tk.BOTH, expand=True)
        self.tree.bind("<Double-1>", self.show_details)

    def _create_context_menu(self):
        self.context_menu = tk.Menu(self.root, tearoff=0)
        self.context_menu.add_command(
            label="?? 復(fù)制用戶名",
            command=lambda: self.copy_selected_field("用戶名"))
        self.context_menu.add_command(
            label="?? 復(fù)制密碼",
            command=lambda: self.copy_selected_field("密碼"))
        self.tree.bind("<Button-3>", self.show_context_menu)

    def show_context_menu(self, event):
        item = self.tree.identify_row(event.y)
        if item:
            self.tree.selection_set(item)
            self.context_menu.tk_popup(event.x_root, event.y_root)

    def copy_selected_field(self, field_name):
        selected = self.tree.selection()
        if not selected:
            return

        index = self.tree.index(selected[0])
        value = self.passwords[index].get(field_name, "")
        if value:
            self.copy_to_clipboard(value)

    def load_data(self):
        try:
            if not os.path.exists(DATA_FILE):
                return []

            with open(DATA_FILE, "rb") as f:
                encrypted_data = f.read()
                data = self.encryptor.decrypt_data(encrypted_data)
                if data is None:
                    messagebox.showerror("錯誤", "數(shù)據(jù)解密失敗，請檢查密碼是否正確")
                    return []
                return data if isinstance(data, list) else []
        except Exception as e:
            messagebox.showerror("錯誤", f"數(shù)據(jù)加載失敗: {str(e)}")
            return []

    def save_data(self):
        try:
            with open(DATA_FILE, "wb") as f:
                encrypted_data = self.encryptor.encrypt_data(self.passwords)
                f.write(encrypted_data)
        except Exception as e:
            messagebox.showerror("錯誤", f"數(shù)據(jù)保存失敗: {str(e)}")
            raise

    def generate_password(self):
        password = generate_strong_password()
        self.generated_pw_entry.delete(0, tk.END)
        self.generated_pw_entry.insert(0, password)

    def apply_generated_password(self):
        password = self.generated_pw_entry.get()
        if password:
            self.entries["密碼"].delete(0, tk.END)
            self.entries["密碼"].insert(0, password)

    def get_input_data(self):
        return {key: entry.get() for key, entry in self.entries.items()}

    def clear_inputs(self):
        for entry in self.entries.values():
            entry.delete(0, tk.END)
        self.generated_pw_entry.delete(0, tk.END)

    def add_password(self):
        data = self.get_input_data()
        required_fields = ["名稱", "網(wǎng)址", "用戶名", "密碼"]

        for field in required_fields:
            if not data[field].strip():
                messagebox.showwarning("錯誤", f"{field}不能為空！")
                return

        self.passwords.append(data)
        try:
            self.save_data()
        except:
            self.passwords.pop()
            return
        self.update_tree()
        self.clear_inputs()
        messagebox.showinfo("成功", "? 數(shù)據(jù)添加成功！")

    def delete_password(self):
        selected = self.tree.selection()
        if not selected:
            messagebox.showwarning("錯誤", "請先選擇要刪除的數(shù)據(jù)！")
            return

        index = self.tree.index(selected[0])
        del self.passwords[index]
        self.save_data()
        self.update_tree()

    def update_password(self):
        selected = self.tree.selection()
        if not selected:
            messagebox.showwarning("錯誤", "請先選擇要修改的數(shù)據(jù)！")
            return

        index = self.tree.index(selected[0])
        original_data = self.passwords[index]

        edit_win = tk.Toplevel(self.root)
        edit_win.title("?? 修改數(shù)據(jù)")
        edit_win.configure(bg=COLORS["bg"])
        center_window(edit_win)
        edit_win.grab_set()  # 獲取焦點，使主窗口不可用

        entries = {}
        for row, (key, value) in enumerate(original_data.items()):
            ttk.Label(edit_win, text=key).grid(row=row, column=0, padx=5, pady=2)
            entry = ttk.Entry(edit_win)
            entry.insert(0, value)
            entry.grid(row=row, column=1, padx=5, pady=2)
            entries[key] = entry

        def save_changes():
            new_data = {key: entry.get() for key, entry in entries.items()}
            required_fields = ["名稱", "網(wǎng)址", "用戶名", "密碼"]
            for field in required_fields:
                if not new_data[field].strip():
                    messagebox.showwarning("錯誤", f"{field}不能為空！")
                    return
            self.passwords[index] = new_data
            self.save_data()
            self.update_tree()
            edit_win.destroy()
            edit_win.grab_release()  # 釋放焦點，使主窗口可用
            messagebox.showinfo("成功", "? 修改已保存！")

        ttk.Button(edit_win,
                   text="?? 保存修改",
                   command=save_changes).grid(
            row=len(original_data),
            column=0,
            columnspan=2,
            pady=10)

    def show_settings(self):
        if self.settings_window and self.settings_window.winfo_exists():
            self.settings_window.lift()  # 如果子窗口已存在，將其提升到最前
            return

        self.settings_window = tk.Toplevel(self.root)
        self.settings_window.title("?? 系統(tǒng)設(shè)置")
        self.settings_window.geometry("300x220")
        self.settings_window.configure(bg=COLORS["bg"])
        center_window(self.settings_window)
        self.settings_window.grab_set()  # 獲取焦點，使主窗口不可用

        buttons = [
            ("?? 修改密碼", self.change_password),
            ("?? 數(shù)據(jù)備份", self.export_backup),
            ("?? 數(shù)據(jù)恢復(fù)", self.import_backup),
            ("?? 關(guān)于程序", self.show_about)
        ]

        def close_settings():
            self.settings_window.destroy()
            self.settings_window = None  # 子窗口關(guān)閉后，將記錄設(shè)為 None

        for text, cmd in buttons:
            ttk.Button(self.settings_window,
                       text=text,
                       command=cmd).pack(pady=5, fill=tk.X, padx=20)

        self.settings_window.protocol("WM_DELETE_WINDOW", close_settings)

    def export_backup(self):
        backup_file = filedialog.asksaveasfilename(
            defaultextension=".bak",
            filetypes=[("備份文件", "*.bak")],
            initialdir=DATA_DIR
        )
        if backup_file:
            backup_password = simpledialog.askstring("備份密碼", "請輸入備份密碼：", show="*")
            if not backup_password:
                return

            try:
                encryptor = SecureEncryptor(backup_password)
                with open(DATA_FILE, "rb") as f:
                    data = f.read()
                encrypted_data = encryptor.encrypt_data(data)
                with open(backup_file, "wb") as f:
                    f.write(encrypted_data)
                messagebox.showinfo("成功", f"?? 備份已保存到：{backup_file}")
            except Exception as e:
                messagebox.showerror("錯誤", f"備份失敗: {str(e)}")

    def import_backup(self):
        backup_file = filedialog.askopenfilename(
            filetypes=[("備份文件", "*.bak")],
            initialdir=DATA_DIR
        )
        if backup_file:
            backup_password = simpledialog.askstring("備份密碼", "請輸入備份密碼：", show="*")
            if not backup_password:
                return

            try:
                encryptor = SecureEncryptor(backup_password)
                with open(backup_file, "rb") as f:
                    encrypted_data = f.read()
                decrypted_data = encryptor.decrypt_data(encrypted_data)
                if decrypted_data is None:
                    messagebox.showerror("錯誤", "備份文件解密失?。?)
                    return

                with open(DATA_FILE, "wb") as f:
                    f.write(self.encryptor.encrypt_data(decrypted_data))
                self.passwords = self.load_data()
                self.update_tree()
                messagebox.showinfo("成功", "?? 數(shù)據(jù)恢復(fù)完成！")
            except Exception as e:
                messagebox.showerror("錯誤", f"恢復(fù)失敗: {str(e)}")

    def show_about(self):
        about_info = """?? 密碼管理系統(tǒng) v1.0

功能特性：
- AES-256 加密存儲
- PBKDF2 密鑰派生
- 智能表單自動填充
- 剪貼板自動清除
- 數(shù)據(jù)備份與恢復(fù)

安全提示：
請定期修改管理員密碼"""
        messagebox.showinfo("關(guān)于程序", about_info)

    def change_password(self):
        pass_win = tk.Toplevel(self.root)
        pass_win.title("?? 修改密碼")
        pass_win.configure(bg=COLORS["bg"])
        center_window(pass_win)

        ttk.Label(pass_win, text="當(dāng)前密碼：").grid(row=0, column=0, padx=5, pady=5)
        current_pass = ttk.Entry(pass_win, show="*")
        current_pass.grid(row=0, column=1, padx=5, pady=5)

        ttk.Label(pass_win, text="新密碼：").grid(row=1, column=0, padx=5, pady=5)
        new_pass = ttk.Entry(pass_win, show="*")
        new_pass.grid(row=1, column=1, padx=5, pady=5)

        ttk.Label(pass_win, text="確認密碼：").grid(row=2, column=0, padx=5, pady=5)
        confirm_pass = ttk.Entry(pass_win, show="*")
        confirm_pass.grid(row=2, column=1, padx=5, pady=5)

        def save_new_password():
            current = current_pass.get()
            new = new_pass.get()
            confirm = confirm_pass.get()

            if new != confirm:
                messagebox.showerror("錯誤", "??; 兩次輸入的密碼不一致！")
                return

            if not is_password_strong(new):
                messagebox.showerror("錯誤", "??; 密碼強度不足！請確保密碼包含大小寫字母、數(shù)字和特殊字符。")
                return

            try:
                with open(ADMIN_FILE, "rb") as f:
                    hashed_password = f.read()

                if not verify_password(current, hashed_password):
                    messagebox.showerror("錯誤", "?? 當(dāng)前密碼驗證失??！")
                    return

                new_hashed_password = hash_password(new)
                with open(ADMIN_FILE, "wb") as f:
                    f.write(new_hashed_password)

                new_encryptor = SecureEncryptor(new)
                new_encrypted_data = new_encryptor.encrypt_data(self.passwords)
                with open(DATA_FILE, "wb") as f:
                    f.write(new_encrypted_data)

                messagebox.showinfo("成功", "? 密碼修改成功！")
                pass_win.destroy()
            except Exception as e:
                messagebox.showerror("錯誤", f"修改失敗: {str(e)}")

        ttk.Button(pass_win,
                   text="??; 保存新密碼",
                   command=save_new_password).grid(
            row=3,
            columnspan=2,
            pady=15)

    def search_password(self):
        search_win = tk.Toplevel(self.root)
        search_win.title("??  搜索記錄")
        search_win.configure(bg=COLORS["bg"])
        center_window(search_win)
        search_win.transient(self.root)
        search_win.grab_set()  # 獲取焦點，使主窗口不可用

        ttk.Label(search_win, text="搜索關(guān)鍵字：").grid(row=0, column=0, padx=5, pady=5)
        keyword_entry = ttk.Entry(search_win)
        keyword_entry.grid(row=0, column=1, padx=5, pady=5)

        ttk.Label(search_win, text="搜索字段：").grid(row=1, column=0, padx=5, pady=5)
        field_combobox = ttk.Combobox(
            search_win,
            values=["名稱", "網(wǎng)址", "用戶名", "密碼", "綁定手機號", "綁定郵箱"],
            state="readonly"
        )
        field_combobox.current(0)
        field_combobox.grid(row=1, column=1, padx=5, pady=5)

        def perform_search():
            keyword = keyword_entry.get().strip().lower()
            field = field_combobox.get()

            if not keyword:
                messagebox.showwarning("錯誤", " ?? 請輸入搜索關(guān)鍵字！")
                return

            filtered = []
            for item in self.passwords:
                value = str(item.get(field, "")).lower()
                if keyword in value:
                    filtered.append(item)

            # 在主窗口上層顯示結(jié)果
            result_win = tk.Toplevel(self.root)
            result_win.title("?? 搜索結(jié)果")
            result_win.configure(bg=COLORS["bg"])
            center_window(result_win)
            result_win.lift(self.root)  # 確保顯示在父窗口上層
            result_win.grab_set()  # 獲取焦點，使主窗口不可用

            # 創(chuàng)建結(jié)果表格
            tree_frame = ttk.Frame(result_win)
            tree_frame.pack(padx=10, pady=10, fill=tk.BOTH, expand=True)

            # 添加滾動條
            tree_scroll = ttk.Scrollbar(tree_frame)
            tree = ttk.Treeview(
                tree_frame,
                columns=("name", "username", "url"),
                show="headings",
                yscrollcommand=tree_scroll.set
            )
            tree_scroll.config(command=tree.yview)
            tree_scroll.pack(side=tk.RIGHT, fill=tk.Y)

            columns = [
                ("name", "名稱", 200),
                ("username", "用戶名", 150),
                ("url", "網(wǎng)址", 300)
            ]

            for col_id, text, width in columns:
                tree.heading(col_id, text=text)
                tree.column(col_id, width=width, anchor="w")

            if filtered:
                for item in filtered:
                    tree.insert("", "end", values=(
                        item["名稱"],
                        item["用戶名"],
                        item["網(wǎng)址"]
                    ))
                tree.bind("<Double-1>", lambda e: self.show_details(e, data=filtered))
            else:
                tree.insert("", "end", values=("未找到匹配記錄",))

            tree.pack(fill=tk.BOTH, expand=True)
            search_win.destroy()
            search_win.grab_release()  # 釋放焦點，使主窗口可用
            result_win.destroy()
            result_win.grab_release()  # 釋放焦點，使主窗口可用
            self.root.after(100, lambda: center_window(self.root))

        ttk.Button(search_win,
                   text="?? 開始搜索",
                   command=perform_search).grid(
            row=2,
            columnspan=2,
            pady=15)

    def open_url(self):
        selected = self.tree.selection()
        if not selected:
            return

        index = self.tree.index(selected[0])
        entry = self.passwords[index]
        url = entry.get("網(wǎng)址", "")

        if url:
            try:
                autofill_html = self._generate_autofill_page(entry)
                # 使用 uuid 生成唯一的文件名
                temp_file_name = f"temp_autofill_{uuid.uuid4()}.html"
                temp_file = os.path.join(DATA_DIR, temp_file_name)

                with open(temp_file, "w", encoding="utf-8") as f:
                    f.write(autofill_html)

                # 先打開目標(biāo)網(wǎng)址
                webbrowser.open(url)
                # 可以選擇保留臨時文件一段時間，用于自動填充
                self.root.after(5000, lambda: self._cleanup_temp_file(temp_file))
            except Exception as e:
                messagebox.showerror("錯誤", f"??; 自動填充失敗: {str(e)}")

    def _cleanup_temp_file(self, filename):
        try:
            if os.path.exists(filename):
                os.remove(filename)
        except Exception as e:
            print(f"清理臨時文件失敗: {str(e)}")

    def _generate_autofill_page(self, entry):
        escaped_password = html.escape(entry['密碼'])
        return f"""
        <!DOCTYPE html>
        <html>
        <head>
            <meta charset="UTF-8">
            <title>自動填充</title>
            <script>
                function autoFill() {{
                    try {{
                        const userKeywords = ['user', 'login', 'account', 'email', 'username', 'name'];
                        const passKeywords = ['pass', 'password', 'pwd', 'secret'];
                        let usernameFilled = false;
                        let passwordFilled = false;

                        document.querySelectorAll('input').forEach(input => {{
                            const lowerType = (input.type || '').toLowerCase();
                            const lowerName = (input.name || '').toLowerCase();
                            const lowerId = (input.id || '').toLowerCase();
                            const lowerPlaceholder = (input.placeholder || '').toLowerCase();

                            // 填充用戶名
                            if (!usernameFilled) {{
                                if (lowerType === 'text' || lowerType === 'email') {{
                                    if (userKeywords.some(kw => lowerName.includes(kw)) ||
                                        userKeywords.some(kw => lowerId.includes(kw)) ||
                                        lowerPlaceholder.includes('用戶名') ||
                                        lowerPlaceholder.includes('賬號')) {{
                                        input.value = '{entry['用戶名']}';
                                        usernameFilled = true;
                                    }}
                                }}
                            }}

                            // 填充密碼
                            if (!passwordFilled) {{
                                if (lowerType === 'password') {{
                                    if (passKeywords.some(kw => lowerName.includes(kw)) ||
                                        passKeywords.some(kw => lowerId.includes(kw)) ||
                                        lowerPlaceholder.includes('密碼')) {{
                                        input.value = '{escaped_password}';
                                        passwordFilled = true;
                                    }}
                                }}
                            }}
                        }});

                        // 自動提交表單
                        if (usernameFilled && passwordFilled) {{
                            document.querySelector('form')?.submit();
                        }}
                    }} catch (e) {{
                        console.error('自動填充錯誤:', e);
                    }}
                }}

                // 多種觸發(fā)方式
                if (document.readyState === 'complete') {{
                    autoFill();
                }} else {{
                    window.addEventListener('load', autoFill);
                    document.addEventListener('DOMContentLoaded', autoFill);
                }}
            </script>
        </head>
        <body>
            <noscript>
                <p>請啟用JavaScript以獲得自動填充功能</p>
                <a href="{entry['網(wǎng)址']}" rel="external nofollow"  rel="external nofollow" >手動訪問網(wǎng)站</a>
            </noscript>
            <p>如果頁面沒有自動跳轉(zhuǎn)，<a href="{entry['網(wǎng)址']}" rel="external nofollow"  rel="external nofollow" >請點擊這里</a></p>
        </body>
        </html>
        """

    def update_tree(self, data=None):
        self.tree.delete(*self.tree.get_children())
        data = data or self.passwords
        for item in data:
            self.tree.insert("", "end", values=(
                item["名稱"],
                item["用戶名"],
                item["網(wǎng)址"]
            ))

    def show_details(self, event, data=None):
        tree = event.widget
        selected = tree.selection()
        if not selected:
            return

        index = tree.index(selected[0])
        details = (data or self.passwords)[index]

        detail_win = tk.Toplevel(self.root)
        detail_win.title("?? 詳細信息")
        detail_win.configure(bg=COLORS["bg"])
        center_window(detail_win)

        for row, (key, value) in enumerate(details.items()):
            ttk.Label(detail_win, text=f"{key}：").grid(row=row, column=0, padx=5, pady=2, sticky="e")
            entry = ttk.Entry(detail_win, width=40)
            entry.insert(0, value)
            entry.config(state="readonly")
            entry.grid(row=row, column=1, padx=5, pady=2, sticky="w")
            ttk.Button(detail_win,
                      text="?? 復(fù)制",
                      command=lambda v=value, win=detail_win: self.copy_with_focus(v, win)
                      ).grid(row=row, column=2, padx=5)

    def copy_with_focus(self, text, parent_window):
        self.copy_to_clipboard(text)
        parent_window.lift()

    def copy_to_clipboard(self, text):
        self.root.clipboard_clear()
        self.root.clipboard_append(text)
        msg = messagebox.showinfo("復(fù)制成功", "?? 內(nèi)容已復(fù)制到剪貼板，15秒后自動清除")
        self.root.after(self.clipboard_timeout * 1000, self.clear_clipboard)

    def clear_clipboard(self):
        self.root.clipboard_clear()

def generate_strong_password(length=16):
    """生成符合NIST標(biāo)準(zhǔn)的強密碼"""
    if length < 12:
        length = 12

    while True:
        uppercase = secrets.choice(string.ascii_uppercase)
        lowercase = secrets.choice(string.ascii_lowercase)
        digit = secrets.choice(string.digits)
        special = secrets.choice("!@#$%^&*~-+_=")

        remaining = length - 4
        chars = string.ascii_letters + string.digits + "!@#$%^&*~-+_="
        others = [secrets.choice(chars) for _ in range(remaining)]

        password_chars = [uppercase, lowercase, digit, special] + others
        secrets.SystemRandom().shuffle(password_chars)
        password = ''.join(password_chars)

        # 驗證密碼強度
        if (any(c.islower() for c in password) and
            any(c.isupper() for c in password) and
            any(c.isdigit() for c in password) and
            sum(c in "!@#$%^&*~-+_=" for c in password) >= 2 and
            not any(password[i] == password[i+1] for i in range(len(password)-1))):
            return password

if __name__ == "__main__":
    LoginSystem()