package postgres

import (
	"context"
	"errors"
	"fmt"
	"reflect"
	"telesrv/internal/domain"
	"testing"
	"time"
)

func TestChannelStoreCreateChannelCreatesPermanentInviteAndHasLink(t *testing.T) {
	pool := testPool(t)
	ctx := context.Background()
	suffix := randomSuffix(t)

	users := NewUserStore(pool)
	owner, err := users.Create(ctx, domain.User{
		AccessHash: 30,
		Phone:      "+1777" + suffix + "11",
		FirstName:  "LinkOwner",
	})
	if err != nil {
		t.Fatalf("create owner: %v", err)
	}
	var channelID int64
	t.Cleanup(func() {
		if channelID != 0 {
			_, _ = pool.Exec(ctx, "DELETE FROM channels WHERE id = $1", channelID)
		}
		_, _ = pool.Exec(ctx, "DELETE FROM users WHERE id = $1", owner.ID)
	})

	channels := NewChannelStore(pool)
	created, err := channels.CreateChannel(ctx, domain.CreateChannelRequest{
		CreatorUserID: owner.ID,
		Title:         "Linked On Create " + suffix,
		Megagroup:     true,
		Date:          1700000300,
	})
	if err != nil {
		t.Fatalf("create channel: %v", err)
	}
	channelID = created.Channel.ID
	if !created.Channel.HasLink {
		t.Fatalf("created channel HasLink = false, want true")
	}
	view, err := channels.GetChannel(ctx, owner.ID, channelID)
	if err != nil {
		t.Fatalf("get channel: %v", err)
	}
	if !view.Channel.HasLink {
		t.Fatalf("stored channel HasLink = false, want true")
	}
	if view.ExportedInvite == nil || !view.ExportedInvite.Permanent || view.ExportedInvite.Revoked || view.ExportedInvite.AdminUserID != owner.ID {
		t.Fatalf("owner view exported invite = %+v, want creator permanent main link", view.ExportedInvite)
	}
	invites, err := channels.ListExportedInvites(ctx, domain.ChannelInviteListRequest{
		UserID:      owner.ID,
		ChannelID:   channelID,
		AdminUserID: owner.ID,
		Limit:       10,
	})
	if err != nil {
		t.Fatalf("list exported invites: %v", err)
	}
	if invites.Count != 1 || len(invites.Invites) != 1 || !invites.Invites[0].Permanent || invites.Invites[0].Revoked {
		t.Fatalf("invites = %+v, want one active permanent main link", invites)
	}
}

