package memory

import (
	"context"
	"errors"
	"testing"

	"telesrv/internal/domain"
)

func TestStoryStoreReadMaxAndPeerMaxIDs(t *testing.T) {
	ctx := context.Background()
	store := NewStoryStore()
	owner := domain.Peer{Type: domain.PeerTypeUser, ID: 1001}
	for _, id := range []int{1, 2} {
		if _, err := store.UpsertStory(ctx, domain.UpsertStoryRequest{Story: domain.Story{
			Owner:      owner,
			ID:         id,
			Date:       100 + id,
			ExpireDate: 1000,
			Public:     true,
		}}); err != nil {
			t.Fatalf("upsert story %d: %v", id, err)
		}
	}

	read, err := store.MarkRead(ctx, 2001, owner, 2, 200)
	if err != nil {
		t.Fatalf("mark read: %v", err)
	}
	if !read.Advanced || read.MaxReadID != 2 {
		t.Fatalf("read = %+v, want advanced max 2", read)
	}
	read, err = store.MarkRead(ctx, 2001, owner, 1, 201)
	if err != nil {
		t.Fatalf("mark read lower: %v", err)
	}
	if read.Advanced || read.MaxReadID != 2 {
		t.Fatalf("lower read = %+v, want unchanged max 2", read)
	}

	peerStories, err := store.GetPeerStories(ctx, 2001, owner, 300)
	if err != nil {
		t.Fatalf("get peer stories: %v", err)
	}
	if peerStories.MaxReadID != 2 || len(peerStories.Stories) != 2 {
		t.Fatalf("peer stories = %+v, want max read 2 and two stories", peerStories)
	}
	recent, err := store.GetPeerMaxIDs(ctx, 2001, []domain.Peer{owner}, 300)
	if err != nil {
		t.Fatalf("peer max ids: %v", err)
	}
	if len(recent) != 1 || recent[0].MaxID != 2 {
		t.Fatalf("recent = %+v, want max id 2", recent)
	}
	projections, err := store.GetPeerStoryProjections(ctx, 2001, []domain.Peer{owner}, 300)
	if err != nil {
		t.Fatalf("peer projections: %v", err)
	}
	if len(projections) != 1 || projections[0].Peer != owner || projections[0].Recent.MaxID != 2 || projections[0].Hidden {
		t.Fatalf("projections = %+v, want max id 2 and visible owner", projections)
	}
}

func TestStoryStorePeerHiddenStates(t *testing.T) {
	ctx := context.Background()
	store := NewStoryStore()
	viewerID := int64(2001)
	owner := domain.Peer{Type: domain.PeerTypeUser, ID: 1001}
	channel := domain.Peer{Type: domain.PeerTypeChannel, ID: 3001}

	states, err := store.GetPeerHiddenStates(ctx, viewerID, []domain.Peer{owner, channel})
	if err != nil {
		t.Fatalf("initial hidden states: %v", err)
	}
	if states[owner] || states[channel] {
		t.Fatalf("initial hidden states = %+v, want both false", states)
	}
	if err := store.SetPeerHidden(ctx, viewerID, owner, true); err != nil {
		t.Fatalf("set owner hidden: %v", err)
	}
	states, err = store.GetPeerHiddenStates(ctx, viewerID, []domain.Peer{owner, channel})
	if err != nil {
		t.Fatalf("hidden states after set: %v", err)
	}
	if !states[owner] || states[channel] {
		t.Fatalf("hidden states after set = %+v, want owner true channel false", states)
	}
	projections, err := store.GetPeerStoryProjections(ctx, viewerID, []domain.Peer{owner, channel}, 300)
	if err != nil {
		t.Fatalf("story projections after set: %v", err)
	}
	if len(projections) != 2 || !projections[0].Hidden || projections[1].Hidden {
		t.Fatalf("story projections after set = %+v, want owner hidden channel visible", projections)
	}
	if err := store.SetPeerHidden(ctx, viewerID, owner, false); err != nil {
		t.Fatalf("clear owner hidden: %v", err)
	}
	states, err = store.GetPeerHiddenStates(ctx, viewerID, []domain.Peer{owner})
	if err != nil {
		t.Fatalf("hidden states after clear: %v", err)
	}
	if states[owner] {
		t.Fatalf("hidden states after clear = %+v, want owner false", states)
	}
}

func TestStoryStoreListActiveStoriesPaginatesByPeer(t *testing.T) {
	ctx := context.Background()
	store := NewStoryStore()
	owners := []domain.Peer{
		{Type: domain.PeerTypeUser, ID: 1001},
		{Type: domain.PeerTypeUser, ID: 1002},
		{Type: domain.PeerTypeUser, ID: 1003},
	}
	for i, owner := range owners {
		if _, err := store.UpsertStory(ctx, domain.UpsertStoryRequest{Story: domain.Story{
			Owner:      owner,
			ID:         1,
			Date:       300 - i*100,
			ExpireDate: 1000,
			Public:     true,
		}}); err != nil {
			t.Fatalf("upsert owner %d story: %v", owner.ID, err)
		}
	}
	if _, err := store.UpsertStory(ctx, domain.UpsertStoryRequest{Story: domain.Story{
		Owner:      owners[0],
		ID:         2,
		Date:       250,
		ExpireDate: 1000,
		Public:     true,
	}}); err != nil {
		t.Fatalf("upsert second story for first owner: %v", err)
	}

	first, err := store.ListActiveStoriesPage(ctx, 2001, false, 400, domain.StoryListCursor{}, 2)
	if err != nil {
		t.Fatalf("first page: %v", err)
	}
	if first.Count != 3 || !first.HasMore || len(first.Peers) != 2 {
		t.Fatalf("first page = count %d more %v peers %d, want count 3 more true peers 2", first.Count, first.HasMore, len(first.Peers))
	}
	if first.Peers[0].Peer != owners[0] || len(first.Peers[0].Stories) != 2 {
		t.Fatalf("first peer = %+v stories %d, want owner 1001 with two stories", first.Peers[0].Peer, len(first.Peers[0].Stories))
	}

	next, err := store.ListActiveStoriesPage(ctx, 2001, false, 400, domain.StoryListCursor{
		Set:  true,
		Date: 200,
		Peer: owners[1],
	}, 2)
	if err != nil {
		t.Fatalf("next page: %v", err)
	}
	if next.Count != 3 || next.HasMore || len(next.Peers) != 1 || next.Peers[0].Peer != owners[2] {
		t.Fatalf("next page = %+v, want final page with owner 1003", next)
	}
	digest, err := store.ActiveStoriesDigest(ctx, 2001, false, 400)
	if err != nil {
		t.Fatalf("digest active stories: %v", err)
	}
	if digest.Count != 3 {
		t.Fatalf("digest count = %d, want 3", digest.Count)
	}
	if _, err := store.MarkRead(ctx, 2001, owners[0], 2, 401); err != nil {
		t.Fatalf("mark read for digest: %v", err)
	}
	changed, err := store.ActiveStoriesDigest(ctx, 2001, false, 400)
	if err != nil {
		t.Fatalf("changed digest active stories: %v", err)
	}
	if changed.Hash == digest.Hash {
		t.Fatalf("digest hash unchanged after read boundary: %#x", changed.Hash)
	}
}

func TestStoryStoreSelfUserViewAndReactionDoNotPolluteOwnerInteractions(t *testing.T) {
	ctx := context.Background()
	store := NewStoryStore()
	owner := domain.Peer{Type: domain.PeerTypeUser, ID: 1001}
	if _, err := store.UpsertStory(ctx, domain.UpsertStoryRequest{Story: domain.Story{
		Owner:      owner,
		ID:         1,
		Date:       100,
		ExpireDate: 1000,
		Public:     true,
	}}); err != nil {
		t.Fatalf("upsert story: %v", err)
	}

	created, err := store.IncrementViews(ctx, owner.ID, owner, []int{1}, 200)
	if err != nil {
		t.Fatalf("increment self view: %v", err)
	}
	if created != 0 {
		t.Fatalf("created self views = %d, want 0", created)
	}
	if _, err := store.SetReaction(ctx, owner.ID, owner, 1, &domain.MessageReaction{
		Type:     domain.MessageReactionEmoji,
		Emoticon: "🔥",
	}, 201); err != domain.ErrStoryPeerInvalid {
		t.Fatalf("self reaction err = %v, want ErrStoryPeerInvalid", err)
	}
	list, err := store.ListStoryViews(ctx, domain.StoryViewListRequest{
		ViewerUserID: owner.ID,
		Owner:        owner,
		StoryID:      1,
		Limit:        10,
	})
	if err != nil {
		t.Fatalf("list story views: %v", err)
	}
	if list.Count != 0 || list.ViewsCount != 0 || list.ReactionsCount != 0 || len(list.Views) != 0 {
		t.Fatalf("self view list = %+v, want empty counters", list)
	}
}

func TestStoryStoreBlocklistHidesOwnerStoriesFromViewer(t *testing.T) {
	ctx := context.Background()
	store := NewStoryStore()
	owner := domain.Peer{Type: domain.PeerTypeUser, ID: 1001}
	blockedViewerID := int64(2001)
	otherViewerID := int64(2002)
	if _, err := store.UpsertStory(ctx, domain.UpsertStoryRequest{Story: domain.Story{
		Owner:      owner,
		ID:         1,
		Date:       100,
		ExpireDate: 1000,
		Public:     true,
	}}); err != nil {
		t.Fatalf("upsert story: %v", err)
	}
	if created, err := store.IncrementViews(ctx, blockedViewerID, owner, []int{1}, 105); err != nil || created != 1 {
		t.Fatalf("pre-block increment = %d, %v, want 1 nil", created, err)
	}
	store.SetStoryBlockedUsers(owner.ID, blockedViewerID)

	peerStories, err := store.GetPeerStories(ctx, blockedViewerID, owner, 200)
	if err != nil {
		t.Fatalf("get peer stories: %v", err)
	}
	if len(peerStories.Stories) != 0 {
		t.Fatalf("blocked peer stories = %+v, want empty", peerStories.Stories)
	}
	exact, err := store.GetStoriesByID(ctx, blockedViewerID, owner, []int{1}, 200)
	if err != nil {
		t.Fatalf("get stories by id: %v", err)
	}
	if len(exact.Stories) != 0 {
		t.Fatalf("blocked exact stories = %+v, want empty", exact.Stories)
	}
	recent, err := store.GetPeerMaxIDs(ctx, blockedViewerID, []domain.Peer{owner}, 200)
	if err != nil {
		t.Fatalf("get peer max ids: %v", err)
	}
	if len(recent) != 1 || recent[0].MaxID != 0 {
		t.Fatalf("blocked recent = %+v, want max id 0", recent)
	}
	active, err := store.ListActiveStories(ctx, blockedViewerID, false, 200, 100)
	if err != nil {
		t.Fatalf("list active stories: %v", err)
	}
	if active.Count != 0 || len(active.Stories) != 0 {
		t.Fatalf("blocked active stories = %+v, want empty", active)
	}
	if created, err := store.IncrementViews(ctx, blockedViewerID, owner, []int{1}, 210); err != nil || created != 0 {
		t.Fatalf("blocked increment = %d, %v, want 0 nil", created, err)
	}
	if _, err := store.SetReaction(ctx, blockedViewerID, owner, 1, &domain.MessageReaction{
		Type:     domain.MessageReactionEmoji,
		Emoticon: "🔥",
	}, 211); err != domain.ErrStoryNotFound {
		t.Fatalf("blocked reaction err = %v, want ErrStoryNotFound", err)
	}

	ownerStories, err := store.GetPeerStories(ctx, owner.ID, owner, 200)
	if err != nil {
		t.Fatalf("owner get peer stories: %v", err)
	}
	if len(ownerStories.Stories) != 1 {
		t.Fatalf("owner peer stories = %+v, want one story", ownerStories.Stories)
	}
	otherStories, err := store.GetPeerStories(ctx, otherViewerID, owner, 200)
	if err != nil {
		t.Fatalf("other get peer stories: %v", err)
	}
	if len(otherStories.Stories) != 1 {
		t.Fatalf("other peer stories = %+v, want one story", otherStories.Stories)
	}
	if created, err := store.IncrementViews(ctx, otherViewerID, owner, []int{1}, 220); err != nil || created != 1 {
		t.Fatalf("other increment = %d, %v, want 1 nil", created, err)
	}
	list, err := store.ListStoryViews(ctx, domain.StoryViewListRequest{
		ViewerUserID: owner.ID,
		Owner:        owner,
		StoryID:      1,
		Limit:        10,
	})
	if err != nil {
		t.Fatalf("list story views: %v", err)
	}
	got := map[int64]domain.StoryView{}
	for _, view := range list.Views {
		got[view.ViewerID] = view
	}
	if list.Count != 2 || len(list.Views) != 2 {
		t.Fatalf("view list = %+v, want historical blocked viewer and other viewer", list)
	}
	if !got[blockedViewerID].BlockedMyStoriesFrom {
		t.Fatalf("blocked viewer row = %+v, want blocked_my_stories_from", got[blockedViewerID])
	}
	if got[otherViewerID].BlockedMyStoriesFrom {
		t.Fatalf("other viewer row = %+v, want not blocked", got[otherViewerID])
	}
}

