package postgres

import (
	"context"
	"fmt"
	"sync"
	"sync/atomic"
	"testing"
	"time"

	"telesrv/internal/domain"
)

func TestChannelMemberCacheNilDisabled(t *testing.T) {
	if c := NewChannelMemberCache(0); c != nil {
		t.Fatalf("max<=0 should return nil (disabled), got %v", c)
	}
	var nilCache *ChannelMemberCache
	nilCache.put(domain.ChannelMember{ChannelID: 1, UserID: 2})
	nilCache.delete(1, 2)
	nilCache.deleteChannel(1)
	nilCache.flush()
	if _, ok := nilCache.get(1, 2); ok {
		t.Fatalf("nil cache get must return ok=false")
	}
}

func TestChannelMemberCachePutGetDeleteFlush(t *testing.T) {
	c := NewChannelMemberCache(16)
	member := domain.ChannelMember{
		ChannelID:      10,
		UserID:         20,
		Role:           domain.ChannelRoleAdmin,
		Status:         domain.ChannelMemberActive,
		ReadInboxMaxID: 9,
	}

	if _, ok := c.get(10, 20); ok {
		t.Fatalf("an empty cache should not hit")
	}
	c.put(member)
	got, ok := c.get(10, 20)
	if !ok || got.ChannelID != 10 || got.UserID != 20 || got.Role != domain.ChannelRoleAdmin || got.ReadInboxMaxID != 9 {
		t.Fatalf("put/get round trip failed: %+v ok=%v", got, ok)
	}

	c.delete(10, 20)
	if _, ok := c.get(10, 20); ok {
		t.Fatalf("should not hit after delete")
	}
	c.put(member)
	c.flush()
	if _, ok := c.get(10, 20); ok {
		t.Fatalf("should not hit after flush")
	}
}

func TestChannelMemberCachePutIfEpochRejectsStaleSnapshot(t *testing.T) {
	c := NewChannelMemberCache(16)
	epoch := c.cacheEpoch()
	c.delete(10, 20)
	c.putIfEpoch(domain.ChannelMember{
		ChannelID: 10,
		UserID:    20,
		Status:    domain.ChannelMemberActive,
	}, epoch)
	if _, ok := c.get(10, 20); ok {
		t.Fatal("stale materialized membership restored after invalidation")
	}
	freshEpoch := c.cacheEpoch()
	c.putIfEpoch(domain.ChannelMember{
		ChannelID: 10,
		UserID:    20,
		Status:    domain.ChannelMemberActive,
	}, freshEpoch)
	if member, ok := c.get(10, 20); !ok || member.Status != domain.ChannelMemberActive {
		t.Fatalf("fresh materialized membership = %+v ok=%v", member, ok)
	}
}

func TestChannelMemberCacheDeleteChannelAndCap(t *testing.T) {
	c := NewChannelMemberCache(2)
	c.put(domain.ChannelMember{ChannelID: 1, UserID: 10})
	c.put(domain.ChannelMember{ChannelID: 1, UserID: 11})
	c.deleteChannel(1)
	if _, ok := c.get(1, 10); ok {
		t.Fatalf("deleteChannel should invalidate members of the same channel")
	}
	if _, ok := c.get(1, 11); ok {
		t.Fatalf("deleteChannel should invalidate members of the same channel")
	}

	c.put(domain.ChannelMember{ChannelID: 2, UserID: 10})
	c.put(domain.ChannelMember{ChannelID: 2, UserID: 11})
	c.put(domain.ChannelMember{ChannelID: 2, UserID: 12}) // over cap=2: LRU evicts the oldest single entry (2,10)
	if _, ok := c.get(2, 10); ok {
		t.Fatalf("over the limit the oldest entry (2,10) should be evicted")
	}
	if _, ok := c.get(2, 11); !ok {
		t.Fatalf("single-entry LRU eviction should keep the next-newest entry (2,11), proving it is not a whole-table flush")
	}
	if _, ok := c.get(2, 12); !ok {
		t.Fatalf("the newest written entry (2,12) should be present after exceeding the limit")
	}
}

