package message

// ReceiveTeamContextsForRecipient converts the durable Team delivery snapshots
// on one concrete agent recipient into the ReceiveMessage/daemon wire shape.
// Internal overlay version fields stay out of the daemon payload.
func ReceiveTeamContextsForRecipient(recipient AgentRecipient) []ReceiveTeamContext {
	if len(recipient.TeamContexts) == 0 {
		return nil
	}
	contexts := make([]ReceiveTeamContext, 0, len(recipient.TeamContexts))
	for _, context := range recipient.TeamContexts {
		contexts = append(contexts, ReceiveTeamContext{
			TeamID:            context.TeamID,
			TeamHandle:        context.TeamHandle,
			TeamDisplayName:   context.TeamDisplayName,
			TeamDescription:   context.TeamDescription,
			TeamMemberID:      context.TeamMemberID,
			Role:              context.Role,
			RoleLabel:         context.RoleLabel,
			RoleOverlayPrompt: context.RoleOverlayPromptSnapshot,
			MemberRoster:      receiveTeamRoster(context.MemberRoster),
			Workflow:          context.Workflow,
		})
	}
	return contexts
}

// ReceiveMessageWithRecipientTeamContexts decorates msg with recipient-local
// Team Contexts. If the recipient carries no Team Context snapshot, the message
// is returned unchanged so non-Team delivery intents can provide their own
// explicit TeamContexts in the future.
func ReceiveMessageWithRecipientTeamContexts(msg ReceiveMessage, recipient AgentRecipient) ReceiveMessage {
	if contexts := ReceiveTeamContextsForRecipient(recipient); len(contexts) > 0 {
		msg.TeamContexts = contexts
	}
	return msg
}

// ReceiveMessageForAgentRecipient applies every recipient-local projection to
// an Agent wake payload. In particular, callback authority is retained only for
// the frozen workflow responder while ordinary co-recipients still receive the
// visible message and their own Team Context snapshot.
func ReceiveMessageForAgentRecipient(msg ReceiveMessage, recipient AgentRecipient) ReceiveMessage {
	msg.Metadata = WorkflowContextMetadataForAgentRecipient(msg.Metadata, recipient.AgentID)
	return ReceiveMessageWithRecipientTeamContexts(msg, recipient)
}

func receiveTeamRoster(roster []TeamDeliveryRosterMember) []ReceiveTeamMemberContext {
	if len(roster) == 0 {
		return nil
	}
	members := make([]ReceiveTeamMemberContext, 0, len(roster))
	for _, member := range roster {
		members = append(members, ReceiveTeamMemberContext{
			TeamMemberID:      member.TeamMemberID,
			ActorKind:         member.ActorKind,
			ActorID:           member.ActorID,
			DisplayName:       member.DisplayName,
			Handle:            member.Handle,
			Role:              member.Role,
			RoleLabel:         member.RoleLabel,
			RoleOverlayPrompt: member.RoleOverlayPrompt,
			WakeOnTeamMention: member.WakeOnTeamMention,
			DeliveryKind:      member.DeliveryKind,
			Self:              member.Self,
		})
	}
	return members
}