func TestStoryStoreChannelStoriesRequireActiveMember(t *testing.T) {
	ctx := context.Background()
	store := NewStoryStore()
	channel := domain.Peer{Type: domain.PeerTypeChannel, ID: 3001}
	memberID := int64(2001)
	outsiderID := int64(2002)
	store.SetStoryChannelMembers(channel.ID, memberID)

	if _, err := store.CreateStory(ctx, domain.StoryCreateRequest{
		Owner:    channel,
		RandomID: 300101,
		Date:     100,
		Period:   86400,
		Public:   true,
	}); err != nil {
		t.Fatalf("create channel story: %v", err)
	}

	memberStories, err := store.GetPeerStories(ctx, memberID, channel, 200)
	if err != nil {
		t.Fatalf("member get peer stories: %v", err)
	}
	if len(memberStories.Stories) != 1 || memberStories.Stories[0].Owner != channel {
		t.Fatalf("member stories = %+v, want channel story", memberStories.Stories)
	}
	outsiderStories, err := store.GetPeerStories(ctx, outsiderID, channel, 200)
	if err != nil {
		t.Fatalf("outsider get peer stories: %v", err)
	}
	if len(outsiderStories.Stories) != 0 {
		t.Fatalf("outsider stories = %+v, want empty", outsiderStories.Stories)
	}
	exact, err := store.GetStoriesByID(ctx, outsiderID, channel, []int{1}, 200)
	if err != nil {
		t.Fatalf("outsider exact story: %v", err)
	}
	if len(exact.Stories) != 0 {
		t.Fatalf("outsider exact = %+v, want empty", exact.Stories)
	}
	recent, err := store.GetPeerMaxIDs(ctx, outsiderID, []domain.Peer{channel}, 200)
	if err != nil {
		t.Fatalf("outsider peer max ids: %v", err)
	}
	if len(recent) != 1 || recent[0].MaxID != 0 {
		t.Fatalf("outsider recent = %+v, want max id 0", recent)
	}
	active, err := store.ListActiveStories(ctx, outsiderID, false, 200, 100)
	if err != nil {
		t.Fatalf("outsider active stories: %v", err)
	}
	if active.Count != 0 || len(active.Stories) != 0 {
		t.Fatalf("outsider active stories = %+v, want empty", active)
	}
	if created, err := store.IncrementViews(ctx, outsiderID, channel, []int{1}, 201); err != nil || created != 0 {
		t.Fatalf("outsider increment = %d, %v, want 0 nil", created, err)
	}
	if _, err := store.SetReaction(ctx, outsiderID, channel, 1, &domain.MessageReaction{
		Type:     domain.MessageReactionEmoji,
		Emoticon: "like",
	}, 202); !errors.Is(err, domain.ErrStoryNotFound) {
		t.Fatalf("outsider reaction err = %v, want ErrStoryNotFound", err)
	}
}

func TestStoryStoreMediaAreasRoundTripEditClearAndClone(t *testing.T) {
	ctx := context.Background()
	store := NewStoryStore()
	owner := domain.Peer{Type: domain.PeerTypeUser, ID: 1001}
	created, err := store.CreateStory(ctx, domain.StoryCreateRequest{
		Owner:      owner,
		RandomID:   101,
		Date:       100,
		Period:     900,
		Public:     true,
		MediaAreas: []domain.StoryMediaArea{testDomainStoryMediaArea("🔥", 10)},
	})
	if err != nil {
		t.Fatalf("create story: %v", err)
	}
	assertDomainStoryMediaArea(t, created.Story, "🔥", 10)
	created.Story.MediaAreas[0].Reaction.Emoticon = "mutated"

	list, err := store.GetStoriesByID(ctx, owner.ID, owner, []int{created.Story.ID, created.Story.ID}, 200)
	if err != nil {
		t.Fatalf("get stories by id: %v", err)
	}
	if len(list.Stories) != 1 {
		t.Fatalf("stories by duplicate ids = %+v, want one story", list.Stories)
	}
	assertDomainStoryMediaArea(t, list.Stories[0], "🔥", 10)
	if _, err := store.GetStoriesByID(ctx, owner.ID, owner, nil, 200); !errors.Is(err, domain.ErrStoryIDInvalid) {
		t.Fatalf("empty get stories by id err = %v, want ErrStoryIDInvalid", err)
	}

	edited, err := store.EditStory(ctx, domain.StoryEditRequest{
		Owner:            owner,
		ID:               created.Story.ID,
		UpdateMediaAreas: true,
		MediaAreas:       []domain.StoryMediaArea{testDomainStoryURLMediaArea("https://example.com/story/link", 25)},
	})
	if err != nil {
		t.Fatalf("edit story media areas: %v", err)
	}
	assertDomainStoryURLMediaArea(t, edited.Story, "https://example.com/story/link", 25)
	edited.Story.MediaAreas[0].URL = "https://mutated.invalid"

	list, err = store.GetStoriesByID(ctx, owner.ID, owner, []int{created.Story.ID}, 201)
	if err != nil {
		t.Fatalf("get edited story by id: %v", err)
	}
	assertDomainStoryURLMediaArea(t, list.Stories[0], "https://example.com/story/link", 25)

	geoEdited, err := store.EditStory(ctx, domain.StoryEditRequest{
		Owner:            owner,
		ID:               created.Story.ID,
		UpdateMediaAreas: true,
		MediaAreas:       []domain.StoryMediaArea{testDomainStoryGeoPointMediaArea(31.2304, 121.4737, 35)},
	})
	if err != nil {
		t.Fatalf("edit story geo media area: %v", err)
	}
	assertDomainStoryGeoPointMediaArea(t, geoEdited.Story, 31.2304, 121.4737, 35)
	geoEdited.Story.MediaAreas[0].Geo.Lat = 0
	geoEdited.Story.MediaAreas[0].GeoAddress.City = "Mutated"

	list, err = store.GetStoriesByID(ctx, owner.ID, owner, []int{created.Story.ID}, 202)
	if err != nil {
		t.Fatalf("get geo edited story by id: %v", err)
	}
	assertDomainStoryGeoPointMediaArea(t, list.Stories[0], 31.2304, 121.4737, 35)

	venueEdited, err := store.EditStory(ctx, domain.StoryEditRequest{
		Owner:            owner,
		ID:               created.Story.ID,
		UpdateMediaAreas: true,
		MediaAreas:       []domain.StoryMediaArea{testDomainStoryVenueMediaArea("Inline Cafe", 31.231, 121.474, 40)},
	})
	if err != nil {
		t.Fatalf("edit story venue media area: %v", err)
	}
	assertDomainStoryVenueMediaArea(t, venueEdited.Story, "Inline Cafe", 31.231, 121.474, 40)
	venueEdited.Story.MediaAreas[0].Venue.Title = "Mutated"

	list, err = store.GetStoriesByID(ctx, owner.ID, owner, []int{created.Story.ID}, 203)
	if err != nil {
		t.Fatalf("get venue edited story by id: %v", err)
	}
	assertDomainStoryVenueMediaArea(t, list.Stories[0], "Inline Cafe", 31.231, 121.474, 40)

	weatherEdited, err := store.EditStory(ctx, domain.StoryEditRequest{
		Owner:            owner,
		ID:               created.Story.ID,
		UpdateMediaAreas: true,
		MediaAreas:       []domain.StoryMediaArea{testDomainStoryWeatherMediaArea("☀️", 22.5, 0x00cc6600, 45)},
	})
	if err != nil {
		t.Fatalf("edit story weather media area: %v", err)
	}
	assertDomainStoryWeatherMediaArea(t, weatherEdited.Story, "☀️", 22.5, 0x00cc6600, 45)
	weatherEdited.Story.MediaAreas[0].WeatherEmoji = "mutated"
	weatherEdited.Story.MediaAreas[0].TemperatureC = -100
	weatherEdited.Story.MediaAreas[0].Color = 0

	list, err = store.GetStoriesByID(ctx, owner.ID, owner, []int{created.Story.ID}, 204)
	if err != nil {
		t.Fatalf("get weather edited story by id: %v", err)
	}
	assertDomainStoryWeatherMediaArea(t, list.Stories[0], "☀️", 22.5, 0x00cc6600, 45)

	channelPostEdited, err := store.EditStory(ctx, domain.StoryEditRequest{
		Owner:            owner,
		ID:               created.Story.ID,
		UpdateMediaAreas: true,
		MediaAreas:       []domain.StoryMediaArea{testDomainStoryChannelPostMediaArea(777001, 42, 50)},
	})
	if err != nil {
		t.Fatalf("edit story channel post media area: %v", err)
	}
	assertDomainStoryChannelPostMediaArea(t, channelPostEdited.Story, 777001, 42, 50)
	channelPostEdited.Story.MediaAreas[0].ChannelID = 0
	channelPostEdited.Story.MediaAreas[0].MsgID = 0

	list, err = store.GetStoriesByID(ctx, owner.ID, owner, []int{created.Story.ID}, 205)
	if err != nil {
		t.Fatalf("get channel post edited story by id: %v", err)
	}
	assertDomainStoryChannelPostMediaArea(t, list.Stories[0], 777001, 42, 50)

	starGiftEdited, err := store.EditStory(ctx, domain.StoryEditRequest{
		Owner:            owner,
		ID:               created.Story.ID,
		UpdateMediaAreas: true,
		MediaAreas:       []domain.StoryMediaArea{testDomainStoryStarGiftMediaArea("Gift.Series_01-42", 55)},
	})
	if err != nil {
		t.Fatalf("edit story star gift media area: %v", err)
	}
	assertDomainStoryStarGiftMediaArea(t, starGiftEdited.Story, "Gift.Series_01-42", 55)
	starGiftEdited.Story.MediaAreas[0].StarGiftSlug = "mutated"

	list, err = store.GetStoriesByID(ctx, owner.ID, owner, []int{created.Story.ID}, 206)
	if err != nil {
		t.Fatalf("get star gift edited story by id: %v", err)
	}
	assertDomainStoryStarGiftMediaArea(t, list.Stories[0], "Gift.Series_01-42", 55)

	cleared, err := store.EditStory(ctx, domain.StoryEditRequest{
		Owner:            owner,
		ID:               created.Story.ID,
		UpdateMediaAreas: true,
	})
	if err != nil {
		t.Fatalf("clear story media areas: %v", err)
	}
	if len(cleared.Story.MediaAreas) != 0 {
		t.Fatalf("cleared story media areas = %+v, want none", cleared.Story.MediaAreas)
	}
}

