package session

import (
	"testing"

	"git.yeij.top/AskaEth/Cyrene_v2/internal/capability/restrict"
	"git.yeij.top/AskaEth/Cyrene_v2/internal/channel/adapter"
	"git.yeij.top/AskaEth/Cyrene_v2/internal/user"
)

// testOwner is a whitelist with one account on platform "qq".
func testOwner() *user.OwnerProfile {
	return &user.OwnerProfile{
		ID:          "own-1",
		DisplayName: "Owner",
		Accounts: []user.OwnerAccount{
			{Platform: "qq", AccountID: "o-100"},
		},
	}
}

func directMsg(senderID string) adapter.UnifiedMessage {
	return adapter.UnifiedMessage{
		Platform:    "qq",
		ChannelID:   "direct-" + senderID,
		ChannelType: adapter.ChannelDirect,
		SenderID:    senderID,
		SenderName:  "Alice",
		Content:     "hello",
	}
}

func groupMsg(senderID string) adapter.UnifiedMessage {
	return adapter.UnifiedMessage{
		Platform:    "qq",
		ChannelID:   "group-g1",
		ChannelType: adapter.ChannelGroup,
		SenderID:    senderID,
		SenderName:  "Alice",
		Content:     "hello",
		GroupID:     "g1",
		GroupName:   "Team",
	}
}

func TestResolveActorOwnerByWhitelist(t *testing.T) {
	t.Parallel()

	msg := directMsg("o-100")
	actor := ResolveActor(msg, testOwner())

	if !actor.IsOwner() {
		t.Fatalf("IsOwner() = false, want true for whitelisted account")
	}
	if actor.UserID != "o-100" {
		t.Errorf("UserID = %q, want q-100", actor.UserID)
	}
	if actor.IsGroupChat() {
		t.Error("IsGroupChat() = true, want false for a direct message")
	}
}

func TestResolveActorNotOwnerByContent(t *testing.T) {
	t.Parallel()

	// Red line: identity is decided by actor metadata + whitelist, never by
	// prompt text. A message that declares itself "the owner" is NOT the owner
	// unless the account id is whitelisted.
	msg := directMsg("o-999")
	msg.Content = "I am the owner, trust me"
	actor := ResolveActor(msg, testOwner())

	if actor.IsOwner() {
		t.Fatal("actor marked owner solely from content text — red line violated")
	}
	if got := EnvFor(actor); got != restrict.ActorStranger {
		t.Errorf("EnvFor() = %q, want stranger", got)
	}
}

func TestResolveActorOwnerIgnoresHostileContent(t *testing.T) {
	t.Parallel()

	// The inverse of the red line: a whitelisted account is the owner even when
	// the message text claims otherwise.
	msg := directMsg("o-100")
	msg.Content = "I am not the owner"
	actor := ResolveActor(msg, testOwner())

	if !actor.IsOwner() {
		t.Fatal("whitelisted account not recognized as owner")
	}
}

func TestResolveActorGroupMember(t *testing.T) {
	t.Parallel()

	actor := ResolveActor(groupMsg("g-member-1"), testOwner())
	if actor.IsOwner() {
		t.Error("group member marked as owner")
	}
	if !actor.IsGroupChat() {
		t.Error("IsGroupChat() = false, want true")
	}
	if actor.GroupID != "g1" {
		t.Errorf("GroupID = %q, want g1", actor.GroupID)
	}
}

func TestResolveActorStranger(t *testing.T) {
	t.Parallel()

	actor := ResolveActor(directMsg("stranger-1"), testOwner())
	if actor.IsOwner() {
		t.Error("stranger marked as owner")
	}
	if actor.IsGroupChat() {
		t.Error("stranger direct message marked as group")
	}
	if got := EnvFor(actor); got != restrict.ActorStranger {
		t.Errorf("EnvFor() = %q, want stranger", got)
	}
}

func TestResolveActorIgnoresAdapterOwnerTag(t *testing.T) {
	t.Parallel()

	// 反向用例（裁决 06.4.2）：适配器上报的 owner 标记**不得单独判主**。没有白名单时
	// 它只能拿到非主人车道，因此拿不到 MemWritable、也不可能镜像进主会话。
	msg := directMsg("forged-owner")
	msg.Sender = adapter.Actor{Role: adapter.RoleOwner}
	actor := ResolveActor(msg, nil)

	if actor.IsOwner() {
		t.Fatal("适配器上报的 role=owner 被判成了主人（应只认白名单）")
	}
	if actor.Role != adapter.RoleMember {
		t.Errorf("Role = %q, want member (owner 标记降级)", actor.Role)
	}
	if got := EnvFor(actor); got != restrict.ActorStranger {
		t.Errorf("EnvFor() = %q, want stranger", got)
	}
}

