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,  # 遠(yuǎn)超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,       # 最小長(zhǎng)度
    uppercase=1,    # 至少1個(gè)大寫字母  
    numbers=1,      # 至少1個(gè)數(shù)字
    special=1,      # 至少1個(gè)特殊字符
    nonletters=1,   # 至少1個(gè)非字母字符
)

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'];
        // 智能識(shí)別表單元素...
    }}
    </script>
    """

def generate_strong_password(length=16):
    while True:
        # 強(qiáng)制包含四類字符
        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):
    # 要求單獨(dú)設(shè)置備份密碼
    backup_password = simpledialog.askstring("備份密碼", 
        "請(qǐng)輸入與主密碼不同的備份密碼：", 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)

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

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):
    """驗(yàn)證密碼"""
    return bcrypt.checkpw(password.encode(), hashed_password)

def is_password_strong(password):
    """檢查密碼強(qiáng)度"""
    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("解密錯(cuò)誤", 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):
        """首次啟動(dòng)時(shí)設(shè)置管理員密碼"""
        if not os.path.exists(ADMIN_FILE):
            self.show_set_password_dialog("首次啟動(dòng)，請(qǐng)?jiān)O(shè)置管理員密碼")

    def show_set_password_dialog(self, message):
        """顯示設(shè)置密碼對(duì)話框"""
        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="確認(rèn)密碼：").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("錯(cuò)誤", "兩次輸入的密碼不一致！")
                return
            if not is_password_strong(new_pass):
                messagebox.showerror("錯(cuò)誤", "密碼強(qiáng)度不足！請(qǐng)確保密碼包含大小寫字母、數(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("錯(cuò)誤", "請(qǐng)輸入密碼！")
            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("錯(cuò)誤", "密碼錯(cuò)誤！")
        except Exception as e:
            messagebox.showerror("錯(cuò)誤", 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  # 默認(rèn)剪貼板清除時(shí)間
        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="??; 密碼信息（*為必填項(xiàng)）")
        input_frame.pack(padx=10, pady=5, fill=tk.BOTH, expand=True)

        fields = [
            ("*名稱", True), ("*網(wǎng)址", True),
            ("*用戶名", True), ("*密碼", True),
            ("綁定手機(jī)號(hào)", 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)

        # 水平滾動(dòng)條
        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("錯(cuò)誤", "數(shù)據(jù)解密失敗，請(qǐng)檢查密碼是否正確")
                    return []
                return data if isinstance(data, list) else []
        except Exception as e:
            messagebox.showerror("錯(cuò)誤", 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("錯(cuò)誤", 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("錯(cuò)誤", 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("錯(cuò)誤", "請(qǐng)先選擇要?jiǎng)h除的數(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("錯(cuò)誤", "請(qǐng)先選擇要修改的數(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()  # 獲取焦點(diǎn)，使主窗口不可用

        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("錯(cuò)誤", f"{field}不能為空！")
                    return
            self.passwords[index] = new_data
            self.save_data()
            self.update_tree()
            edit_win.destroy()
            edit_win.grab_release()  # 釋放焦點(diǎn)，使主窗口可用
            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()  # 獲取焦點(diǎn)，使主窗口不可用

        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("備份密碼", "請(qǐng)輸入備份密碼：", 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("錯(cuò)誤", f"備份失敗: {str(e)}")

    def import_backup(self):
        backup_file = filedialog.askopenfilename(
            filetypes=[("備份文件", "*.bak")],
            initialdir=DATA_DIR
        )
        if backup_file:
            backup_password = simpledialog.askstring("備份密碼", "請(qǐng)輸入備份密碼：", 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("錯(cuò)誤", "備份文件解密失??！")
                    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("錯(cuò)誤", f"恢復(fù)失敗: {str(e)}")

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

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

安全提示：
請(qǐng)定期修改管理員密碼"""
        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="確認(rèn)密碼：").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("錯(cuò)誤", "??; 兩次輸入的密碼不一致！")
                return

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

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

                if not verify_password(current, hashed_password):
                    messagebox.showerror("錯(cuò)誤", "?? 當(dāng)前密碼驗(yàn)證失敗！")
                    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("錯(cuò)誤", 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()  # 獲取焦點(diǎn)，使主窗口不可用

        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)址", "用戶名", "密碼", "綁定手機(jī)號(hào)", "綁定郵箱"],
            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("錯(cuò)誤", " ?? 請(qǐng)輸入搜索關(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()  # 獲取焦點(diǎn)，使主窗口不可用

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

            # 添加滾動(dòng)條
            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()  # 釋放焦點(diǎn)，使主窗口可用
            result_win.destroy()
            result_win.grab_release()  # 釋放焦點(diǎn)，使主窗口可用
            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)
                # 可以選擇保留臨時(shí)文件一段時(shí)間，用于自動(dòng)填充
                self.root.after(5000, lambda: self._cleanup_temp_file(temp_file))
            except Exception as e:
                messagebox.showerror("錯(cuò)誤", f"??; 自動(dòng)填充失敗: {str(e)}")

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

    def _generate_autofill_page(self, entry):
        escaped_password = html.escape(entry['密碼'])
        return f"""
        <!DOCTYPE html>
        <html>
        <head>
            <meta charset="UTF-8">
            <title>自動(dòng)填充</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('賬號(hào)')) {{
                                        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;
                                    }}
                                }}
                            }}
                        }});

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

                // 多種觸發(fā)方式
                if (document.readyState === 'complete') {{
                    autoFill();
                }} else {{
                    window.addEventListener('load', autoFill);
                    document.addEventListener('DOMContentLoaded', autoFill);
                }}
            </script>
        </head>
        <body>
            <noscript>
                <p>請(qǐng)啟用JavaScript以獲得自動(dòng)填充功能</p>
                <a href="{entry['網(wǎng)址']}" rel="external nofollow"  rel="external nofollow" >手動(dòng)訪問網(wǎng)站</a>
            </noscript>
            <p>如果頁面沒有自動(dòng)跳轉(zhuǎn)，<a href="{entry['網(wǎng)址']}" rel="external nofollow"  rel="external nofollow" >請(qǐng)點(diǎn)擊這里</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("?? 詳細(xì)信息")
        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秒后自動(dòng)清除")
        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)的強(qiáng)密碼"""
    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)

        # 驗(yàn)證密碼強(qiáng)度
        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()