func TestStoryStoreForwardRoundTripEditAndClone(t *testing.T) {
	ctx := context.Background()
	store := NewStoryStore()
	owner := domain.Peer{Type: domain.PeerTypeUser, ID: 1002}
	source := domain.Peer{Type: domain.PeerTypeUser, ID: 2002}
	created, err := store.CreateStory(ctx, domain.StoryCreateRequest{
		Owner:    owner,
		RandomID: 202,
		Date:     200,
		Period:   900,
		Public:   true,
		Forward: &domain.StoryForward{
			From:     source,
			StoryID:  7,
			Modified: true,
		},
	})
	if err != nil {
		t.Fatalf("create story: %v", err)
	}
	assertDomainStoryForward(t, created.Story, source, 7, true)
	created.Story.Forward.From.ID = 9999
	created.Story.Forward.StoryID = 99

	list, err := store.GetStoriesByID(ctx, owner.ID, owner, []int{created.Story.ID}, 201)
	if err != nil {
		t.Fatalf("get story by id: %v", err)
	}
	if len(list.Stories) != 1 {
		t.Fatalf("stories by id = %+v, want one story", list.Stories)
	}
	assertDomainStoryForward(t, list.Stories[0], source, 7, true)

	edited, err := store.EditStory(ctx, domain.StoryEditRequest{
		Owner:         owner,
		ID:            created.Story.ID,
		UpdateCaption: true,
		Caption:       "edited repost caption",
	})
	if err != nil {
		t.Fatalf("edit story caption: %v", err)
	}
	assertDomainStoryForward(t, edited.Story, source, 7, true)
	edited.Story.Forward.From.ID = 9998

	list, err = store.GetStoriesByID(ctx, owner.ID, owner, []int{created.Story.ID}, 202)
	if err != nil {
		t.Fatalf("get edited story by id: %v", err)
	}
	assertDomainStoryForward(t, list.Stories[0], source, 7, true)

	hidden, err := store.CreateStory(ctx, domain.StoryCreateRequest{
		Owner:    owner,
		RandomID: 203,
		Date:     203,
		Period:   900,
		Public:   true,
		Forward: &domain.StoryForward{
			FromName: "Alice Hidden",
			StoryID:  8,
		},
	})
	if err != nil {
		t.Fatalf("create hidden-author story: %v", err)
	}
	assertDomainStoryForwardName(t, hidden.Story, "Alice Hidden", 8, false)
	hidden.Story.Forward.From = source
	hidden.Story.Forward.FromName = "mutated"
	hidden.Story.Forward.StoryID = 88

	list, err = store.GetStoriesByID(ctx, owner.ID, owner, []int{hidden.Story.ID}, 204)
	if err != nil {
		t.Fatalf("get hidden-author story by id: %v", err)
	}
	if len(list.Stories) != 1 {
		t.Fatalf("hidden-author stories by id = %+v, want one story", list.Stories)
	}
	assertDomainStoryForwardName(t, list.Stories[0], "Alice Hidden", 8, false)

	editedHidden, err := store.EditStory(ctx, domain.StoryEditRequest{
		Owner:         owner,
		ID:            hidden.Story.ID,
		UpdateCaption: true,
		Caption:       "edited hidden repost caption",
	})
	if err != nil {
		t.Fatalf("edit hidden-author story caption: %v", err)
	}
	assertDomainStoryForwardName(t, editedHidden.Story, "Alice Hidden", 8, false)
}

func TestStoryStorePublicRepostForwardCountAndViewsList(t *testing.T) {
	ctx := context.Background()
	store := NewStoryStore()
	sourceOwner := domain.Peer{Type: domain.PeerTypeUser, ID: 1101}
	repostOwner := domain.Peer{Type: domain.PeerTypeUser, ID: 2202}
	source, err := store.CreateStory(ctx, domain.StoryCreateRequest{
		Owner:    sourceOwner,
		RandomID: 1101,
		Date:     100,
		Period:   86400,
		Public:   true,
	})
	if err != nil {
		t.Fatalf("create source story: %v", err)
	}
	repost, err := store.CreateStory(ctx, domain.StoryCreateRequest{
		Owner:    repostOwner,
		RandomID: 2202,
		Date:     200,
		Period:   86400,
		Public:   true,
		Forward: &domain.StoryForward{
			From:    sourceOwner,
			StoryID: source.Story.ID,
		},
	})
	if err != nil {
		t.Fatalf("create repost story: %v", err)
	}
	sourceList, err := store.GetStoriesByID(ctx, sourceOwner.ID, sourceOwner, []int{source.Story.ID}, 201)
	if err != nil {
		t.Fatalf("get source story: %v", err)
	}
	if len(sourceList.Stories) != 1 || sourceList.Stories[0].Views.ForwardsCount != 1 {
		t.Fatalf("source story = %+v, want forwards_count=1", sourceList.Stories)
	}
	views, err := store.ListStoryViews(ctx, domain.StoryViewListRequest{
		ViewerUserID:  sourceOwner.ID,
		Owner:         sourceOwner,
		StoryID:       source.Story.ID,
		Limit:         20,
		ForwardsFirst: true,
	})
	if err != nil {
		t.Fatalf("list story views: %v", err)
	}
	if views.Count != 1 || views.ForwardsCount != 1 || len(views.Views) != 1 || views.Views[0].Repost == nil {
		t.Fatalf("views list = %+v, want one repost interaction", views)
	}
	if views.Views[0].Repost.Owner != repostOwner || views.Views[0].Repost.ID != repost.Story.ID {
		t.Fatalf("repost interaction = %+v, want owner %+v story %d", views.Views[0].Repost, repostOwner, repost.Story.ID)
	}
	if _, err := store.DeleteStories(ctx, repostOwner, []int{repost.Story.ID}, 202); err != nil {
		t.Fatalf("delete repost: %v", err)
	}
	sourceList, err = store.GetStoriesByID(ctx, sourceOwner.ID, sourceOwner, []int{source.Story.ID}, 202)
	if err != nil {
		t.Fatalf("get source story after delete: %v", err)
	}
	if len(sourceList.Stories) != 1 || sourceList.Stories[0].Views.ForwardsCount != 0 {
		t.Fatalf("source story after delete = %+v, want forwards_count=0", sourceList.Stories)
	}
}

func TestStoryStorePublicForwardListReturnsRepostsOnly(t *testing.T) {
	ctx := context.Background()
	store := NewStoryStore()
	sourceOwner := domain.Peer{Type: domain.PeerTypeChannel, ID: 3311}
	repostOwner := domain.Peer{Type: domain.PeerTypeChannel, ID: 4412}
	privateRepostOwner := domain.Peer{Type: domain.PeerTypeChannel, ID: 4413}
	source, err := store.CreateStory(ctx, domain.StoryCreateRequest{
		Owner:    sourceOwner,
		RandomID: 331101,
		Date:     100,
		Period:   86400,
		Public:   true,
	})
	if err != nil {
		t.Fatalf("create source story: %v", err)
	}
	repost, err := store.CreateStory(ctx, domain.StoryCreateRequest{
		Owner:    repostOwner,
		RandomID: 441201,
		Date:     200,
		Period:   86400,
		Public:   true,
		Forward: &domain.StoryForward{
			From:    sourceOwner,
			StoryID: source.Story.ID,
		},
	})
	if err != nil {
		t.Fatalf("create public repost: %v", err)
	}
	hiddenRepost, err := store.CreateStory(ctx, domain.StoryCreateRequest{
		Owner:    repostOwner,
		RandomID: 441202,
		Date:     202,
		Period:   86400,
		Public:   true,
		Forward: &domain.StoryForward{
			Source:   sourceOwner,
			FromName: "Hidden Source",
			StoryID:  source.Story.ID,
		},
	})
	if err != nil {
		t.Fatalf("create hidden-source public repost: %v", err)
	}
	if _, err := store.CreateStory(ctx, domain.StoryCreateRequest{
		Owner:    privateRepostOwner,
		RandomID: 441301,
		Date:     201,
		Period:   86400,
		Public:   false,
		Forward: &domain.StoryForward{
			From:    sourceOwner,
			StoryID: source.Story.ID,
		},
	}); err != nil {
		t.Fatalf("create private repost: %v", err)
	}
	list, err := store.ListStoryPublicForwards(ctx, domain.StoryPublicForwardListRequest{
		ViewerUserID: sourceOwner.ID,
		Owner:        sourceOwner,
		StoryID:      source.Story.ID,
		Limit:        20,
	})
	if err != nil {
		t.Fatalf("list story public forwards: %v", err)
	}
	if list.Count != 2 || len(list.Forwards) != 2 || list.Forwards[0].Repost == nil || list.Forwards[1].Repost == nil {
		t.Fatalf("public forwards = %+v, want two public reposts", list)
	}
	if list.Forwards[0].Repost.ID != hiddenRepost.Story.ID ||
		list.Forwards[0].Repost.Forward == nil ||
		list.Forwards[0].Repost.Forward.From != (domain.Peer{}) ||
		list.Forwards[0].Repost.Forward.Source != sourceOwner ||
		list.Forwards[0].Repost.Forward.FromName != "Hidden Source" {
		t.Fatalf("hidden public forward repost = %+v, want from_name-only header with source %+v", list.Forwards[0].Repost, sourceOwner)
	}
	if list.Forwards[1].Repost.Owner != repostOwner || list.Forwards[1].Repost.ID != repost.Story.ID {
		t.Fatalf("public forward repost = %+v, want owner %+v story %d", list.Forwards[1].Repost, repostOwner, repost.Story.ID)
	}
	if _, err := store.DeleteStories(ctx, repostOwner, []int{repost.Story.ID}, 202); err != nil {
		t.Fatalf("delete repost: %v", err)
	}
	afterVisibleDelete, err := store.ListStoryPublicForwards(ctx, domain.StoryPublicForwardListRequest{
		ViewerUserID: sourceOwner.ID,
		Owner:        sourceOwner,
		StoryID:      source.Story.ID,
		Limit:        20,
	})
	if err != nil {
		t.Fatalf("list story public forwards after delete: %v", err)
	}
	if afterVisibleDelete.Count != 1 || len(afterVisibleDelete.Forwards) != 1 || afterVisibleDelete.Forwards[0].Repost == nil ||
		afterVisibleDelete.Forwards[0].Repost.ID != hiddenRepost.Story.ID {
		t.Fatalf("public forwards after visible delete = %+v, want hidden repost only", afterVisibleDelete)
	}
	if _, err := store.DeleteStories(ctx, repostOwner, []int{hiddenRepost.Story.ID}, 203); err != nil {
		t.Fatalf("delete hidden repost: %v", err)
	}
	empty, err := store.ListStoryPublicForwards(ctx, domain.StoryPublicForwardListRequest{
		ViewerUserID: sourceOwner.ID,
		Owner:        sourceOwner,
		StoryID:      source.Story.ID,
		Limit:        20,
	})
	if err != nil {
		t.Fatalf("list story public forwards after hidden delete: %v", err)
	}
	if empty.Count != 0 || len(empty.Forwards) != 0 {
		t.Fatalf("public forwards after delete = %+v, want empty", empty)
	}
}

