package store

import (
	"bytes"
	"context"
	"crypto/sha256"
	"errors"
	"path/filepath"
	"testing"
	"time"

	"github.com/klauspost/compress/zstd"
	"github.com/rvbox/rvbox/internal/domain"
)

func TestQueueCommandDurableIdempotency_HP_DISPATCH_01(t *testing.T) {
	t.Parallel()
	ctx := context.Background()
	opened, err := Open(ctx, Options{DataDir: filepath.Join(t.TempDir(), "state"), BusyTimeout: time.Second})
	if err != nil {
		t.Fatal(err)
	}
	t.Cleanup(func() { _ = opened.Close() })
	if _, err := opened.RegisterClientSession(ctx, ClientRegistration{
		ClientID: "win-client", Platform: 2, Architecture: "amd64", DaemonVersion: "test", DaemonCWD: `C:\`, SupportedShells: []byte{1},
		ClientInstanceID: [16]byte{1}, SessionID: [16]byte{2}, ConnectedAt: time.Date(2026, time.September, 6, 12, 0, 0, 0, time.UTC),
	}); err != nil {
		t.Fatal(err)
	}
	issue, err := domain.ParseUUIDv7("019c46f1-1d02-7000-8000-000000000091")
	if err != nil {
		t.Fatal(err)
	}
	immutable := sha256.Sum256([]byte("queue immutable request"))
	now := time.Date(2026, time.September, 6, 12, 0, 1, 0, time.UTC)
	input := QueueCommandInput{IssueUUID: issue, ClientID: "win-client", IssueTime: now, ReceiptTime: now, ImmutableSHA256: immutable, ExecutionSpec: []byte("serialized execution spec")}
	queued, err := opened.QueueCommand(ctx, input)
	if err != nil || queued.Duplicate || queued.Lifecycle != 1 || queued.Revision != 1 {
		t.Fatalf("initial queue = %#v, %v", queued, err)
	}
	duplicate, err := opened.QueueCommand(ctx, input)
	if err != nil || !duplicate.Duplicate || duplicate.Lifecycle != 1 || duplicate.Revision != 1 {
		t.Fatalf("idempotent queue = %#v, %v", duplicate, err)
	}
	var stored []byte
	var compression, rawBytes, storedBytes uint64
	if err := opened.DB().QueryRow(`SELECT execution_spec, execution_spec_compression, execution_spec_raw_bytes, execution_spec_stored_bytes FROM commands WHERE issue_uuid = ?`, issue[:]).Scan(&stored, &compression, &rawBytes, &storedBytes); err != nil {
		t.Fatal(err)
	}
	decoder, err := zstd.NewReader(nil, zstd.WithDecoderConcurrency(1))
	if err != nil {
		t.Fatal(err)
	}
	decompressed, err := decoder.DecodeAll(stored, nil)
	decoder.Close()
	if err != nil || !bytes.Equal(decompressed, input.ExecutionSpec) || compression != 2 || rawBytes != uint64(len(input.ExecutionSpec)) || storedBytes != uint64(len(stored)) {
		t.Fatalf("stored command = raw=%q compression=%d sizes=%d/%d err=%v", decompressed, compression, rawBytes, storedBytes, err)
	}
	different := input
	different.ImmutableSHA256 = sha256.Sum256([]byte("different request"))
	if _, err := opened.QueueCommand(ctx, different); !errors.Is(err, ErrCommandConflict) {
		t.Fatalf("conflicting UUID error = %v", err)
	}
	different = input
	different.IssueUUID, err = domain.ParseUUIDv7("019c46f1-1d02-7000-8000-000000000092")
	if err != nil {
		t.Fatal(err)
	}
	different.ClientID = "missing-client"
	if _, err := opened.QueueCommand(ctx, different); !errors.Is(err, ErrClientNotFound) {
		t.Fatalf("missing client error = %v", err)
	}
}

func TestClaimDispatchExpiresAndFencesRequeue_HP_DISPATCH_02(t *testing.T) {
	t.Parallel()
	ctx := context.Background()
	opened, err := Open(ctx, Options{DataDir: filepath.Join(t.TempDir(), "state"), BusyTimeout: time.Second})
	if err != nil {
		t.Fatal(err)
	}
	t.Cleanup(func() { _ = opened.Close() })
	if _, err := opened.RegisterClientSession(ctx, ClientRegistration{
		ClientID: "win-client", Platform: 2, Architecture: "amd64", DaemonVersion: "test", DaemonCWD: `C:\`, SupportedShells: []byte{1},
		ClientInstanceID: [16]byte{3}, SessionID: [16]byte{4}, ConnectedAt: time.Date(2026, time.September, 6, 12, 0, 0, 0, time.UTC),
	}); err != nil {
		t.Fatal(err)
	}
	now := time.Date(2026, time.September, 6, 12, 0, 1, 0, time.UTC)
	expiredIssue, err := domain.ParseUUIDv7("019c46f1-1d02-7000-8000-000000000093")
	if err != nil {
		t.Fatal(err)
	}
	queuedIssue, err := domain.ParseUUIDv7("019c46f1-1d02-7000-8000-000000000094")
	if err != nil {
		t.Fatal(err)
	}
	for _, input := range []QueueCommandInput{
		{IssueUUID: expiredIssue, ClientID: "win-client", IssueTime: now.Add(-time.Minute), ReceiptTime: now.Add(-time.Minute), QueueExpiryTime: timePtr(now.Add(-time.Second)), ImmutableSHA256: sha256.Sum256([]byte("expired")), ExecutionSpec: []byte("expired spec")},
		{IssueUUID: queuedIssue, ClientID: "win-client", IssueTime: now, ReceiptTime: now, ImmutableSHA256: sha256.Sum256([]byte("queued")), ExecutionSpec: []byte("queued spec")},
	} {
		if _, err := opened.QueueCommand(ctx, input); err != nil {
			t.Fatal(err)
		}
	}
	candidate, err := opened.ClaimNextDispatch(ctx, "win-client", 7, now)
	if err != nil || candidate == nil || candidate.IssueUUID != queuedIssue || candidate.Revision != 1 || string(candidate.ExecutionSpec) != "queued spec" {
		t.Fatalf("dispatch candidate = %#v, %v", candidate, err)
	}
	if requeued, err := opened.RequeueDispatch(ctx, queuedIssue, "win-client", 6); err != nil || requeued {
		t.Fatalf("stale requeue = %t, %v", requeued, err)
	}
	if requeued, err := opened.RequeueDispatch(ctx, queuedIssue, "win-client", 7); err != nil || !requeued {
		t.Fatalf("owned requeue = %t, %v", requeued, err)
	}
	candidate, err = opened.ClaimNextDispatch(ctx, "win-client", 8, now)
	if err != nil || candidate == nil || candidate.IssueUUID != queuedIssue {
		t.Fatalf("reclaimed candidate = %#v, %v", candidate, err)
	}
	var lifecycle, revision uint64
	if err := opened.DB().QueryRow(`SELECT lifecycle, revision FROM commands WHERE issue_uuid = ?`, expiredIssue[:]).Scan(&lifecycle, &revision); err != nil || lifecycle != 10 || revision != 2 {
		t.Fatalf("expired command lifecycle/revision = %d/%d, %v", lifecycle, revision, err)
	}
}

func timePtr(value time.Time) *time.Time { return &value }