scrabble-game/backend/internal/inttest/account_test.go

//go:build integration

package inttest

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

	"github.com/google/uuid"

	"scrabble/backend/internal/account"
	"scrabble/backend/internal/engine"
	"scrabble/backend/internal/game"
)

// TestAccountProvisionByIdentity covers find-or-create semantics, distinct
// accounts per identity, GetByID, and the identity confirmed flag per kind.
func TestAccountProvisionByIdentity(t *testing.T) {
	ctx := context.Background()
	store := account.NewStore(testDB)

	tgExternal := "tg-" + uuid.NewString()
	first, err := store.ProvisionByIdentity(ctx, account.KindTelegram, tgExternal)
	if err != nil {
		t.Fatalf("provision telegram: %v", err)
	}
	if first.ID == uuid.Nil {
		t.Fatal("expected a non-nil account id")
	}
	if first.PreferredLanguage != "en" {
		t.Errorf("PreferredLanguage = %q, want default en", first.PreferredLanguage)
	}
	if first.TimeZone != "UTC" {
		t.Errorf("TimeZone = %q, want default UTC", first.TimeZone)
	}

	// Re-provisioning the same identity returns the same account.
	again, err := store.ProvisionByIdentity(ctx, account.KindTelegram, tgExternal)
	if err != nil {
		t.Fatalf("re-provision telegram: %v", err)
	}
	if again.ID != first.ID {
		t.Errorf("re-provision id = %s, want %s", again.ID, first.ID)
	}

	// A different identity yields a different account.
	other, err := store.ProvisionByIdentity(ctx, account.KindTelegram, "tg-"+uuid.NewString())
	if err != nil {
		t.Fatalf("provision other telegram: %v", err)
	}
	if other.ID == first.ID {
		t.Error("distinct identity must map to a distinct account")
	}

	// GetByID round-trips, and a random id reports ErrNotFound.
	got, err := store.GetByID(ctx, first.ID)
	if err != nil {
		t.Fatalf("get by id: %v", err)
	}
	if got.ID != first.ID {
		t.Errorf("get id = %s, want %s", got.ID, first.ID)
	}
	if _, err := store.GetByID(ctx, uuid.New()); !errors.Is(err, account.ErrNotFound) {
		t.Errorf("get missing = %v, want ErrNotFound", err)
	}

	// A platform identity is confirmed; an email identity starts unconfirmed.
	if c := identityConfirmed(t, account.KindTelegram, tgExternal); !c {
		t.Error("telegram identity must be confirmed")
	}
	emailExternal := "e-" + uuid.NewString() + "@example.com"
	if _, err := store.ProvisionByIdentity(ctx, account.KindEmail, emailExternal); err != nil {
		t.Fatalf("provision email: %v", err)
	}
	if c := identityConfirmed(t, account.KindEmail, emailExternal); c {
		t.Error("email identity must start unconfirmed")
	}
}

// TestGetStatsZeroForFreshAccount checks that an account with no finished games
// reads back the zero statistics rather than an error (the stats screen).
func TestGetStatsZeroForFreshAccount(t *testing.T) {
	ctx := context.Background()
	store := account.NewStore(testDB)
	id := provisionAccount(t)
	st, err := store.GetStats(ctx, id)
	if err != nil {
		t.Fatalf("get stats: %v", err)
	}
	if (st != account.Stats{}) {
		t.Fatalf("fresh stats = %+v, want zero", st)
	}
}

// identityConfirmed reads the confirmed flag for one identity directly.
func identityConfirmed(t *testing.T, kind, externalID string) bool {
	t.Helper()
	var confirmed bool
	err := testDB.QueryRowContext(context.Background(),
		"SELECT confirmed FROM identities WHERE kind = $1 AND external_id = $2",
		kind, externalID,
	).Scan(&confirmed)
	if err != nil {
		t.Fatalf("read confirmed for (%s, %s): %v", kind, externalID, err)
	}
	return confirmed
}

// TestProvisionTelegramSeedsNewAccountOnly checks that Telegram first contact
// seeds the new account's language and display name from the launch fields,
// defaults the in-app-only flag on, and never overwrites an existing account on a
// later login (language seeding).
func TestProvisionTelegramSeedsNewAccountOnly(t *testing.T) {
	ctx := context.Background()
	store := account.NewStore(testDB)
	ext := "tg-" + uuid.NewString()

	acc, err := store.ProvisionTelegram(ctx, ext, "ru-RU", "thehandle", "Иван")
	if err != nil {
		t.Fatalf("provision telegram: %v", err)
	}
	if acc.PreferredLanguage != "ru" {
		t.Errorf("PreferredLanguage = %q, want ru", acc.PreferredLanguage)
	}
	if acc.DisplayName != "Иван" {
		t.Errorf("DisplayName = %q, want Иван", acc.DisplayName)
	}
	if !acc.NotificationsInAppOnly {
		t.Error("NotificationsInAppOnly should default to true")
	}

	// A later login with different fields returns the same account, unchanged.
	again, err := store.ProvisionTelegram(ctx, ext, "en", "other", "Other")
	if err != nil {
		t.Fatalf("re-provision telegram: %v", err)
	}
	if again.ID != acc.ID {
		t.Errorf("re-provision id = %s, want %s", again.ID, acc.ID)
	}
	if again.PreferredLanguage != "ru" || again.DisplayName != "Иван" {
		t.Errorf("existing account overwritten: lang=%q name=%q", again.PreferredLanguage, again.DisplayName)
	}
}