func TestStoryStorePublicRepostStoryReactionsList(t *testing.T) {
	ctx := context.Background()
	store := NewStoryStore()
	sourceOwner := domain.Peer{Type: domain.PeerTypeChannel, ID: 3301}
	repostOwner := domain.Peer{Type: domain.PeerTypeUser, ID: 4402}
	source, err := store.CreateStory(ctx, domain.StoryCreateRequest{
		Owner:    sourceOwner,
		RandomID: 3301,
		Date:     100,
		Period:   86400,
		Public:   true,
	})
	if err != nil {
		t.Fatalf("create source story: %v", err)
	}
	if _, err := store.SetReaction(ctx, 5503, sourceOwner, source.Story.ID, &domain.MessageReaction{
		Type:     domain.MessageReactionEmoji,
		Emoticon: "🔥",
	}, 150); err != nil {
		t.Fatalf("set reaction: %v", err)
	}
	repost, err := store.CreateStory(ctx, domain.StoryCreateRequest{
		Owner:    repostOwner,
		RandomID: 4402,
		Date:     200,
		Period:   86400,
		Public:   true,
		Forward: &domain.StoryForward{
			From:    sourceOwner,
			StoryID: source.Story.ID,
		},
	})
	if err != nil {
		t.Fatalf("create repost story: %v", err)
	}
	list, err := store.ListStoryReactions(ctx, domain.StoryReactionListRequest{
		ViewerUserID:  sourceOwner.ID,
		Owner:         sourceOwner,
		StoryID:       source.Story.ID,
		Limit:         20,
		ForwardsFirst: true,
	})
	if err != nil {
		t.Fatalf("list story reactions: %v", err)
	}
	if list.Count != 2 || len(list.Reactions) != 2 || list.Reactions[0].Repost == nil {
		t.Fatalf("reaction list = %+v, want repost first plus reaction", list)
	}
	if list.Reactions[0].Repost.Owner != repostOwner || list.Reactions[0].Repost.ID != repost.Story.ID {
		t.Fatalf("repost reaction = %+v, want owner %+v story %d", list.Reactions[0].Repost, repostOwner, repost.Story.ID)
	}
	filtered, err := store.ListStoryReactions(ctx, domain.StoryReactionListRequest{
		ViewerUserID: sourceOwner.ID,
		Owner:        sourceOwner,
		StoryID:      source.Story.ID,
		Limit:        20,
		Reaction: &domain.MessageReaction{
			Type:     domain.MessageReactionEmoji,
			Emoticon: "🔥",
		},
	})
	if err != nil {
		t.Fatalf("list filtered story reactions: %v", err)
	}
	if filtered.Count != 1 || len(filtered.Reactions) != 1 || filtered.Reactions[0].Repost != nil || filtered.Reactions[0].ViewerID != 5503 {
		t.Fatalf("filtered reaction list = %+v, want only emoji reactor", filtered)
	}
	if _, err := store.DeleteStories(ctx, repostOwner, []int{repost.Story.ID}, 202); err != nil {
		t.Fatalf("delete repost: %v", err)
	}
	list, err = store.ListStoryReactions(ctx, domain.StoryReactionListRequest{
		ViewerUserID:  sourceOwner.ID,
		Owner:         sourceOwner,
		StoryID:       source.Story.ID,
		Limit:         20,
		ForwardsFirst: true,
	})
	if err != nil {
		t.Fatalf("list story reactions after delete: %v", err)
	}
	if list.Count != 1 || len(list.Reactions) != 1 || list.Reactions[0].Repost != nil {
		t.Fatalf("reaction list after delete = %+v, want only durable reaction", list)
	}
}

func TestStoryStoreListStoriesArchiveCountAndSeek(t *testing.T) {
	ctx := context.Background()
	store := NewStoryStore()
	owner := domain.Peer{Type: domain.PeerTypeUser, ID: 1001}
	fixtures := []domain.Story{
		{Owner: owner, ID: 1, Date: 101, ExpireDate: 900, Public: true},
		{Owner: owner, ID: 2, Date: 102, ExpireDate: 1200, Public: true},
		{Owner: owner, ID: 3, Date: 103, ExpireDate: 900, Public: true, Pinned: true},
		{Owner: owner, ID: 4, Date: 104, ExpireDate: 900, Public: true, Deleted: true},
		{Owner: owner, ID: 5, Date: 105, ExpireDate: 900, Public: true},
		{Owner: domain.Peer{Type: domain.PeerTypeUser, ID: 1002}, ID: 1, Date: 106, ExpireDate: 900, Public: true},
	}
	for _, story := range fixtures {
		if _, err := store.UpsertStory(ctx, domain.UpsertStoryRequest{Story: story}); err != nil {
			t.Fatalf("upsert story %d/%d: %v", story.Owner.ID, story.ID, err)
		}
	}

	countOnly, err := store.ListStoriesArchive(ctx, owner.ID, owner, 0, 0, 1000)
	if err != nil {
		t.Fatalf("count archive stories: %v", err)
	}
	if countOnly.Count != 3 || len(countOnly.Stories) != 0 {
		t.Fatalf("count-only archive = %+v, want count 3 and no page", countOnly)
	}
	first, err := store.ListStoriesArchive(ctx, owner.ID, owner, 0, 2, 1000)
	if err != nil {
		t.Fatalf("list archive first page: %v", err)
	}
	if first.Count != 3 || !sameStoryIDs(storyIDs(first.Stories), []int{5, 3}) {
		t.Fatalf("first archive page = count %d ids %v, want count 3 ids 5,3", first.Count, storyIDs(first.Stories))
	}
	if !first.Stories[1].Pinned || !first.Stories[0].Out || !first.Stories[1].Out {
		t.Fatalf("first archive stories = %+v, want pinned expired retained and owner out=true", first.Stories)
	}
	second, err := store.ListStoriesArchive(ctx, owner.ID, owner, 3, 2, 1000)
	if err != nil {
		t.Fatalf("list archive second page: %v", err)
	}
	if second.Count != 3 || !sameStoryIDs(storyIDs(second.Stories), []int{1}) {
		t.Fatalf("second archive page = count %d ids %v, want count 3 ids 1", second.Count, storyIDs(second.Stories))
	}
}

func TestStoryStoreListOwnerActiveStoriesReturnsFanoutSnapshots(t *testing.T) {
	ctx := context.Background()
	store := NewStoryStore()
	owner := domain.Peer{Type: domain.PeerTypeUser, ID: 1001}
	other := domain.Peer{Type: domain.PeerTypeUser, ID: 1002}
	reaction := &domain.MessageReaction{Type: domain.MessageReactionEmoji, Emoticon: "👍"}
	for _, story := range []domain.Story{
		{
			Owner:        owner,
			ID:           1,
			Date:         100,
			ExpireDate:   1000,
			CloseFriends: true,
			Out:          true,
			Views:        domain.StoryViews{ViewsCount: 1, HasViewers: true, RecentViewers: []int64{2001}},
			SentReaction: reaction,
		},
		{Owner: owner, ID: 2, Date: 101, ExpireDate: 90, CloseFriends: true},
		{Owner: owner, ID: 3, Date: 102, ExpireDate: 1000, CloseFriends: true, Deleted: true},
		{Owner: other, ID: 1, Date: 103, ExpireDate: 1000, CloseFriends: true},
	} {
		if _, err := store.UpsertStory(ctx, domain.UpsertStoryRequest{Story: story}); err != nil {
			t.Fatalf("upsert story %d/%d: %v", story.Owner.ID, story.ID, err)
		}
	}

	list, err := store.ListOwnerActiveStories(ctx, owner, 200, 100)
	if err != nil {
		t.Fatalf("list owner active stories: %v", err)
	}
	if len(list.Stories) != 1 || list.Stories[0].ID != 1 {
		t.Fatalf("owner active stories = %+v, want only story 1", list.Stories)
	}
	story := list.Stories[0]
	if story.Out || story.Views.HasViewers || story.Views.ViewsCount != 0 || story.SentReaction != nil {
		t.Fatalf("fanout snapshot = %+v, want no out/views/reaction", story)
	}
}

func testDomainStoryMediaArea(emoticon string, x float64) domain.StoryMediaArea {
	return domain.StoryMediaArea{
		Kind: domain.StoryMediaAreaSuggestedReaction,
		Coordinates: domain.StoryMediaAreaCoordinates{
			X:         x,
			Y:         10,
			W:         10,
			H:         10,
			Rotation:  15,
			Radius:    8,
			HasRadius: true,
		},
		Dark:     true,
		Flipped:  true,
		Reaction: &domain.MessageReaction{Type: domain.MessageReactionEmoji, Emoticon: emoticon},
	}
}

func assertDomainStoryMediaArea(t *testing.T, story domain.Story, wantEmoticon string, wantX float64) {
	t.Helper()
	if len(story.MediaAreas) != 1 {
		t.Fatalf("story media areas = %+v, want one area", story.MediaAreas)
	}
	area := story.MediaAreas[0]
	if area.Kind != domain.StoryMediaAreaSuggestedReaction || area.Reaction == nil {
		t.Fatalf("story media area = %+v, want suggested reaction", area)
	}
	if area.Reaction.Type != domain.MessageReactionEmoji || area.Reaction.Emoticon != wantEmoticon {
		t.Fatalf("story media area reaction = %+v, want emoji %q", area.Reaction, wantEmoticon)
	}
	if area.Coordinates.X != wantX || area.Coordinates.Y != 10 || area.Coordinates.W != 10 || area.Coordinates.H != 10 ||
		area.Coordinates.Rotation != 15 || !area.Coordinates.HasRadius || area.Coordinates.Radius != 8 {
		t.Fatalf("story media area coordinates = %+v, want x %v y/w/h 10 rotation 15 radius 8", area.Coordinates, wantX)
	}
	if !area.Dark || !area.Flipped {
		t.Fatalf("story media area flags = dark %v flipped %v, want true/true", area.Dark, area.Flipped)
	}
}

func testDomainStoryURLMediaArea(url string, x float64) domain.StoryMediaArea {
	return domain.StoryMediaArea{
		Kind: domain.StoryMediaAreaURL,
		Coordinates: domain.StoryMediaAreaCoordinates{
			X:        x,
			Y:        10,
			W:        20,
			H:        10,
			Rotation: 15,
		},
		URL: url,
	}
}

func assertDomainStoryURLMediaArea(t *testing.T, story domain.Story, wantURL string, wantX float64) {
	t.Helper()
	if len(story.MediaAreas) != 1 {
		t.Fatalf("story media areas = %+v, want one url area", story.MediaAreas)
	}
	area := story.MediaAreas[0]
	if area.Kind != domain.StoryMediaAreaURL || area.URL != wantURL {
		t.Fatalf("story media area = %+v, want url %q", area, wantURL)
	}
	if area.Coordinates.X != wantX || area.Coordinates.Y != 10 || area.Coordinates.W != 20 || area.Coordinates.H != 10 ||
		area.Coordinates.Rotation != 15 {
		t.Fatalf("story media area coordinates = %+v, want x %v y 10 w 20 h 10 rotation 15", area.Coordinates, wantX)
	}
}

func testDomainStoryGeoPointMediaArea(lat, long, x float64) domain.StoryMediaArea {
	return domain.StoryMediaArea{
		Kind: domain.StoryMediaAreaGeoPoint,
		Coordinates: domain.StoryMediaAreaCoordinates{
			X:        x,
			Y:        12,
			W:        22,
			H:        11,
			Rotation: 20,
		},
		Geo: &domain.MessageGeoPoint{
			Lat:        lat,
			Long:       long,
			AccessHash: 123456,
		},
		GeoAddress: &domain.StoryGeoPointAddress{
			CountryISO2: "CN",
			State:       "Shanghai",
			City:        "Shanghai",
			Street:      "People Square",
		},
	}
}

