def scan_network(self):
    # 使用并發(fā)Ping掃描（支持Windows/Linux雙平臺(tái)）
    with concurrent.futures.ThreadPoolExecutor() as executor:
        futures = {executor.submit(self.ping_host, ip): ip for ip in all_hosts}
        # ...結(jié)果實(shí)時(shí)更新UI...

def _send_file(self, ip, file_path, password):
    # 斷點(diǎn)續(xù)傳實(shí)現(xiàn)邏輯
    offset = struct.unpack("!Q", offset_data)[0]
    with open(file_path, 'rb') as f:
        f.seek(offset)  # 定位到斷點(diǎn)位置

# 安裝依賴(lài)庫(kù)
pip install -r requirements.txt
# 所需庫(kù)：
# PyQt5==5.15.7
# psutil==5.8.0

if __name__ == "__main__":
    app = QApplication(sys.argv)
    window = FileSharingApp()
    window.show()
    sys.exit(app.exec_())

def ping_host(self, ip):
    # 跨平臺(tái)ping命令適配
    param = '-n' if platform.system() == 'Windows' else '-c'
    command = ['ping', param, '1', '-w', '1000', ip]
    
    # 使用subprocess避免阻塞主線(xiàn)程
    output = subprocess.run(command, capture_output=True, text=True)
    
    # 解析延遲（Windows/Linux不同輸出格式）
    if 'TTL=' in output.stdout:  # Windows
        latency = int(output.stdout.split('time=')[1].split('ms')[0])

# 接收方處理邏輯
if os.path.exists(temp_path):
    received = os.path.getsize(temp_path)  # 獲取已接收字節(jié)數(shù)
    client_socket.sendall(struct.pack("!Q", received))  # 告知發(fā)送方偏移量

# 發(fā)送方定位文件指針
f.seek(offset)  # 跳轉(zhuǎn)到斷點(diǎn)位置

import sys
import os
import socket
import threading
import time
import hashlib
import pickle
import struct
import json
import platform
import subprocess
import concurrent.futures
import psutil
from datetime import datetime
from PyQt5.QtWidgets import (QApplication, QMainWindow, QWidget, QVBoxLayout, QHBoxLayout, 
                            QSplitter, QTreeWidget, QTreeWidgetItem, QLabel, QLineEdit, 
                            QPushButton, QTextEdit, QFileDialog, QMessageBox, QInputDialog, 
                            QSpinBox, QProgressBar, QTabWidget, QStatusBar, QFrame, 
                            QHeaderView)
from PyQt5.QtCore import Qt, QTimer, QSize
from PyQt5.QtGui import QFont, QIcon