func TestChannelMemberCacheSingleflightsColdLoad(t *testing.T) {
	c := NewChannelMemberCache(16)
	var calls atomic.Int32
	started := make(chan struct{})
	release := make(chan struct{})
	var once sync.Once
	load := func() (domain.ChannelMember, error) {
		calls.Add(1)
		once.Do(func() { close(started) })
		<-release
		return domain.ChannelMember{ChannelID: 7, UserID: 100, Status: domain.ChannelMemberActive}, nil
	}

	const goroutines = 16
	var wg sync.WaitGroup
	errs := make(chan error, goroutines)
	wg.Add(goroutines)
	for i := 0; i < goroutines; i++ {
		go func() {
			defer wg.Done()
			member, err := c.getOrLoad(context.Background(), 7, 100, load)
			if err != nil {
				errs <- err
				return
			}
			if member.ChannelID != 7 || member.UserID != 100 || member.Status != domain.ChannelMemberActive {
				errs <- fmt.Errorf("member = %+v, want active 7/100", member)
			}
		}()
	}
	<-started
	time.Sleep(20 * time.Millisecond)
	close(release)
	wg.Wait()
	close(errs)
	for err := range errs {
		if err != nil {
			t.Fatal(err)
		}
	}
	if got := calls.Load(); got != 1 {
		t.Fatalf("load calls = %d, want 1", got)
	}
	if _, err := c.getOrLoad(context.Background(), 7, 100, load); err != nil {
		t.Fatalf("cached getOrLoad: %v", err)
	}
	if got := calls.Load(); got != 1 {
		t.Fatalf("cache hit called load again: calls=%d", got)
	}
}

func TestReadModelChangeListenerInvalidatesChannelCaches(t *testing.T) {
	rows := NewChannelRowCache(16)
	members := NewChannelMemberCache(16)
	fullBots := &fakeChannelFullBotReadModelCache{}
	botMembers := &fakeChannelBotMemberReadModelCache{}
	mediaCounts := &fakeChannelMediaCountReadModelCache{}
	rows.put(domain.Channel{ID: 7, Title: "old"})
	members.put(domain.ChannelMember{ChannelID: 7, UserID: 100, Status: domain.ChannelMemberActive})
	members.put(domain.ChannelMember{ChannelID: 7, UserID: 200, Status: domain.ChannelMemberActive})
	members.put(domain.ChannelMember{ChannelID: 8, UserID: 100, Status: domain.ChannelMemberActive})

	listener := NewReadModelChangeListener("", ReadModelCacheSet{
		ChannelRows:        rows,
		ChannelMembers:     members,
		ChannelFullBots:    fullBots,
		ChannelBotMembers:  botMembers,
		ChannelMediaCounts: mediaCounts,
	}, nil)
	listener.handlePayload(`{"model":"channel_member","owner_user_id":100,"peer_type":"channel","peer_id":7,"version":2}`)
	if _, ok := members.get(7, 100); ok {
		t.Fatalf("a channel_member event should invalidate the specified member")
	}
	if _, ok := members.get(7, 200); !ok {
		t.Fatalf("a channel_member event should not invalidate other members of the same channel")
	}
	if got := fullBots.channelsSnapshot(); len(got) != 1 || got[0] != 7 {
		t.Fatalf("channel_member should invalidate full bot info: %+v", got)
	}
	if got := botMembers.channelsSnapshot(); len(got) != 1 || got[0] != 7 {
		t.Fatalf("channel_member should invalidate bot member ids: %+v", got)
	}
	if got := mediaCounts.viewerSnapshot(); len(got) != 1 || got[0] != [2]int64{100, 7} {
		t.Fatalf("channel_member should invalidate the media count for that viewer: %+v", got)
	}

	listener.handlePayload(`{"model":"channel_base","owner_user_id":0,"peer_type":"channel","peer_id":7,"version":3}`)
	if _, ok := rows.get(7); ok {
		t.Fatalf("a channel_base event should invalidate the channel row")
	}
	if _, ok := members.get(7, 200); ok {
		t.Fatalf("a channel_base event should invalidate all members of that channel")
	}
	if _, ok := members.get(8, 100); !ok {
		t.Fatalf("a channel_base event should not invalidate members of other channels")
	}
	if got := fullBots.channelsSnapshot(); len(got) != 2 || got[1] != 7 {
		t.Fatalf("channel_base should invalidate full bot info: %+v", got)
	}
	if got := botMembers.channelsSnapshot(); len(got) != 2 || got[1] != 7 {
		t.Fatalf("channel_base should invalidate bot member ids: %+v", got)
	}

	listener.handlePayload(`{"model":"channel_participants","owner_user_id":0,"peer_type":"channel","peer_id":7,"version":4}`)
	if got := botMembers.channelsSnapshot(); len(got) != 3 || got[2] != 7 {
		t.Fatalf("channel_participants should invalidate bot member ids: %+v", got)
	}

	listener.handlePayload(`{"model":"channel_media_counts","owner_user_id":0,"peer_type":"channel","peer_id":7,"version":5}`)
	if got := mediaCounts.channelSnapshot(); len(got) != 1 || got[0] != 7 {
		t.Fatalf("channel_media_counts should invalidate the media count for that channel: %+v", got)
	}
}