func assertDomainStoryGeoPointMediaArea(t *testing.T, story domain.Story, wantLat, wantLong, wantX float64) {
	t.Helper()
	if len(story.MediaAreas) != 1 {
		t.Fatalf("story media areas = %+v, want one geo area", story.MediaAreas)
	}
	area := story.MediaAreas[0]
	if area.Kind != domain.StoryMediaAreaGeoPoint || area.Geo == nil {
		t.Fatalf("story media area = %+v, want geo point", area)
	}
	if area.Geo.Lat != wantLat || area.Geo.Long != wantLong || area.Geo.AccessHash != 123456 {
		t.Fatalf("story media area geo = %+v, want lat %v long %v access_hash 123456", area.Geo, wantLat, wantLong)
	}
	if area.GeoAddress == nil || area.GeoAddress.CountryISO2 != "CN" || area.GeoAddress.State != "Shanghai" || area.GeoAddress.City != "Shanghai" || area.GeoAddress.Street != "People Square" {
		t.Fatalf("story media area address = %+v, want CN/Shanghai/Shanghai/People Square", area.GeoAddress)
	}
	if area.Coordinates.X != wantX || area.Coordinates.Y != 12 || area.Coordinates.W != 22 || area.Coordinates.H != 11 ||
		area.Coordinates.Rotation != 20 {
		t.Fatalf("story media area coordinates = %+v, want x %v y 12 w 22 h 11 rotation 20", area.Coordinates, wantX)
	}
}

func testDomainStoryVenueMediaArea(title string, lat, long, x float64) domain.StoryMediaArea {
	venue := &domain.MessageVenue{
		Geo:       domain.MessageGeoPoint{Lat: lat, Long: long, AccessHash: 123456},
		Title:     title,
		Address:   "Inline Street",
		Provider:  "gplaces",
		VenueID:   "venue-id",
		VenueType: "cafe",
	}
	return domain.StoryMediaArea{
		Kind: domain.StoryMediaAreaVenue,
		Coordinates: domain.StoryMediaAreaCoordinates{
			X:        x,
			Y:        13,
			W:        23,
			H:        12,
			Rotation: 22,
		},
		Geo:   &venue.Geo,
		Venue: venue,
	}
}

func assertDomainStoryVenueMediaArea(t *testing.T, story domain.Story, wantTitle string, wantLat, wantLong, wantX float64) {
	t.Helper()
	if len(story.MediaAreas) != 1 {
		t.Fatalf("story media areas = %+v, want one venue area", story.MediaAreas)
	}
	area := story.MediaAreas[0]
	if area.Kind != domain.StoryMediaAreaVenue || area.Venue == nil || area.Geo == nil {
		t.Fatalf("story media area = %+v, want venue", area)
	}
	if area.Venue.Title != wantTitle || area.Venue.Address != "Inline Street" || area.Venue.Provider != "gplaces" || area.Venue.VenueID != "venue-id" || area.Venue.VenueType != "cafe" {
		t.Fatalf("story venue = %+v, want %q/Inline Street/gplaces/venue-id/cafe", area.Venue, wantTitle)
	}
	if area.Venue.Geo.Lat != wantLat || area.Venue.Geo.Long != wantLong || area.Venue.Geo.AccessHash != 123456 ||
		area.Geo.Lat != wantLat || area.Geo.Long != wantLong || area.Geo.AccessHash != 123456 {
		t.Fatalf("story venue geo = venue %+v area %+v, want lat %v long %v access_hash 123456", area.Venue.Geo, area.Geo, wantLat, wantLong)
	}
	if area.Coordinates.X != wantX || area.Coordinates.Y != 13 || area.Coordinates.W != 23 || area.Coordinates.H != 12 ||
		area.Coordinates.Rotation != 22 {
		t.Fatalf("story media area coordinates = %+v, want x %v y 13 w 23 h 12 rotation 22", area.Coordinates, wantX)
	}
}

func testDomainStoryWeatherMediaArea(emoji string, temperatureC float64, color int, x float64) domain.StoryMediaArea {
	return domain.StoryMediaArea{
		Kind: domain.StoryMediaAreaWeather,
		Coordinates: domain.StoryMediaAreaCoordinates{
			X:        x,
			Y:        14,
			W:        24,
			H:        12,
			Rotation: 25,
		},
		WeatherEmoji: emoji,
		TemperatureC: temperatureC,
		Color:        color,
	}
}

func assertDomainStoryWeatherMediaArea(t *testing.T, story domain.Story, wantEmoji string, wantTemperatureC float64, wantColor int, wantX float64) {
	t.Helper()
	if len(story.MediaAreas) != 1 {
		t.Fatalf("story media areas = %+v, want one weather area", story.MediaAreas)
	}
	area := story.MediaAreas[0]
	if area.Kind != domain.StoryMediaAreaWeather {
		t.Fatalf("story media area = %+v, want weather", area)
	}
	if area.WeatherEmoji != wantEmoji || area.TemperatureC != wantTemperatureC || area.Color != wantColor {
		t.Fatalf("story weather area = emoji %q temp %v color %d, want %q/%v/%d", area.WeatherEmoji, area.TemperatureC, area.Color, wantEmoji, wantTemperatureC, wantColor)
	}
	if area.Coordinates.X != wantX || area.Coordinates.Y != 14 || area.Coordinates.W != 24 || area.Coordinates.H != 12 ||
		area.Coordinates.Rotation != 25 {
		t.Fatalf("story media area coordinates = %+v, want x %v y 14 w 24 h 12 rotation 25", area.Coordinates, wantX)
	}
}

func testDomainStoryChannelPostMediaArea(channelID int64, msgID int, x float64) domain.StoryMediaArea {
	return domain.StoryMediaArea{
		Kind: domain.StoryMediaAreaChannelPost,
		Coordinates: domain.StoryMediaAreaCoordinates{
			X:        x,
			Y:        15,
			W:        25,
			H:        12,
			Rotation: 27,
		},
		ChannelID: channelID,
		MsgID:     msgID,
	}
}

func assertDomainStoryChannelPostMediaArea(t *testing.T, story domain.Story, wantChannelID int64, wantMsgID int, wantX float64) {
	t.Helper()
	if len(story.MediaAreas) != 1 {
		t.Fatalf("story media areas = %+v, want one channel post area", story.MediaAreas)
	}
	area := story.MediaAreas[0]
	if area.Kind != domain.StoryMediaAreaChannelPost || area.ChannelID != wantChannelID || area.MsgID != wantMsgID {
		t.Fatalf("story channel post area = %+v, want channel %d msg %d", area, wantChannelID, wantMsgID)
	}
	if area.Coordinates.X != wantX || area.Coordinates.Y != 15 || area.Coordinates.W != 25 || area.Coordinates.H != 12 ||
		area.Coordinates.Rotation != 27 {
		t.Fatalf("story media area coordinates = %+v, want x %v y 15 w 25 h 12 rotation 27", area.Coordinates, wantX)
	}
}

func testDomainStoryStarGiftMediaArea(slug string, x float64) domain.StoryMediaArea {
	return domain.StoryMediaArea{
		Kind: domain.StoryMediaAreaStarGift,
		Coordinates: domain.StoryMediaAreaCoordinates{
			X:        x,
			Y:        16,
			W:        26,
			H:        12,
			Rotation: 29,
		},
		StarGiftSlug: slug,
	}
}

func assertDomainStoryStarGiftMediaArea(t *testing.T, story domain.Story, wantSlug string, wantX float64) {
	t.Helper()
	if len(story.MediaAreas) != 1 {
		t.Fatalf("story media areas = %+v, want one star gift area", story.MediaAreas)
	}
	area := story.MediaAreas[0]
	if area.Kind != domain.StoryMediaAreaStarGift || area.StarGiftSlug != wantSlug {
		t.Fatalf("story star gift area = %+v, want slug %q", area, wantSlug)
	}
	if area.Coordinates.X != wantX || area.Coordinates.Y != 16 || area.Coordinates.W != 26 || area.Coordinates.H != 12 ||
		area.Coordinates.Rotation != 29 {
		t.Fatalf("story media area coordinates = %+v, want x %v y 16 w 26 h 12 rotation 29", area.Coordinates, wantX)
	}
}

func assertDomainStoryForward(t *testing.T, story domain.Story, wantSource domain.Peer, wantStoryID int, wantModified bool) {
	t.Helper()
	if story.Forward == nil {
		t.Fatalf("story forward is nil, want source %+v story %d", wantSource, wantStoryID)
	}
	if story.Forward.From != wantSource || story.Forward.StoryID != wantStoryID || story.Forward.Modified != wantModified {
		t.Fatalf("story forward = %+v, want source %+v story %d modified %v", story.Forward, wantSource, wantStoryID, wantModified)
	}
}

func assertDomainStoryForwardName(t *testing.T, story domain.Story, wantName string, wantStoryID int, wantModified bool) {
	t.Helper()
	if story.Forward == nil {
		t.Fatalf("story forward is nil, want from_name %q story %d", wantName, wantStoryID)
	}
	if story.Forward.From != (domain.Peer{}) || story.Forward.FromName != wantName ||
		story.Forward.StoryID != wantStoryID || story.Forward.Modified != wantModified {
		t.Fatalf("story forward = %+v, want from_name %q story %d modified %v", story.Forward, wantName, wantStoryID, wantModified)
	}
}