// TestProvisionTelegramUnknownLanguageDefaults checks an unsupported Telegram
// client language falls back to the account default rather than failing the
// language CHECK.
func TestProvisionTelegramUnknownLanguageDefaults(t *testing.T) {
	ctx := context.Background()
	acc, err := account.NewStore(testDB).ProvisionTelegram(ctx, "tg-"+uuid.NewString(), "fr", "", "")
	if err != nil {
		t.Fatalf("provision telegram: %v", err)
	}
	if acc.PreferredLanguage != "en" {
		t.Errorf("PreferredLanguage = %q, want default en", acc.PreferredLanguage)
	}
}

// TestServiceLanguageRoundTrip checks SetServiceLanguage persists the push-routing
// language (the bot a Telegram user last signed in through): a fresh account has
// none, a set value reads back, a later login overwrites it (last-login-wins), and
// an empty value is a no-op. The push-target route coalesces it with the preferred
// language.
func TestServiceLanguageRoundTrip(t *testing.T) {
	ctx := context.Background()
	store := account.NewStore(testDB)
	acc, err := store.ProvisionTelegram(ctx, "tg-"+uuid.NewString(), "en", "", "Player")
	if err != nil {
		t.Fatalf("provision telegram: %v", err)
	}
	if acc.ServiceLanguage != "" {
		t.Errorf("fresh ServiceLanguage = %q, want empty", acc.ServiceLanguage)
	}

	if err := store.SetServiceLanguage(ctx, acc.ID, "ru"); err != nil {
		t.Fatalf("set service language: %v", err)
	}
	if got, err := store.GetByID(ctx, acc.ID); err != nil {
		t.Fatalf("get by id: %v", err)
	} else if got.ServiceLanguage != "ru" {
		t.Errorf("ServiceLanguage = %q, want ru", got.ServiceLanguage)
	}

	// A later login through the other bot updates it; a subsequent empty value
	// (a non-Telegram login) leaves it unchanged.
	if err := store.SetServiceLanguage(ctx, acc.ID, "en"); err != nil {
		t.Fatalf("update service language: %v", err)
	}
	if err := store.SetServiceLanguage(ctx, acc.ID, ""); err != nil {
		t.Fatalf("noop service language: %v", err)
	}
	if got, err := store.GetByID(ctx, acc.ID); err != nil {
		t.Fatalf("get by id: %v", err)
	} else if got.ServiceLanguage != "en" {
		t.Errorf("ServiceLanguage after update+noop = %q, want en", got.ServiceLanguage)
	}
}

// TestHighRateFlagRoundTrip covers the soft high-rate marker: a fresh account
// is unflagged, FlagHighRate stamps it exactly once (a second sustained episode
// never moves the timestamp), ClearHighRateFlag reverses it, and a re-flag after
// the operator clear takes a fresh timestamp.
func TestHighRateFlagRoundTrip(t *testing.T) {
	ctx := context.Background()
	store := account.NewStore(testDB)
	acc, err := store.ProvisionTelegram(ctx, "tg-"+uuid.NewString(), "en", "", "Player")
	if err != nil {
		t.Fatalf("provision telegram: %v", err)
	}
	if !acc.FlaggedHighRateAt.IsZero() {
		t.Fatalf("fresh FlaggedHighRateAt = %v, want zero", acc.FlaggedHighRateAt)
	}

	first := time.Date(2026, 6, 1, 12, 0, 0, 0, time.UTC)
	set, err := store.FlagHighRate(ctx, acc.ID, first)
	if err != nil {
		t.Fatalf("flag: %v", err)
	}
	if !set {
		t.Fatal("first FlagHighRate reported not set")
	}
	if set, err = store.FlagHighRate(ctx, acc.ID, first.Add(time.Hour)); err != nil {
		t.Fatalf("re-flag: %v", err)
	} else if set {
		t.Fatal("second FlagHighRate must not overwrite the marker")
	}
	got, err := store.GetByID(ctx, acc.ID)
	if err != nil {
		t.Fatalf("get by id: %v", err)
	}
	if !got.FlaggedHighRateAt.Equal(first) {
		t.Errorf("FlaggedHighRateAt = %v, want %v", got.FlaggedHighRateAt, first)
	}

	if err := store.ClearHighRateFlag(ctx, acc.ID); err != nil {
		t.Fatalf("clear: %v", err)
	}
	if got, err = store.GetByID(ctx, acc.ID); err != nil {
		t.Fatalf("get by id: %v", err)
	} else if !got.FlaggedHighRateAt.IsZero() {
		t.Errorf("cleared FlaggedHighRateAt = %v, want zero", got.FlaggedHighRateAt)
	}

	second := first.Add(24 * time.Hour)
	if set, err = store.FlagHighRate(ctx, acc.ID, second); err != nil || !set {
		t.Fatalf("re-flag after clear = (%v, %v), want (true, nil)", set, err)
	}
	if got, err = store.GetByID(ctx, acc.ID); err != nil {
		t.Fatalf("get by id: %v", err)
	} else if !got.FlaggedHighRateAt.Equal(second) {
		t.Errorf("re-flagged FlaggedHighRateAt = %v, want %v", got.FlaggedHighRateAt, second)
	}
}

