package skills

import (
	"context"
	"strings"

	"github.com/tidbcloud/AgentTeam/internal/service/resource/activity"

	activitystore "github.com/tidbcloud/AgentTeam/internal/store/resource/activity"
	"github.com/tidbcloud/AgentTeam/internal/store/resource/repos"
	store "github.com/tidbcloud/AgentTeam/internal/store/resource/skills"
)

func (s *Service) ListSkillActivity(ctx context.Context, workspaceID, subject string, opts activity.ResourceActivityListOptions) (activity.ResourceActivityPage, error) {
	if s == nil || s.store == nil {
		return activity.ResourceActivityPage{}, invalidArgument("skill service is not configured")
	}
	if s.activityStore == nil {
		return activity.ResourceActivityPage{}, invalidArgument("activity store is not configured")
	}
	if err := validateSubject(subject); err != nil {
		return activity.ResourceActivityPage{}, err
	}
	maxRows := 0
	if s.contentAuthority != nil {
		maxRows = store.MaxAgentAccessibleSkillRows
	}
	visible, err := s.store.ListVisibleSkills(ctx, workspaceID, subject, true, maxRows)
	if err != nil {
		return activity.ResourceActivityPage{}, err
	}
	visibleAssets := skillActivityVisibleAssets(visible)
	if err := s.refreshLegacySkillActivity(ctx, workspaceID, visible); err != nil {
		return activity.ResourceActivityPage{}, err
	}
	return activity.ListResourceActivity(ctx, s.activityStore, workspaceID, activity.ResourceActivityDescriptor{
		AssetType:        activitystore.AssetTypeSkill,
		VisibleAssets:    visibleAssets,
		TombstoneActorID: subject,
		TombstoneEventTypes: []string{
			skillActivityArchived,
			skillActivityDeleted,
		},
	}, opts)
}

func (s *Service) refreshLegacySkillActivity(ctx context.Context, workspaceID string, skills []store.Skill) error {
	legacy := skills
	if s.contentAuthority != nil && len(skills) > 0 {
		skillIDs := make([]string, 0, len(skills))
		for _, skill := range skills {
			skillIDs = append(skillIDs, skill.ID)
		}
		native, err := s.nativeSkillReads(ctx, workspaceID, skillIDs)
		if err != nil {
			return err
		}
		legacy = make([]store.Skill, 0, len(skills))
		for _, skill := range skills {
			if !native[skill.ID] {
				legacy = append(legacy, skill)
			}
		}
	}
	activity.RefreshVisibleResourceActivity(ctx, s.activityProjector, s.repositoryStore, workspaceID, repos.ResourceTypeSkillRepository, skillActivityVisibleAssets(legacy), s.activityRefreshAfter, nil)
	return nil
}

func skillActivityVisibleAssets(skills []store.Skill) []activity.ResourceActivityVisibleAsset {
	visibleAssets := make([]activity.ResourceActivityVisibleAsset, 0, len(skills))
	for _, skill := range skills {
		visibleAssets = append(visibleAssets, activity.ResourceActivityVisibleAsset{
			ID:   skill.ID,
			Name: skill.Name,
		})
	}
	return visibleAssets
}

func appendVisibleSkillIfMissing(skills []store.Skill, skill store.Skill) []store.Skill {
	if strings.TrimSpace(skill.ID) == "" {
		return skills
	}
	for _, existing := range skills {
		if strings.TrimSpace(existing.ID) == strings.TrimSpace(skill.ID) {
			return skills
		}
	}
	return append(skills, skill)
}