func TestReadModelChangeListenerInvalidatesPrivateMediaCountCache(t *testing.T) {
	privateCounts := &fakePrivateMediaCountReadModelCache{}
	listener := NewReadModelChangeListener("", ReadModelCacheSet{
		PrivateMediaCounts: privateCounts,
	}, nil)

	listener.handlePayload(`{"model":"private_media_counts","owner_user_id":100,"peer_type":"user","peer_id":200,"version":2}`)
	if got := privateCounts.keysSnapshot(); len(got) != 1 || got[0] != [2]int64{100, 200} {
		t.Fatalf("private_media_counts should invalidate the owner+peer media count: %+v", got)
	}
}

func TestReadModelChangeListenerInvalidatesAccountSettingsCache(t *testing.T) {
	settings := &fakeAccountSettingsReadModelCache{}
	listener := NewReadModelChangeListener("", ReadModelCacheSet{
		AccountSettings: settings,
	}, nil)

	listener.handlePayload(`{"model":"account_settings","owner_user_id":100,"peer_type":"user","peer_id":100,"version":2}`)
	if len(settings.invalidated) != 1 || settings.invalidated[0] != 100 {
		t.Fatalf("account_settings invalidations = %v, want [100]", settings.invalidated)
	}
	if len(settings.warmed) != 1 || settings.warmed[0] != 100 {
		t.Fatalf("account_settings warmups = %v, want [100]", settings.warmed)
	}

	listener.flush("test")
	if settings.flushes != 1 {
		t.Fatalf("account_settings flushes = %d, want 1", settings.flushes)
	}
}

type fakeAccountSettingsReadModelCache struct {
	invalidated []int64
	warmed      []int64
	flushes     int
}

func (f *fakeAccountSettingsReadModelCache) InvalidateAccountSettingsReadModel(userID int64) {
	f.invalidated = append(f.invalidated, userID)
}

func (f *fakeAccountSettingsReadModelCache) FlushAccountSettingsReadModel() {
	f.flushes++
}

func (f *fakeAccountSettingsReadModelCache) WarmAccountSettingsReadModel(_ context.Context, userID int64) error {
	f.warmed = append(f.warmed, userID)
	return nil
}

// TestReadModelChangeListenerBotFullFlushesChannelFullBots regression: a bot profile change (bot_full event,
// migration 0013) must flush channelFullBotInfoCache (otherwise the group info page's bot bio/commands stay stale across instances until TTL);
// a regular user's user_base event must not flush (otherwise the cache is effectively useless).
func TestReadModelChangeListenerBotFullFlushesChannelFullBots(t *testing.T) {
	fullBots := &fakeChannelFullBotReadModelCache{}
	listener := NewReadModelChangeListener("", ReadModelCacheSet{
		ChannelFullBots: fullBots,
	}, nil)

	listener.handlePayload(`{"model":"bot_full","owner_user_id":1780243210,"peer_type":"user","peer_id":1780243210,"version":2}`)
	if got := fullBots.flushCount(); got != 1 {
		t.Fatalf("bot_full should flush channelFullBotInfoCache: flushes=%d", got)
	}

	listener.handlePayload(`{"model":"user_base","owner_user_id":500,"peer_type":"user","peer_id":500,"version":3}`)
	if got := fullBots.flushCount(); got != 1 {
		t.Fatalf("user_base (regular user) should not flush channelFullBots: flushes=%d", got)
	}
}

