routeranalytics

func (*wasmPrefetcher) request(resources []string)
{
	if len(resources) == 0 {
		return
	}
	p.mu.Lock()
	defer p.mu.Unlock()
	if p.requested == nil {
		p.requested = make(map[string]struct{})
	}
	filtered := make([]string, 0, len(resources))
	for _, r := range resources {
		if r == "" {
			continue
		}
		if _, ok := p.requested[r]; ok {
			continue
		}
		p.requested[r] = struct{}{}
		filtered = append(filtered, r)
	}
	if len(filtered) == 0 {
		return
	}
	p.tick++
	// Same wire shape a netcode client would produce: hints are one-way, so
	// the full client (snapshots, interpolation) is not needed here.
	hostclient.Send(p.channel, map[string]any{
		"tick":     p.tick,
		"commands": []any{map[string]any{"resources": filtered}},
	})
}

func (*Plugin) TransitionProbabilities(from string) []TransitionProbability
{
	if p == nil {
		return nil
	}
	probs := p.tracker.probabilities(from)
	if len(probs) == 0 {
		return nil
	}
	out := make([]TransitionProbability, len(probs))
	copy(out, probs)
	return out
}

func (*Plugin) MostLikelyNext(from string, limit int) []TransitionProbability
{
	if p == nil || limit <= 0 {
		return nil
	}
	probs := p.tracker.mostLikelyNext(from, limit)
	if len(probs) == 0 {
		return nil
	}
	out := make([]TransitionProbability, len(probs))
	copy(out, probs)
	return out
}

func (*Plugin) handleNavigation(path string)
{
	normalized := strings.TrimSpace(path)
	if p.opts.Normalize != nil {
		normalized = p.opts.Normalize(path)
	}
	if normalized == "" {
		return
	}
	p.tracker.visit(normalized)
	p.enqueuePrefetch(normalized)
}

func (*Plugin) enqueuePrefetch(current string)
{
	if p.opts.PrefetchLimit <= 0 || p.prefetch == nil {
		return
	}
	predictions := p.tracker.mostLikelyNext(current, p.opts.PrefetchLimit)
	if len(predictions) == 0 {
		return
	}
	threshold := p.opts.PrefetchThreshold
	if threshold < 0 {
		threshold = 0
	}
	resources := make([]string, 0, len(predictions))
	for _, prob := range predictions {
		if prob.Probability < threshold {
			continue
		}
		resources = append(resources, prob.To)
	}
	if len(resources) == 0 {
		return
	}
	p.prefetch.request(resources)
}

func (*transitionTracker) visit(routeID string)
{
	if routeID == "" {
		return
	}
	t.mu.Lock()
	if t.last != "" {
		t.recordLocked(t.last, routeID)
	}
	t.last = routeID
	t.mu.Unlock()
}

func (*transitionTracker) probabilities(from string) []TransitionProbability
{
	t.mu.RLock()
	total := t.totals[from]
	if total == 0 {
		t.mu.RUnlock()
		return nil
	}
	counts := t.transitions[from]
	result := make([]TransitionProbability, 0, len(counts))
	for to, count := range counts {
		result = append(result, TransitionProbability{
			From:        from,
			To:          to,
			Count:       count,
			Probability: float64(count) / float64(total),
		})
	}
	t.mu.RUnlock()
	sort.Slice(result, func(i, j int) bool {
		if result[i].Probability == result[j].Probability {
			return result[i].To < result[j].To
		}
		return result[i].Probability > result[j].Probability
	})
	return result
}

func (*transitionTracker) mostLikelyNext(from string, limit int) []TransitionProbability
{
	if limit <= 0 {
		return nil
	}
	probs := t.probabilities(from)
	if len(probs) == 0 {
		return nil
	}
	if limit >= len(probs) {
		out := make([]TransitionProbability, len(probs))
		copy(out, probs)
		return out
	}
	out := make([]TransitionProbability, limit)
	copy(out, probs[:limit])
	return out
}