package systemtables

import (
	"context"
	"sync"
	"testing"
)

type testSchemaVersionProvider struct {
	mu      sync.Mutex
	current string
}

func (p *testSchemaVersionProvider) Current(_ context.Context, _, _ string) (string, error) {
	p.mu.Lock()
	defer p.mu.Unlock()
	return p.current, nil
}

func (p *testSchemaVersionProvider) Bump(_ context.Context, _, _ string) (string, error) {
	p.mu.Lock()
	defer p.mu.Unlock()
	p.current = p.current + "_next"
	return p.current, nil
}

func TestRefreshSchemaVersionUpdatesCachedValue(t *testing.T) {
	provider := &testSchemaVersionProvider{current: "v1"}
	state := &SystemTableState{schemaProvider: provider}

	if err := state.EnsureSchemaVersion(context.Background(), "user", "pass"); err != nil {
		t.Fatalf("EnsureSchemaVersion failed: %v", err)
	}
	if got := state.SchemaVersion(); got != "v1" {
		t.Fatalf("expected cached version v1, got %s", got)
	}

	provider.mu.Lock()
	provider.current = "v2"
	provider.mu.Unlock()

	version, changed, err := state.RefreshSchemaVersion(context.Background(), "user", "pass")
	if err != nil {
		t.Fatalf("RefreshSchemaVersion failed: %v", err)
	}
	if !changed {
		t.Fatalf("expected schema_version change to be detected")
	}
	if version != "v2" {
		t.Fatalf("expected version v2, got %s", version)
	}
	if got := state.SchemaVersion(); got != "v2" {
		t.Fatalf("expected cached version v2, got %s", got)
	}
}