type fakeChannelFullBotReadModelCache struct {
	mu       sync.Mutex
	channels []int64
	flushes  int
}

func (f *fakeChannelFullBotReadModelCache) InvalidateChannelFullBotInfoReadModel(channelID int64) {
	f.mu.Lock()
	defer f.mu.Unlock()
	f.channels = append(f.channels, channelID)
}

func (f *fakeChannelFullBotReadModelCache) FlushChannelFullBotInfoReadModel() {
	f.mu.Lock()
	defer f.mu.Unlock()
	f.flushes++
}

func (f *fakeChannelFullBotReadModelCache) channelsSnapshot() []int64 {
	f.mu.Lock()
	defer f.mu.Unlock()
	return append([]int64(nil), f.channels...)
}

func (f *fakeChannelFullBotReadModelCache) flushCount() int {
	f.mu.Lock()
	defer f.mu.Unlock()
	return f.flushes
}

type fakeChannelBotMemberReadModelCache struct {
	mu       sync.Mutex
	channels []int64
	flushes  int
}

func (f *fakeChannelBotMemberReadModelCache) InvalidateActiveBotMemberIDsReadModel(channelID int64) {
	f.mu.Lock()
	defer f.mu.Unlock()
	f.channels = append(f.channels, channelID)
}

func (f *fakeChannelBotMemberReadModelCache) FlushActiveBotMemberIDsReadModel() {
	f.mu.Lock()
	defer f.mu.Unlock()
	f.flushes++
}

func (f *fakeChannelBotMemberReadModelCache) channelsSnapshot() []int64 {
	f.mu.Lock()
	defer f.mu.Unlock()
	return append([]int64(nil), f.channels...)
}

type fakeChannelMediaCountReadModelCache struct {
	mu       sync.Mutex
	channels []int64
	viewers  [][2]int64
	flushes  int
}

func (f *fakeChannelMediaCountReadModelCache) InvalidateChannelMediaCountReadModel(channelID int64) {
	f.mu.Lock()
	defer f.mu.Unlock()
	f.channels = append(f.channels, channelID)
}

func (f *fakeChannelMediaCountReadModelCache) InvalidateChannelMediaCountReadModelForViewer(userID, channelID int64) {
	f.mu.Lock()
	defer f.mu.Unlock()
	f.viewers = append(f.viewers, [2]int64{userID, channelID})
}

func (f *fakeChannelMediaCountReadModelCache) FlushChannelMediaCountReadModel() {
	f.mu.Lock()
	defer f.mu.Unlock()
	f.flushes++
}

func (f *fakeChannelMediaCountReadModelCache) channelSnapshot() []int64 {
	f.mu.Lock()
	defer f.mu.Unlock()
	return append([]int64(nil), f.channels...)
}

func (f *fakeChannelMediaCountReadModelCache) viewerSnapshot() [][2]int64 {
	f.mu.Lock()
	defer f.mu.Unlock()
	return append([][2]int64(nil), f.viewers...)
}

func (f *fakeChannelMediaCountReadModelCache) flushCount() int {
	f.mu.Lock()
	defer f.mu.Unlock()
	return f.flushes
}

type fakePrivateMediaCountReadModelCache struct {
	mu      sync.Mutex
	keys    [][2]int64
	flushes int
}

func (f *fakePrivateMediaCountReadModelCache) InvalidatePrivateMediaCountReadModel(userID, peerID int64) {
	f.mu.Lock()
	defer f.mu.Unlock()
	f.keys = append(f.keys, [2]int64{userID, peerID})
}

func (f *fakePrivateMediaCountReadModelCache) FlushPrivateMediaCountReadModel() {
	f.mu.Lock()
	defer f.mu.Unlock()
	f.flushes++
}

