package main

import (
	"crypto/sha1"
	"encoding/base64"
	"fmt"
	"net/http"
	"strings"
)

const port = ":9999"

func main() {
	http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("content-Type", "text/plain;charset=utf-8")
		w.WriteHeader(http.StatusOK)
		w.Write([]byte("这个是一个测试websockt"))
	})
	http.HandleFunc("/ws", func(w http.ResponseWriter, r *http.Request) {
		if !strings.EqualFold(r.Header.Get("Upgrade"), "websocket") {
			http.Error(w, "HTTP/1.1 400 Bad Request", http.StatusBadRequest)
			return
		}

		secWsKey := r.Header.Get("Sec-WebSocket-Key")
		if secWsKey == "" {
			http.Error(w, "Missing Sec-WebSocket-Key", http.StatusBadRequest)
			return
		}
		// 生成Accept值
		acceptKey := generateAcceptValue(secWsKey)
		hj, ok := w.(http.Hijacker)
		if !ok {
			http.Error(w, "Webserver doesn't support hijacking", http.StatusInternalServerError)
			return
		}
		conn, bufrw, err := hj.Hijack()
		if err != nil {
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
		defer conn.Close()
		// 构造握手响应
		response := []string{
			"HTTP/1.1 101 Switching Protocols",
			"Upgrade: websocket",
			"Connection: Upgrade",
			"Sec-WebSocket-Accept: " + acceptKey,
			"", // 空行分隔头与主体
			"",
		}
		if _, err := bufrw.WriteString(strings.Join(response, "\r\n")); err != nil {
			return
		}
		bufrw.Flush()
		// 这里可以添加WebSocket数据帧处理逻辑
		fmt.Println("WebSocket连接已建立")
		// 简单保持连接（实际需要处理帧数据）
		select {}
	})
	fmt.Printf("服务器运行在 http://localhost%s\n", port)
	if err := http.ListenAndServe(port, nil); err != nil {
		panic(err)
	}
}

// 生成Sec-WebSocket-Accept值
func generateAcceptValue(challengeKey string) string {
	const magicGUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"
	hash := sha1.New()
	hash.Write([]byte(challengeKey + magicGUID))
	return base64.StdEncoding.EncodeToString(hash.Sum(nil))
}

		 简单保持连接（实际需要处理帧数据）
		for {
			header := make([]byte, 2)
			_, err := io.ReadFull(bufrw, header)
			if err != nil {
				fmt.Println("读取帧头错误:err")
			}
			fin := header[0] & 0x80             // 获取FIN位
			opcode := header[0] & 0x0F          // 获取操作码
			masked := header[1]&0x80 != 0       // 是否有掩码
			payloadLen := int(header[1] & 0x7F) // 负载长度

			fmt.Printf("收到帧: FIN=%t, Opcode=%d, Masked=%t, PayloadLen=%d\n",
				fin, opcode, masked, payloadLen)

			// 处理关闭帧 (0x8)
			if opcode == 0x8 {
				fmt.Println("收到关闭帧，关闭连接")
				return
			}
			if opcode == 0x1 {
				//读取掩码键
				maskKey := make([]byte, 4)
				if masked {
					_, err := io.ReadFull(bufrw, maskKey)
					if err != nil {
						fmt.Println("读取掩码错误:", err)
						return
					}
				}
				// 读取负载数据
				payload := make([]byte, payloadLen)
				_, err := io.ReadFull(bufrw, payload)
				if err != nil {
					fmt.Println("读取负载错误:", err)
					return
				}

				// 解掩码
				if masked {
					for i := 0; i < len(payload); i++ {
						payload[i] ^= maskKey[i%4]
					}
				}

				message := string(payload)
				fmt.Printf("收到消息: %s\n", message)

				// 构造回显响应
				response := createTextFrame("服务器收到: " + message)
				if _, err := conn.Write(response); err != nil {
					fmt.Println("发送响应错误:", err)
					return
				}
				fmt.Println("已发送回显响应")

			} else {
				// 跳过非文本帧
				fmt.Printf("跳过操作码 %d 的帧\n", opcode)
				_, err := bufrw.Discard(payloadLen)
				if err != nil {
					fmt.Println("跳过帧错误:", err)
					return
				}
			}
		}

