package catalogue

import (
	"sort"
)

// Chosen is the provider somebody named for a provision: the module, and the node it runs on. Both,
// always (novox/hq #258) — a provision comes from a module, and the same module on two machines is
// two answers, so neither half alone says which. Module is empty only on a record made before this
// was asked, and such a record is honoured exactly as long as it is unambiguous.
type Chosen struct {
	Node   string
	Module string
}

func (c Chosen) String() string {
	if c.Module == "" {
		return c.Node
	}
	return c.Node + "/" + c.Module
}

// matches is whether this provider is the one chosen.
func (c Chosen) matches(p Provider) bool {
	return p.Node == c.Node && (c.Module == "" || p.Module == c.Module)
}

// among is every offered provider the choice names — one, when the choice is whole.
func (c Chosen) among(where []Provider) []Provider {
	var out []Provider
	for _, p := range where {
		if c.matches(p) {
			out = append(out, p)
		}
	}
	return out
}

// nameOf is how a refusal names a provider: the node and the module on it.
func nameOf(p Provider) string {
	return Chosen{Node: p.Node, Module: p.Module}.String()
}

// providerNames is every provider named, sorted, for a refusal to list.
func providerNames(where []Provider) []string {
	out := make([]string, 0, len(where))
	for _, p := range where {
		out = append(out, nameOf(p))
	}
	sort.Strings(out)
	return out
}

// providersHere is which modules in this node's own set offer a provision, sorted.
func providersHere(catalogue map[string]Manifest, here func(string) bool, want string) []string {
	var out []string
	for name, m := range catalogue {
		if !here(name) {
			continue
		}
		for _, o := range m.Offers() {
			if o == want {
				out = append(out, name)
				break
			}
		}
	}
	sort.Strings(out)
	return out
}

// servedByOne is what one provider beside the consumer says a consumer needs to know, or nothing.
//
// Serving is *whether* a need is created at all when the provider is on this same machine (novox/hq
// 04-ISSUES/038's sibling): a need never created is a binding the consumer never gets. The manifest
// alone answers that; the values are settled later, with the node's settings.
func servedByOne(m Manifest, want string) map[string]any {
	if _, ok := m.Serves[want]; ok {
		return ServedOn(m, want, nil)
	}
	return nil
}

// sharedByOne is the own secret that provider names as its credential (ADR 0158), or "" when it
// gives each consumer its own.
func sharedByOne(m Manifest, want string) string {
	if own, shared := m.SharedCredentialOf(want); shared {
		return own
	}
	return ""
}

func oneOf(list []string, s string) bool {
	for _, x := range list {
		if x == s {
			return true
		}
	}
	return false
}