func (f *fakePrivateMediaCountReadModelCache) keysSnapshot() [][2]int64 {
	f.mu.Lock()
	defer f.mu.Unlock()
	return append([][2]int64(nil), f.keys...)
}

func (f *fakePrivateMediaCountReadModelCache) flushCount() int {
	f.mu.Lock()
	defer f.mu.Unlock()
	return f.flushes
}

type fakeContactReadModelCache struct {
	mu      sync.Mutex
	ids     []int64
	flushes int
}

func (f *fakeContactReadModelCache) InvalidateViewers(ids ...int64) {
	f.mu.Lock()
	defer f.mu.Unlock()
	f.ids = append(f.ids, ids...)
}

func (f *fakeContactReadModelCache) FlushReadModelCache() {
	f.mu.Lock()
	defer f.mu.Unlock()
	f.flushes++
}

func (f *fakeContactReadModelCache) idsSnapshot() []int64 {
	f.mu.Lock()
	defer f.mu.Unlock()
	return append([]int64(nil), f.ids...)
}

func (f *fakeContactReadModelCache) flushCount() int {
	f.mu.Lock()
	defer f.mu.Unlock()
	return f.flushes
}

type fakeDialogReadModelCache struct {
	mu      sync.Mutex
	keys    []domain.Peer
	owners  []int64
	flushes int
}

func (f *fakeDialogReadModelCache) InvalidateDialog(ownerUserID int64, peer domain.Peer) {
	f.mu.Lock()
	defer f.mu.Unlock()
	f.owners = append(f.owners, ownerUserID)
	f.keys = append(f.keys, peer)
}

func (f *fakeDialogReadModelCache) FlushReadModelCache() {
	f.mu.Lock()
	defer f.mu.Unlock()
	f.flushes++
}

func (f *fakeDialogReadModelCache) entriesSnapshot() ([]int64, []domain.Peer) {
	f.mu.Lock()
	defer f.mu.Unlock()
	return append([]int64(nil), f.owners...), append([]domain.Peer(nil), f.keys...)
}

func (f *fakeDialogReadModelCache) flushCount() int {
	f.mu.Lock()
	defer f.mu.Unlock()
	return f.flushes
}

type fakePrivacyReadModelCache struct {
	mu      sync.Mutex
	ids     []int64
	warmed  []int64
	flushes int
}

func (f *fakePrivacyReadModelCache) InvalidateOwners(ids ...int64) {
	f.mu.Lock()
	defer f.mu.Unlock()
	f.ids = append(f.ids, ids...)
}

func (f *fakePrivacyReadModelCache) WarmOwners(_ context.Context, ids ...int64) error {
	f.mu.Lock()
	defer f.mu.Unlock()
	f.warmed = append(f.warmed, ids...)
	return nil
}

func (f *fakePrivacyReadModelCache) FlushReadModelCache() {
	f.mu.Lock()
	defer f.mu.Unlock()
	f.flushes++
}

func (f *fakePrivacyReadModelCache) idsSnapshot() []int64 {
	f.mu.Lock()
	defer f.mu.Unlock()
	return append([]int64(nil), f.ids...)
}

func (f *fakePrivacyReadModelCache) warmedSnapshot() []int64 {
	f.mu.Lock()
	defer f.mu.Unlock()
	return append([]int64(nil), f.warmed...)
}

func (f *fakePrivacyReadModelCache) flushCount() int {
	f.mu.Lock()
	defer f.mu.Unlock()
	return f.flushes
}

type fakeProfilePhotoReadModelCache struct {
	mu      sync.Mutex
	owners  []domain.Peer
	flushes int
}

func (f *fakeProfilePhotoReadModelCache) InvalidateOwner(ownerType domain.PeerType, ownerID int64) {
	f.mu.Lock()
	defer f.mu.Unlock()
	f.owners = append(f.owners, domain.Peer{Type: ownerType, ID: ownerID})
}

func (f *fakeProfilePhotoReadModelCache) FlushReadModelCache() {
	f.mu.Lock()
	defer f.mu.Unlock()
	f.flushes++
}

func (f *fakeProfilePhotoReadModelCache) ownersSnapshot() []domain.Peer {
	f.mu.Lock()
	defer f.mu.Unlock()
	return append([]domain.Peer(nil), f.owners...)
}

