package integration

import (
	"fmt"
	"net"
	"testing"
	"time"

	"github.com/noahlann/nnet/pkg/nnet"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
)

func randomTCPAddr(t *testing.T) string {
	listener, err := net.Listen("tcp", "127.0.0.1:0")
	require.NoError(t, err)
	port := listener.Addr().(*net.TCPAddr).Port
	listener.Close()
	return fmt.Sprintf("tcp://127.0.0.1:%d", port)
}

func TestPresetBuilderIntegration(t *testing.T) {
	addr := randomTCPAddr(t)

	server, err := nnet.NewPreset().
		WithAddress(addr).
		WithRouteString("hello", func(ctx nnet.Context) error {
			return ctx.Response().WriteBytes([]byte("hello preset\n"))
		}).
		Build()
	require.NoError(t, err)

	ts := &TestServer{
		Server: server,
		Addr:   addr,
		stopCh: make(chan struct{}),
	}

	ts.wg.Add(1)
	go func() {
		defer ts.wg.Done()
		if err := server.Start(); err != nil {
			t.Logf("server error: %v", err)
		}
	}()

	require.Eventually(t, func() bool {
		return server.Started()
	}, 3*time.Second, 50*time.Millisecond, "server should start")
	time.Sleep(100 * time.Millisecond)

	defer CleanupTestServer(t, ts)

	client := NewTestClient(t, ts.Addr, nil)
	defer CleanupTestClient(t, client)
	ConnectTestClient(t, client)

	resp := RequestWithTimeout(t, client, []byte("hello"), 3*time.Second)
	assert.Contains(t, string(resp), "hello preset")
}

func TestBroadcastGroupIntegration(t *testing.T) {
	const groupID = "broadcast"
	cfg := &nnet.Config{
		Addr: "tcp://:0",
		Codec: &nnet.CodecConfig{
			DefaultCodec: "json",
		},
	}

	ts := StartTestServerWithRoutes(t, cfg, func(s nnet.Server) {
		connMgr := s.ConnectionManager()

		s.Router().RegisterString("join", func(ctx nnet.Context) error {
			conn := ctx.Connection()
			if err := connMgr.AddToGroup(groupID, conn.ID()); err != nil {
				return err
			}
			return ctx.Response().WriteBytes([]byte("joined\n"))
		})

		s.Router().RegisterString("send", func(ctx nnet.Context) error {
			if err := ctx.Response().WriteBytes([]byte("sent\n")); err != nil {
				return err
			}
			return connMgr.BroadcastToGroup(groupID, []byte("broadcast: hello\n"))
		})
	})
	defer CleanupTestServer(t, ts)

	clientA := NewTestClient(t, ts.Addr, nil)
	defer CleanupTestClient(t, clientA)
	ConnectTestClient(t, clientA)

	clientB := NewTestClient(t, ts.Addr, nil)
	defer CleanupTestClient(t, clientB)
	ConnectTestClient(t, clientB)

	resp := RequestWithTimeout(t, clientA, []byte("join"), 3*time.Second)
	assert.Contains(t, string(resp), "joined")

	resp = RequestWithTimeout(t, clientB, []byte("join"), 3*time.Second)
	assert.Contains(t, string(resp), "joined")

	resp = RequestWithTimeout(t, clientA, []byte("send"), 3*time.Second)
	assert.Contains(t, string(resp), "sent")

	msgA, err := clientA.Receive()
	require.NoError(t, err)
	assert.Contains(t, string(msgA), "broadcast")

	msgB, err := clientB.Receive()
	require.NoError(t, err)
	assert.Contains(t, string(msgB), "broadcast")
}