// Go
type Sendable interface {
    SendBytes(data []byte) error
    SendText(data string) error
}

package main

import (
    "context"
    "fmt"
    "log"
    "net/http"
    "sync"

    "github.com/cloudwego/hertz/pkg/app"
    "github.com/cloudwego/hertz/pkg/app/server"
    "github.com/hertz-contrib/websocket"

    "github.com/geminiwen/how/golang/client"
)

// wsSender implements Sendable for hertz-contrib/websocket.
type wsSender struct {
    conn *websocket.Conn
    mu   sync.Mutex
}

func (s *wsSender) SendBytes(data []byte) error {
    s.mu.Lock()
    defer s.mu.Unlock()
    return s.conn.WriteMessage(websocket.BinaryMessage, data)
}

func (s *wsSender) SendText(data string) error {
    s.mu.Lock()
    defer s.mu.Unlock()
    return s.conn.WriteMessage(websocket.TextMessage, []byte(data))
}

var upgrader = websocket.HertzUpgrader{}

func main() {
    // Option 1: Forward to a local HTTP service
    // (ForwardHandler always streams chunks as they arrive from upstream)
    handler, _ := client.ForwardTo("http://localhost:3000")

    // Option 2: Wrap an http.Handler — buffered by default. Add
    // client.WithStreaming() to forward every w.Write as a separate
    // HTTPResponseChunk, which matters for SSE and other long-lived responses.
    mux := http.NewServeMux()
    mux.HandleFunc("/hello", func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprint(w, "hello")
    })
    handler = client.HTTPHandler(mux)
    // handler = client.HTTPHandler(mux, client.WithStreaming())

    h := server.Default(server.WithHostPorts("0.0.0.0:8888"))
    h.NoHijackConnPool = true

    h.GET("/ws", func(ctx context.Context, c *app.RequestContext) {
        upgrader.Upgrade(c, func(conn *websocket.Conn) {
            sender := &wsSender{conn: conn}
            // Binary mode (default)
            howHandler := client.NewHandler(handler, sender)
            // Or text mode:
            // howHandler := client.NewHandler(handler, sender, client.WithHandlerTextMode())

            for {
                msgType, data, err := conn.ReadMessage()
                if err != nil {
                    log.Println("read:", err)
                    break
                }
                if msgType == websocket.TextMessage {
                    howHandler.HandleTextMessage(ctx, string(data))
                } else {
                    howHandler.HandleBinaryMessage(ctx, data)
                }
            }
        })
    })

    h.Spin()
}

package main

import (
    "context"
    "fmt"
    "io"
    "log"
    "sync"

    "github.com/hertz-contrib/websocket"

    "github.com/geminiwen/how/golang/client"
    "github.com/geminiwen/how/golang/protocol"
)

// wsSender implements Sendable for hertz-contrib/websocket.
type wsSender struct {
    conn *websocket.Conn
    mu   sync.Mutex
}

func (s *wsSender) SendBytes(data []byte) error {
    s.mu.Lock()
    defer s.mu.Unlock()
    return s.conn.WriteMessage(websocket.BinaryMessage, data)
}

func (s *wsSender) SendText(data string) error {
    s.mu.Lock()
    defer s.mu.Unlock()
    return s.conn.WriteMessage(websocket.TextMessage, []byte(data))
}

func main() {
    dialer := websocket.DefaultDialer
    conn, _, err := dialer.Dial("ws://localhost:8888/ws", nil)
    if err != nil {
        log.Fatal("dial:", err)
    }
    defer conn.Close()

    sender := &wsSender{conn: conn}
    // Binary mode (default)
    caller := client.NewCaller(sender)
    // Or text mode:
    // caller := client.NewCaller(sender, client.WithTextMode())

    // Read loop in background
    go func() {
        for {
            msgType, data, err := conn.ReadMessage()
            if err != nil {
                return
            }
            if msgType == websocket.TextMessage {
                caller.HandleTextMessage(context.Background(), string(data))
            } else {
                caller.HandleBinaryMessage(context.Background(), data)
            }
        }
    }()

    // Send a request. resp.Body is an io.ReadCloser that you MUST close —
    // otherwise the pending request leaks until the transport dies, and a
    // finalizer will log a warning.
    resp, err := caller.Request(context.Background(), &protocol.HTTPRequestPayload{
        Method:  "GET",
        URL:     "/hello",
        Headers: map[string][]string{},
    })
    if err != nil {
        log.Fatal(err)
    }
    defer resp.Body.Close()

    body, err := io.ReadAll(resp.Body)
    if err != nil {
        log.Fatal(err)
    }

    fmt.Println(resp.StatusCode)  // 200
    fmt.Println(string(body))     // "hello"
}