func TestStoryStoreViewsIdempotentAndReactionReplace(t *testing.T) {
	ctx := context.Background()
	store := NewStoryStore()
	owner := domain.Peer{Type: domain.PeerTypeUser, ID: 1001}
	if _, err := store.UpsertStory(ctx, domain.UpsertStoryRequest{Story: domain.Story{
		Owner:      owner,
		ID:         1,
		Date:       100,
		ExpireDate: 1000,
		Public:     true,
	}}); err != nil {
		t.Fatalf("upsert story: %v", err)
	}

	if created, err := store.IncrementViews(ctx, 2001, owner, []int{1, 1}, 200); err != nil || created != 1 {
		t.Fatalf("increment views first = %d, %v; want 1 nil", created, err)
	}
	if created, err := store.IncrementViews(ctx, 2001, owner, []int{1}, 201); err != nil || created != 0 {
		t.Fatalf("increment views duplicate = %d, %v; want 0 nil", created, err)
	}
	if _, err := store.IncrementViews(ctx, 2001, owner, nil, 201); !errors.Is(err, domain.ErrStoryIDInvalid) {
		t.Fatalf("empty increment views err = %v, want ErrStoryIDInvalid", err)
	}
	like := &domain.MessageReaction{Type: domain.MessageReactionEmoji, Emoticon: "👍"}
	fire := &domain.MessageReaction{Type: domain.MessageReactionEmoji, Emoticon: "🔥"}
	res, err := store.SetReaction(ctx, 2001, owner, 1, like, 202)
	if err != nil {
		t.Fatalf("set reaction: %v", err)
	}
	if !res.Changed || res.Story.Views.ViewsCount != 1 || res.Story.Views.ReactionsCount != 1 {
		t.Fatalf("reaction result = %+v, want one view and one reaction", res)
	}
	res, err = store.SetReaction(ctx, 2001, owner, 1, fire, 203)
	if err != nil {
		t.Fatalf("replace reaction: %v", err)
	}
	if !res.Changed || res.Story.Views.ReactionsCount != 1 || len(res.Story.Views.Reactions) != 1 || res.Story.Views.Reactions[0].Reaction.Emoticon != "🔥" {
		t.Fatalf("replace result = %+v, want only fire reaction", res)
	}
	res, err = store.SetReaction(ctx, 2001, owner, 1, fire, 204)
	if err != nil {
		t.Fatalf("retry same reaction: %v", err)
	}
	if res.Changed || res.Date != 203 || res.Story.Views.ReactionsCount != 1 || len(res.Story.Views.Reactions) != 1 || res.Story.Views.Reactions[0].Reaction.Emoticon != "🔥" {
		t.Fatalf("retry same reaction result = %+v, want unchanged fire reaction at original date", res)
	}
	reactions, err := store.ListStoryReactions(ctx, domain.StoryReactionListRequest{
		ViewerUserID: owner.ID,
		Owner:        owner,
		StoryID:      1,
		Limit:        10,
	})
	if err != nil {
		t.Fatalf("list reactions after retry: %v", err)
	}
	if reactions.Count != 1 || len(reactions.Reactions) != 1 || reactions.Reactions[0].ViewerID != 2001 || reactions.Reactions[0].Date != 203 {
		t.Fatalf("reactions after retry = %+v, want original reaction date", reactions)
	}
	custom := &domain.MessageReaction{Type: domain.MessageReactionCustomEmoji, DocumentID: 12345}
	res, err = store.SetReaction(ctx, 2001, owner, 1, custom, 204)
	if err != nil {
		t.Fatalf("replace with custom reaction: %v", err)
	}
	if !res.Changed || res.Story.Views.ReactionsCount != 1 || len(res.Story.Views.Reactions) != 1 || res.Story.Views.Reactions[0].Reaction.DocumentID != 12345 {
		t.Fatalf("custom replace result = %+v, want one custom reaction", res)
	}
	res, err = store.SetReaction(ctx, 2001, owner, 1, custom, 205)
	if err != nil {
		t.Fatalf("retry same custom reaction: %v", err)
	}
	if res.Changed || res.Date != 204 || res.Story.Views.ReactionsCount != 1 || len(res.Story.Views.Reactions) != 1 || res.Story.Views.Reactions[0].Reaction.DocumentID != 12345 {
		t.Fatalf("retry same custom reaction result = %+v, want unchanged custom reaction at original date", res)
	}
	reactions, err = store.ListStoryReactions(ctx, domain.StoryReactionListRequest{
		ViewerUserID: owner.ID,
		Owner:        owner,
		StoryID:      1,
		Reaction:     custom,
		Limit:        10,
	})
	if err != nil {
		t.Fatalf("list custom reactions: %v", err)
	}
	if reactions.Count != 1 || len(reactions.Reactions) != 1 || reactions.Reactions[0].ViewerID != 2001 || reactions.Reactions[0].Date != 204 || reactions.Reactions[0].Reaction == nil || reactions.Reactions[0].Reaction.DocumentID != 12345 {
		t.Fatalf("custom reactions = %+v, want original custom reaction date", reactions)
	}
	if _, err := store.ListStoryViews(ctx, domain.StoryViewListRequest{
		ViewerUserID: owner.ID,
		Owner:        owner,
		StoryID:      1,
		Offset:       "bad",
		Limit:        10,
	}); !errors.Is(err, domain.ErrStoryOffsetInvalid) {
		t.Fatalf("bad story views offset err = %v, want ErrStoryOffsetInvalid", err)
	}
	if _, err := store.ListStoryReactions(ctx, domain.StoryReactionListRequest{
		ViewerUserID: owner.ID,
		Owner:        owner,
		StoryID:      1,
		Offset:       "1:203:2001",
		Limit:        10,
	}); !errors.Is(err, domain.ErrStoryOffsetInvalid) {
		t.Fatalf("bad story reactions offset err = %v, want ErrStoryOffsetInvalid", err)
	}
	res, err = store.SetReaction(ctx, 2001, owner, 1, nil, 206)
	if err != nil {
		t.Fatalf("clear reaction: %v", err)
	}
	if !res.Changed || res.Story.Views.ReactionsCount != 0 || len(res.Story.Views.Reactions) != 0 {
		t.Fatalf("clear result = %+v, want no reactions", res)
	}
}

func TestStoryStoreExpiredUnpinnedStoriesDoNotAcceptNewInteractions(t *testing.T) {
	ctx := context.Background()
	store := NewStoryStore()
	owner := domain.Peer{Type: domain.PeerTypeUser, ID: 1001}
	for _, story := range []domain.Story{
		{Owner: owner, ID: 1, Date: 100, ExpireDate: 150, Public: true},
		{Owner: owner, ID: 2, Date: 101, ExpireDate: 150, Public: true, Pinned: true},
	} {
		if _, err := store.UpsertStory(ctx, domain.UpsertStoryRequest{Story: story}); err != nil {
			t.Fatalf("upsert story %d: %v", story.ID, err)
		}
	}

	if created, err := store.IncrementViews(ctx, 2001, owner, []int{1}, 200); err != nil || created != 0 {
		t.Fatalf("expired unpinned increment = %d, %v; want 0 nil", created, err)
	}
	if _, err := store.SetReaction(ctx, 2001, owner, 1, &domain.MessageReaction{Type: domain.MessageReactionEmoji, Emoticon: "like"}, 200); !errors.Is(err, domain.ErrStoryNotFound) {
		t.Fatalf("expired unpinned reaction err = %v, want ErrStoryNotFound", err)
	}
	if created, err := store.IncrementViews(ctx, 2001, owner, []int{2}, 200); err != nil || created != 1 {
		t.Fatalf("expired pinned increment = %d, %v; want 1 nil", created, err)
	}
	res, err := store.SetReaction(ctx, 2002, owner, 2, &domain.MessageReaction{Type: domain.MessageReactionEmoji, Emoticon: "fire"}, 201)
	if err != nil {
		t.Fatalf("expired pinned reaction: %v", err)
	}
	if !res.Changed || res.Story.Views.ViewsCount != 2 || res.Story.Views.ReactionsCount != 1 {
		t.Fatalf("expired pinned reaction result = %+v, want accepted profile interaction", res)
	}
}

func TestStoryStoreListsViewsAndReactions(t *testing.T) {
	ctx := context.Background()
	store := NewStoryStore()
	owner := domain.Peer{Type: domain.PeerTypeUser, ID: 1001}
	if _, err := store.UpsertStory(ctx, domain.UpsertStoryRequest{Story: domain.Story{
		Owner:      owner,
		ID:         1,
		Date:       100,
		ExpireDate: 1000,
		Public:     true,
	}}); err != nil {
		t.Fatalf("upsert story: %v", err)
	}

	if _, err := store.IncrementViews(ctx, 2001, owner, []int{1}, 201); err != nil {
		t.Fatalf("increment viewer 2001: %v", err)
	}
	if _, err := store.IncrementViews(ctx, 2004, owner, []int{1}, 204); err != nil {
		t.Fatalf("increment viewer 2004: %v", err)
	}
	like := &domain.MessageReaction{Type: domain.MessageReactionEmoji, Emoticon: "like"}
	fire := &domain.MessageReaction{Type: domain.MessageReactionEmoji, Emoticon: "fire"}
	if _, err := store.SetReaction(ctx, 2002, owner, 1, like, 202); err != nil {
		t.Fatalf("set like reaction: %v", err)
	}
	if _, err := store.SetReaction(ctx, 2003, owner, 1, fire, 203); err != nil {
		t.Fatalf("set fire reaction: %v", err)
	}

	viewerIDs, err := store.ListStoryViewerIDs(ctx, owner, 1, 3)
	if err != nil {
		t.Fatalf("list story viewer ids: %v", err)
	}
	if len(viewerIDs) != 3 || viewerIDs[0] != 2001 || viewerIDs[1] != 2002 || viewerIDs[2] != 2003 {
		t.Fatalf("viewer ids = %v, want first three ascending ids", viewerIDs)
	}

	first, err := store.ListStoryViews(ctx, domain.StoryViewListRequest{
		ViewerUserID:   owner.ID,
		Owner:          owner,
		StoryID:        1,
		Limit:          2,
		ReactionsFirst: true,
	})
	if err != nil {
		t.Fatalf("list views first page: %v", err)
	}
	if first.Count != 4 || first.ViewsCount != 4 || first.ReactionsCount != 2 || len(first.Views) != 2 || first.NextOffset == "" {
		t.Fatalf("first page = %+v, want 4 total, 2 reactions, 2 rows and next offset", first)
	}
	if first.Views[0].ViewerID != 2003 || first.Views[1].ViewerID != 2002 {
		t.Fatalf("first page viewers = %+v, want reactions newest first", first.Views)
	}
	second, err := store.ListStoryViews(ctx, domain.StoryViewListRequest{
		ViewerUserID:   owner.ID,
		Owner:          owner,
		StoryID:        1,
		Limit:          2,
		ReactionsFirst: true,
		Offset:         first.NextOffset,
	})
	if err != nil {
		t.Fatalf("list views second page: %v", err)
	}
	if len(second.Views) != 2 || second.NextOffset != "" || second.Views[0].ViewerID != 2004 || second.Views[1].ViewerID != 2001 {
		t.Fatalf("second page = %+v, want remaining non-reaction viewers", second)
	}

	reactions, err := store.ListStoryReactions(ctx, domain.StoryReactionListRequest{
		ViewerUserID: owner.ID,
		Owner:        owner,
		StoryID:      1,
		Limit:        10,
	})
	if err != nil {
		t.Fatalf("list reactions: %v", err)
	}
	if reactions.Count != 2 || len(reactions.Reactions) != 2 || reactions.Reactions[0].ViewerID != 2003 {
		t.Fatalf("reactions = %+v, want two newest reactions", reactions)
	}
	filtered, err := store.ListStoryReactions(ctx, domain.StoryReactionListRequest{
		ViewerUserID: owner.ID,
		Owner:        owner,
		StoryID:      1,
		Reaction:     fire,
		Limit:        10,
	})
	if err != nil {
		t.Fatalf("list filtered reactions: %v", err)
	}
	if filtered.Count != 1 || len(filtered.Reactions) != 1 || filtered.Reactions[0].ViewerID != 2003 {
		t.Fatalf("filtered reactions = %+v, want viewer 2003 only", filtered)
	}
	if _, err := store.SetReaction(ctx, 2003, owner, 1, nil, 205); err != nil {
		t.Fatalf("clear reaction: %v", err)
	}
	reactions, err = store.ListStoryReactions(ctx, domain.StoryReactionListRequest{
		ViewerUserID: owner.ID,
		Owner:        owner,
		StoryID:      1,
		Limit:        10,
	})
	if err != nil {
		t.Fatalf("list reactions after clear: %v", err)
	}
	if reactions.Count != 1 || len(reactions.Reactions) != 1 || reactions.Reactions[0].ViewerID != 2002 {
		t.Fatalf("reactions after clear = %+v, want only viewer 2002", reactions)
	}
	if _, err := store.DeleteStories(ctx, owner, []int{1}, 206); err != nil {
		t.Fatalf("delete story: %v", err)
	}
	deletedViewerIDs, err := store.ListStoryViewerIDs(ctx, owner, 1, 10)
	if err != nil {
		t.Fatalf("list deleted story viewer ids: %v", err)
	}
	if len(deletedViewerIDs) != 4 || deletedViewerIDs[0] != 2001 || deletedViewerIDs[1] != 2002 || deletedViewerIDs[2] != 2003 || deletedViewerIDs[3] != 2004 {
		t.Fatalf("deleted story viewer ids = %v, want all durable viewers ascending", deletedViewerIDs)
	}
}

func TestStoryStoreViewerIDsIncludeCachedStoryExposure(t *testing.T) {
	ctx := context.Background()
	store := NewStoryStore()
	owner := domain.Peer{Type: domain.PeerTypeUser, ID: 1001}
	if _, err := store.UpsertStory(ctx, domain.UpsertStoryRequest{Story: domain.Story{
		Owner:      owner,
		ID:         1,
		Date:       100,
		ExpireDate: 1000,
		Public:     true,
	}}); err != nil {
		t.Fatalf("upsert story: %v", err)
	}
	if list, err := store.ListActiveStories(ctx, 2005, false, 200, 10); err != nil || len(list.Stories) != 1 {
		t.Fatalf("list active exposure = %+v err=%v, want one story", list, err)
	}
	if peerStories, err := store.GetPeerStories(ctx, 2006, owner, 200); err != nil || len(peerStories.Stories) != 1 {
		t.Fatalf("peer stories exposure = %+v err=%v, want one story", peerStories, err)
	}
	if exact, err := store.GetStoriesByID(ctx, 2007, owner, []int{1}, 200); err != nil || len(exact.Stories) != 1 {
		t.Fatalf("exact exposure = %+v err=%v, want one story", exact, err)
	}

	viewerIDs, err := store.ListStoryViewerIDs(ctx, owner, 1, 10)
	if err != nil {
		t.Fatalf("list story viewer ids: %v", err)
	}
	if len(viewerIDs) != 3 || viewerIDs[0] != 2005 || viewerIDs[1] != 2006 || viewerIDs[2] != 2007 {
		t.Fatalf("viewer ids = %v, want exposure viewers ascending", viewerIDs)
	}
	views, err := store.ListStoryViews(ctx, domain.StoryViewListRequest{
		ViewerUserID: owner.ID,
		Owner:        owner,
		StoryID:      1,
		Limit:        10,
	})
	if err != nil {
		t.Fatalf("list story views: %v", err)
	}
	if views.Count != 0 || views.ViewsCount != 0 || len(views.Views) != 0 {
		t.Fatalf("views = %+v, exposure must not count as a real view", views)
	}
}