// 创建文本帧
func createTextFrame(message string) []byte {
	payload := []byte(message)
	frame := make([]byte, 2+len(payload))

	// 设置帧头: FIN=1, Opcode=1 (文本帧)
	frame[0] = 0x81 // 10000001

	// 设置负载长度
	frame[1] = byte(len(payload))

	// 复制负载数据
	copy(frame[2:], payload)

	return frame
}

//main.go
package main

import (
	"flag"
	"log"
	"net/http"
)

var addr = flag.String("addr", ":9999", "http service address")

func serveHome(w http.ResponseWriter, r *http.Request) {
	log.Println(r.URL)
	if r.URL.Path != "/" {
		http.Error(w, "Not found", http.StatusNotFound)
		return
	}
	if r.Method != http.MethodGet {
		http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
		return
	}
	http.ServeFile(w, r, "home.html")
}

func main() {
	flag.Parse()
	hub := newHub()
	go hub.run()
	http.HandleFunc("/", serveHome)
	http.HandleFunc("/ws", func(w http.ResponseWriter, r *http.Request) {
		serveWs(hub, w, r)
	})
	err := http.ListenAndServe(*addr, nil)
	if err != nil {
		log.Fatal("ListenAndServe: ", err)
	}
}

//hub.go
package main

type Hub struct {
	//register clients
	clients map[*Client]bool

	broadcast chan []byte

	register chan *Client

	unregister chan *Client
}

func newHub() *Hub {
	return &Hub{
		clients:    make(map[*Client]bool),
		broadcast:  make(chan []byte),
		register:   make(chan *Client),
		unregister: make(chan *Client),
	}
}

func (h *Hub) run() {
	for {
		select {
		case client := <-h.register:
			h.clients[client] = true
		case client := <-h.unregister:
			if _, ok := h.clients[client]; ok {
				delete(h.clients, client)
				close(client.send)
			}
		case message := <-h.broadcast:
			for client := range h.clients {
				select {
				case client.send <- message:
				default:
					close(client.send)
					delete(h.clients, client)
				}
			}
		}
	}
}

func (c *Conn) SetPongHandler(h func(appData string) error) {
	if h == nil {
		h = func(string) error { return nil }
	}
	c.handlePong = h
}

func (c *Conn) SetPingHandler(h func(appData string) error) {
	if h == nil {
		h = func(message string) error {
			err := c.WriteControl(PongMessage, []byte(message), time.Now().Add(writeWait))
			if err == ErrCloseSent {
				return nil
			} else if e, ok := err.(net.Error); ok && e.Temporary() {
				return nil
			}
			return err
		}
	}
	c.handlePing = h
}