func TestChannelStoreJoinRejectsKickedMember(t *testing.T) {
	pool := testPool(t)
	ctx := context.Background()
	suffix := randomSuffix(t)

	users := NewUserStore(pool)
	owner, err := users.Create(ctx, domain.User{
		AccessHash: 33,
		Phone:      "+1777" + suffix + "21",
		FirstName:  "BanOwner",
	})
	if err != nil {
		t.Fatalf("create owner: %v", err)
	}
	member, err := users.Create(ctx, domain.User{
		AccessHash: 34,
		Phone:      "+1777" + suffix + "22",
		FirstName:  "BanMember",
	})
	if err != nil {
		t.Fatalf("create member: %v", err)
	}
	helper, err := users.Create(ctx, domain.User{
		AccessHash: 35,
		Phone:      "+1777" + suffix + "23",
		FirstName:  "BanHelper",
	})
	if err != nil {
		t.Fatalf("create helper: %v", err)
	}
	var channelID int64
	t.Cleanup(func() {
		if channelID != 0 {
			_, _ = pool.Exec(ctx, "DELETE FROM channels WHERE id = $1", channelID)
		}
		_, _ = pool.Exec(ctx, "DELETE FROM users WHERE id = ANY($1::bigint[])", []int64{owner.ID, member.ID, helper.ID})
	})

	channels := NewChannelStore(pool)
	created, err := channels.CreateChannel(ctx, domain.CreateChannelRequest{
		CreatorUserID: owner.ID,
		Title:         "Ban Join " + suffix,
		Megagroup:     true,
		MemberUserIDs: []int64{member.ID, helper.ID},
		Date:          1700000305,
	})
	if err != nil {
		t.Fatalf("create channel: %v", err)
	}
	channelID = created.Channel.ID
	ptsFloor := created.Channel.Pts
	banned, err := channels.EditChannelBanned(ctx, domain.EditChannelBannedRequest{
		UserID:      owner.ID,
		ChannelID:   channelID,
		Participant: domain.Peer{Type: domain.PeerTypeUser, ID: member.ID},
		BannedRights: domain.ChannelBannedRights{
			ViewMessages: true,
			UntilDate:    1700001300,
		},
		Date: 1700000306,
	})
	if err != nil {
		t.Fatalf("kick member: %v", err)
	}
	// participant update 不占 channel pts，但 megagroup 踢人产生
	// "X removed Y" 服务消息占一个 pts，离线成员靠它收敛成员状态。
	if banned.Event.Pts != 0 || banned.Event.PtsCount != 0 {
		t.Fatalf("kick participant event = (%d,%d), must stay transient", banned.Event.Pts, banned.Event.PtsCount)
	}
	if banned.ServiceEvent.Pts != ptsFloor+1 || banned.Channel.Pts != ptsFloor+1 {
		t.Fatalf("kick service pts = %d channel %d, want %d", banned.ServiceEvent.Pts, banned.Channel.Pts, ptsFloor+1)
	}
	if banned.Message.Action == nil || banned.Message.Action.Type != domain.ChannelActionChatDelete {
		t.Fatalf("kick service message = %+v, want ChatDelete action", banned.Message)
	}
	banDiff, err := channels.ListChannelDifference(ctx, domain.ChannelDifferenceRequest{
		UserID:    owner.ID,
		ChannelID: channelID,
		Pts:       ptsFloor,
		Limit:     10,
	})
	if err != nil {
		t.Fatalf("difference after kick: %v", err)
	}
	if len(banDiff.Events) != 1 || banDiff.Pts != ptsFloor+1 {
		t.Fatalf("difference after kick = %+v, want only the kick service message at pts %d", banDiff, ptsFloor+1)
	}
	if _, err := channels.JoinChannel(ctx, channelID, member.ID, 1700000307); !errors.Is(err, domain.ErrChannelUserBanned) {
		t.Fatalf("kicked JoinChannel err = %v, want ErrChannelUserBanned", err)
	}
	if _, err := channels.InviteToChannel(ctx, channelID, helper.ID, []int64{member.ID}, 1700000308); !errors.Is(err, domain.ErrUserKicked) {
		t.Fatalf("helper InviteToChannel kicked err = %v, want ErrUserKicked", err)
	}
	restored, err := channels.InviteToChannel(ctx, channelID, owner.ID, []int64{member.ID}, 1700000309)
	if err != nil {
		t.Fatalf("owner InviteToChannel kicked: %v", err)
	}
	if len(restored.Members) != 1 || restored.Members[0].Status != domain.ChannelMemberActive || restored.Members[0].BannedRights != (domain.ChannelBannedRights{}) {
		t.Fatalf("restored members = %+v, want active unbanned member", restored.Members)
	}
	if restored.Channel.ParticipantsCount != 3 || restored.Channel.KickedCount != 0 {
		t.Fatalf("restored counts = participants:%d kicked:%d, want 3/0", restored.Channel.ParticipantsCount, restored.Channel.KickedCount)
	}
	if _, err := channels.InviteToChannel(ctx, channelID, owner.ID, []int64{member.ID}, 1700000310); !errors.Is(err, domain.ErrUserAlreadyParticipant) {
		t.Fatalf("duplicate InviteToChannel err = %v, want ErrUserAlreadyParticipant", err)
	}
}

