package starnotify

import (
	"context"
	"errors"
	"testing"
	"time"

	"b612.me/notify"
)

func TestUseSignalReliabilityClient(t *testing.T) {
	const key = "signal-reliable-client"
	_ = DeleteClient(key)
	defer DeleteClient(key)

	NewClient(key)
	err := UseSignalReliabilityClient(key, &notify.SignalReliabilityOptions{
		AckTimeout:        50 * time.Millisecond,
		SendRetry:         4,
		ReceiveCacheLimit: 8,
	})
	if err != nil {
		t.Fatalf("UseSignalReliabilityClient failed: %v", err)
	}
}

func TestUseSignalReliabilityServer(t *testing.T) {
	const key = "signal-reliable-server"
	_ = DeleteServer(key)
	defer DeleteServer(key)

	NewServer(key)
	opts := notify.DefaultSignalReliabilityOptions()
	err := UseSignalReliabilityServer(key, &opts)
	if err != nil {
		t.Fatalf("UseSignalReliabilityServer failed: %v", err)
	}
}

func TestUseSignalReliabilityMissingKey(t *testing.T) {
	if err := UseSignalReliabilityClient("missing-client", nil); err == nil {
		t.Fatal("UseSignalReliabilityClient should fail for missing client key")
	}
	if err := UseSignalReliabilityServer("missing-server", nil); err == nil {
		t.Fatal("UseSignalReliabilityServer should fail for missing server key")
	}
}

func TestGetSignalReliabilityStatsByKey(t *testing.T) {
	const clientKey = "signal-reliable-stats-client"
	const serverKey = "signal-reliable-stats-server"
	_ = DeleteClient(clientKey)
	_ = DeleteServer(serverKey)
	defer DeleteClient(clientKey)
	defer DeleteServer(serverKey)

	NewClient(clientKey)
	NewServer(serverKey)

	clientStats, err := GetSignalReliabilityStatsClient(clientKey)
	if err != nil {
		t.Fatalf("GetSignalReliabilityStatsClient failed: %v", err)
	}
	if clientStats != (notify.SignalReliabilityStats{}) {
		t.Fatalf("client stats mismatch: %+v", clientStats)
	}

	serverStats, err := GetSignalReliabilityStatsServer(serverKey)
	if err != nil {
		t.Fatalf("GetSignalReliabilityStatsServer failed: %v", err)
	}
	if serverStats != (notify.SignalReliabilityStats{}) {
		t.Fatalf("server stats mismatch: %+v", serverStats)
	}
}

func TestGetSignalReliabilityStatsMissingKey(t *testing.T) {
	if _, err := GetSignalReliabilityStatsClient("missing-client"); err == nil {
		t.Fatal("GetSignalReliabilityStatsClient should fail for missing key")
	}
	if _, err := GetSignalReliabilityStatsServer("missing-server"); err == nil {
		t.Fatal("GetSignalReliabilityStatsServer should fail for missing key")
	}
}

func TestConnectRetryWrappersContextCanceled(t *testing.T) {
	const clientKey = "signal-reliable-retry-client"
	const serverKey = "signal-reliable-retry-server"
	_ = DeleteClient(clientKey)
	_ = DeleteServer(serverKey)
	defer DeleteClient(clientKey)
	defer DeleteServer(serverKey)

	NewClient(clientKey)
	NewServer(serverKey)

	ctx, cancel := context.WithCancel(context.Background())
	cancel()

	connectErr := ConnectClientWithRetryCtx(ctx, clientKey, "tcp", "127.0.0.1:1", &notify.ConnectRetryOptions{
		MaxAttempts: 3,
		BaseDelay:   time.Millisecond,
		MaxDelay:    time.Millisecond,
	})
	if !errors.Is(connectErr, context.Canceled) {
		t.Fatalf("ConnectClientWithRetryCtx error = %v, want %v", connectErr, context.Canceled)
	}

	listenErr := ListenServerWithRetryCtx(ctx, serverKey, "tcp", "127.0.0.1:1", &notify.ConnectRetryOptions{
		MaxAttempts: 3,
		BaseDelay:   time.Millisecond,
		MaxDelay:    time.Millisecond,
	})
	if !errors.Is(listenErr, context.Canceled) {
		t.Fatalf("ListenServerWithRetryCtx error = %v, want %v", listenErr, context.Canceled)
	}
}