package ws

import (
	"net/http"
	"net/http/httptest"
	"net/url"
	"testing"
	"time"

	"github.com/gin-gonic/gin"
	"github.com/stretchr/testify/assert"
)

func newTestRequest(method, path string) *http.Request {
	req := httptest.NewRequest(method, path, nil)
	return req
}

func TestDefaultHeartbeatConfig(t *testing.T) {
	cfg := DefaultHeartbeatConfig()
	assert.NotNil(t, cfg)
	assert.Equal(t, 30*time.Second, cfg.PingInterval)
	assert.Equal(t, 10*time.Second, cfg.WriteTimeout)
	assert.Equal(t, 10*time.Second, cfg.PresenceRefreshInterval)
	assert.Equal(t, 30*time.Second, cfg.PresenceCleanupInterval)
}

func TestParseWSQueryParams(t *testing.T) {
	query := url.Values{}
	query.Set("account_id", "1")
	query.Set("conversation_id", "42")
	query.Set("inbox_id", "3")
	query.Set("pubsub_token", "abc123")
	query.Set("user_id", "5")
	query.Set("token", "jwt-token")
	query.Set("ignored_param", "should_not_appear")

	params := ParseWSQueryParams(query)

	assert.Equal(t, "1", params["account_id"])
	assert.Equal(t, "42", params["conversation_id"])
	assert.Equal(t, "3", params["inbox_id"])
	assert.Equal(t, "abc123", params["pubsub_token"])
	assert.Equal(t, "5", params["user_id"])
	assert.Equal(t, "jwt-token", params["token"])
	_, exists := params["ignored_param"]
	assert.False(t, exists)
}

func TestParseWSQueryParams_Empty(t *testing.T) {
	query := url.Values{}
	params := ParseWSQueryParams(query)
	assert.Empty(t, params)
}

func TestExtractWSToken_QueryToken(t *testing.T) {
	gin.SetMode(gin.TestMode)
	c, _ := gin.CreateTestContext(nil)
	c.Request = newTestRequest("GET", "/ws?token=abc123")
	token := extractWSToken(c)
	assert.Equal(t, "abc123", token)
}

func TestExtractWSToken_AccessToken(t *testing.T) {
	gin.SetMode(gin.TestMode)
	c, _ := gin.CreateTestContext(nil)
	c.Request = newTestRequest("GET", "/ws?access-token=xyz789")
	token := extractWSToken(c)
	assert.Equal(t, "xyz789", token)
}

func TestExtractWSToken_BearerHeader(t *testing.T) {
	gin.SetMode(gin.TestMode)
	c, _ := gin.CreateTestContext(nil)
	c.Request = newTestRequest("GET", "/ws")
	c.Request.Header.Set("Authorization", "Bearer bearer-token")
	token := extractWSToken(c)
	assert.Equal(t, "bearer-token", token)
}

func TestExtractWSToken_None(t *testing.T) {
	gin.SetMode(gin.TestMode)
	c, _ := gin.CreateTestContext(nil)
	c.Request = newTestRequest("GET", "/ws")
	token := extractWSToken(c)
	assert.Equal(t, "", token)
}

func TestWSClaims_JSON(t *testing.T) {
	claims := WSClaims{
		UserID:    1,
		AccountID: 2,
		Role:      "agent",
	}
	assert.Equal(t, uint(1), claims.UserID)
	assert.Equal(t, uint(2), claims.AccountID)
	assert.Equal(t, "agent", claims.Role)
}