class FileSharingApp(QMainWindow):
    def __init__(self):
        super().__init__()
        self.setWindowTitle("?? 局域網(wǎng)文件共享工具")
        self.setGeometry(100, 100, 1200, 800)
        
        # 初始化變量
        self.password = "123456"
        self.hosts = {}
        self.connections = {}
        self.server_running = False
        self.discovery_running = False
        self.file_transfers = {}
        self.retry_attempts = 3
        self.retry_delay = 2
        self.max_threads = 4
        
        # 創(chuàng)建UI
        self.init_ui()
        
        # 確保接收目錄存在
        os.makedirs("received_files", exist_ok=True)
        
        # 加載配置
        self.load_config()
        
        # 啟動(dòng)服務(wù)
        self.start_server()
        self.start_discovery()
        
        # 設(shè)置定時(shí)器
        self.setup_timers()

    def init_ui(self):
        """初始化用戶(hù)界面"""
        main_widget = QWidget()
        main_layout = QVBoxLayout()
        main_widget.setLayout(main_layout)
        self.setCentralWidget(main_widget)
        
        # 主分割器
        main_splitter = QSplitter(Qt.Vertical)
        main_layout.addWidget(main_splitter)
        
        # 上部區(qū)域
        upper_splitter = QSplitter(Qt.Horizontal)
        main_splitter.addWidget(upper_splitter)
        
        # 左側(cè) - 網(wǎng)絡(luò)主機(jī)發(fā)現(xiàn)
        self.setup_host_discovery_ui(upper_splitter)
        
        # 右側(cè) - 已連接主機(jī)
        self.setup_connection_ui(upper_splitter)
        
        # 下部區(qū)域
        self.setup_transfer_log_ui(main_splitter)
        
        # 狀態(tài)欄
        self.setup_status_bar()
        
        # 設(shè)置初始大小
        main_splitter.setSizes([600, 200])
        upper_splitter.setSizes([400, 600])

    def setup_host_discovery_ui(self, parent):
        """設(shè)置網(wǎng)絡(luò)主機(jī)發(fā)現(xiàn)UI"""
        frame = QFrame()
        frame.setFrameShape(QFrame.StyledPanel)
        layout = QVBoxLayout()
        frame.setLayout(layout)
        
        label = QLabel("??? 網(wǎng)絡(luò)主機(jī)發(fā)現(xiàn)")
        label.setStyleSheet("font-size: 14px; font-weight: bold;")
        layout.addWidget(label)
        
        self.host_tree = QTreeWidget()
        self.host_tree.setHeaderLabels(["IP地址", "主機(jī)名稱(chēng)", "最后在線(xiàn)", "信號(hào)強(qiáng)度"])
        self.host_tree.setColumnCount(4)
        self.host_tree.header().setSectionResizeMode(QHeaderView.ResizeToContents)
        layout.addWidget(self.host_tree)
        
        # 主機(jī)操作按鈕
        btn_layout = QHBoxLayout()
        buttons = [
            ("?? 連接選中主機(jī)", self.connect_to_host),
            ("? 手動(dòng)連接主機(jī)", self.manual_connect),
            ("?? 重新掃描網(wǎng)絡(luò)", self.rescan_network),
            ("??? 清除列表", self.clear_host_list)
        ]
        
        for text, callback in buttons:
            btn = QPushButton(text)
            btn.clicked.connect(callback)
            btn_layout.addWidget(btn)
        
        layout.addLayout(btn_layout)
        parent.addWidget(frame)

    def setup_connection_ui(self, parent):
        """設(shè)置已連接主機(jī)UI"""
        frame = QFrame()
        frame.setFrameShape(QFrame.StyledPanel)
        layout = QVBoxLayout()
        frame.setLayout(layout)
        
        label = QLabel("?? 已連接主機(jī)")
        label.setStyleSheet("font-size: 14px; font-weight: bold;")
        layout.addWidget(label)
        
        self.conn_tree = QTreeWidget()
        self.conn_tree.setHeaderLabels(["IP地址", "主機(jī)名稱(chēng)", "狀態(tài)", "延遲"])
        self.conn_tree.setColumnCount(4)
        self.conn_tree.header().setSectionResizeMode(QHeaderView.ResizeToContents)
        layout.addWidget(self.conn_tree)
        
        # 文件傳輸部分
        self.setup_file_transfer_ui(layout)
        
        # 密碼設(shè)置部分
        self.setup_password_settings_ui(layout)
        
        parent.addWidget(frame)

    def setup_file_transfer_ui(self, parent_layout):
        """設(shè)置文件傳輸U(kuò)I"""
        frame = QFrame()
        layout = QVBoxLayout()
        frame.setLayout(layout)
        
        label = QLabel("?? 文件傳輸")
        label.setStyleSheet("font-size: 14px; font-weight: bold;")
        layout.addWidget(label)
        
        # 文件選擇
        file_layout = QHBoxLayout()
        file_layout.addWidget(QLabel("選擇文件:"))
        
        self.file_path = QLineEdit()
        file_layout.addWidget(self.file_path)
        
        self.browse_btn = QPushButton("?? 瀏覽...")
        self.browse_btn.clicked.connect(self.browse_file)
        file_layout.addWidget(self.browse_btn)
        layout.addLayout(file_layout)
        
        # 密碼和發(fā)送
        pass_layout = QHBoxLayout()
        pass_layout.addWidget(QLabel("密碼:"))
        
        self.file_password = QLineEdit()
        self.file_password.setEchoMode(QLineEdit.Password)
        self.file_password.setText(self.password)
        pass_layout.addWidget(self.file_password)
        
        self.send_btn = QPushButton("?? 發(fā)送文件")
        self.send_btn.clicked.connect(self.send_file)
        pass_layout.addWidget(self.send_btn)
        layout.addLayout(pass_layout)
        
        parent_layout.addWidget(frame)

    def setup_password_settings_ui(self, parent_layout):
        """設(shè)置密碼和配置UI"""
        frame = QFrame()
        layout = QVBoxLayout()
        frame.setLayout(layout)
        
        label = QLabel("?? 密碼與設(shè)置")
        label.setStyleSheet("font-size: 14px; font-weight: bold;")
        layout.addWidget(label)
        
        # 密碼更新
        pass_layout = QHBoxLayout()
        pass_layout.addWidget(QLabel("新密碼:"))
        
        self.new_password = QLineEdit()
        self.new_password.setEchoMode(QLineEdit.Password)
        pass_layout.addWidget(self.new_password)
        
        pass_layout.addWidget(QLabel("確認(rèn)密碼:"))
        
        self.confirm_password = QLineEdit()
        self.confirm_password.setEchoMode(QLineEdit.Password)
        pass_layout.addWidget(self.confirm_password)
        
        self.update_pass_btn = QPushButton("?? 更新密碼")
        self.update_pass_btn.clicked.connect(self.update_password)
        pass_layout.addWidget(self.update_pass_btn)
        layout.addLayout(pass_layout)
        
        # 其他設(shè)置
        settings_layout = QHBoxLayout()
        settings_layout.addWidget(QLabel("傳輸線(xiàn)程:"))
        
        self.thread_spin = QSpinBox()
        self.thread_spin.setRange(1, 16)
        self.thread_spin.setValue(self.max_threads)
        settings_layout.addWidget(self.thread_spin)
        
        settings_layout.addWidget(QLabel("重試次數(shù):"))
        
        self.retry_spin = QSpinBox()
        self.retry_spin.setRange(1, 10)
        self.retry_spin.setValue(self.retry_attempts)
        settings_layout.addWidget(self.retry_spin)
        
        self.save_settings_btn = QPushButton("?? 保存設(shè)置")
        self.save_settings_btn.clicked.connect(self.save_settings)
        settings_layout.addWidget(self.save_settings_btn)
        layout.addLayout(settings_layout)
        
        parent_layout.addWidget(frame)

    def setup_transfer_log_ui(self, parent):
        """設(shè)置傳輸狀態(tài)和日志UI"""
        tabs = QTabWidget()
        
        # 傳輸狀態(tài)標(biāo)簽頁(yè)
        transfer_tab = QWidget()
        transfer_layout = QVBoxLayout()
        transfer_tab.setLayout(transfer_layout)
        
        label = QLabel("?? 傳輸狀態(tài)")
        label.setStyleSheet("font-size: 14px; font-weight: bold;")
        transfer_layout.addWidget(label)
        
        self.transfer_tree = QTreeWidget()
        self.transfer_tree.setHeaderLabels(["ID", "文件名", "目標(biāo)IP", "進(jìn)度", "狀態(tài)", "速度"])
        self.transfer_tree.setColumnCount(6)
        self.transfer_tree.header().setSectionResizeMode(QHeaderView.ResizeToContents)
        transfer_layout.addWidget(self.transfer_tree)
        
        # 傳輸控制按鈕
        btn_layout = QHBoxLayout()
        buttons = [
            ("?? 暫停傳輸", self.pause_transfer),
            ("?? 繼續(xù)傳輸", self.resume_transfer),
            ("? 取消傳輸", self.cancel_transfer),
            ("?? 清除已完成", self.clear_completed)
        ]
        
        for text, callback in buttons:
            btn = QPushButton(text)
            btn.clicked.connect(callback)
            btn_layout.addWidget(btn)
        
        transfer_layout.addLayout(btn_layout)
        tabs.addTab(transfer_tab, "?? 傳輸狀態(tài)")
        
        # 日志標(biāo)簽頁(yè)
        log_tab = QWidget()
        log_layout = QVBoxLayout()
        log_tab.setLayout(log_layout)
        
        label = QLabel("?? 操作日志")
        label.setStyleSheet("font-size: 14px; font-weight: bold;")
        log_layout.addWidget(label)
        
        self.log_text = QTextEdit()
        self.log_text.setReadOnly(True)
        log_layout.addWidget(self.log_text)
        tabs.addTab(log_tab, "?? 操作日志")
        
        parent.addWidget(tabs)

    def setup_status_bar(self):
        """設(shè)置狀態(tài)欄"""
        status_bar = QStatusBar()
        self.setStatusBar(status_bar)
        
        self.status_label = QLabel()
        self.update_status_text()
        status_bar.addWidget(self.status_label, 1)
        
        # 網(wǎng)絡(luò)狀態(tài)指示器
        self.network_status = QLabel("?? 網(wǎng)絡(luò): 檢測(cè)中...")
        status_bar.addPermanentWidget(self.network_status)
        
        # 定時(shí)更新網(wǎng)絡(luò)狀態(tài)
        self.network_timer = QTimer(self)
        self.network_timer.timeout.connect(self.update_network_status)
        self.network_timer.start(5000)

    def setup_timers(self):
        """設(shè)置各種定時(shí)器"""
        # 清理舊主機(jī)定時(shí)器
        self.cleanup_timer = QTimer(self)
        self.cleanup_timer.timeout.connect(self.cleanup_old_hosts)
        self.cleanup_timer.start(10000)  # 每10秒清理一次
        
        # 更新傳輸狀態(tài)定時(shí)器
        self.status_timer = QTimer(self)
        self.status_timer.timeout.connect(self.update_transfer_status)
        self.status_timer.start(1000)  # 每秒更新一次
        
        # 更新連接狀態(tài)定時(shí)器
        self.connection_timer = QTimer(self)
        self.connection_timer.timeout.connect(self.update_connection_status)
        self.connection_timer.start(3000)  # 每3秒更新一次

    # 以下是網(wǎng)絡(luò)發(fā)現(xiàn)和掃描功能 --------------------------------------

    def get_local_network_info(self):
        """獲取本地網(wǎng)絡(luò)信息，包括IP和子網(wǎng)掩碼"""
        try:
            # 獲取所有網(wǎng)絡(luò)接口信息
            interfaces = psutil.net_if_addrs()
            for interface, addrs in interfaces.items():
                for addr in addrs:
                    if addr.family == socket.AF_INET and not addr.address.startswith('127.'):
                        # 獲取子網(wǎng)掩碼
                        netmask = addr.netmask
                        if netmask:
                            # 計(jì)算網(wǎng)絡(luò)地址
                            network = self.calculate_network(addr.address, netmask)
                            return network, netmask
            return None, None
        except Exception as e:
            self.log_message(f"?? 獲取網(wǎng)絡(luò)信息失敗: {str(e)}")
            return None, None

    def calculate_network(self, ip, netmask):
        """計(jì)算網(wǎng)絡(luò)地址"""
        ip_parts = list(map(int, ip.split('.')))
        mask_parts = list(map(int, netmask.split('.')))
        network_parts = [ip_parts[i] & mask_parts[i] for i in range(4)]
        return '.'.join(map(str, network_parts))

    def get_all_hosts_in_network(self, network, netmask):
        """獲取網(wǎng)絡(luò)中的所有可能主機(jī)IP"""
        network_parts = list(map(int, network.split('.')))
        mask_parts = list(map(int, netmask.split('.')))
        
        # 計(jì)算主機(jī)位數(shù)
        host_bits = sum([bin(x).count('0') - 1 for x in mask_parts])
        num_hosts = 2 ** host_bits - 2  # 減去網(wǎng)絡(luò)地址和廣播地址
        
        # 生成所有可能的IP
        base_ip = network_parts.copy()
        hosts = []
        for i in range(1, num_hosts + 1):
            host_ip = base_ip.copy()
            host_ip[3] += i
            # 處理進(jìn)位
            for j in range(3, 0, -1):
                if host_ip[j] > 255:
                    host_ip[j] = 0
                    host_ip[j-1] += 1
            hosts.append('.'.join(map(str, host_ip)))
        
        return hosts

    def ping_host(self, ip):
        """ping指定主機(jī)，返回是否在線(xiàn)和延遲"""
        try:
            # Windows系統(tǒng)使用'-n'參數(shù)，Linux/Unix使用'-c'
            param = '-n' if platform.system().lower() == 'windows' else '-c'
            count = '1'
            timeout = '1000'  # 毫秒
            
            # 構(gòu)建ping命令
            command = ['ping', param, count, '-w', timeout, ip]
            
            # 執(zhí)行ping命令
            output = subprocess.run(command, capture_output=True, text=True)
            
            # 解析輸出結(jié)果
            if platform.system().lower() == 'windows':
                if 'TTL=' in output.stdout:
                    # 提取延遲時(shí)間
                    time_line = [line for line in output.stdout.split('\n') if 'time=' in line][0]
                    latency = int(float(time_line.split('time=')[1].split('ms')[0]))
                    return True, latency
            else:
                if '1 received' in output.stdout:
                    # 提取延遲時(shí)間
                    time_line = [line for line in output.stdout.split('\n') if 'time=' in line][0]
                    latency = int(float(time_line.split('time=')[1].split(' ms')[0]))
                    return True, latency
            
            return False, -1
        except Exception as e:
            self.log_message(f"?? ping {ip} 失敗: {str(e)}")
            return False, -1

    def scan_network(self):
        """掃描網(wǎng)絡(luò)中的在線(xiàn)主機(jī)"""
        self.log_message("?? 正在掃描網(wǎng)絡(luò)...")
        
        # 獲取本地網(wǎng)絡(luò)信息
        network, netmask = self.get_local_network_info()
        if not network or not netmask:
            self.log_message("? 無(wú)法確定本地網(wǎng)絡(luò)信息")
            return
        
        # 獲取所有可能的IP
        all_hosts = self.get_all_hosts_in_network(network, netmask)
        self.log_message(f"?? 掃描范圍: {network}/{netmask} (共{len(all_hosts)}個(gè)IP)")
        
        # 使用線(xiàn)程池并發(fā)ping
        with concurrent.futures.ThreadPoolExecutor(max_workers=self.max_threads) as executor:
            futures = {executor.submit(self.ping_host, ip): ip for ip in all_hosts}
            
            for future in concurrent.futures.as_completed(futures):
                ip = futures[future]
                try:
                    is_online, latency = future.result()
                    if is_online:
                        try:
                            # 嘗試獲取主機(jī)名
                            hostname = socket.gethostbyaddr(ip)[0]
                        except:
                            hostname = "未知"
                        
                        # 更新主機(jī)列表
                        self.hosts[ip] = {
                            'name': hostname,
                            'last_seen': time.time(),
                            'latency': latency
                        }
                        
                        # 更新UI
                        self.update_host_tree()
                except Exception as e:
                    self.log_message(f"?? 掃描 {ip} 時(shí)出錯(cuò): {str(e)}")
        
        self.log_message(f"? 掃描完成，發(fā)現(xiàn) {len(self.hosts)} 臺(tái)在線(xiàn)主機(jī)")

    def start_discovery(self):
        """啟動(dòng)主機(jī)發(fā)現(xiàn)服務(wù)"""
        self.discovery_running = True
        self.discovery_thread = threading.Thread(target=self.run_discovery, daemon=True)
        self.discovery_thread.start()
        self.log_message("?? 主機(jī)發(fā)現(xiàn)服務(wù)已啟動(dòng) (使用Ping掃描)")

    def run_discovery(self):
        """運(yùn)行主機(jī)發(fā)現(xiàn)主循環(huán)"""
        while self.discovery_running:
            self.scan_network()
            # 每30秒掃描一次
            time.sleep(30)

    def update_host_tree(self):
        """更新主機(jī)樹(shù)顯示"""
        self.host_tree.clear()
        
        for ip, info in self.hosts.items():
            last_seen_str = time.strftime("%H:%M:%S", time.localtime(info['last_seen']))
            
            # 信號(hào)強(qiáng)度指示
            if info['latency'] < 0:
                signal = "? 離線(xiàn)"
            elif info['latency'] < 50:
                signal = "?? 強(qiáng)"
            elif info['latency'] < 150:
                signal = "?? 中"
            else:
                signal = "?? 弱"
            
            item = QTreeWidgetItem([ip, info['name'], last_seen_str, signal])
            
            # 根據(jù)延遲設(shè)置顏色
            if info['latency'] > 150:
                item.setForeground(3, Qt.red)
            elif info['latency'] > 0:
                item.setForeground(3, Qt.darkYellow)
            else:
                item.setForeground(3, Qt.green)
            
            self.host_tree.addTopLevelItem(item)

    # 以下是文件傳輸和連接管理功能 --------------------------------------

    def update_status_text(self):
        """更新?tīng)顟B(tài)欄文本"""
        hostname = socket.gethostname()
        ip = self.get_local_ip()
        self.status_label.setText(f"?? 就緒 | 主機(jī): {hostname} | IP: {ip} | 線(xiàn)程: {self.max_threads}")

    def update_network_status(self):
        """更新網(wǎng)絡(luò)狀態(tài)指示"""
        online_hosts = len(self.hosts)
        if online_hosts > 0:
            self.network_status.setText(f"?? 網(wǎng)絡(luò): 良好 (發(fā)現(xiàn){online_hosts}臺(tái)主機(jī))")
        else:
            self.network_status.setText("?? 網(wǎng)絡(luò): 無(wú)連接")

    def get_local_ip(self):
        """獲取本地IP地址"""
        try:
            s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
            s.connect(("8.8.8.8", 80))
            ip = s.getsockname()[0]
            s.close()
            return ip
        except:
            return "127.0.0.1"

    def log_message(self, message):
        """記錄日志消息"""
        timestamp = datetime.now().strftime("%H:%M:%S")
        self.log_text.append(f"[{timestamp}] {message}")

    def browse_file(self):
        """瀏覽選擇文件"""
        file_path, _ = QFileDialog.getOpenFileName(self, "選擇文件", "", "所有文件 (*.*)")
        if file_path:
            self.file_path.setText(file_path)

    def update_password(self):
        """更新密碼"""
        new_pass = self.new_password.text()
        confirm_pass = self.confirm_password.text()
        
        if not new_pass:
            QMessageBox.warning(self, "警告", "密碼不能為空！")
            return
        
        if new_pass != confirm_pass:
            QMessageBox.warning(self, "警告", "兩次輸入的密碼不一致！")
            return
        
        self.password = new_pass
        self.file_password.setText(new_pass)
        self.log_message(f"?? 密碼已更新為: {new_pass}")
        QMessageBox.information(self, "成功", "密碼更新成功！")
        
        self.new_password.clear()
        self.confirm_password.clear()
        self.save_config()

    def save_settings(self):
        """保存設(shè)置"""
        try:
            self.max_threads = self.thread_spin.value()
            self.retry_attempts = self.retry_spin.value()
            self.save_config()
            self.log_message(f"?? 設(shè)置已保存: 線(xiàn)程數(shù)={self.max_threads}, 重試次數(shù)={self.retry_attempts}")
            self.update_status_text()
            QMessageBox.information(self, "成功", "設(shè)置保存成功！")
        except Exception as e:
            QMessageBox.critical(self, "錯(cuò)誤", f"保存設(shè)置時(shí)出錯(cuò): {str(e)}")

    def load_config(self):
        """加載配置"""
        try:
            if os.path.exists("config.json"):
                with open("config.json", "r") as f:
                    config = json.load(f)
                    self.password = config.get("password", self.password)
                    self.max_threads = config.get("max_threads", self.max_threads)
                    self.retry_attempts = config.get("retry_attempts", self.retry_attempts)
                    self.retry_delay = config.get("retry_delay", self.retry_delay)
                    
                    # 更新UI控件
                    self.file_password.setText(self.password)
                    self.thread_spin.setValue(self.max_threads)
                    self.retry_spin.setValue(self.retry_attempts)
        except Exception as e:
            self.log_message(f"?? 加載配置失敗: {str(e)}")

    def save_config(self):
        """保存配置"""
        try:
            config = {
                "password": self.password,
                "max_threads": self.max_threads,
                "retry_attempts": self.retry_attempts,
                "retry_delay": self.retry_delay
            }
            with open("config.json", "w") as f:
                json.dump(config, f)
        except Exception as e:
            self.log_message(f"?? 保存配置失敗: {str(e)}")

    def start_server(self):
        """啟動(dòng)文件傳輸服務(wù)器"""
        self.server_running = True
        self.server_thread = threading.Thread(target=self.run_server, daemon=True)
        self.server_thread.start()
        self.log_message("??? 文件傳輸服務(wù)器已啟動(dòng) (端口: 12345)")

    def run_server(self):
        """運(yùn)行服務(wù)器主循環(huán)"""
        server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
        
        try:
            server_socket.bind(('', 12345))
            server_socket.listen(5)
            
            while self.server_running:
                try:
                    client_socket, addr = server_socket.accept()
                    threading.Thread(target=self.handle_client, args=(client_socket, addr), daemon=True).start()
                except Exception as e:
                    if self.server_running:
                        self.log_message(f"? 服務(wù)器錯(cuò)誤: {str(e)}")
        finally:
            server_socket.close()

    def handle_client(self, client_socket, addr):
        """處理客戶(hù)端連接"""
        ip = addr[0]
        transfer_id = None
        
        try:
            # 認(rèn)證階段
            auth_data = client_socket.recv(1024)
            if not auth_data:
                return
                
            auth_info = pickle.loads(auth_data)
            host_name = auth_info.get('hostname', '未知')
            password = auth_info.get('password', '')
            
            if password != self.password:
                self.log_message(f"?? 來(lái)自 {ip} 的連接嘗試使用無(wú)效密碼")
                client_socket.sendall(b"AUTH_FAIL")
                return
            
            client_socket.sendall(b"AUTH_OK")
            
            self.connections[ip] = client_socket
            self.log_message(f"?? 已連接: {host_name} ({ip})")
            self.update_connection_tree()
            
            # 接收文件信息
            file_info_data = client_socket.recv(1024)
            if not file_info_data:
                return
                
            file_info = pickle.loads(file_info_data)
            file_id = file_info['file_id']
            filename = file_info['filename']
            filesize = file_info['filesize']
            file_hash = file_info['hash']
            chunk_size = file_info.get('chunk_size', 4096)
            
            # 處理文件名沖突
            save_path = os.path.join("received_files", filename)
            os.makedirs("received_files", exist_ok=True)
            
            counter = 1
            base, ext = os.path.splitext(filename)
            while os.path.exists(save_path):
                save_path = os.path.join("received_files", f"{base}_{counter}{ext}")
                counter += 1
            
            # 檢查是否有未完成的傳輸
            received = 0
            temp_path = save_path + ".tmp"
            
            if os.path.exists(temp_path):
                received = os.path.getsize(temp_path)
                self.log_message(f"?? 發(fā)現(xiàn)未完成傳輸: {filename}, 已接收: {self.format_size(received)}")
            
            # 告訴客戶(hù)端從哪個(gè)位置繼續(xù)
            client_socket.sendall(struct.pack("!Q", received))
            
            transfer_id = f"{ip}_{file_id}"
            self.file_transfers[transfer_id] = {
                'filename': filename,
                'size': filesize,
                'received': received,
                'status': 'transferring',
                'start_time': time.time(),
                'last_update': time.time(),
                'speed': 0
            }
            
            # 開(kāi)始接收文件
            hasher = hashlib.sha256()
            
            with open(temp_path, 'ab') as f:
                while received < filesize:
                    try:
                        # 接收塊長(zhǎng)度信息
                        chunk_info = client_socket.recv(8)
                        if not chunk_info:
                            break
                        
                        chunk_len = struct.unpack("!Q", chunk_info)[0]
                        chunk = b''
                        remaining = chunk_len
                        
                        # 設(shè)置超時(shí)
                        client_socket.settimeout(30.0)
                        
                        # 接收實(shí)際數(shù)據(jù)
                        start_time = time.time()
                        while remaining > 0:
                            part = client_socket.recv(remaining)
                            if not part:
                                break
                            chunk += part
                            remaining -= len(part)
                        
                        if len(chunk) != chunk_len:
                            self.log_message(f"?? 數(shù)據(jù)包不完整: {len(chunk)}/{chunk_len}字節(jié)")
                            # 請(qǐng)求重傳
                            client_socket.sendall(struct.pack("!Q", received))
                            continue
                        
                        # 寫(xiě)入文件并更新哈希
                        f.write(chunk)
                        hasher.update(chunk)
                        received += len(chunk)
                        
                        # 更新傳輸狀態(tài)
                        now = time.time()
                        time_elapsed = now - self.file_transfers[transfer_id]['last_update']
                        if time_elapsed > 0:
                            bytes_elapsed = received - self.file_transfers[transfer_id]['received']
                            self.file_transfers[transfer_id]['speed'] = bytes_elapsed / time_elapsed
                        
                        self.file_transfers[transfer_id]['received'] = received
                        self.file_transfers[transfer_id]['last_update'] = now
                        
                        # 每接收1MB發(fā)送一次確認(rèn)
                        if received % (1024*1024) == 0:
                            client_socket.sendall(struct.pack("!Q", received))
                        
                    except socket.timeout:
                        self.log_message(f"?? 接收超時(shí)，等待重傳...")
                        # 發(fā)送當(dāng)前接收位置
                        client_socket.sendall(struct.pack("!Q", received))
                        continue
                    except Exception as e:
                        self.log_message(f"? 接收數(shù)據(jù)時(shí)出錯(cuò): {str(e)}")
                        break
            
            # 傳輸完成，驗(yàn)證文件
            if received == filesize and hasher.hexdigest() == file_hash:
                os.rename(temp_path, save_path)
                self.log_message(f"? 成功接收文件: {save_path} ({self.format_size(filesize)})")
                client_socket.sendall(b"FILE_OK")
                self.file_transfers[transfer_id]['status'] = 'completed'
            else:
                self.log_message(f"? 文件校驗(yàn)失敗: {filename}")
                client_socket.sendall(b"FILE_FAIL")
                self.file_transfers[transfer_id]['status'] = 'failed'
                
        except Exception as e:
            self.log_message(f"? 處理客戶(hù)端 {ip} 時(shí)出錯(cuò): {str(e)}")
            if transfer_id in self.file_transfers:
                self.file_transfers[transfer_id]['status'] = 'failed'
        finally:
            client_socket.close()
            if ip in self.connections:
                del self.connections[ip]
                self.update_connection_tree()

    def cleanup_old_hosts(self):
        """清理過(guò)期的主機(jī)記錄"""
        current_time = time.time()
        to_remove = []
        
        for ip, info in self.hosts.items():
            if current_time - info['last_seen'] > 30:  # 30秒無(wú)響應(yīng)視為離線(xiàn)
                to_remove.append(ip)
        
        for ip in to_remove:
            del self.hosts[ip]
        
        if to_remove:
            self.update_host_tree()

    def update_connection_tree(self):
        """更新連接樹(shù)"""
        self.conn_tree.clear()
        
        for ip, sock in list(self.connections.items()):
            try:
                hostname = socket.gethostbyaddr(ip)[0]
            except:
                hostname = "未知"
            
            # 測(cè)量延遲
            latency = self.measure_latency(ip)
            if latency < 0:
                status = "? 斷開(kāi)"
                try:
                    sock.close()
                except:
                    pass
                del self.connections[ip]
                continue
            else:
                status = "? 已連接"
            
            item = QTreeWidgetItem([ip, hostname, status, f"{latency}ms"])
            
            # 根據(jù)延遲設(shè)置顏色
            if latency > 150:
                item.setForeground(2, Qt.red)
                item.setForeground(3, Qt.red)
            elif latency > 50:
                item.setForeground(2, Qt.darkYellow)
                item.setForeground(3, Qt.darkYellow)
            else:
                item.setForeground(2, Qt.green)
                item.setForeground(3, Qt.green)
            
            self.conn_tree.addTopLevelItem(item)

    def measure_latency(self, ip):
        """測(cè)量主機(jī)延遲"""
        try:
            start_time = time.time()
            sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            sock.settimeout(2)
            sock.connect((ip, 12345))
            sock.close()
            return int((time.time() - start_time) * 1000)  # 毫秒
        except:
            return -1  # 表示無(wú)法測(cè)量

    def update_connection_status(self):
        """定時(shí)更新連接狀態(tài)"""
        for ip in list(self.connections.keys()):
            latency = self.measure_latency(ip)
            if latency < 0:  # 連接已斷開(kāi)
                try:
                    self.connections[ip].close()
                except:
                    pass
                del self.connections[ip]
                self.log_message(f"?? 連接斷開(kāi): {ip}")
        
        self.update_connection_tree()

    def update_transfer_status(self):
        """更新傳輸狀態(tài)"""
        self.transfer_tree.clear()
        
        current_time = time.time()
        
        for transfer_id, transfer in list(self.file_transfers.items()):
            file_id = transfer_id.split('_')[-1]
            filename = transfer['filename']
            target_ip = transfer_id.split('_')[0]
            received = transfer['received']
            total = transfer['size']
            
            # 計(jì)算進(jìn)度和速度
            progress = 0
            if total > 0:
                progress = min(100, int(received * 100 / total))
            
            # 計(jì)算傳輸速度
            time_elapsed = current_time - transfer['start_time']
            if time_elapsed > 0:
                speed = received / time_elapsed  # 字節(jié)/秒
            else:
                speed = 0
            
            # 格式化速度
            if speed > 1024*1024:
                speed_str = f"{speed/(1024*1024):.1f} MB/s"
            elif speed > 1024:
                speed_str = f"{speed/1024:.1f} KB/s"
            else:
                speed_str = f"{speed:.1f} B/s"
            
            # 狀態(tài)文本
            status = transfer['status']
            if status == 'transferring':
                status_text = f"傳輸中 ({progress}%)"
            elif status == 'completed':
                status_text = "? 已完成"
            elif status == 'failed':
                status_text = "? 失敗"
            elif status == 'paused':
                status_text = "?? 已暫停"
            elif status == 'canceled':
                status_text = "?? 已取消"
            else:
                status_text = status
            
            item = QTreeWidgetItem([
                file_id[:6], 
                filename, 
                target_ip, 
                f"{progress}%",
                status_text,
                speed_str
            ])
            
            # 設(shè)置進(jìn)度條
            progress_bar = QProgressBar()
            progress_bar.setValue(progress)
            progress_bar.setAlignment(Qt.AlignCenter)
            
            # 根據(jù)狀態(tài)設(shè)置顏色
            if status == 'completed':
                progress_bar.setStyleSheet("QProgressBar::chunk { background-color: green; }")
            elif status in ['failed', 'canceled']:
                progress_bar.setStyleSheet("QProgressBar::chunk { background-color: red; }")
            elif status == 'paused':
                progress_bar.setStyleSheet("QProgressBar::chunk { background-color: orange; }")
            
            self.transfer_tree.setItemWidget(item, 3, progress_bar)
            self.transfer_tree.addTopLevelItem(item)
            
            # 更新傳輸速度
            transfer['speed'] = speed

    def connect_to_host(self):
        """連接選中的主機(jī)"""
        selected = self.host_tree.selectedItems()
        if not selected:
            QMessageBox.warning(self, "警告", "請(qǐng)先選擇一個(gè)主機(jī)")
            return
        
        ip = selected[0].text(0)
        self.connect_to_ip(ip)

    def manual_connect(self):
        """手動(dòng)連接主機(jī)"""
        ip, ok = QInputDialog.getText(self, "手動(dòng)連接", "請(qǐng)輸入目標(biāo)IP地址:")
        if ok and ip:
            self.connect_to_ip(ip)

    def connect_to_ip(self, ip):
        """連接到指定IP"""
        if ip in self.connections:
            QMessageBox.information(self, "信息", f"已經(jīng)連接到 {ip}")
            return
        
        try:
            # 先測(cè)量延遲
            latency = self.measure_latency(ip)
            if latency < 0:
                QMessageBox.critical(self, "錯(cuò)誤", f"無(wú)法連接到 {ip}")
                return
            
            # 建立連接
            client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            client_socket.settimeout(5)
            client_socket.connect((ip, 12345))
            
            # 認(rèn)證
            auth_info = {
                'hostname': socket.gethostname(),
                'password': self.password
            }
            client_socket.sendall(pickle.dumps(auth_info))
            
            response = client_socket.recv(1024)
            if response == b"AUTH_OK":
                self.connections[ip] = client_socket
                self.update_connection_tree()
                self.log_message(f"? 成功連接到 {ip} (延遲: {latency}ms)")
            else:
                client_socket.close()
                QMessageBox.critical(self, "錯(cuò)誤", "密碼錯(cuò)誤或連接被拒絕")
                self.log_message(f"? 連接 {ip} 失敗: 認(rèn)證失敗")
        except socket.timeout:
            QMessageBox.critical(self, "錯(cuò)誤", f"連接 {ip} 超時(shí)")
            self.log_message(f"? 連接 {ip} 失敗: 連接超時(shí)")
        except Exception as e:
            QMessageBox.critical(self, "錯(cuò)誤", f"無(wú)法連接到 {ip}: {str(e)}")
            self.log_message(f"? 連接 {ip} 失敗: {str(e)}")

    def rescan_network(self):
        """重新掃描網(wǎng)絡(luò)"""
        self.log_message("?? 正在重新掃描網(wǎng)絡(luò)...")
        self.hosts = {}
        self.update_host_tree()
        self.scan_network()

    def clear_host_list(self):
        """清除主機(jī)列表"""
        self.hosts = {}
        self.update_host_tree()
        self.log_message("?? 主機(jī)列表已清除")

    def send_file(self):
        """發(fā)送文件"""
        selected = self.conn_tree.selectedItems()
        if not selected:
            QMessageBox.warning(self, "警告", "請(qǐng)先選擇一個(gè)連接")
            return
        
        file_path = self.file_path.text()
        if not file_path:
            QMessageBox.warning(self, "警告", "請(qǐng)先選擇要發(fā)送的文件")
            return
        
        if not os.path.isfile(file_path):
            QMessageBox.warning(self, "警告", "文件不存在")
            return
        
        password = self.file_password.text()
        if not password:
            QMessageBox.warning(self, "警告", "請(qǐng)輸入密碼")
            return
        
        ip = selected[0].text(0)
        
        if ip not in self.connections:
            QMessageBox.critical(self, "錯(cuò)誤", "連接已斷開(kāi)")
            return
        
        # 在單獨(dú)的線(xiàn)程中發(fā)送文件
        threading.Thread(
            target=self._send_file, 
            args=(ip, file_path, password),
            daemon=True
        ).start()

    def _send_file(self, ip, file_path, password):
        """實(shí)際發(fā)送文件的實(shí)現(xiàn)"""
        file_id = str(int(time.time() * 1000))
        transfer_id = f"{ip}_{file_id}"
        
        try:
            # 檢查連接是否仍然有效
            if ip not in self.connections:
                self.log_message(f"? 連接已斷開(kāi): {ip}")
                return
            
            sock = self.connections[ip]
            
            # 獲取文件信息
            filename = os.path.basename(file_path)
            filesize = os.path.getsize(file_path)
            
            # 計(jì)算文件哈希
            self.log_message(f"?? 正在計(jì)算文件哈希...")
            hasher = hashlib.sha256()
            with open(file_path, 'rb') as f:
                while chunk := f.read(4096):
                    hasher.update(chunk)
            file_hash = hasher.hexdigest()
            
            # 準(zhǔn)備文件信息
            file_info = {
                'file_id': file_id,
                'filename': filename,
                'filesize': filesize,
                'hash': file_hash,
                'password': password,
                'chunk_size': 4096
            }
            
            # 發(fā)送文件信息
            sock.sendall(pickle.dumps(file_info))
            
            # 獲取偏移量（用于斷點(diǎn)續(xù)傳）
            offset_data = sock.recv(8)
            if not offset_data or len(offset_data) != 8:
                self.log_message(f"? 接收偏移量失敗: {filename}")
                return
                
            offset = struct.unpack("!Q", offset_data)[0]
            
            # 初始化傳輸記錄
            self.file_transfers[transfer_id] = {
                'filename': filename,
                'size': filesize,
                'sent': offset,
                'status': 'transferring',
                'start_time': time.time(),
                'last_update': time.time(),
                'speed': 0
            }
            
            # 開(kāi)始傳輸文件
            with open(file_path, 'rb') as f:
                f.seek(offset)
                
                chunk_size = 4096
                total_sent = offset
                attempts = 0
                last_active_time = time.time()
                
                while total_sent < filesize:
                    # 檢查傳輸狀態(tài)
                    if self.file_transfers[transfer_id]['status'] == 'paused':
                        time.sleep(1)
                        continue
                    elif self.file_transfers[transfer_id]['status'] == 'canceled':
                        self.log_message(f"?? 傳輸已取消: {filename}")
                        return
                    
                    # 檢查連接是否超時(shí)
                    if time.time() - last_active_time > 30:  # 30秒無(wú)活動(dòng)
                        self.log_message(f"?? 連接超時(shí)，嘗試重新連接...")
                        try:
                            sock.shutdown(socket.SHUT_RDWR)
                            sock.close()
                        except:
                            pass
                        
                        # 重新連接
                        try:
                            new_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
                            new_sock.settimeout(10)
                            new_sock.connect((ip, 12345))
                            # 重新認(rèn)證
                            auth_info = {'hostname': socket.gethostname(), 'password': password}
                            new_sock.sendall(pickle.dumps(auth_info))
                            response = new_sock.recv(1024)
                            if response == b"AUTH_OK":
                                sock = new_sock
                                self.connections[ip] = sock
                                # 重新發(fā)送文件信息
                                sock.sendall(pickle.dumps(file_info))
                                offset_data = sock.recv(8)
                                offset = struct.unpack("!Q", offset_data)[0]
                                f.seek(offset)
                                total_sent = offset
                                last_active_time = time.time()
                                continue
                        except Exception as e:
                            self.log_message(f"? 重新連接失敗: {str(e)}")
                            break
                    
                    # 讀取并發(fā)送數(shù)據(jù)塊
                    chunk = f.read(chunk_size)
                    if not chunk:
                        break
                        
                    try:
                        # 發(fā)送塊長(zhǎng)度
                        sock.sendall(struct.pack("!Q", len(chunk)))
                        # 發(fā)送實(shí)際數(shù)據(jù)
                        sock.sendall(chunk)
                        
                        total_sent += len(chunk)
                        self.file_transfers[transfer_id]['sent'] = total_sent
                        attempts = 0
                        last_active_time = time.time()
                        
                        # 更新傳輸速度
                        now = time.time()
                        time_elapsed = now - self.file_transfers[transfer_id]['last_update']
                        if time_elapsed > 0:
                            bytes_elapsed = total_sent - self.file_transfers[transfer_id]['sent']
                            self.file_transfers[transfer_id]['speed'] = bytes_elapsed / time_elapsed
                            self.file_transfers[transfer_id]['last_update'] = now
                        
                    except Exception as e:
                        attempts += 1
                        if attempts > self.retry_attempts:
                            self.log_message(f"? 發(fā)送失敗超過(guò)重試次數(shù): {str(e)}")
                            self.file_transfers[transfer_id]['status'] = 'failed'
                            return
                        
                        self.log_message(f"?? 發(fā)送失敗: {str(e)} (嘗試 {attempts}/{self.retry_attempts})")
                        time.sleep(self.retry_delay)
                        f.seek(total_sent)
            
            # 傳輸完成，等待確認(rèn)
            response = sock.recv(1024)
            if response == b"FILE_OK":
                # 驗(yàn)證文件哈希
                sock.sendall(b"VERIFY_HASH")
                local_hash = hashlib.sha256(open(file_path, 'rb').read()).hexdigest()
                sock.sendall(local_hash.encode())
                
                verify_response = sock.recv(1024)
                if verify_response == b"HASH_MATCH":
                    self.log_message(f"? 文件校驗(yàn)成功: {filename}")
                    self.file_transfers[transfer_id]['status'] = 'completed'
                else:
                    self.log_message(f"? 文件校驗(yàn)失敗: {filename}")
                    self.file_transfers[transfer_id]['status'] = 'hash_failed'
            else:
                self.log_message(f"? 文件傳輸失敗: {filename}")
                self.file_transfers[transfer_id]['status'] = 'failed'
                
        except Exception as e:
            self.log_message(f"? 發(fā)送文件到 {ip} 時(shí)出錯(cuò): {str(e)}")
            if transfer_id in self.file_transfers:
                self.file_transfers[transfer_id]['status'] = 'failed'
            if ip in self.connections:
                del self.connections[ip]
                self.update_connection_tree()

    def pause_transfer(self):
        """暫停傳輸"""
        selected = self.transfer_tree.selectedItems()
        if not selected:
            return
            
        for item in selected:
            transfer_id = f"{item.text(2)}_{item.text(0)}"
            if transfer_id in self.file_transfers and self.file_transfers[transfer_id]['status'] == 'transferring':
                self.file_transfers[transfer_id]['status'] = 'paused'
                self.log_message(f"?? 已暫停傳輸: {item.text(1)}")

    def resume_transfer(self):
        """繼續(xù)傳輸"""
        selected = self.transfer_tree.selectedItems()
        if not selected:
            return
            
        for item in selected:
            transfer_id = f"{item.text(2)}_{item.text(0)}"
            if transfer_id in self.file_transfers and self.file_transfers[transfer_id]['status'] == 'paused':
                self.file_transfers[transfer_id]['status'] = 'transferring'
                self.log_message(f"?? 已繼續(xù)傳輸: {item.text(1)}")

    def cancel_transfer(self):
        """取消傳輸"""
        selected = self.transfer_tree.selectedItems()
        if not selected:
            return
            
        for item in selected:
            transfer_id = f"{item.text(2)}_{item.text(0)}"
            if transfer_id in self.file_transfers:
                self.file_transfers[transfer_id]['status'] = 'canceled'
                self.log_message(f"?? 已取消傳輸: {item.text(1)}")

    def clear_completed(self):
        """清除已完成傳輸"""
        to_remove = []
        for transfer_id, transfer in self.file_transfers.items():
            if transfer['status'] in ['completed', 'failed', 'canceled', 'hash_failed']:
                to_remove.append(transfer_id)
        
        for transfer_id in to_remove:
            del self.file_transfers[transfer_id]
        
        if to_remove:
            self.log_message(f"?? 已清除 {len(to_remove)} 個(gè)傳輸記錄")

    def format_size(self, size):
        """格式化文件大小"""
        for unit in ['B', 'KB', 'MB', 'GB']:
            if size < 1024:
                return f"{size:.1f} {unit}"
            size /= 1024
        return f"{size:.1f} TB"

    def closeEvent(self, event):
        """關(guān)閉窗口事件處理"""
        self.server_running = False
        self.discovery_running = False
        
        # 關(guān)閉所有連接
        for sock in self.connections.values():
            try:
                sock.close()
            except:
                pass
        
        # 保存配置
        self.save_config()
        
        # 停止所有定時(shí)器
        self.cleanup_timer.stop()
        self.status_timer.stop()
        self.connection_timer.stop()
        self.network_timer.stop()
        
        event.accept()

if __name__ == "__main__":
    app = QApplication(sys.argv)
    
    # 設(shè)置應(yīng)用程序樣式
    app.setStyle('Fusion')
    
    # 設(shè)置應(yīng)用程序圖標(biāo)
    if hasattr(sys, '_MEIPASS'):
        icon_path = os.path.join(sys._MEIPASS, 'icon.ico')
    else:
        icon_path = 'icon.ico' if os.path.exists('icon.ico') else None
    
    if icon_path and os.path.exists(icon_path):
        app.setWindowIcon(QIcon(icon_path))
    
    # 創(chuàng)建并顯示主窗口
    window = FileSharingApp()
    window.show()
    
    # 運(yùn)行應(yīng)用程序
    sys.exit(app.exec_())