func (u *Upgrader) Upgrade(w http.ResponseWriter, r *http.Request, responseHeader http.Header) (*Conn, error) {
	const badHandshake = "websocket: the client is not using the websocket protocol: "

	if !tokenListContainsValue(r.Header, "Connection", "upgrade") {
		return u.returnError(w, r, http.StatusBadRequest, badHandshake+"'upgrade' token not found in 'Connection' header")
	}

	if !tokenListContainsValue(r.Header, "Upgrade", "websocket") {
		return u.returnError(w, r, http.StatusBadRequest, badHandshake+"'websocket' token not found in 'Upgrade' header")
	}

	if r.Method != http.MethodGet {
		return u.returnError(w, r, http.StatusMethodNotAllowed, badHandshake+"request method is not GET")
	}

	if !tokenListContainsValue(r.Header, "Sec-Websocket-Version", "13") {
		return u.returnError(w, r, http.StatusBadRequest, "websocket: unsupported version: 13 not found in 'Sec-Websocket-Version' header")
	}

	if _, ok := responseHeader["Sec-Websocket-Extensions"]; ok {
		return u.returnError(w, r, http.StatusInternalServerError, "websocket: application specific 'Sec-WebSocket-Extensions' headers are unsupported")
	}

	checkOrigin := u.CheckOrigin
	if checkOrigin == nil {
		checkOrigin = checkSameOrigin
	}
	if !checkOrigin(r) {
		return u.returnError(w, r, http.StatusForbidden, "websocket: request origin not allowed by Upgrader.CheckOrigin")
	}

	challengeKey := r.Header.Get("Sec-Websocket-Key")
	if !isValidChallengeKey(challengeKey) {
		return u.returnError(w, r, http.StatusBadRequest, "websocket: not a websocket handshake: 'Sec-WebSocket-Key' header must be Base64 encoded value of 16-byte in length")
	}

	subprotocol := u.selectSubprotocol(r, responseHeader)

    //me:是否支持压缩功能
	// Negotiate PMCE
	var compress bool
	if u.EnableCompression {
		for _, ext := range parseExtensions(r.Header) {
			if ext[""] != "permessage-deflate" {
				continue
			}
			compress = true
			break
		}
	}

	h, ok := w.(http.Hijacker)
	if !ok {
		return u.returnError(w, r, http.StatusInternalServerError, "websocket: response does not implement http.Hijacker")
	}
	var brw *bufio.ReadWriter
	netConn, brw, err := h.Hijack()
	if err != nil {
		return u.returnError(w, r, http.StatusInternalServerError, err.Error())
	}

	if brw.Reader.Buffered() > 0 {
		netConn.Close()
		return nil, errors.New("websocket: client sent data before handshake is complete")
	}

	var br *bufio.Reader
	if u.ReadBufferSize == 0 && bufioReaderSize(netConn, brw.Reader) > 256 {
		// Reuse hijacked buffered reader as connection reader.
		br = brw.Reader
	}

	buf := bufioWriterBuffer(netConn, brw.Writer)

	var writeBuf []byte
	if u.WriteBufferPool == nil && u.WriteBufferSize == 0 && len(buf) >= maxFrameHeaderSize+256 {
		// Reuse hijacked write buffer as connection buffer.
		writeBuf = buf
	}

//me: 新建这个Conn的连接
	c := newConn(netConn, true, u.ReadBufferSize, u.WriteBufferSize, u.WriteBufferPool, br, writeBuf)
	c.subprotocol = subprotocol

	if compress {
		c.newCompressionWriter = compressNoContextTakeover
		c.newDecompressionReader = decompressNoContextTakeover
	}

	// Use larger of hijacked buffer and connection write buffer for header.
	p := buf
	if len(c.writeBuf) > len(p) {
		p = c.writeBuf
	}
	p = p[:0]

	p = append(p, "HTTP/1.1 101 Switching Protocols\r\nUpgrade: websocket\r\nConnection: Upgrade\r\nSec-WebSocket-Accept: "...)
	p = append(p, computeAcceptKey(challengeKey)...)
	p = append(p, "\r\n"...)
	if c.subprotocol != "" {
		p = append(p, "Sec-WebSocket-Protocol: "...)
		p = append(p, c.subprotocol...)
		p = append(p, "\r\n"...)
	}
	if compress {
		p = append(p, "Sec-WebSocket-Extensions: permessage-deflate; server_no_context_takeover; client_no_context_takeover\r\n"...)
	}
	for k, vs := range responseHeader {
		if k == "Sec-Websocket-Protocol" {
			continue
		}
		for _, v := range vs {
			p = append(p, k...)
			p = append(p, ": "...)
			for i := 0; i < len(v); i++ {
				b := v[i]
				if b <= 31 {
					// prevent response splitting.
					b = ' '
				}
				p = append(p, b)
			}
			p = append(p, "\r\n"...)
		}
	}
	p = append(p, "\r\n"...)

	// Clear deadlines set by HTTP server.
	netConn.SetDeadline(time.Time{})

    //me: 设置握手写入超时
	if u.HandshakeTimeout > 0 {
		netConn.SetWriteDeadline(time.Now().Add(u.HandshakeTimeout))
	}
    //me: p 是准备好的 WebSocket 握手响应数据（HTTP 101 状态码和协议升级头）
	if _, err = netConn.Write(p); err != nil {
		netConn.Close()
		return nil, err
	}
    //me: 成功写入握手响应后，立即清除写超时设置
	if u.HandshakeTimeout > 0 {
		netConn.SetWriteDeadline(time.Time{})
	}

	return c, nil
}

var brw *bufio.ReadWriter
netConn, brw, err := h.Hijack()
if err != nil {
	return u.returnError(w, r, http.StatusInternalServerError, err.Error())
}

if brw.Reader.Buffered() > 0 {
	netConn.Close()
	return nil, errors.New("websocket: client sent data before handshake is complete")
}

var br *bufio.Reader
if u.ReadBufferSize == 0 && bufioReaderSize(netConn, brw.Reader) > 256 {
	// Reuse hijacked buffered reader as connection reader.
	br = brw.Reader
}