package store

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

	rvboxv1 "github.com/rvbox/rvbox/gen/go/rvbox/v1"
	"github.com/rvbox/rvbox/internal/domain"
)

func TestReconcileSnapshotMutatesMissingAndRetargets_HP_SES_13(t *testing.T) {
	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: "reconcile-client", Platform: 3, Architecture: "amd64", DaemonVersion: "test", DaemonCWD: `C:\`, SupportedShells: []byte{1}, ClientInstanceID: [16]byte{1}, SessionID: [16]byte{2}, ConnectedAt: time.Now().UTC()}); err != nil {
		t.Fatal(err)
	}
	if _, err := opened.RegisterClientSession(ctx, ClientRegistration{ClientID: "reconcile-active", Platform: 3, Architecture: "amd64", DaemonVersion: "test", DaemonCWD: `C:\`, SupportedShells: []byte{1}, ClientInstanceID: [16]byte{3}, SessionID: [16]byte{4}, ConnectedAt: time.Now().UTC()}); err != nil {
		t.Fatal(err)
	}
	now := time.Now().UTC()
	queued := mustReconcileIssue(t, "019c46f1-1d02-7000-8000-0000000000c1")
	if _, err := opened.QueueCommand(ctx, QueueCommandInput{IssueUUID: queued, ClientID: "reconcile-client", IssueTime: now, ReceiptTime: now, ImmutableSHA256: sha256.Sum256([]byte("queued")), ExecutionSpec: []byte("opaque")}); err != nil {
		t.Fatal(err)
	}
	if _, err := opened.ClaimNextDispatch(ctx, "reconcile-client", 1, now); err != nil {
		t.Fatal(err)
	}
	result, err := opened.ReconcileClientSnapshotForSession(ctx, "reconcile-client", 2, &rvboxv1.ReconcileSnapshot{})
	if err != nil || len(result.GetTerminateLocalIssueUuids()) != 0 {
		t.Fatalf("missing dispatched result = %#v, %v", result, err)
	}
	var lifecycle uint32
	var target any
	if err := opened.DB().QueryRowContext(ctx, `SELECT lifecycle, target_session_generation FROM commands WHERE issue_uuid = ?`, queued[:]).Scan(&lifecycle, &target); err != nil {
		t.Fatal(err)
	}
	if lifecycle != uint32(rvboxv1.CommandLifecycle_COMMAND_QUEUED) || target != nil {
		t.Fatalf("missing dispatched command = lifecycle=%d target=%v", lifecycle, target)
	}

	active := mustReconcileIssue(t, "019c46f1-1d02-7000-8000-0000000000c2")
	if _, err := opened.QueueCommand(ctx, QueueCommandInput{IssueUUID: active, ClientID: "reconcile-active", IssueTime: now.Add(time.Second), ReceiptTime: now.Add(time.Second), ImmutableSHA256: sha256.Sum256([]byte("active")), ExecutionSpec: []byte("opaque")}); err != nil {
		t.Fatal(err)
	}
	if _, err := opened.ClaimNextDispatch(ctx, "reconcile-active", 1, now.Add(time.Second)); err != nil {
		t.Fatal(err)
	}
	if _, err := opened.RecordCommandAcceptance(ctx, active, "reconcile-active", 1, 1, true, now.Add(2*time.Second)); err != nil {
		t.Fatal(err)
	}
	result, err = opened.ReconcileClientSnapshotForSession(ctx, "reconcile-active", 2, &rvboxv1.ReconcileSnapshot{})
	if err != nil || len(result.GetTerminateLocalIssueUuids()) != 0 {
		t.Fatalf("missing accepted result = %#v, %v", result, err)
	}
	if err := opened.DB().QueryRowContext(ctx, `SELECT lifecycle, revision, target_session_generation FROM commands WHERE issue_uuid = ?`, active[:]).Scan(&lifecycle, new(uint64), &target); err != nil {
		t.Fatal(err)
	}
	if lifecycle != uint32(rvboxv1.CommandLifecycle_COMMAND_INTERRUPTED) || target != nil {
		t.Fatalf("missing accepted command = lifecycle=%d target=%v", lifecycle, target)
	}
	var incidents int
	if err := opened.DB().QueryRowContext(ctx, `SELECT count(*) FROM storage_incidents WHERE scope = 'command' AND scope_key = ?`, active.String()).Scan(&incidents); err != nil || incidents != 1 {
		t.Fatalf("reconciliation incident count = %d, %v", incidents, err)
	}
}

func TestReconcileSessionBoundaryLeavesNewlyQueuedCommandForDispatch_HP_RECONCILE_08(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() })
	boundary := time.Date(2026, time.September, 11, 12, 0, 0, 0, time.UTC)
	if _, err := opened.RegisterClientSession(ctx, ClientRegistration{ClientID: "boundary-client", Platform: 3, Architecture: "amd64", DaemonVersion: "test", DaemonCWD: `C:\\`, SupportedShells: []byte{1}, ClientInstanceID: [16]byte{31}, SessionID: [16]byte{32}, ConnectedAt: boundary}); err != nil {
		t.Fatal(err)
	}
	issue := mustReconcileIssue(t, "019c46f1-1d02-7000-8000-0000000000d1")
	if _, err := opened.QueueCommand(ctx, QueueCommandInput{IssueUUID: issue, ClientID: "boundary-client", IssueTime: boundary.Add(time.Nanosecond), ReceiptTime: boundary.Add(time.Nanosecond), ImmutableSHA256: sha256.Sum256([]byte("new-after-reconcile-boundary")), ExecutionSpec: []byte("echo queued")}); err != nil {
		t.Fatal(err)
	}
	if _, err := opened.ReconcileClientSnapshotForSessionAt(ctx, "boundary-client", 1, &rvboxv1.ReconcileSnapshot{}, boundary); err != nil {
		t.Fatal(err)
	}
	view, err := opened.GetCommandView(ctx, "boundary-client", issue)
	if err != nil || view.Lifecycle != uint32(rvboxv1.CommandLifecycle_COMMAND_QUEUED) {
		t.Fatalf("post-boundary command = %#v, %v", view, err)
	}
}

func mustReconcileIssue(t *testing.T, value string) domain.UUID {
	t.Helper()
	issue, err := domain.ParseUUIDv7(value)
	if err != nil {
		t.Fatal(err)
	}
	return issue
}