func TestStoryStoreListStoryViewsFiltersByContactsAndQuery(t *testing.T) {
	ctx := context.Background()
	store := NewStoryStore()
	owner := domain.Peer{Type: domain.PeerTypeUser, ID: 1001}
	if _, err := store.UpsertStory(ctx, domain.UpsertStoryRequest{Story: domain.Story{
		Owner:      owner,
		ID:         1,
		Date:       100,
		ExpireDate: 1000,
		Public:     true,
	}}); err != nil {
		t.Fatalf("upsert story: %v", err)
	}
	store.SetStoryViewerProfiles(
		domain.User{ID: 2001, FirstName: "Alice", LastName: "Viewer", Username: "alicev", Phone: "155501"},
		domain.User{ID: 2002, FirstName: "Bob", LastName: "Stranger", Username: "bobstory", Phone: "155502"},
		domain.User{ID: 2003, FirstName: "Carol", LastName: "Contact", Username: "carolstory", Phone: "155503"},
	)
	store.SetStoryViewerContacts(owner.ID,
		domain.Contact{User: domain.User{ID: 2001, FirstName: "Alice", Username: "alicev"}, FirstName: "Close", LastName: "Friend", Phone: "7001"},
		domain.Contact{User: domain.User{ID: 2003, FirstName: "Carol", Username: "carolstory"}, FirstName: "Work", LastName: "Carol", Phone: "7003"},
	)
	for _, item := range []struct {
		viewerID int64
		date     int
	}{
		{viewerID: 2001, date: 201},
		{viewerID: 2002, date: 202},
		{viewerID: 2003, date: 203},
	} {
		if _, err := store.IncrementViews(ctx, item.viewerID, owner, []int{1}, item.date); err != nil {
			t.Fatalf("increment viewer %d: %v", item.viewerID, err)
		}
	}

	contactsOnly, err := store.ListStoryViews(ctx, domain.StoryViewListRequest{
		ViewerUserID: owner.ID,
		Owner:        owner,
		StoryID:      1,
		Limit:        10,
		JustContacts: true,
	})
	if err != nil {
		t.Fatalf("list contacts-only: %v", err)
	}
	if contactsOnly.Count != 2 || contactsOnly.ViewsCount != 3 || len(contactsOnly.Views) != 2 || contactsOnly.Views[0].ViewerID != 2003 || contactsOnly.Views[1].ViewerID != 2001 {
		t.Fatalf("contacts-only = %+v, want two contacts and total views 3", contactsOnly)
	}

	remark, err := store.ListStoryViews(ctx, domain.StoryViewListRequest{
		ViewerUserID: owner.ID,
		Owner:        owner,
		StoryID:      1,
		Limit:        10,
		Query:        "close",
	})
	if err != nil {
		t.Fatalf("list query remark: %v", err)
	}
	if remark.Count != 1 || len(remark.Views) != 1 || remark.Views[0].ViewerID != 2001 {
		t.Fatalf("remark query = %+v, want viewer 2001", remark)
	}

	stranger, err := store.ListStoryViews(ctx, domain.StoryViewListRequest{
		ViewerUserID: owner.ID,
		Owner:        owner,
		StoryID:      1,
		Limit:        10,
		Query:        "@bobstory",
	})
	if err != nil {
		t.Fatalf("list query username: %v", err)
	}
	if stranger.Count != 1 || len(stranger.Views) != 1 || stranger.Views[0].ViewerID != 2002 {
		t.Fatalf("username query = %+v, want viewer 2002", stranger)
	}

	hiddenAccountPhone, err := store.ListStoryViews(ctx, domain.StoryViewListRequest{
		ViewerUserID: owner.ID,
		Owner:        owner,
		StoryID:      1,
		Limit:        10,
		Query:        "155502",
	})
	if err != nil {
		t.Fatalf("list query hidden account phone: %v", err)
	}
	if hiddenAccountPhone.Count != 0 || len(hiddenAccountPhone.Views) != 0 {
		t.Fatalf("hidden account phone query = %+v, want no match", hiddenAccountPhone)
	}
	knownContactPhone, err := store.ListStoryViews(ctx, domain.StoryViewListRequest{
		ViewerUserID: owner.ID,
		Owner:        owner,
		StoryID:      1,
		Limit:        10,
		Query:        "7001",
	})
	if err != nil {
		t.Fatalf("list query known contact phone: %v", err)
	}
	if knownContactPhone.Count != 1 || len(knownContactPhone.Views) != 1 || knownContactPhone.Views[0].ViewerID != 2001 {
		t.Fatalf("known contact phone query = %+v, want viewer 2001", knownContactPhone)
	}

	intersection, err := store.ListStoryViews(ctx, domain.StoryViewListRequest{
		ViewerUserID: owner.ID,
		Owner:        owner,
		StoryID:      1,
		Limit:        10,
		Query:        "bob",
		JustContacts: true,
	})
	if err != nil {
		t.Fatalf("list query contacts intersection: %v", err)
	}
	if intersection.Count != 0 || len(intersection.Views) != 0 {
		t.Fatalf("intersection = %+v, want no contact match for bob", intersection)
	}
}

func TestStoryStorePrivacyVisibility(t *testing.T) {
	ctx := context.Background()
	store := NewStoryStore()
	owner := domain.Peer{Type: domain.PeerTypeUser, ID: 1001}
	selectedViewer := int64(2001)
	stranger := int64(2002)
	contactViewer := int64(2003)
	excludedContact := int64(2004)
	closeFriendViewer := int64(2005)
	store.SetStoryViewerContacts(owner.ID,
		domain.Contact{User: domain.User{ID: contactViewer, FirstName: "Contact"}},
		domain.Contact{User: domain.User{ID: excludedContact, FirstName: "Excluded"}},
		domain.Contact{User: domain.User{ID: closeFriendViewer, FirstName: "Close"}, CloseFriend: true},
	)
	stories := []domain.Story{
		{
			Owner:           owner,
			ID:              1,
			Date:            100,
			ExpireDate:      1000,
			Public:          true,
			DisallowUserIDs: []int64{stranger},
			PrivacyRules: []domain.PrivacyRule{
				{Kind: domain.PrivacyRuleAllowAll},
				{Kind: domain.PrivacyRuleDisallowUsers, UserIDs: []int64{stranger}},
			},
		},
		{
			Owner:            owner,
			ID:               2,
			Date:             101,
			ExpireDate:       1000,
			SelectedContacts: true,
			AllowUserIDs:     []int64{selectedViewer},
			PrivacyRules: []domain.PrivacyRule{
				{Kind: domain.PrivacyRuleAllowUsers, UserIDs: []int64{selectedViewer}},
			},
		},
		{
			Owner:           owner,
			ID:              3,
			Date:            102,
			ExpireDate:      1000,
			Contacts:        true,
			DisallowUserIDs: []int64{excludedContact},
			PrivacyRules: []domain.PrivacyRule{
				{Kind: domain.PrivacyRuleAllowContacts},
				{Kind: domain.PrivacyRuleDisallowUsers, UserIDs: []int64{excludedContact}},
			},
		},
		{
			Owner:        owner,
			ID:           4,
			Date:         103,
			ExpireDate:   1000,
			CloseFriends: true,
			PrivacyRules: []domain.PrivacyRule{
				{Kind: domain.PrivacyRuleAllowCloseFriends},
			},
		},
	}
	for _, story := range stories {
		if _, err := store.UpsertStory(ctx, domain.UpsertStoryRequest{Story: story}); err != nil {
			t.Fatalf("upsert story %d: %v", story.ID, err)
		}
	}

	selected, err := store.GetStoriesByID(ctx, selectedViewer, owner, []int{1, 2, 3, 4}, 200)
	if err != nil {
		t.Fatalf("selected viewer get stories: %v", err)
	}
	if gotIDs := storyIDs(selected.Stories); !sameStoryIDs(gotIDs, []int{1, 2}) {
		t.Fatalf("selected viewer story ids = %v, want [1 2]", gotIDs)
	}
	hidden, err := store.GetStoriesByID(ctx, stranger, owner, []int{1, 2, 3, 4}, 200)
	if err != nil {
		t.Fatalf("stranger get stories: %v", err)
	}
	if len(hidden.Stories) != 0 {
		t.Fatalf("stranger stories = %+v, want none", hidden.Stories)
	}
	contacts, err := store.GetStoriesByID(ctx, contactViewer, owner, []int{1, 2, 3, 4}, 200)
	if err != nil {
		t.Fatalf("contact get stories: %v", err)
	}
	if gotIDs := storyIDs(contacts.Stories); !sameStoryIDs(gotIDs, []int{1, 3}) {
		t.Fatalf("contact story ids = %v, want [1 3]", gotIDs)
	}
	excluded, err := store.GetStoriesByID(ctx, excludedContact, owner, []int{3}, 200)
	if err != nil {
		t.Fatalf("excluded contact get stories: %v", err)
	}
	if len(excluded.Stories) != 0 {
		t.Fatalf("excluded contact stories = %+v, want none", excluded.Stories)
	}
	closeFriend, err := store.GetStoriesByID(ctx, closeFriendViewer, owner, []int{1, 2, 3, 4}, 200)
	if err != nil {
		t.Fatalf("close friend get stories: %v", err)
	}
	if gotIDs := storyIDs(closeFriend.Stories); !sameStoryIDs(gotIDs, []int{1, 3, 4}) {
		t.Fatalf("close friend story ids = %v, want [1 3 4]", gotIDs)
	}
	if created, err := store.IncrementViews(ctx, stranger, owner, []int{2}, 210); err != nil || created != 0 {
		t.Fatalf("hidden increment views = %d, %v; want 0 nil", created, err)
	}
	if _, err := store.SetReaction(ctx, stranger, owner, 2, &domain.MessageReaction{Type: domain.MessageReactionEmoji, Emoticon: "like"}, 211); err != domain.ErrStoryNotFound {
		t.Fatalf("hidden set reaction err = %v, want ErrStoryNotFound", err)
	}
}

