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

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

# 安裝依賴庫
pip install -r requirements.txt
# 所需庫：
# 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):
    # 跨平臺ping命令適配
    param = '-n' if platform.system() == 'Windows' else '-c'
    command = ['ping', param, '1', '-w', '1000', ip]
    
    # 使用subprocess避免阻塞主線程
    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)到斷點位置

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()
        
        # 啟動服務(wù)
        self.start_server()
        self.start_discovery()
        
        # 設(shè)置定時器
        self.setup_timers()

    def init_ui(self):
        """初始化用戶界面"""
        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ī)名稱", "最后在線", "信號強(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),
            ("? 手動連接主機(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ī)名稱", "狀態(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("傳輸線程:"))
        
        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)簽頁
        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)簽頁
        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ò): 檢測中...")
        status_bar.addPermanentWidget(self.network_status)
        
        # 定時更新網(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è)置各種定時器"""
        # 清理舊主機(jī)定時器
        self.cleanup_timer = QTimer(self)
        self.cleanup_timer.timeout.connect(self.cleanup_old_hosts)
        self.cleanup_timer.start(10000)  # 每10秒清理一次
        
        # 更新傳輸狀態(tài)定時器
        self.status_timer = QTimer(self)
        self.status_timer.timeout.connect(self.update_transfer_status)
        self.status_timer.start(1000)  # 每秒更新一次
        
        # 更新連接狀態(tài)定時器
        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:
                            # 計算網(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):
        """計算網(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ī)位數(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ī)，返回是否在線和延遲"""
        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:
                    # 提取延遲時間
                    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:
                    # 提取延遲時間
                    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ò)中的在線主機(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ǎng)絡(luò)信息")
            return
        
        # 獲取所有可能的IP
        all_hosts = self.get_all_hosts_in_network(network, netmask)
        self.log_message(f"?? 掃描范圍: {network}/{netmask} (共{len(all_hosts)}個IP)")
        
        # 使用線程池并發(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} 時出錯: {str(e)}")
        
        self.log_message(f"? 掃描完成，發(fā)現(xiàn) {len(self.hosts)} 臺在線主機(jī)")

    def start_discovery(self):
        """啟動主機(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ù)已啟動 (使用Ping掃描)")

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

    def update_host_tree(self):
        """更新主機(jī)樹顯示"""
        self.host_tree.clear()
        
        for ip, info in self.hosts.items():
            last_seen_str = time.strftime("%H:%M:%S", time.localtime(info['last_seen']))
            
            # 信號強(qiáng)度指示
            if info['latency'] < 0:
                signal = "? 離線"
            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ài)欄文本"""
        hostname = socket.gethostname()
        ip = self.get_local_ip()
        self.status_label.setText(f"?? 就緒 | 主機(jī): {hostname} | IP: {ip} | 線程: {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}臺主機(jī))")
        else:
            self.network_status.setText("?? 網(wǎng)絡(luò): 無連接")

    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è)置已保存: 線程數(shù)={self.max_threads}, 重試次數(shù)={self.retry_attempts}")
            self.update_status_text()
            QMessageBox.information(self, "成功", "設(shè)置保存成功！")
        except Exception as e:
            QMessageBox.critical(self, "錯誤", f"保存設(shè)置時出錯: {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):
        """啟動文件傳輸服務(wù)器"""
        self.server_running = True
        self.server_thread = threading.Thread(target=self.run_server, daemon=True)
        self.server_thread.start()
        self.log_message("??? 文件傳輸服務(wù)器已啟動 (端口: 12345)")

    def run_server(self):
        """運行服務(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ù)器錯誤: {str(e)}")
        finally:
            server_socket.close()

    def handle_client(self, client_socket, addr):
        """處理客戶端連接"""
        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"?? 來自 {ip} 的連接嘗試使用無效密碼")
                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)}")
            
            # 告訴客戶端從哪個位置繼續(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
            }
            
            # 開始接收文件
            hasher = hashlib.sha256()
            
            with open(temp_path, 'ab') as f:
                while received < filesize:
                    try:
                        # 接收塊長度信息
                        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è)置超時
                        client_socket.settimeout(30.0)
                        
                        # 接收實際數(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é)")
                            # 請求重傳
                            client_socket.sendall(struct.pack("!Q", received))
                            continue
                        
                        # 寫入文件并更新哈希
                        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"?? 接收超時，等待重傳...")
                        # 發(fā)送當(dāng)前接收位置
                        client_socket.sendall(struct.pack("!Q", received))
                        continue
                    except Exception as e:
                        self.log_message(f"? 接收數(shù)據(jù)時出錯: {str(e)}")
                        break
            
            # 傳輸完成，驗證文件
            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"? 文件校驗失敗: {filename}")
                client_socket.sendall(b"FILE_FAIL")
                self.file_transfers[transfer_id]['status'] = 'failed'
                
        except Exception as e:
            self.log_message(f"? 處理客戶端 {ip} 時出錯: {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):
        """清理過期的主機(jī)記錄"""
        current_time = time.time()
        to_remove = []
        
        for ip, info in self.hosts.items():
            if current_time - info['last_seen'] > 30:  # 30秒無響應(yīng)視為離線
                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):
        """更新連接樹"""
        self.conn_tree.clear()
        
        for ip, sock in list(self.connections.items()):
            try:
                hostname = socket.gethostbyaddr(ip)[0]
            except:
                hostname = "未知"
            
            # 測量延遲
            latency = self.measure_latency(ip)
            if latency < 0:
                status = "? 斷開"
                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):
        """測量主機(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  # 表示無法測量

    def update_connection_status(self):
        """定時更新連接狀態(tài)"""
        for ip in list(self.connections.keys()):
            latency = self.measure_latency(ip)
            if latency < 0:  # 連接已斷開
                try:
                    self.connections[ip].close()
                except:
                    pass
                del self.connections[ip]
                self.log_message(f"?? 連接斷開: {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ìn)度和速度
            progress = 0
            if total > 0:
                progress = min(100, int(received * 100 / total))
            
            # 計算傳輸速度
            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, "警告", "請先選擇一個主機(jī)")
            return
        
        ip = selected[0].text(0)
        self.connect_to_ip(ip)

    def manual_connect(self):
        """手動連接主機(jī)"""
        ip, ok = QInputDialog.getText(self, "手動連接", "請輸入目標(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:
            # 先測量延遲
            latency = self.measure_latency(ip)
            if latency < 0:
                QMessageBox.critical(self, "錯誤", f"無法連接到 {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, "錯誤", "密碼錯誤或連接被拒絕")
                self.log_message(f"? 連接 {ip} 失敗: 認(rèn)證失敗")
        except socket.timeout:
            QMessageBox.critical(self, "錯誤", f"連接 {ip} 超時")
            self.log_message(f"? 連接 {ip} 失敗: 連接超時")
        except Exception as e:
            QMessageBox.critical(self, "錯誤", f"無法連接到 {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, "警告", "請先選擇一個連接")
            return
        
        file_path = self.file_path.text()
        if not file_path:
            QMessageBox.warning(self, "警告", "請先選擇要發(fā)送的文件")
            return
        
        if not os.path.isfile(file_path):
            QMessageBox.warning(self, "警告", "文件不存在")
            return
        
        password = self.file_password.text()
        if not password:
            QMessageBox.warning(self, "警告", "請輸入密碼")
            return
        
        ip = selected[0].text(0)
        
        if ip not in self.connections:
            QMessageBox.critical(self, "錯誤", "連接已斷開")
            return
        
        # 在單獨的線程中發(fā)送文件
        threading.Thread(
            target=self._send_file, 
            args=(ip, file_path, password),
            daemon=True
        ).start()

    def _send_file(self, ip, file_path, password):
        """實際發(fā)送文件的實現(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"? 連接已斷開: {ip}")
                return
            
            sock = self.connections[ip]
            
            # 獲取文件信息
            filename = os.path.basename(file_path)
            filesize = os.path.getsize(file_path)
            
            # 計算文件哈希
            self.log_message(f"?? 正在計算文件哈希...")
            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))
            
            # 獲取偏移量（用于斷點續(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
            }
            
            # 開始傳輸文件
            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
                    
                    # 檢查連接是否超時
                    if time.time() - last_active_time > 30:  # 30秒無活動
                        self.log_message(f"?? 連接超時，嘗試重新連接...")
                        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ā)送塊長度
                        sock.sendall(struct.pack("!Q", len(chunk)))
                        # 發(fā)送實際數(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ā)送失敗超過重試次數(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":
                # 驗證文件哈希
                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"? 文件校驗成功: {filename}")
                    self.file_transfers[transfer_id]['status'] = 'completed'
                else:
                    self.log_message(f"? 文件校驗失敗: {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} 時出錯: {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)} 個傳輸記錄")

    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()
        
        # 停止所有定時器
        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īng)用程序
    sys.exit(app.exec_())