func TestChannelStoreImportInviteRequestNeededAndUsageLimitErrors(t *testing.T) {
	pool := testPool(t)
	ctx := context.Background()
	suffix := randomSuffix(t)

	users := NewUserStore(pool)
	owner, err := users.Create(ctx, domain.User{
		AccessHash: 61,
		Phone:      "+1888" + suffix + "21",
		FirstName:  "InviteErrorOwner",
	})
	if err != nil {
		t.Fatalf("create owner: %v", err)
	}
	first, err := users.Create(ctx, domain.User{
		AccessHash: 62,
		Phone:      "+1888" + suffix + "22",
		FirstName:  "InviteErrorFirst",
	})
	if err != nil {
		t.Fatalf("create first: %v", err)
	}
	second, err := users.Create(ctx, domain.User{
		AccessHash: 63,
		Phone:      "+1888" + suffix + "23",
		FirstName:  "InviteErrorSecond",
	})
	if err != nil {
		t.Fatalf("create second: %v", err)
	}
	var channelID int64
	t.Cleanup(func() {
		if channelID != 0 {
			_, _ = pool.Exec(ctx, "DELETE FROM channels WHERE id = $1", channelID)
		}
		_, _ = pool.Exec(ctx, "DELETE FROM users WHERE id = ANY($1::bigint[])", []int64{owner.ID, first.ID, second.ID})
	})

	channels := NewChannelStore(pool)
	created, err := channels.CreateChannel(ctx, domain.CreateChannelRequest{
		CreatorUserID: owner.ID,
		Title:         "Invite Errors " + suffix,
		Megagroup:     true,
		Date:          1700000340,
	})
	if err != nil {
		t.Fatalf("create channel: %v", err)
	}
	channelID = created.Channel.ID
	requested, err := channels.ExportInvite(ctx, domain.ExportChannelInviteRequest{
		UserID:        owner.ID,
		ChannelID:     channelID,
		Title:         "approval",
		RequestNeeded: true,
		Date:          1700000341,
	})
	if err != nil {
		t.Fatalf("export request-needed invite: %v", err)
	}
	if _, err := channels.ImportInvite(ctx, domain.ImportChannelInviteRequest{
		UserID: first.ID,
		Hash:   requested.Invite.Hash,
		Date:   1700000342,
	}); !errors.Is(err, domain.ErrInviteRequestSent) {
		t.Fatalf("import request-needed err = %v, want ErrInviteRequestSent", err)
	}
	limited, err := channels.ExportInvite(ctx, domain.ExportChannelInviteRequest{
		UserID:     owner.ID,
		ChannelID:  channelID,
		Title:      "one",
		UsageLimit: 1,
		Date:       1700000343,
	})
	if err != nil {
		t.Fatalf("export limited invite: %v", err)
	}
	if _, err := channels.ImportInvite(ctx, domain.ImportChannelInviteRequest{
		UserID: first.ID,
		Hash:   limited.Invite.Hash,
		Date:   1700000344,
	}); err != nil {
		t.Fatalf("first import limited invite: %v", err)
	}
	if _, err := channels.ImportInvite(ctx, domain.ImportChannelInviteRequest{
		UserID: second.ID,
		Hash:   limited.Invite.Hash,
		Date:   1700000345,
	}); !errors.Is(err, domain.ErrUsersTooMuch) {
		t.Fatalf("second import limited invite err = %v, want ErrUsersTooMuch", err)
	}
}