func TestStoryStoreCreateEditDeleteAndPinned(t *testing.T) {
	ctx := context.Background()
	store := NewStoryStore()
	owner := domain.Peer{Type: domain.PeerTypeUser, ID: 1001}
	media := &domain.MessageMedia{Kind: domain.MessageMediaKindPhoto, Photo: &domain.Photo{ID: 77, AccessHash: 7, DCID: 2}}

	created, err := store.CreateStory(ctx, domain.StoryCreateRequest{
		Owner:      owner,
		RandomID:   9001,
		Date:       100,
		Period:     86400,
		Public:     true,
		Pinned:     true,
		Caption:    "first",
		Media:      media,
		NoForwards: true,
	})
	if err != nil {
		t.Fatalf("create story: %v", err)
	}
	if created.Duplicate || created.Story.ID != 1 || created.Story.ExpireDate != 86500 || !created.Story.Pinned {
		t.Fatalf("created = %+v, want new pinned story id 1", created)
	}
	dup, err := store.CreateStory(ctx, domain.StoryCreateRequest{
		Owner:    owner,
		RandomID: 9001,
		Date:     101,
		Period:   86400,
		Public:   true,
		Caption:  "retry must not win",
		Media:    media,
	})
	if err != nil {
		t.Fatalf("create duplicate: %v", err)
	}
	if !dup.Duplicate || dup.Story.ID != created.Story.ID || dup.Story.Caption != "first" {
		t.Fatalf("duplicate = %+v, want original story", dup)
	}
	read, err := store.GetPeerStories(ctx, owner.ID, owner, 102)
	if err != nil {
		t.Fatalf("get self stories: %v", err)
	}
	if read.MaxReadID != 1 {
		t.Fatalf("self max read = %d, want created story id", read.MaxReadID)
	}

	edited, err := store.EditStory(ctx, domain.StoryEditRequest{
		Owner:         owner,
		ID:            created.Story.ID,
		Caption:       "edited",
		UpdateCaption: true,
	})
	if err != nil {
		t.Fatalf("edit story: %v", err)
	}
	if edited.Previous.Caption != "first" || edited.Previous.Edited {
		t.Fatalf("previous = %+v, want pre-edit story", edited.Previous)
	}
	if !edited.Story.Edited || edited.Story.Caption != "edited" || !edited.Story.Pinned {
		t.Fatalf("edited = %+v, want edited caption preserving pin", edited)
	}
	pinned, err := store.ListPinnedStories(ctx, owner.ID, owner, 0, 10, 103)
	if err != nil {
		t.Fatalf("list pinned: %v", err)
	}
	if len(pinned.Stories) != 1 || pinned.Stories[0].ID != created.Story.ID {
		t.Fatalf("pinned = %+v, want created story", pinned)
	}

	deleted, err := store.DeleteStories(ctx, owner, []int{created.Story.ID}, 104)
	if err != nil {
		t.Fatalf("delete story: %v", err)
	}
	if len(deleted.Stories) != 1 || !deleted.Stories[0].Deleted || deleted.Stories[0].Pinned {
		t.Fatalf("deleted = %+v, want deleted unpinned snapshot", deleted)
	}
	if len(deleted.Previous) != 1 || deleted.Previous[0].Deleted || !deleted.Previous[0].Pinned {
		t.Fatalf("deleted previous = %+v, want pre-delete pinned snapshot", deleted.Previous)
	}
	active, err := store.GetPeerStories(ctx, owner.ID, owner, 105)
	if err != nil {
		t.Fatalf("get active after delete: %v", err)
	}
	if len(active.Stories) != 0 {
		t.Fatalf("active after delete = %+v, want empty", active)
	}
}

func TestStoryMutationIDsAreDeduped(t *testing.T) {
	ctx := context.Background()
	store := NewStoryStore()
	owner := domain.Peer{Type: domain.PeerTypeUser, ID: 1001}
	media := &domain.MessageMedia{Kind: domain.MessageMediaKindPhoto, Photo: &domain.Photo{ID: 1}}
	created, err := store.CreateStory(ctx, domain.StoryCreateRequest{
		Owner:    owner,
		RandomID: 9101,
		Date:     100,
		Period:   86400,
		Public:   true,
		Media:    media,
	})
	if err != nil {
		t.Fatalf("create story: %v", err)
	}

	toggled, err := store.TogglePinned(ctx, owner, []int{created.Story.ID, created.Story.ID}, true, 101)
	if err != nil {
		t.Fatalf("toggle pinned: %v", err)
	}
	if len(toggled.IDs) != 1 || toggled.IDs[0] != created.Story.ID || len(toggled.Stories) != 1 || !toggled.Stories[0].Pinned {
		t.Fatalf("toggled = %+v, want one pinned story", toggled)
	}
	if len(toggled.Previous) != 1 || toggled.Previous[0].Pinned {
		t.Fatalf("toggled previous = %+v, want pre-toggle unpinned snapshot", toggled.Previous)
	}
	retryToggled, err := store.TogglePinned(ctx, owner, []int{created.Story.ID}, true, 102)
	if err != nil {
		t.Fatalf("retry toggle pinned: %v", err)
	}
	if len(retryToggled.IDs) != 1 || retryToggled.IDs[0] != created.Story.ID || len(retryToggled.Stories) != 0 || len(retryToggled.Previous) != 0 {
		t.Fatalf("retry toggled = %+v, want id echo without mutation snapshot", retryToggled)
	}
	unpinned, err := store.TogglePinned(ctx, owner, []int{created.Story.ID}, false, 103)
	if err != nil {
		t.Fatalf("toggle unpinned: %v", err)
	}
	if len(unpinned.Stories) != 1 || unpinned.Stories[0].Pinned || len(unpinned.Previous) != 1 || !unpinned.Previous[0].Pinned {
		t.Fatalf("unpinned = %+v, want unpinned story with pre-toggle pinned snapshot", unpinned)
	}
	retryUnpinned, err := store.TogglePinned(ctx, owner, []int{created.Story.ID}, false, 104)
	if err != nil {
		t.Fatalf("retry toggle unpinned: %v", err)
	}
	if len(retryUnpinned.Stories) != 0 || len(retryUnpinned.Previous) != 0 {
		t.Fatalf("retry unpinned = %+v, want no mutation snapshots", retryUnpinned)
	}

	emptyToggle, err := store.TogglePinned(ctx, owner, nil, false, 101)
	if err != nil {
		t.Fatalf("empty toggle pinned: %v", err)
	}
	if len(emptyToggle.IDs) != 0 || len(emptyToggle.Stories) != 0 {
		t.Fatalf("empty toggle = %+v, want no-op", emptyToggle)
	}

	deleted, err := store.DeleteStories(ctx, owner, []int{created.Story.ID, created.Story.ID}, 102)
	if err != nil {
		t.Fatalf("delete story: %v", err)
	}
	if len(deleted.IDs) != 1 || deleted.IDs[0] != created.Story.ID || len(deleted.Stories) != 1 || !deleted.Stories[0].Deleted {
		t.Fatalf("deleted = %+v, want one deleted story", deleted)
	}
	retryDeleted, err := store.DeleteStories(ctx, owner, []int{created.Story.ID}, 103)
	if err != nil {
		t.Fatalf("retry delete story: %v", err)
	}
	if len(retryDeleted.IDs) != 1 || retryDeleted.IDs[0] != created.Story.ID || len(retryDeleted.Stories) != 0 {
		t.Fatalf("retry deleted = %+v, want id echo without mutation snapshot", retryDeleted)
	}
}

func TestStoryStorePinnedToTopOrder(t *testing.T) {
	ctx := context.Background()
	store := NewStoryStore()
	owner := domain.Peer{Type: domain.PeerTypeUser, ID: 1001}
	for _, id := range []int{1, 2, 3, 4} {
		if _, err := store.UpsertStory(ctx, domain.UpsertStoryRequest{Story: domain.Story{
			Owner:      owner,
			ID:         id,
			Date:       100 + id,
			ExpireDate: 1000,
			Pinned:     true,
			Public:     true,
		}}); err != nil {
			t.Fatalf("upsert story %d: %v", id, err)
		}
	}
	if err := store.TogglePinnedToTop(ctx, owner, []int{3, 1, 3}); err != nil {
		t.Fatalf("toggle pinned to top: %v", err)
	}
	pinned, err := store.ListPinnedStories(ctx, owner.ID, owner, 0, 2, 200)
	if err != nil {
		t.Fatalf("list pinned stories: %v", err)
	}
	if pinned.Count != 4 || !sameStoryIDs(storyIDs(pinned.Stories), []int{4, 3}) || !sameStoryIDs(pinned.PinnedToTop, []int{3, 1}) {
		t.Fatalf("pinned = count %d stories %v top %v, want count 4 stories 4,3 top 3,1", pinned.Count, storyIDs(pinned.Stories), pinned.PinnedToTop)
	}
	androidInitial, err := store.ListPinnedStories(ctx, owner.ID, owner, -1, 2, 200)
	if err != nil {
		t.Fatalf("list pinned stories with android sentinel: %v", err)
	}
	if androidInitial.Count != pinned.Count || !sameStoryIDs(storyIDs(androidInitial.Stories), []int{4, 3}) || !sameStoryIDs(androidInitial.PinnedToTop, []int{3, 1}) {
		t.Fatalf("android sentinel pinned = count %d stories %v top %v, want same first page 4,3 top 3,1", androidInitial.Count, storyIDs(androidInitial.Stories), androidInitial.PinnedToTop)
	}
	if err := store.TogglePinnedToTop(ctx, owner, []int{2, 1, 4}); err != nil {
		t.Fatalf("replace pinned to top: %v", err)
	}
	pinned, err = store.ListPinnedStories(ctx, owner.ID, owner, 0, 10, 201)
	if err != nil {
		t.Fatalf("list replaced pinned stories: %v", err)
	}
	if !sameStoryIDs(pinned.PinnedToTop, []int{2, 1, 4}) {
		t.Fatalf("replaced top = %v, want 2,1,4", pinned.PinnedToTop)
	}
	pageAfterOffset, err := store.ListPinnedStories(ctx, owner.ID, owner, 3, 10, 201)
	if err != nil {
		t.Fatalf("list pinned page after offset: %v", err)
	}
	if !sameStoryIDs(storyIDs(pageAfterOffset.Stories), []int{2, 1}) || !sameStoryIDs(pageAfterOffset.PinnedToTop, []int{2, 1, 4}) {
		t.Fatalf("offset page stories %v top %v, want stories 2,1 and full top 2,1,4", storyIDs(pageAfterOffset.Stories), pageAfterOffset.PinnedToTop)
	}
	if _, err := store.TogglePinned(ctx, owner, []int{2}, false, 202); err != nil {
		t.Fatalf("unpin story: %v", err)
	}
	pinned, err = store.ListPinnedStories(ctx, owner.ID, owner, 0, 10, 203)
	if err != nil {
		t.Fatalf("list after unpin: %v", err)
	}
	if !sameStoryIDs(pinned.PinnedToTop, []int{1, 4}) {
		t.Fatalf("top after unpin = %v, want 1,4", pinned.PinnedToTop)
	}
	if err := store.TogglePinnedToTop(ctx, owner, []int{2}); !errors.Is(err, domain.ErrStoryIDInvalid) {
		t.Fatalf("unpinned top err = %v, want ErrStoryIDInvalid", err)
	}
	if _, err := store.DeleteStories(ctx, owner, []int{1}, 204); err != nil {
		t.Fatalf("delete story: %v", err)
	}
	pinned, err = store.ListPinnedStories(ctx, owner.ID, owner, 0, 10, 205)
	if err != nil {
		t.Fatalf("list after delete: %v", err)
	}
	if !sameStoryIDs(pinned.PinnedToTop, []int{4}) {
		t.Fatalf("top after delete = %v, want 4", pinned.PinnedToTop)
	}
	if err := store.TogglePinnedToTop(ctx, owner, nil); err != nil {
		t.Fatalf("clear pinned to top: %v", err)
	}
	pinned, err = store.ListPinnedStories(ctx, owner.ID, owner, 0, 10, 206)
	if err != nil {
		t.Fatalf("list after clear: %v", err)
	}
	if len(pinned.PinnedToTop) != 0 {
		t.Fatalf("top after clear = %v, want empty", pinned.PinnedToTop)
	}
}

func storyIDs(stories []domain.Story) []int {
	out := make([]int, 0, len(stories))
	for _, story := range stories {
		out = append(out, story.ID)
	}
	return out
}

func sameStoryIDs(got, want []int) bool {
	if len(got) != len(want) {
		return false
	}
	for i := range got {
		if got[i] != want[i] {
			return false
		}
	}
	return true
}