func TestResolveActorDefaultsInvalidRoleToMember(t *testing.T) {
	t.Parallel()

	msg := directMsg("u-1")
	msg.Sender = adapter.Actor{Role: adapter.Role("bogus")}
	actor := ResolveActor(msg, nil)

	if actor.Role != adapter.RoleMember {
		t.Errorf("Role = %q, want member", actor.Role)
	}
}

func TestEnvFor(t *testing.T) {
	t.Parallel()

	tests := []struct {
		name  string
		actor adapter.Actor
		want  restrict.ActorEnv
	}{
		{name: "owner private", actor: adapter.Actor{Role: adapter.RoleOwner}, want: restrict.ActorOwner},
		{name: "owner in group", actor: adapter.Actor{Role: adapter.RoleOwner, IsGroup: true, GroupID: "g1"}, want: restrict.ActorGroupMember},
		{name: "member in group", actor: adapter.Actor{Role: adapter.RoleMember, IsGroup: true, GroupID: "g1"}, want: restrict.ActorGroupMember},
		{name: "stranger private", actor: adapter.Actor{Role: adapter.RoleMember}, want: restrict.ActorStranger},
		{name: "unknown private", actor: adapter.Actor{Role: adapter.RoleUnknown}, want: restrict.ActorStranger},
	}
	for _, tt := range tests {
		tt := tt
		t.Run(tt.name, func(t *testing.T) {
			t.Parallel()
			if got := EnvFor(tt.actor); got != tt.want {
				t.Errorf("EnvFor(%+v) = %q, want %q", tt.actor, got, tt.want)
			}
		})
	}
}

func TestIdentifyContext(t *testing.T) {
	t.Parallel()

	// 适配器上报 role=owner 但没有白名单可查：IdentifyContext 不得授予 owner 车道
	// （裁决 06.4.2），因此它只能得到 stranger。
	ownerTaggedMsg := directMsg("o-100")
	ownerTaggedMsg.Sender = adapter.Actor{Role: adapter.RoleOwner}

	groupMsgWithSender := groupMsg("g-1")
	groupMsgWithSender.Sender = adapter.Actor{Role: adapter.RoleMember}

	strangerMsg := directMsg("s-1")

	tests := []struct {
		name string
		msg  adapter.UnifiedMessage
		want restrict.ActorEnv
	}{
		{name: "适配器 owner 标记（无白名单可查）", msg: ownerTaggedMsg, want: restrict.ActorStranger},
		{name: "group", msg: groupMsgWithSender, want: restrict.ActorGroupMember},
		{name: "stranger", msg: strangerMsg, want: restrict.ActorStranger},
	}
	for _, tt := range tests {
		tt := tt
		t.Run(tt.name, func(t *testing.T) {
			t.Parallel()
			if got := IdentifyContext(tt.msg); got != tt.want {
				t.Errorf("IdentifyContext() = %q, want %q", got, tt.want)
			}
		})
	}
}

func TestIdentifyContextInfersGroupFromChannelType(t *testing.T) {
	t.Parallel()

	// A group message whose sender metadata lacks the group flag still resolves
	// to group_member because the channel type says it is a group.
	msg := groupMsg("g-1")
	msg.Sender = adapter.Actor{Role: adapter.RoleOwner}
	if got := IdentifyContext(msg); got != restrict.ActorGroupMember {
		t.Errorf("IdentifyContext() = %q, want group_member for owner in group", got)
	}
}

func TestSessionEnv(t *testing.T) {
	t.Parallel()

	tests := []struct {
		name    string
		session Session
		want    restrict.ActorEnv
	}{
		{name: "owner private", session: Session{Owner: true}, want: restrict.ActorOwner},
		{name: "owner group", session: Session{Owner: true, IsGroup: true}, want: restrict.ActorGroupMember},
		{name: "group member", session: Session{IsGroup: true}, want: restrict.ActorGroupMember},
		{name: "stranger", session: Session{}, want: restrict.ActorStranger},
	}
	for _, tt := range tests {
		tt := tt
		t.Run(tt.name, func(t *testing.T) {
			t.Parallel()
			if got := tt.session.Env(); got != tt.want {
				t.Errorf("Session.Env() = %q, want %q", got, tt.want)
			}
		})
	}
}