package content

import (
	"log/slog"
	"sort"
	"strings"
)

// Site is a set of bundles indexed for lookup by permalink key.
type Site struct {
	byKeyLang map[string]Bundle
	aliases   map[string]string
}

// NewSite indexes bundles for lookup. Later variants of a key and language cannot occur, because Scan
// drops ambiguity before this sees it.
func NewSite(bundles []Bundle) *Site {
	s := &Site{
		byKeyLang: make(map[string]Bundle, len(bundles)),
		aliases:   map[string]string{},
	}
	for _, b := range bundles {
		s.byKeyLang[b.Key+"\x00"+b.Lang] = b
	}
	s.indexAliases(bundles)
	return s
}

// indexAliases maps each alias to the key it redirects to.
//
// An alias that names a real bundle, or that two bundles both claim, is ambiguous: it is logged and
// dropped rather than picking a winner, and the real bundle keeps its URL (ADR-0029).
func (s *Site) indexAliases(bundles []Bundle) {
	claimed := map[string][]string{}
	for _, b := range bundles {
		for _, a := range b.Aliases {
			claimed[a] = append(claimed[a], b.Key)
		}
	}
	for alias, keys := range claimed {
		if _, isReal := s.byKeyLang[alias+"\x00"+DefaultLang]; isReal {
			slog.Error("ignoring alias that names a real bundle", "alias", alias, "claimed_by", keys)
			continue
		}
		if len(keys) > 1 {
			slog.Error("ignoring alias claimed by more than one bundle", "alias", alias, "claimed_by", keys)
			continue
		}
		s.aliases[alias] = keys[0]
	}
}

// Alias returns the key an alias redirects to.
func (s *Site) Alias(alias string) (string, bool) {
	key, ok := s.aliases[alias]
	return key, ok
}

// Lookup returns the best variant of a key for a requested language, and the language actually served.
//
// The fallback chain is requested → default → any (ADR-0009); "any" is resolved in sorted order so the
// same request always answers the same way. A key with no variants at all reports false.
func (s *Site) Lookup(key, lang string) (b Bundle, served string, ok bool) {
	for _, try := range []string{lang, DefaultLang} {
		if try == "" {
			continue
		}
		if b, ok = s.byKeyLang[key+"\x00"+try]; ok {
			return b, try, true
		}
	}
	for _, l := range s.Variants(key) {
		b = s.byKeyLang[key+"\x00"+l]
		return b, l, true
	}
	return Bundle{}, "", false
}

// Variants lists the languages a key exists in, sorted.
func (s *Site) Variants(key string) []string {
	var langs []string
	for kl := range s.byKeyLang {
		k, l, found := strings.Cut(kl, "\x00")
		if found && k == key {
			langs = append(langs, l)
		}
	}
	sort.Strings(langs)
	return langs
}

// HasLang reports whether any bundle is written in lang. The resolver needs this to tell a language
// prefix from a section that happens to share its name.
func (s *Site) HasLang(lang string) bool {
	for kl := range s.byKeyLang {
		if _, l, found := strings.Cut(kl, "\x00"); found && l == lang {
			return true
		}
	}
	return false
}

// Len reports how many bundles the site holds.
func (s *Site) Len() int { return len(s.byKeyLang) }

// Query selects bundles into an ordered list.
//
// Every grouping in the engine is a Query — sections now, tags and series later. It carries no cache
// signature yet: nothing caches, and a signature with no consumer is speculation (architecture.md).
type Query struct {
	// Section is the first path segment of a key. Empty matches every section.
	Section string
	// Tag is a tag slug. Empty matches every bundle; set, it matches those carrying the term.
	Tag string
	// Lang is the language to serve, with the usual fallback per key (ADR-0009).
	Lang string
}

// Run applies q, newest first, with undated bundles after dated ones and ties broken by key so the same
// query always answers in the same order.
func (s *Site) Run(q Query) []Bundle {
	seen := map[string]bool{}
	var out []Bundle
	for kl := range s.byKeyLang {
		key, _, found := strings.Cut(kl, "\x00")
		if !found || seen[key] {
			continue
		}
		if q.Section != "" && !strings.HasPrefix(key, q.Section+"/") {
			continue
		}
		seen[key] = true
		b, _, ok := s.Lookup(key, q.Lang)
		if !ok || !b.hasTag(q.Tag) {
			continue
		}
		out = append(out, b)
	}
	sort.Slice(out, func(i, j int) bool {
		a, b := out[i], out[j]
		switch {
		case !a.Date.Equal(b.Date):
			return a.Date.After(b.Date)
		default:
			return a.Key < b.Key
		}
	})
	return out
}

// hasTag reports whether the bundle carries a tag slug. An empty slug matches everything.
func (b Bundle) hasTag(slug string) bool {
	if slug == "" {
		return true
	}
	for _, t := range b.Tags {
		if TagSlug(t) == slug {
			return true
		}
	}
	return false
}

// Section is the first path segment of a bundle's key: its content type by default.
func (b Bundle) Section() string {
	sec, _, nested := strings.Cut(b.Key, "/")
	if !nested {
		return ""
	}
	return sec
}

// Sections lists every section that holds at least one bundle, sorted.
func (s *Site) Sections() []string {
	seen := map[string]bool{}
	for kl := range s.byKeyLang {
		key, _, found := strings.Cut(kl, "\x00")
		if !found {
			continue
		}
		if sec, _, nested := strings.Cut(key, "/"); nested {
			seen[sec] = true
		}
	}
	out := make([]string, 0, len(seen))
	for sec := range seen {
		out = append(out, sec)
	}
	sort.Strings(out)
	return out
}