package testkit

import (
	"context"
	"errors"
	"github.com/stretchr/testify/require"
	"testing"
	"time"

	"galaxy/authsession/internal/domain/common"
	"galaxy/authsession/internal/domain/gatewayprojection"
	"galaxy/authsession/internal/ports"
)

func TestStaticConfigProvider(t *testing.T) {
	t.Parallel()

	limit := 4
	provider := StaticConfigProvider{
		Config: ports.SessionLimitConfig{ActiveSessionLimit: &limit},
	}

	got, err := provider.LoadSessionLimit(context.Background())
	if err != nil {
		require.Failf(t, "test failed", "LoadSessionLimit() returned error: %v", err)
	}
	if got.ActiveSessionLimit == nil || *got.ActiveSessionLimit != limit {
		require.Failf(t, "test failed", "LoadSessionLimit() = %+v, want limit %d", got, limit)
	}
}

func TestSequenceIDGenerator(t *testing.T) {
	t.Parallel()

	generator := &SequenceIDGenerator{
		ChallengeIDs:     []common.ChallengeID{"challenge-queue"},
		DeviceSessionIDs: []common.DeviceSessionID{"device-session-queue"},
	}

	challengeID, err := generator.NewChallengeID()
	if err != nil {
		require.Failf(t, "test failed", "NewChallengeID() returned error: %v", err)
	}
	if challengeID != common.ChallengeID("challenge-queue") {
		require.Failf(t, "test failed", "NewChallengeID() = %q, want queued id", challengeID)
	}

	deviceSessionID, err := generator.NewDeviceSessionID()
	if err != nil {
		require.Failf(t, "test failed", "NewDeviceSessionID() returned error: %v", err)
	}
	if deviceSessionID != common.DeviceSessionID("device-session-queue") {
		require.Failf(t, "test failed", "NewDeviceSessionID() = %q, want queued id", deviceSessionID)
	}
}

func TestFixedCodeGenerator(t *testing.T) {
	t.Parallel()

	generator := FixedCodeGenerator{Code: "123456"}

	got, err := generator.Generate()
	if err != nil {
		require.Failf(t, "test failed", "Generate() returned error: %v", err)
	}
	if got != "123456" {
		require.Failf(t, "test failed", "Generate() = %q, want %q", got, "123456")
	}
}

func TestDeterministicCodeHasher(t *testing.T) {
	t.Parallel()

	hasher := DeterministicCodeHasher{}

	hash, err := hasher.Hash("123456")
	if err != nil {
		require.Failf(t, "test failed", "Hash() returned error: %v", err)
	}

	match, err := hasher.Compare(hash, "123456")
	if err != nil {
		require.Failf(t, "test failed", "Compare() returned error: %v", err)
	}
	if !match {
		require.FailNow(t, "Compare() = false, want true")
	}
}

func TestRecordingMailSender(t *testing.T) {
	t.Parallel()

	sender := &RecordingMailSender{
		Results: []ports.SendLoginCodeResult{
			{Outcome: ports.SendLoginCodeOutcomeSuppressed},
		},
	}

	result, err := sender.SendLoginCode(context.Background(), ports.SendLoginCodeInput{
		Email: common.Email("pilot@example.com"),
		Code:  "654321",
	})
	if err != nil {
		require.Failf(t, "test failed", "SendLoginCode() returned error: %v", err)
	}
	if result.Outcome != ports.SendLoginCodeOutcomeSuppressed {
		require.Failf(t, "test failed", "SendLoginCode().Outcome = %q, want %q", result.Outcome, ports.SendLoginCodeOutcomeSuppressed)
	}
	if len(sender.RecordedInputs()) != 1 {
		require.Failf(t, "test failed", "RecordedInputs() length = %d, want 1", len(sender.RecordedInputs()))
	}
}

func TestRecordingProjectionPublisher(t *testing.T) {
	t.Parallel()

	publisher := &RecordingProjectionPublisher{}
	revokedAt := time.Unix(30, 0).UTC()
	snapshot := gatewayprojection.Snapshot{
		DeviceSessionID:  common.DeviceSessionID("device-session-1"),
		UserID:           common.UserID("user-1"),
		ClientPublicKey:  "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8=",
		Status:           gatewayprojection.StatusRevoked,
		RevokedAt:        &revokedAt,
		RevokeReasonCode: common.RevokeReasonCode("logout_all"),
		RevokeActorType:  common.RevokeActorType("system"),
	}

	if err := publisher.PublishSession(context.Background(), snapshot); err != nil {
		require.Failf(t, "test failed", "PublishSession() returned error: %v", err)
	}
	if len(publisher.PublishedSnapshots()) != 1 {
		require.Failf(t, "test failed", "PublishedSnapshots() length = %d, want 1", len(publisher.PublishedSnapshots()))
	}
}

func TestStaticConfigProviderReturnsConfiguredError(t *testing.T) {
	t.Parallel()

	wantErr := errors.New("config failed")
	provider := StaticConfigProvider{Err: wantErr}

	_, err := provider.LoadSessionLimit(context.Background())
	if !errors.Is(err, wantErr) {
		require.Failf(t, "test failed", "LoadSessionLimit() error = %v, want %v", err, wantErr)
	}
}