// zinx/znet/connection.go

type Connection struct {
    // Current TCP socket connection
    Conn *net.TCPConn
    // Unique ID for the connection, also known as SessionID
    ConnID uint32
    // Connection close status
    isClosed bool
    // Message handler module that manages message IDs and corresponding processing methods
    MsgHandler ziface.IMsgHandle
    // Channel to signal that the connection has exited/stopped
    ExitBuffChan chan bool
    // Unbuffered channel for message communication between the read and write Goroutines
    msgChan chan []byte
}

// Create a connection method
func NewConnection(conn *net.TCPConn, connID uint32, msgHandler ziface.IMsgHandle) *Connection {
    c := &Connection{
        Conn:          conn,
        ConnID:        connID,
        isClosed:      false,
        MsgHandler:    msgHandler,
        ExitBuffChan:  make(chan bool, 1),
        msgChan:       make(chan []byte), // Initialize msgChan
    }

    return c
}

// zinx/znet/connection.go

/*
    Writer Goroutine: Sends data to the client
*/
func (c *Connection) StartWriter() {
    fmt.Println("[Writer Goroutine is running]")
    defer fmt.Println(c.RemoteAddr().String(), "[conn Writer exit!]")

    for {
        select {
        case data := <-c.msgChan:
            // Data to be written to the client
            if _, err := c.Conn.Write(data); err != nil {
                fmt.Println("Send Data error:", err, "Conn Writer exit")
                return
            }
        case <-c.ExitBuffChan:
            // Connection has been closed
            return
        }
    }
}

// zinx/znet/connection.go

// Send Message: Send message data directly to the remote TCP client
func (c *Connection) SendMsg(msgID uint32, data []byte) error {
    if c.isClosed == true {
        return errors.New("Connection closed when sending message")
    }

    // Package the data and send it
    dp := NewDataPack()
    msg, err := dp.Pack(NewMsgPackage(msgID, data))
    if err != nil {
        fmt.Println("Pack error, msgID =", msgID)
        return errors.New("Pack error message")
    }

    // Write back to the client
    // Change the previous direct write using conn.Write to sending the message to the Channel for the Writer to read
    c.msgChan <- msg

    return nil
}

// zinx/znet/connection.go

// Start the connection and make it work
func (c *Connection) Start() {
    // 1. Start a Goroutine for reading data from the client
    go c.StartReader()
    // 2. Start a Goroutine for writing data back to the client
    go c.StartWriter()

    for {
        select {
        case <-c.ExitBuffChan:
            // Received exit message, no longer block
            return
        }
    }
}