package main

import (
  "log"

  pb "github.com/acoBOYZ/grpc-pipe-go/gen"
  "github.com/acoBOYZ/grpc-pipe-go/pipe"
  gs "github.com/acoBOYZ/grpc-pipe-go/server"
	"google.golang.org/grpc"
	"google.golang.org/grpc/keepalive"
)

func main() {
  reg := /* your SchemaRegistry (protobuf) or nil for JSON */
  srv := gs.New(gs.Options{
    Host:          "0.0.0.0",
    Port:          50061,
    Serialization: pipe.SerializationProtobuf, // or pipe.SerializationJSON
    Registry:      reg,
    Compression:   pipe.CompressionSnappy, // false | pipe.Snappy | pipe.Gzip (true means pipe.Snappy)
    Heartbeat:     false,
    ServerOptions: []grpc.ServerOption{
			grpc.WriteBufferSize(1 << 20),
			grpc.ReadBufferSize(1 << 20),
			grpc.InitialWindowSize(1 << 20),
			grpc.InitialConnWindowSize(1 << 20),
			grpc.KeepaliveParams(keepalive.ServerParameters{
				Time:    10 * time.Second,
				Timeout: 5 * time.Second,
			}),
			grpc.KeepaliveEnforcementPolicy(keepalive.EnforcementPolicy{
				MinTime:             20 * time.Second,
				PermitWithoutStream: true,
			}),
		},
    OnConnection: func(ph *pipe.PipeHandler) {
      log.Printf("[SERVER] client connected")
      ph.On("ping", func(v any) {
        if ping, ok := v.(*pb.Ping); ok {
          _ = ph.Post("pong", &pb.Pong{Message: ping.Message})
        }
      })
    },
		OnDisconnect: func(ph *pipe.PipeHandler) {
			log.Printf("[SERVER] Client disconnected")
		},
    OnError: func(where string, err error) {
      log.Printf("[SERVER][%s] %v", where, err)
    },
  })

	log.Printf("[SERVER] Ready.")
	srv.Start()
}

package main

import (
  "context"
  "log"
  "time"

  pb "github.com/acoBOYZ/grpc-pipe-go/gen"
  gc "github.com/acoBOYZ/grpc-pipe-go/client"
  "github.com/acoBOYZ/grpc-pipe-go/pipe"
	"google.golang.org/grpc"
	"google.golang.org/grpc/keepalive"
)

func main() {
  reg := /* your SchemaRegistry (protobuf) or nil for JSON */

  client, err := gc.New("localhost:50061", gc.Options{
    DialOptions: []grpc.DialOption{
      grpc.WithWriteBufferSize(4 << 20),
      grpc.WithReadBufferSize(4 << 20),
      grpc.WithInitialWindowSize(32 << 20),     // per-stream
      grpc.WithInitialConnWindowSize(64 << 20), // per-connection
      grpc.WithDefaultCallOptions(
        grpc.MaxCallRecvMsgSize(64<<20),
        grpc.MaxCallSendMsgSize(64<<20),
      ),
      grpc.WithKeepaliveParams(keepalive.ClientParameters{
        Time:                20 * time.Second,
        Timeout:             10 * time.Second,
        PermitWithoutStream: true,
      }),
    }
    Insecure: true,
    Metadata: map[string]string{
      "clientId": "client_go:123",
    },
    Serialization: pipe.SerializationProtobuf, // or JSON
    Registry:      reg,
    Compression:   pipe.CompressionSnappy, // false | pipe.Snappy | pipe.Gzip (true means pipe.Snappy)
    BackpressureThresholdBytes: 5 << 20,
    OnConnected: func(ph *pipe.PipeHandler) {
      log.Println("[CLIENT] connected")
      ph.On("pong", func(v any) {
        if pong, ok := v.(*pb.Pong); ok {
          log.Printf("got pong: %s", pong.Message)
        }
      })
      _ = ph.Post("ping", &pb.Ping{Message: "Hello from Go"})
    },
    OnDisconnected: func() {
      log.Println("[CLIENT] disconnected")
    },
    OnError: func(where string, err error) {
      log.Printf("[CLIENT][%s] %v", where, err)
    },

		// reconnection behavior
    ReconnectBaseDelay: 2 * time.Second,
    MaxReconnectDelay:  30 * time.Second,
  })
  if err != nil {
    log.Fatal(err)
  }

  client.Start(context.Background())
  select {}
}