// TestIdentityExternalID covers the reverse identity lookup the push-target route
// uses: it returns the external_id for the matching kind and ErrNotFound otherwise,
// including for a guest that carries no identity.
func TestIdentityExternalID(t *testing.T) {
	ctx := context.Background()
	store := account.NewStore(testDB)
	ext := "tg-" + uuid.NewString()
	acc, err := store.ProvisionTelegram(ctx, ext, "en", "", "Tg User")
	if err != nil {
		t.Fatalf("provision telegram: %v", err)
	}
	got, err := store.IdentityExternalID(ctx, acc.ID, account.KindTelegram)
	if err != nil {
		t.Fatalf("identity external id: %v", err)
	}
	if got != ext {
		t.Errorf("external id = %q, want %q", got, ext)
	}
	if _, err := store.IdentityExternalID(ctx, acc.ID, account.KindEmail); !errors.Is(err, account.ErrNotFound) {
		t.Errorf("email lookup = %v, want ErrNotFound", err)
	}
	guest := provisionGuest(t)
	if _, err := store.IdentityExternalID(ctx, guest, account.KindTelegram); !errors.Is(err, account.ErrNotFound) {
		t.Errorf("guest lookup = %v, want ErrNotFound", err)
	}
}

// TestNotificationsInAppOnlyRoundTrip checks the profile flag persists
// through UpdateProfile and reads back through GetByID.
func TestNotificationsInAppOnlyRoundTrip(t *testing.T) {
	ctx := context.Background()
	store := account.NewStore(testDB)
	acc, err := store.ProvisionTelegram(ctx, "tg-"+uuid.NewString(), "en", "", "Player")
	if err != nil {
		t.Fatalf("provision telegram: %v", err)
	}
	if !acc.NotificationsInAppOnly {
		t.Fatal("default should be in-app-only true")
	}
	updated, err := store.UpdateProfile(ctx, acc.ID, account.ProfileUpdate{
		DisplayName:            "Player",
		PreferredLanguage:      "en",
		TimeZone:               "UTC",
		NotificationsInAppOnly: false,
	})
	if err != nil {
		t.Fatalf("update profile: %v", err)
	}
	if updated.NotificationsInAppOnly {
		t.Error("update did not clear NotificationsInAppOnly")
	}
	got, err := store.GetByID(ctx, acc.ID)
	if err != nil {
		t.Fatalf("get by id: %v", err)
	}
	if got.NotificationsInAppOnly {
		t.Error("GetByID still reports in-app-only after clearing")
	}
}

// TestGuestAutoMatchLeavesNoStats drives a guest through a full auto-match game
// against a robot to a natural end and checks the guest holds a seat (the
// game_players foreign key is satisfied) yet accrues no statistics, while the
// durable robot opponent does.
func TestGuestAutoMatchLeavesNoStats(t *testing.T) {
	ctx := context.Background()
	svc := newGameService()
	robots := newRobotService(t, svc)
	if err := robots.EnsurePool(ctx); err != nil {
		t.Fatalf("ensure pool: %v", err)
	}
	robotID, err := robots.Pick(engine.VariantEnglish)
	if err != nil {
		t.Fatalf("pick: %v", err)
	}
	guest := provisionGuest(t)
	seed := openingSeed(t)

	g, err := svc.Create(ctx, game.CreateParams{
		Variant: engine.VariantEnglish, Seats: []uuid.UUID{guest, robotID},
		TurnTimeout: 24 * time.Hour, Seed: seed,
	})
	if err != nil {
		t.Fatalf("create: %v", err)
	}
	const robotSeat = 1 // seats = [guest, robot]

	finished := false
	for i := 0; i < 400 && !finished; i++ {
		_, toMove, status, err := svc.Participants(ctx, g.ID)
		if err != nil {
			t.Fatalf("participants: %v", err)
		}
		if status != game.StatusActive {
			finished = true
			break
		}
		if toMove == robotSeat {
			setTurnStarted(t, g.ID, daytime.Add(-2*time.Hour))
			robots.Drive(ctx, daytime)
			continue
		}
		playHuman(t, ctx, svc, g.ID, guest)
	}
	if !finished {
		t.Fatal("guest game did not finish within the move budget")
	}

	if _, _, _, _, _, ok := readStats(t, guest); ok {
		t.Error("a guest must not accrue a statistics row")
	}
	if _, _, _, _, _, ok := readStats(t, robotID); !ok {
		t.Error("the durable robot opponent should have a statistics row")
	}
}