func (f *fakeProfilePhotoReadModelCache) flushCount() int {
	f.mu.Lock()
	defer f.mu.Unlock()
	return f.flushes
}

func TestReadModelChangeListenerInvalidatesAccountCaches(t *testing.T) {
	contacts := &fakeContactReadModelCache{}
	dialogs := &fakeDialogReadModelCache{}
	privacy := &fakePrivacyReadModelCache{}
	photos := &fakeProfilePhotoReadModelCache{}
	channelMedia := &fakeChannelMediaCountReadModelCache{}
	privateMedia := &fakePrivateMediaCountReadModelCache{}
	listener := NewReadModelChangeListener("", ReadModelCacheSet{
		Contacts:           contacts,
		Dialogs:            dialogs,
		Privacy:            privacy,
		ProfilePhotos:      photos,
		ChannelMediaCounts: channelMedia,
		PrivateMediaCounts: privateMedia,
	}, nil)

	listener.flush()
	if contacts.flushes != 1 || dialogs.flushes != 1 || privacy.flushes != 1 || photos.flushes != 1 ||
		channelMedia.flushCount() != 1 || privateMedia.flushCount() != 1 {
		t.Fatalf("flush counts contacts/dialogs/privacy/photos/channelMedia/privateMedia = %d/%d/%d/%d/%d/%d, want all 1",
			contacts.flushes, dialogs.flushes, privacy.flushes, photos.flushes, channelMedia.flushCount(), privateMedia.flushCount())
	}

	listener.handlePayload(`{"model":"contact_account","owner_user_id":11,"peer_type":"user","peer_id":11,"version":2}`)
	listener.handlePayload(`{"model":"contact_blocklist","owner_user_id":12,"peer_type":"user","peer_id":12,"version":3}`)
	if len(contacts.ids) != 2 || contacts.ids[0] != 11 || contacts.ids[1] != 12 {
		t.Fatalf("contact invalidations = %v, want [11 12]", contacts.ids)
	}

	listener.handlePayload(`{"model":"privacy_rules","owner_user_id":21,"peer_type":"user","peer_id":21,"version":4}`)
	if len(privacy.ids) != 1 || privacy.ids[0] != 21 {
		t.Fatalf("privacy invalidations = %v, want [21]", privacy.ids)
	}
	if warmed := privacy.warmedSnapshot(); len(warmed) != 1 || warmed[0] != 21 {
		t.Fatalf("privacy warms = %v, want [21]", warmed)
	}

	listener.handlePayload(`{"model":"dialog_light","owner_user_id":22,"peer_type":"user","peer_id":32,"version":4}`)
	if len(dialogs.owners) != 1 || dialogs.owners[0] != 22 || dialogs.keys[0] != (domain.Peer{Type: domain.PeerTypeUser, ID: 32}) {
		t.Fatalf("dialog invalidations owners=%v keys=%+v, want owner 22 user 32", dialogs.owners, dialogs.keys)
	}

	listener.handlePayload(`{"model":"channel_member","owner_user_id":23,"peer_type":"channel","peer_id":33,"version":5}`)
	if len(dialogs.owners) != 2 || dialogs.owners[1] != 23 || dialogs.keys[1] != (domain.Peer{Type: domain.PeerTypeChannel, ID: 33}) {
		t.Fatalf("channel member dialog invalidations owners=%v keys=%+v, want owner 23 channel 33", dialogs.owners, dialogs.keys)
	}

	listener.handlePayload(`{"model":"profile_photo","owner_user_id":0,"peer_type":"user","peer_id":31,"version":5}`)
	listener.handlePayload(`{"model":"profile_photo","owner_user_id":0,"peer_type":"channel","peer_id":41,"version":6}`)
	if len(photos.owners) != 2 ||
		photos.owners[0] != (domain.Peer{Type: domain.PeerTypeUser, ID: 31}) ||
		photos.owners[1] != (domain.Peer{Type: domain.PeerTypeChannel, ID: 41}) {
		t.Fatalf("photo invalidations = %+v, want user 31 and channel 41", photos.owners)
	}
}