package team

import (
	"strings"
	"time"

	"github.com/tidbcloud/AgentTeam/internal/api/dto"
	storeteam "github.com/tidbcloud/AgentTeam/internal/store/team"
)

func teamResponses(views []storeteam.TeamView) []dto.TeamResponse {
	if len(views) == 0 {
		return []dto.TeamResponse{}
	}
	items := make([]dto.TeamResponse, 0, len(views))
	for _, view := range views {
		items = append(items, teamResponse(view))
	}
	return items
}

func teamResponse(view storeteam.TeamView) dto.TeamResponse {
	team := view.Team
	response := dto.TeamResponse{
		ID:          strings.TrimSpace(team.ID),
		Handle:      strings.TrimSpace(team.Handle),
		DisplayName: strings.TrimSpace(team.DisplayName),
		Description: strings.TrimSpace(team.Description),
		AvatarURL:   strings.TrimSpace(team.AvatarURL),
		Visibility:  strings.TrimSpace(team.Visibility),
		Status:      strings.TrimSpace(team.Status),
		ChannelID:   strings.TrimSpace(team.ChannelID),
		MemberCount: view.MemberCount,
		CanManage:   view.CanManage,
		CanDelete:   view.CanDelete,
		CreatedAt:   formatTeamTime(team.CreatedAt),
		UpdatedAt:   formatTeamTime(team.UpdatedAt),
	}
	if team.ArchivedAt != nil {
		response.ArchivedAt = formatTeamTime(*team.ArchivedAt)
	}
	return response
}

func instantiatedTeamResponse(result storeteam.InstantiateTeamTemplateResult) dto.InstantiateTeamTemplateResponse {
	return dto.InstantiateTeamTemplateResponse{
		TeamResponse: teamResponse(result.Team),
	}
}

func teamMemberResponses(views []storeteam.TeamMemberView) []dto.TeamMemberResponse {
	if len(views) == 0 {
		return []dto.TeamMemberResponse{}
	}
	items := make([]dto.TeamMemberResponse, 0, len(views))
	for _, view := range views {
		items = append(items, teamMemberResponse(view))
	}
	return items
}

func teamMemberResponse(view storeteam.TeamMemberView) dto.TeamMemberResponse {
	member := view.Member
	return dto.TeamMemberResponse{
		ID:                strings.TrimSpace(member.ID),
		TeamID:            strings.TrimSpace(member.TeamID),
		ActorKind:         strings.TrimSpace(member.ActorKind),
		ActorID:           strings.TrimSpace(member.ActorID),
		ActorProfile:      authorProfile(view.ActorProfile),
		Role:              strings.TrimSpace(member.Role),
		RoleLabel:         strings.TrimSpace(member.RoleLabel),
		RoleOverlayPrompt: strings.TrimSpace(member.RoleOverlayPrompt),
		WakeOnTeamMention: member.WakeOnTeamMention,
		SortOrder:         member.SortOrder,
		AddedAt:           formatTeamTime(member.AddedAt),
		UpdatedAt:         formatTeamTime(member.UpdatedAt),
	}
}

func authorProfile(profile storeteam.ActorProfile) *dto.AuthorProfile {
	if strings.TrimSpace(profile.ActorType) == "" && strings.TrimSpace(profile.DisplayName) == "" {
		return nil
	}
	return &dto.AuthorProfile{
		ActorType:   strings.TrimSpace(profile.ActorType),
		PrincipalID: strings.TrimSpace(profile.PrincipalID),
		MemberID:    strings.TrimSpace(profile.MemberID),
		TargetID:    strings.TrimSpace(profile.TargetID),
		DisplayName: strings.TrimSpace(profile.DisplayName),
		AvatarURL:   strings.TrimSpace(profile.AvatarURL),
	}
}

func mentionCandidateResponses(candidates []storeteam.TeamMentionCandidate) []dto.TeamMentionCandidateResponse {
	if len(candidates) == 0 {
		return []dto.TeamMentionCandidateResponse{}
	}
	items := make([]dto.TeamMentionCandidateResponse, 0, len(candidates))
	for _, candidate := range candidates {
		team := candidate.Team
		id := strings.TrimSpace(team.ID)
		items = append(items, dto.TeamMentionCandidateResponse{
			ID:                  id,
			Handle:              strings.TrimSpace(team.Handle),
			DisplayName:         strings.TrimSpace(team.DisplayName),
			Description:         strings.TrimSpace(team.Description),
			AvatarURL:           strings.TrimSpace(team.AvatarURL),
			MemberCount:         candidate.MemberCount,
			DeliveryPreview:     candidate.DeliveryPreview,
			ScopeAgentCount:     candidate.ScopeAgentCount,
			ReachableAgentCount: candidate.ReachableAgentCount,
		})
	}
	return items
}

func teamTemplateResponses(views []storeteam.TeamTemplateView) []dto.TeamTemplateResponse {
	if len(views) == 0 {
		return []dto.TeamTemplateResponse{}
	}
	items := make([]dto.TeamTemplateResponse, 0, len(views))
	for _, view := range views {
		items = append(items, teamTemplateResponse(view))
	}
	return items
}

func teamTemplateResponse(view storeteam.TeamTemplateView) dto.TeamTemplateResponse {
	template := view.Template
	return dto.TeamTemplateResponse{
		ID:                strings.TrimSpace(template.ID),
		Name:              strings.TrimSpace(template.Name),
		Description:       strings.TrimSpace(template.Description),
		Visibility:        strings.TrimSpace(template.Visibility),
		Source:            strings.TrimSpace(template.Source),
		Scope:             strings.TrimSpace(template.Scope),
		CreatedByMemberID: strings.TrimSpace(template.CreatedByMemberID),
		CreatedFromTeamID: strings.TrimSpace(template.CreatedFromTeamID),
		CanManage:         view.CanManage,
		Members:           teamTemplateMemberResponses(view),
		CreatedAt:         formatTeamTime(template.CreatedAt),
		UpdatedAt:         formatTeamTime(template.UpdatedAt),
	}
}

func teamTemplateMemberResponses(view storeteam.TeamTemplateView) []dto.TeamTemplateMemberResponse {
	if len(view.Members) == 0 {
		return []dto.TeamTemplateMemberResponse{}
	}
	items := make([]dto.TeamTemplateMemberResponse, 0, len(view.Members))
	for _, member := range view.Members {
		items = append(items, dto.TeamTemplateMemberResponse{
			ID:                strings.TrimSpace(member.ID),
			ActorKind:         strings.TrimSpace(member.ActorKind),
			ActorID:           strings.TrimSpace(member.ActorID),
			Role:              strings.TrimSpace(member.Role),
			RoleLabel:         strings.TrimSpace(member.RoleLabel),
			RoleOverlayPrompt: strings.TrimSpace(member.RoleOverlayPrompt),
			WakeOnTeamMention: member.WakeOnTeamMention,
			SortOrder:         member.SortOrder,
		})
	}
	return items
}

func formatTeamTime(value time.Time) string {
	if value.IsZero() {
		return ""
	}
	return value.UTC().Format(time.RFC3339Nano)
}