# -*- coding: utf-8 -*-

# File            :  SockerSever(大模型版） .py
# Author          :  无忆江南
# Create Time     :  2026/5/8 17:39 
# Python Version  :  3.18.12
# "    ————when it is dark enough ,we can see the stars."
import tkinter as tk
from tkinter import scrolledtext, ttk, filedialog
import socket
import threading

# ===================== 【修复：支持中文的通用凯撒加密/解密】 =====================
# 对所有字符（中文、英文、数字、符号）进行移位加密，无字符限制
def caesar_encrypt(text, shift=3):
    encrypted = ""
    for char in text:
        # 直接对字符的Unicode编码进行移位
        encrypted += chr(ord(char) + shift)
    return encrypted

def caesar_decrypt(text, shift=3):
    decrypted = ""
    for char in text:
        decrypted += chr(ord(char) - shift)
    return decrypted
# ==============================================================================

class TCPServerGUI:
    def __init__(self, root):
        self.root = root
        self.root.title("TCP 服务端（加密通信+文件传输）")
        self.root.geometry("750x700")

        self.server_socket = None
        self.is_running = False
        self.clients = {}  # {客户端地址: 套接字}

        self.create_widgets()

    def create_widgets(self):
        # 顶部控制栏
        top_frame = ttk.Frame(self.root)
        top_frame.pack(pady=10, fill=tk.X)
        ttk.Label(top_frame, text="监听端口：").pack(side=tk.LEFT, padx=5)
        self.port_entry = ttk.Entry(top_frame, width=10)
        self.port_entry.insert(0, "8888")
        self.port_entry.pack(side=tk.LEFT, padx=5)
        self.start_btn = ttk.Button(top_frame, text="启动监听", command=self.start_server)
        self.start_btn.pack(side=tk.LEFT, padx=5)
        self.stop_btn = ttk.Button(top_frame, text="停止监听", command=self.stop_server, state=tk.DISABLED)
        self.stop_btn.pack(side=tk.LEFT, padx=5)

        # 客户端选择栏
        client_frame = ttk.Frame(self.root)
        client_frame.pack(pady=5, fill=tk.X)
        ttk.Label(client_frame, text="选择客户端：").pack(side=tk.LEFT, padx=5)
        self.client_combobox = ttk.Combobox(client_frame, width=30, state="readonly")
        self.client_combobox.pack(side=tk.LEFT, padx=5)
        self.broadcast_btn = ttk.Button(client_frame, text="广播消息", command=self.broadcast_msg, state=tk.DISABLED)
        self.broadcast_btn.pack(side=tk.LEFT, padx=5)

        # 消息发送栏
        send_frame = ttk.Frame(self.root)
        send_frame.pack(pady=5, fill=tk.X)
        ttk.Label(send_frame, text="输入明文：").pack(side=tk.LEFT, padx=5)
        self.send_entry = ttk.Entry(send_frame, width=40)
        self.send_entry.pack(side=tk.LEFT, padx=5, fill=tk.X, expand=True)
        self.send_btn = ttk.Button(send_frame, text="发送加密消息", command=self.send_to_client, state=tk.DISABLED)
        self.send_btn.pack(side=tk.LEFT, padx=5)
        self.file_btn = ttk.Button(send_frame, text="选择并发送文件", command=self.send_file, state=tk.DISABLED)
        self.file_btn.pack(side=tk.LEFT, padx=5)

        # 日志区域
        ttk.Label(self.root, text="通信日志（明文+密文+文件）：").pack(anchor=tk.W, padx=10)
        self.msg_text = scrolledtext.ScrolledText(self.root, width=90, height=35)
        self.msg_text.pack(pady=5, padx=10, fill=tk.BOTH, expand=True)

    def log(self, msg):
        self.msg_text.insert(tk.END, msg + "\n")
        self.msg_text.see(tk.END)

    def update_client_list(self):
        client_list = [str(addr) for addr in self.clients.keys()]
        self.client_combobox["values"] = client_list
        if client_list:
            self.client_combobox.current(0)
            self.send_btn.config(state=tk.NORMAL)
            self.broadcast_btn.config(state=tk.NORMAL)
            self.file_btn.config(state=tk.NORMAL)
        else:
            self.client_combobox.set("")
            self.send_btn.config(state=tk.DISABLED)
            self.broadcast_btn.config(state=tk.DISABLED)
            self.file_btn.config(state=tk.DISABLED)

    # 启动服务端
    def start_server(self):
        port = int(self.port_entry.get())
        self.is_running = True
        self.server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self.server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
        try:
            self.server_socket.bind(("0.0.0.0", port))
            self.server_socket.listen(5)
            self.log(f"✅ 服务端启动成功，端口：{port}")
            self.start_btn.config(state=tk.DISABLED)
            self.stop_btn.config(state=tk.NORMAL)
            threading.Thread(target=self.accept_clients, daemon=True).start()
        except Exception as e:
            self.log(f"❌ 启动失败：{str(e)}")

    # 接受客户端连接
    def accept_clients(self):
        while self.is_running:
            try:
                client_sock, addr = self.server_socket.accept()
                self.clients[addr] = client_sock
                self.log(f"🔗 新客户端连接：{addr}")
                self.update_client_list()
                threading.Thread(target=self.handle_client, args=(client_sock, addr), daemon=True).start()
            except Exception:
                break

    # 处理消息/文件（接收+解密）
    def handle_client(self, client_sock, addr):
        while self.is_running:
            try:
                data = client_sock.recv(4096).decode("utf-8")
                if not data: break

                if data.startswith("FILE:"):
                    _, filename, cipher_content = data.split(":", 2)
                    plain_content = caesar_decrypt(cipher_content)
                    save_path = f"接收_服务端_{filename}"
                    with open(save_path, "w", encoding="utf-8") as f:
                        f.write(plain_content)
                    self.log(f"📂 收到 {addr} 文件：{filename}")
                    self.log(f"🔒 文件密文：{cipher_content[:50]}...")
                    self.log(f"🔓 文件明文：{plain_content[:50]}...")
                    self.log(f"✅ 文件已保存：{save_path}\n")
                else:
                    plain_text = caesar_decrypt(data)
                    self.log(f"📩 收到 {addr} 密文：{data}")
                    self.log(f"🔓 解密后明文：{plain_text}\n")
            except Exception as e:
                self.log(f"❌ 接收错误：{str(e)}")
                break
        del self.clients[addr]
        client_sock.close()
        self.log(f"❌ 客户端断开：{addr}")
        self.update_client_list()

    # 发送文本消息
    def send_to_client(self):
        try:
            selected_addr = eval(self.client_combobox.get())
            client_sock = self.clients[selected_addr]
            plain_text = self.send_entry.get().strip()
            if not plain_text: return

            cipher_text = caesar_encrypt(plain_text)
            client_sock.send(cipher_text.encode("utf-8"))

            self.log(f"📤 发送 {selected_addr} 明文：{plain_text}")
            self.log(f"🔒 加密密文：{cipher_text}\n")
            self.send_entry.delete(0, tk.END)
        except Exception as e:
            self.log(f"❌ 发送失败：{str(e)}")

    # 发送文件（加密传输）
    def send_file(self):
        try:
            selected_addr = eval(self.client_combobox.get())
            client_sock = self.clients[selected_addr]
            file_path = filedialog.askopenfilename(title="选择要发送的文件", filetypes=[("文本文件", "*.txt"), ("所有文件", "*.*")])
            if not file_path: return
            filename = file_path.split("/")[-1].split("\\")[-1]

            with open(file_path, "r", encoding="utf-8") as f:
                plain_content = f.read()
            cipher_content = caesar_encrypt(plain_content)

            send_data = f"FILE:{filename}:{cipher_content}"
            client_sock.send(send_data.encode("utf-8"))

            self.log(f"📤 发送文件到 {selected_addr}：{filename}")
            self.log(f"🔒 文件密文：{cipher_content[:50]}...")
            self.log(f"🔓 文件明文：{plain_content[:50]}...")
            self.log(f"✅ 文件发送成功！\n")
        except Exception as e:
            self.log(f"❌ 文件发送失败：{str(e)}")

    # 广播消息
    def broadcast_msg(self):
        plain_text = self.send_entry.get().strip()
        if not plain_text: return
        cipher_text = caesar_encrypt(plain_text)
        try:
            for addr, sock in self.clients.items():
                sock.send(cipher_text.encode("utf-8"))
            self.log(f"📢 广播明文：{plain_text}")
            self.log(f"🔒 广播密文：{cipher_text}\n")
            self.send_entry.delete(0, tk.END)
        except Exception as e:
            self.log(f"❌ 广播失败：{str(e)}")

    # 停止服务端
    def stop_server(self):
        self.is_running = False
        for sock in self.clients.values(): sock.close()
        self.server_socket.close()
        self.log("🛑 服务端已停止")
        self.start_btn.config(state=tk.NORMAL)
        self.stop_btn.config(state=tk.DISABLED)
        self.update_client_list()

if __name__ == "__main__":
    root = tk.Tk()
    app = TCPServerGUI(root)
    root.mainloop()