package notify

import (
	"b612.me/stario"
	"context"
	"errors"
	"math"
	"net"
	"testing"
)

func TestClientEncodeEnvelopeRequiresRuntimeQueue(t *testing.T) {
	client := NewClient().(*ClientCommon)
	UseLegacySecurityClient(client)

	_, err := client.encodeEnvelope(newSignalAckEnvelope(1))
	if !errors.Is(err, errClientSessionQueueUnavailable) {
		t.Fatalf("client encodeEnvelope error = %v, want %v", err, errClientSessionQueueUnavailable)
	}
}

func TestServerEncodeEnvelopeRequiresRuntimeQueue(t *testing.T) {
	server := NewServer().(*ServerCommon)
	UseLegacySecurityServer(server)
	client := newServerCodecClientConnForTest(server)

	_, err := server.encodeEnvelope(client, newSignalAckEnvelope(1))
	if !errors.Is(err, errServerSessionQueueUnavailable) {
		t.Fatalf("server encodeEnvelope error = %v, want %v", err, errServerSessionQueueUnavailable)
	}
}

func TestClientEncodeEnvelopeUsesRuntimeQueue(t *testing.T) {
	client := NewClient().(*ClientCommon)
	UseLegacySecurityClient(client)
	stopCtx, stopFn := context.WithCancel(context.Background())
	defer stopFn()
	client.setClientSessionRuntime(&clientSessionRuntime{
		stopCtx: stopCtx,
		stopFn:  stopFn,
		queue:   stario.NewQueueCtx(stopCtx, 4, math.MaxUint32),
		epoch:   1,
	})

	data, err := client.encodeEnvelope(newSignalAckEnvelope(2))
	if err != nil {
		t.Fatalf("client encodeEnvelope failed: %v", err)
	}
	if len(data) == 0 {
		t.Fatal("client encodeEnvelope should return framed payload")
	}
}

func TestServerEncodeEnvelopeUsesRuntimeQueue(t *testing.T) {
	server := NewServer().(*ServerCommon)
	UseLegacySecurityServer(server)
	stopCtx, stopFn := context.WithCancel(context.Background())
	defer stopFn()
	server.setServerSessionRuntime(&serverSessionRuntime{
		stopCtx: stopCtx,
		stopFn:  stopFn,
		queue:   stario.NewQueueCtx(stopCtx, 4, math.MaxUint32),
	})
	client := newServerCodecClientConnForTest(server)

	data, err := server.encodeEnvelope(client, newSignalAckEnvelope(3))
	if err != nil {
		t.Fatalf("server encodeEnvelope failed: %v", err)
	}
	if len(data) == 0 {
		t.Fatal("server encodeEnvelope should return framed payload")
	}
}

func TestClientEncodeEnvelopeUsesPreservedQueueAfterTransportClear(t *testing.T) {
	client := NewClient().(*ClientCommon)
	UseLegacySecurityClient(client)
	stopCtx, stopFn := context.WithCancel(context.Background())
	defer stopFn()
	queue := stario.NewQueueCtx(stopCtx, 4, math.MaxUint32)
	left, right := net.Pipe()
	defer left.Close()
	defer right.Close()
	client.setClientSessionRuntime(&clientSessionRuntime{
		conn:    left,
		stopCtx: stopCtx,
		stopFn:  stopFn,
		queue:   queue,
		epoch:   2,
	})

	client.clearClientSessionRuntimeTransport()

	data, err := client.encodeEnvelope(newSignalAckEnvelope(4))
	if err != nil {
		t.Fatalf("client encodeEnvelope failed after transport clear: %v", err)
	}
	if len(data) == 0 {
		t.Fatal("client encodeEnvelope should return framed payload after transport clear")
	}
}