package main

import (
	"math/rand"
	"os"
	"strings"
	"sync"
)

type MarkovChain struct {
	chain map[string][]string
	words []string
	keys  []string
}

var sharedBabbler = sync.OnceValue(NewBabbler)

func NewBabbler() *MarkovChain {
	text, err := os.ReadFile(sourceText)
	if err != nil {
		fatal("could not read source text for babbler", "path", sourceText, "err", err)
	}
	fields := strings.Fields(string(text))

	chain := make(map[string][]string)
	for i := 0; i < len(fields)-1; i++ {
		chain[fields[i]] = append(chain[fields[i]], fields[i+1])
	}

	seen := make(map[string]struct{})
	words := make([]string, 0, len(chain))
	for _, field := range fields {
		slug := Slugify(field)
		if slug == "" {
			continue
		}
		if _, dup := seen[slug]; dup {
			continue
		}
		seen[slug] = struct{}{}
		words = append(words, slug)
	}

	keys := make([]string, 0, len(chain))
	for k := range chain {
		keys = append(keys, k)
	}

	logger.Debug("babbler corpus loaded",
		"path", sourceText,
		"words", len(fields),
		"unique_words", len(words),
		"chain_entries", len(chain),
	)

	return &MarkovChain{chain: chain, words: words, keys: keys}
}

func (m *MarkovChain) Generate(maxWords int) string {
	if len(m.keys) == 0 {
		return ""
	}

	word := m.keys[rand.Intn(len(m.keys))]

	var result []string
	result = append(result, word)

	for i := 1; i < maxWords; i++ {
		next, ok := m.chain[word]
		if !ok || len(next) == 0 {
			break
		}
		word = next[rand.Intn(len(next))]
		result = append(result, word)
	}

	return strings.Join(result, " ")
}

func (m *MarkovChain) Links(n int) []string {
	if len(m.words) == 0 {
		return nil
	}
	if n > len(m.words) {
		n = len(m.words)
	}

	seen := make(map[string]struct{}, n)
	links := make([]string, 0, n)
	for len(links) < n {
		link := m.randomLink()
		if _, dup := seen[link]; dup {
			continue
		}
		seen[link] = struct{}{}
		links = append(links, link)
	}
	return links
}

func (m *MarkovChain) randomLink() string {
	first := m.words[rand.Intn(len(m.words))]
	second := m.words[rand.Intn(len(m.words))]
	return first + "/" + second
}