func TestChannelStorePendingJoinRequestsSummaryAndInviteAdmins(t *testing.T) {
	pool := testPool(t)
	ctx := context.Background()
	suffix := randomSuffix(t)

	users := NewUserStore(pool)
	userIDs := make([]int64, 0, 11)
	createUser := func(label string, accessHash int64, phoneSuffix int) domain.User {
		t.Helper()
		user, err := users.Create(ctx, domain.User{
			AccessHash: accessHash,
			Phone:      fmt.Sprintf("+1889%s%02d", suffix, phoneSuffix),
			FirstName:  label,
		})
		if err != nil {
			t.Fatalf("create %s: %v", label, err)
		}
		userIDs = append(userIDs, user.ID)
		return user
	}
	owner := createUser("PendingOwner", 71, 1)
	inviteAdmin := createUser("PendingInviteAdmin", 72, 2)
	plainMember := createUser("PendingPlainMember", 73, 3)
	changeAdmin := createUser("PendingChangeAdmin", 74, 4)
	requesters := make([]domain.User, 0, domain.MaxChannelPendingJoinRecentRequesters+2)
	for i := 0; i < domain.MaxChannelPendingJoinRecentRequesters+2; i++ {
		requesters = append(requesters, createUser("PendingRequester", int64(80+i), 10+i))
	}

	var channelID int64
	t.Cleanup(func() {
		if channelID != 0 {
			_, _ = pool.Exec(ctx, "DELETE FROM channels WHERE id = $1", channelID)
		}
		_, _ = pool.Exec(ctx, "DELETE FROM users WHERE id = ANY($1::bigint[])", userIDs)
	})

	channels := NewChannelStore(pool)
	created, err := channels.CreateChannel(ctx, domain.CreateChannelRequest{
		CreatorUserID: owner.ID,
		Title:         "Pending Summary " + suffix,
		Megagroup:     true,
		MemberUserIDs: []int64{inviteAdmin.ID, plainMember.ID, changeAdmin.ID},
		Date:          1700000360,
	})
	if err != nil {
		t.Fatalf("create channel: %v", err)
	}
	channelID = created.Channel.ID
	if _, err := channels.EditChannelAdmin(ctx, domain.EditChannelAdminRequest{
		UserID:    owner.ID,
		ChannelID: channelID,
		MemberID:  inviteAdmin.ID,
		AdminRights: domain.ChannelAdminRights{
			InviteUsers: true,
		},
		Date: 1700000361,
	}); err != nil {
		t.Fatalf("promote invite admin: %v", err)
	}
	if _, err := channels.EditChannelAdmin(ctx, domain.EditChannelAdminRequest{
		UserID:    owner.ID,
		ChannelID: channelID,
		MemberID:  changeAdmin.ID,
		AdminRights: domain.ChannelAdminRights{
			ChangeInfo: true,
		},
		Date: 1700000362,
	}); err != nil {
		t.Fatalf("promote change-info admin: %v", err)
	}
	invite, err := channels.ExportInvite(ctx, domain.ExportChannelInviteRequest{
		UserID:        owner.ID,
		ChannelID:     channelID,
		Title:         "approval",
		RequestNeeded: true,
		Date:          1700000363,
	})
	if err != nil {
		t.Fatalf("export invite: %v", err)
	}
	for i, requester := range requesters {
		_, err := channels.ImportInvite(ctx, domain.ImportChannelInviteRequest{
			UserID: requester.ID,
			Hash:   invite.Invite.Hash,
			Date:   1700000370 + i,
		})
		if !errors.Is(err, domain.ErrInviteRequestSent) {
			t.Fatalf("import pending %d err = %v, want ErrInviteRequestSent", i, err)
		}
	}
	pending, err := channels.PendingJoinRequests(ctx, channelID, 99)
	if err != nil {
		t.Fatalf("pending join requests: %v", err)
	}
	if pending.Count != len(requesters) || len(pending.RecentRequesters) != domain.MaxChannelPendingJoinRecentRequesters {
		t.Fatalf("pending summary = %+v, want bounded recent with full count", pending)
	}
	if pending.RecentRequesters[0] != requesters[len(requesters)-1].ID ||
		pending.RecentRequesters[len(pending.RecentRequesters)-1] != requesters[2].ID {
		t.Fatalf("recent requesters = %+v, want newest first", pending.RecentRequesters)
	}
	admins, err := channels.ListChannelInviteAdminMemberIDs(ctx, channelID, 0)
	if err != nil {
		t.Fatalf("invite admins: %v", err)
	}
	want := []int64{owner.ID, inviteAdmin.ID, changeAdmin.ID}
	if !reflect.DeepEqual(admins, want) {
		t.Fatalf("invite admins = %+v, want %+v", admins, want)
	}
}

