package socketapi

import (
	"net/http"
	"testing"

	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/mock"
	"github.com/stretchr/testify/require"

	"realy.lol/context"
	"realy.lol/envelopes/reqenvelope"
	"realy.lol/event"
	"realy.lol/filter"
	"realy.lol/filters"
	"realy.lol/subscription"
	"realy.lol/ws"
)

func TestA_HandleReq_NoStorage(t *testing.T) {
	mockServer := &MockServer{}
	mockServer.On("Storage").Return(nil)
	mockServer.On("AcceptReq", mock.Anything, mock.Anything, mock.Anything, mock.Anything, "127.0.0.1").
		Return((*filters.T)(nil), true, false)

	// Create a mock listener with a request
	req := &http.Request{}
	mockListener := &ws.Listener{Request: req}

	a := &A{Server: mockServer, Listener: mockListener}

	// Create a proper req envelope with valid filters
	filters, err := filters.GenFilters(1)
	require.NoError(t, err)
	sub := subscription.NewStd()
	env := reqenvelope.NewFrom(sub, filters)
	msg := env.Marshal(nil)

	// Should handle gracefully when no storage
	result := a.HandleReq(context.Bg(), msg, mockServer, "127.0.0.1")

	// Should return empty result
	assert.Empty(t, result)

	mockServer.AssertExpectations(t)
}

func TestA_HandleReq_AcceptReqFalse(t *testing.T) {
	mockServer := &MockServer{}
	mockStore := &MockStore{}

	mockServer.On("Storage").Return(mockStore)
	mockServer.On("AcceptReq", mock.Anything, mock.Anything, mock.Anything, mock.Anything, "127.0.0.1").
		Return((*filters.T)(nil), false, false)

	// Create a mock listener with a request
	req := &http.Request{}
	mockListener := &ws.Listener{Request: req}

	a := &A{Server: mockServer, Listener: mockListener}

	// Create a proper req envelope with valid filters
	filters, err := filters.GenFilters(1)
	require.NoError(t, err)
	sub := subscription.NewStd()
	env := reqenvelope.NewFrom(sub, filters)
	msg := env.Marshal(nil)

	result := a.HandleReq(context.Bg(), msg, mockServer, "127.0.0.1")

	// Should return empty since request was not accepted
	assert.Empty(t, result)

	mockServer.AssertExpectations(t)
}

func TestA_HandleReq_EmptyFilters(t *testing.T) {
	mockServer := &MockServer{}
	mockStore := &MockStore{}

	// Create empty filters
	emptyFilters := filters.New()

	mockServer.On("Storage").Return(mockStore)
	mockServer.On("AcceptReq", mock.Anything, mock.Anything, mock.Anything, mock.Anything, "127.0.0.1").
		Return(emptyFilters, true, false)

	// Create a mock listener with a request
	req := &http.Request{}
	mockListener := &ws.Listener{Request: req}

	a := &A{Server: mockServer, Listener: mockListener}

	// Create a proper req envelope with valid filters
	filters, err := filters.GenFilters(1)
	require.NoError(t, err)
	sub := subscription.NewStd()
	env := reqenvelope.NewFrom(sub, filters)
	msg := env.Marshal(nil)

	result := a.HandleReq(context.Bg(), msg, mockServer, "127.0.0.1")

	// Should return empty since no filters to process
	assert.Empty(t, result)

	mockServer.AssertExpectations(t)
}

func TestA_HandleReq_WithValidFilters(t *testing.T) {
	// Test filter creation and validation
	validFilters := filters.New()
	f := filter.New()
	limit := uint(10)
	f.Limit = &limit
	validFilters.F = []*filter.T{f}

	// Test that filters are properly configured
	assert.NotNil(t, validFilters)
	assert.Len(t, validFilters.F, 1)
	assert.Equal(t, uint(10), *validFilters.F[0].Limit)
}

func TestA_HandleReq_ZeroLimit(t *testing.T) {
	// Test filters with zero limit
	validFilters := filters.New()
	f := filter.New()
	limit := uint(0)
	f.Limit = &limit
	validFilters.F = []*filter.T{f}

	// Test that zero limit is properly set
	assert.NotNil(t, validFilters)
	assert.Len(t, validFilters.F, 1)
	assert.Equal(t, uint(0), *validFilters.F[0].Limit)
}

func TestReqEnvelope_Creation(t *testing.T) {
	// Test req envelope creation
	env := reqenvelope.New()
	assert.NotNil(t, env)

	// Test with subscription
	env.Subscription = subscription.NewStd()
	assert.NotNil(t, env.Subscription)

	// Test with filters
	env.Filters = filters.New()
	assert.NotNil(t, env.Filters)
}

func TestFilterLimits(t *testing.T) {
	// Test various filter limits
	f1 := filter.New()
	limit1 := uint(10)
	f1.Limit = &limit1
	assert.Equal(t, uint(10), *f1.Limit)

	f2 := filter.New()
	limit2 := uint(0)
	f2.Limit = &limit2
	assert.Equal(t, uint(0), *f2.Limit)

	f3 := filter.New()
	assert.Nil(t, f3.Limit)
}

func TestEventSliceOperations(t *testing.T) {
	// Test event slice operations
	events := event.Ts{}
	assert.Len(t, events, 0)

	// Add events
	ev1 := event.New()
	ev2 := event.New()
	events = append(events, ev1, ev2)
	assert.Len(t, events, 2)

	// Test limit logic
	limit := 1
	for i, ev := range events {
		if i >= limit {
			break
		}
		assert.NotNil(t, ev)
	}
}