package integration

import (
	"encoding/json"
	"fmt"
	"net"
	"testing"
	"time"

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

// TestCodecJSON 测试JSON编解码器
func TestCodecJSON(t *testing.T) {
	listener, err := net.Listen("tcp", "127.0.0.1:0")
	require.NoError(t, err)
	port := listener.Addr().(*net.TCPAddr).Port
	listener.Close()

	cfg := &nnet.Config{
		Addr: fmt.Sprintf("tcp://127.0.0.1:%d", port),
		Codec: &nnet.CodecConfig{
			DefaultCodec:         "json", // 显式指定json用于测试
			EnableProtocolEncode: false,
		},
	}

	ts := StartTestServerWithRoutes(t, cfg, func(srv nnet.Server) {
		srv.Router().RegisterString("json", func(ctx nnet.Context) error {
			return ctx.Response().Write(map[string]any{
				"code":    200,
				"message": "success",
				"data":    "test data",
			})
		})
	})
	defer CleanupTestServer(t, ts)

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

	ConnectTestClient(t, client)
	time.Sleep(100 * time.Millisecond)

	resp := RequestWithTimeout(t, client, []byte("json"), 3*time.Second)
	t.Logf("Response: %q", string(resp))

	var result map[string]any
	err = json.Unmarshal(resp, &result)
	assert.NoError(t, err, "Response should be valid JSON")
	assert.Equal(t, float64(200), result["code"], "Code should be 200")
	assert.Equal(t, "success", result["message"], "Message should be success")
}

// TestCodecBinary 测试二进制编解码器
func TestCodecBinary(t *testing.T) {
	listener, err := net.Listen("tcp", "127.0.0.1:0")
	require.NoError(t, err)
	port := listener.Addr().(*net.TCPAddr).Port
	listener.Close()

	cfg := &nnet.Config{
		Addr: fmt.Sprintf("tcp://127.0.0.1:%d", port),
		Codec: &nnet.CodecConfig{
			DefaultCodec:         "binary",
			EnableProtocolEncode: false,
		},
	}

	ts := StartTestServerWithRoutes(t, cfg, func(srv nnet.Server) {
		srv.Router().RegisterString("binary", func(ctx nnet.Context) error {
			return ctx.Response().WriteBytes([]byte("binary response"))
		})
	})
	defer CleanupTestServer(t, ts)

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

	ConnectTestClient(t, client)
	time.Sleep(100 * time.Millisecond)

	resp := RequestWithTimeout(t, client, []byte("binary"), 3*time.Second)
	t.Logf("Response: %q", string(resp))
	assert.Contains(t, string(resp), "binary response", "Response should contain binary response")
}

// TestRouteNotFound 测试路由未找到
func TestRouteNotFound(t *testing.T) {
	listener, err := net.Listen("tcp", "127.0.0.1:0")
	require.NoError(t, err)
	port := listener.Addr().(*net.TCPAddr).Port
	listener.Close()

	cfg := &nnet.Config{
		Addr: fmt.Sprintf("tcp://127.0.0.1:%d", port),
	}

	ts := StartTestServerWithRoutes(t, cfg, func(srv nnet.Server) {
		srv.Router().RegisterString("hello", func(ctx nnet.Context) error {
			return ctx.Response().WriteString("Hello\n")
		})
	})
	defer CleanupTestServer(t, ts)

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

	ConnectTestClient(t, client)
	time.Sleep(100 * time.Millisecond)

	// 发送一个不存在的路由
	resp, err := client.Request([]byte("notfound\n"), 3*time.Second)
	// 路由未找到时，服务器会发送错误响应
	if err != nil {
		// 如果请求失败（超时等），这也是可以接受的
		assert.Error(t, err, "Request to non-existent route may timeout or return error")
	} else {
		// 如果收到响应，应该包含错误信息
		assert.NotNil(t, resp, "Response should not be nil")
		assert.Contains(t, string(resp), "Route not found", "Response should contain error message")
		t.Logf("Received error response: %q", string(resp))
	}
}