func TestChannelStoreImportInviteUsageLimitSeesConcurrentIncrement(t *testing.T) {
	pool := testPool(t)
	ctx := context.Background()
	suffix := randomSuffix(t)

	users := NewUserStore(pool)
	owner, err := users.Create(ctx, domain.User{
		AccessHash: 64,
		Phone:      "+1888" + suffix + "31",
		FirstName:  "InviteLimitOwner",
	})
	if err != nil {
		t.Fatalf("create owner: %v", err)
	}
	joiner, err := users.Create(ctx, domain.User{
		AccessHash: 65,
		Phone:      "+1888" + suffix + "32",
		FirstName:  "InviteLimitJoiner",
	})
	if err != nil {
		t.Fatalf("create joiner: %v", err)
	}
	var channelID int64
	t.Cleanup(func() {
		if channelID != 0 {
			_, _ = pool.Exec(ctx, "DELETE FROM channels WHERE id = $1", channelID)
		}
		_, _ = pool.Exec(ctx, "DELETE FROM users WHERE id = ANY($1::bigint[])", []int64{owner.ID, joiner.ID})
	})

	channels := NewChannelStore(pool)
	created, err := channels.CreateChannel(ctx, domain.CreateChannelRequest{
		CreatorUserID: owner.ID,
		Title:         "Invite Limit Race " + suffix,
		Megagroup:     true,
		Date:          1700000350,
	})
	if err != nil {
		t.Fatalf("create channel: %v", err)
	}
	channelID = created.Channel.ID
	invite, err := channels.ExportInvite(ctx, domain.ExportChannelInviteRequest{
		UserID:     owner.ID,
		ChannelID:  channelID,
		Title:      "single",
		UsageLimit: 1,
		Date:       1700000351,
	})
	if err != nil {
		t.Fatalf("export limited invite: %v", err)
	}

	lockTx, err := pool.Begin(ctx)
	if err != nil {
		t.Fatalf("begin lock tx: %v", err)
	}
	defer func() { _ = lockTx.Rollback(ctx) }()
	if _, err := lockTx.Exec(ctx, `
UPDATE channel_invites
SET usage_count = usage_limit
WHERE channel_id = $1 AND invite_id = $2`, channelID, invite.Invite.InviteID); err != nil {
		t.Fatalf("lock and update invite usage: %v", err)
	}

	importCtx, cancel := context.WithTimeout(ctx, 5*time.Second)
	defer cancel()
	errCh := make(chan error, 1)
	go func() {
		_, err := channels.ImportInvite(importCtx, domain.ImportChannelInviteRequest{
			UserID: joiner.ID,
			Hash:   invite.Invite.Hash,
			Date:   1700000352,
		})
		errCh <- err
	}()
	time.Sleep(100 * time.Millisecond)
	if err := lockTx.Commit(ctx); err != nil {
		t.Fatalf("commit lock tx: %v", err)
	}
	err = <-errCh
	if !errors.Is(err, domain.ErrUsersTooMuch) {
		t.Fatalf("concurrent import err = %v, want ErrUsersTooMuch after seeing committed usage_count", err)
	}
	if _, err := channels.GetChannel(ctx, joiner.ID, channelID); !errors.Is(err, domain.ErrChannelPrivate) {
		t.Fatalf("joiner channel after rejected import err = %v, want ErrChannelPrivate", err)
	}
}

// TestChannelStoreEnsurePermanentInvite 验证主链接幂等保障：缺失即建、存在复用、
// 撤销后重建、非授权用户被拒（DrKLO 建频道后 getExportedChatInvites 直接取
// invites[0]，主链接缺失即客户端闪退）。
func TestChannelStoreEnsurePermanentInvite(t *testing.T) {
	pool := testPool(t)
	ctx := context.Background()
	suffix := randomSuffix(t)

	users := NewUserStore(pool)
	owner, err := users.Create(ctx, domain.User{
		AccessHash: 71,
		Phone:      "+1888" + suffix + "41",
		FirstName:  "EnsureOwner",
	})
	if err != nil {
		t.Fatalf("create owner: %v", err)
	}
	outsider, err := users.Create(ctx, domain.User{
		AccessHash: 72,
		Phone:      "+1888" + suffix + "42",
		FirstName:  "EnsureOutsider",
	})
	if err != nil {
		t.Fatalf("create outsider: %v", err)
	}
	var channelID int64
	t.Cleanup(func() {
		if channelID != 0 {
			_, _ = pool.Exec(ctx, "DELETE FROM channel_invites WHERE channel_id = $1", channelID)
			_, _ = pool.Exec(ctx, "DELETE FROM channels WHERE id = $1", channelID)
		}
		_, _ = pool.Exec(ctx, "DELETE FROM users WHERE id = ANY($1::bigint[])", []int64{owner.ID, outsider.ID})
	})

	channels := NewChannelStore(pool)
	created, err := channels.CreateChannel(ctx, domain.CreateChannelRequest{
		CreatorUserID: owner.ID,
		Title:         "Ensure Permanent " + suffix,
		Broadcast:     true,
		Date:          1700000400,
	})
	if err != nil {
		t.Fatalf("create channel: %v", err)
	}
	channelID = created.Channel.ID

	first, err := channels.EnsurePermanentInvite(ctx, channelID, owner.ID, 1700000401)
	if err != nil {
		t.Fatalf("ensure permanent invite: %v", err)
	}
	if !first.Permanent || first.Revoked || first.AdminUserID != owner.ID || first.Hash == "" {
		t.Fatalf("ensured invite = %+v, want creator's non-revoked permanent link", first)
	}

	second, err := channels.EnsurePermanentInvite(ctx, channelID, owner.ID, 1700000500)
	if err != nil {
		t.Fatalf("ensure permanent invite again: %v", err)
	}
	if second.Hash != first.Hash {
		t.Fatalf("second ensure hash = %q, want stable %q (must not duplicate)", second.Hash, first.Hash)
	}

	if _, err := channels.EditExportedInvite(ctx, domain.EditChannelInviteRequest{
		UserID:    owner.ID,
		ChannelID: channelID,
		Hash:      first.Hash,
		Revoked:   true,
		Date:      1700000600,
	}); err != nil {
		t.Fatalf("revoke permanent invite: %v", err)
	}
	third, err := channels.EnsurePermanentInvite(ctx, channelID, owner.ID, 1700000601)
	if err != nil {
		t.Fatalf("ensure after revoke: %v", err)
	}
	if !third.Permanent || third.Revoked || third.Hash == first.Hash {
		t.Fatalf("post-revoke ensure = %+v, want fresh non-revoked permanent link", third)
	}

	if _, err := channels.EnsurePermanentInvite(ctx, channelID, outsider.ID, 0); err == nil {
		t.Fatal("ensure by non-member must fail")
	}

	list, err := channels.ListExportedInvites(ctx, domain.ChannelInviteListRequest{
		UserID:      owner.ID,
		ChannelID:   channelID,
		AdminUserID: owner.ID,
		Limit:       10,
	})
	if err != nil {
		t.Fatalf("list invites: %v", err)
	}
	found := false
	for _, invite := range list.Invites {
		if invite.Hash == third.Hash && invite.Permanent && !invite.Revoked {
			found = true
		}
	}
	if !found {
		t.Fatalf("invite list = %+v, missing ensured permanent link %q", list.Invites, third.Hash)
	}
}