// Package assign is the assigner's judgement, as functions over what it read from the bus: the composition check of a
// change (novox/hq ADR 0446 clauses 1 to 5, ADR 0528 clause 5, issue 1297), the six rules of what each node should
// run (ADR 0429 §6, ADR 0528 clause 3) and the comparison with what the controller sends (ADR 0528 clause 4). It reads
// and writes nothing itself: the program hands it what it watched and writes what it answers.
package assign

import (
	"fmt"
	"slices"
	"sort"
	"strings"
	"time"

	"git.novox.be/novox/mesh-sdk/go/catalogue"
	"git.novox.be/novox/mesh-sdk/go/compose"
	"git.novox.be/novox/mesh-sdk/go/delivery"
)

// SDKRepository is the repository of mesh-sdk: a group with a member there changes the composition itself.
const SDKRepository = "novox/mesh-sdk"

// NotJudged names, in a composition's warnings, the failures of ADR 0446 clause 1 the assigner cannot judge from the
// bus, because what they need is only in the controller's facts snapshot, which is not on the bus yet (issue 1461;
// the design limit of R4g, issue 1297): said on every verdict, never passed silently.
const NotJudged = "not judged until the facts snapshot is on the bus (issue 1461): a consumer left out of a grant, a " +
	"credential left bound elsewhere, a stored setting the changed definition cannot keep, and a new module the " +
	"node-engine's validator would refuse"

// Mesh is the mesh as the trunk holds it: every module's manifest by name, the manifests that cannot be read with
// why, and each node's open assignments.
type Mesh struct {
	Manifests  map[string]catalogue.Manifest
	Unreadable map[string]string
	Assigned   map[string][]string
	// Digests is every trunk module's manifest digest in the indexer's manifests bucket, readable or not: what a
	// composer at another mesh-sdk reads (issue 1622).
	Digests map[string]string
}

// Change is a group's change as the indexer's candidate holds it: the manifest of every module it moves or adds, those
// it cannot read and why, the modules it removes, every module defined twice with where, the heads of a mesh-sdk
// member (empty when none), and how many modules it rebuilds.
type Change struct {
	Group, Heads string
	Manifests    map[string]catalogue.Manifest
	Unreadable   map[string]string
	Removed      []string
	Twice        map[string][]string
	SDKHead      string
	Rebuilt      int
	// Digests is the manifest digest of every module the change moves or adds, readable by the assigner or not, and
	// Members the head of each member by repository: what a composer at the group's mesh-sdk reads (issues 1622, 1623).
	Digests map[string]string
	Members map[string]string
}

// Touched is the machines a change touches (ADR 0446 clause 3): those running a module the change moves, adds or
// removes, those running a consumer of a provision such a module provides (before or after), and those running a
// provider of a provision such a module requires after the change. A module the change adds that is assigned nowhere
// touches no machine.
func Touched(m Mesh, c Change) []string {
	moved := map[string]bool{}
	for name := range c.Manifests {
		moved[name] = true
	}
	for name := range c.Unreadable {
		moved[name] = true
	}
	for _, name := range c.Removed {
		moved[name] = true
	}
	provided, required := map[string]bool{}, map[string]bool{}
	for name := range moved {
		for _, man := range []catalogue.Manifest{m.Manifests[name], c.Manifests[name]} {
			for _, o := range man.Provides {
				provided[o.Name] = true
			}
		}
		for _, r := range c.Manifests[name].Requires {
			required[r] = true
		}
	}
	var out []string
	for node, modules := range m.Assigned {
		for _, mod := range modules {
			man := m.Manifests[mod]
			if moved[mod] || slices.ContainsFunc(man.Requires, func(r string) bool { return provided[r] }) ||
				slices.ContainsFunc(man.Provides, func(o catalogue.Offer) bool { return required[o.Name] }) {
				out = append(out, node)
				break
			}
		}
	}
	sort.Strings(out)
	return out
}

// input is the composition's input for the mesh's catalogue and assignments: the nodes by name with what is assigned
// to them, and every seat the assigned modules claim as held there. What the bus does not carry (places on the
// private network, settings, credentials, licences) is left empty, so a trunk composition and a change's are made
// with the same gaps and compared (ADR 0446 clause 1: what was already broken is said and fails nothing).
func input(catalog map[string]catalogue.Manifest, assigned map[string][]string) compose.Input {
	in := compose.Input{Catalogue: catalog}
	nodes := make([]string, 0, len(assigned))
	for n := range assigned {
		nodes = append(nodes, n)
	}
	sort.Strings(nodes)
	for _, n := range nodes {
		in.Nodes = append(in.Nodes, compose.Node{Name: n, Assigned: slices.Clone(assigned[n])})
		for _, mod := range assigned[n] {
			for _, cl := range catalog[mod].Claims {
				scope := cl.Scope
				if seat, ok := catalogue.SeatNamed(cl.Name); ok && scope == "" {
					scope = seat.Scope
				}
				in.Holdings = append(in.Holdings, catalogue.Held{Claim: cl.Name, Scope: scope, Node: n, Module: mod})
			}
		}
	}
	return in
}

// Compose is the composition check of change c over the mesh m, composed with the mesh-sdk version sdk: every touched
// machine resolved as the trunk holds it and as the change leaves it. It fails on a manifest of the change that cannot
// be read, a module a machine runs that the change removes, a module defined twice, and a machine that resolves on the
// trunk and not with the change; a machine that does not resolve on either is said and fails nothing. It warns past
// CompositionRebuildWarning modules rebuilt, says what it does not judge (NotJudged), and for a group with a mesh-sdk
// member says it composed with its own mesh-sdk, not the member's head (issue 1621). took is how long it took.
func Compose(m Mesh, c Change, sdk string, took time.Duration) delivery.CompositionVerdict {
	v := delivery.CompositionVerdict{Group: c.Group, Heads: c.Heads, SDK: sdk, Took: took.Milliseconds()}
	var fails []string
	failAt := func(machine, words string) {
		if v.Machine == "" && machine != "" {
			v.Machine = machine
		}
		fails = append(fails, words)
	}
	for _, name := range sortedKeys(c.Unreadable) {
		failAt("", fmt.Sprintf("the manifest of %s cannot be read: %s", name, c.Unreadable[name]))
	}
	for _, name := range sortedKeys(c.Twice) {
		failAt("", fmt.Sprintf("%s is defined twice, in %s", name, strings.Join(c.Twice[name], " and ")))
	}
	machines := Touched(m, c)
	v.Machines = machines
	for _, node := range machines {
		for _, name := range c.Removed {
			if slices.Contains(m.Assigned[node], name) {
				failAt(node, fmt.Sprintf("%s runs %s, which the change removes from its source", node, name))
			}
		}
	}
	trunk := input(m.Manifests, m.Assigned)
	changed := map[string]catalogue.Manifest{}
	for name, man := range m.Manifests {
		changed[name] = man
	}
	for name, man := range c.Manifests {
		changed[name] = man
	}
	for _, name := range c.Removed {
		delete(changed, name)
	}
	after := input(changed, m.Assigned)
	for _, node := range machines {
		_, before := compose.Resolve(trunk, node)
		_, now := compose.Resolve(after, node)
		switch {
		case now == nil:
		case before != nil:
			v.Warnings = append(v.Warnings, fmt.Sprintf("%s does not compose on the trunk either, so the change is not blamed: %v", node, before))
		default:
			failAt(node, fmt.Sprintf("%s composes on the trunk and not with the change: %v", node, now))
		}
	}
	if c.SDKHead != "" {
		v.Warnings = append(v.Warnings, fmt.Sprintf("composed with the assigner's own mesh-sdk %s, not the group's mesh-sdk head %s, "+
			"and a field the running controller cannot read is not judged (issues 1621, 1622, 1623)", sdk, c.SDKHead))
	}
	return finish(v, m, c, machines, fails)
}

// finish adds what every composition says beside its own judgement (more modules rebuilt than CompositionRebuildWarning,
// what is not judged, the machines not composed, a change that touches none) and its state from fails.
func finish(v delivery.CompositionVerdict, m Mesh, c Change, machines []string, fails []string) delivery.CompositionVerdict {
	if c.Rebuilt > delivery.CompositionRebuildWarning {
		v.Warnings = append(v.Warnings, fmt.Sprintf("the merge rebuilds %d modules, more than %d", c.Rebuilt, delivery.CompositionRebuildWarning))
	}
	v.Warnings = append(v.Warnings, NotJudged)
	if could := CouldRun(m, c, machines); len(could) > 0 {
		v.Warnings = append(v.Warnings, "not judged until the facts snapshot is on the bus (issue 1461, ADR 0537 clause 1): "+
			"the machines that could run a moved or added module and are not assigned it: "+strings.Join(could, ", "))
	}
	if grants := GrantsAlone(m, c, machines); len(grants) > 0 {
		v.Warnings = append(v.Warnings, "not judged until the facts snapshot is on the bus (issue 1461, ADR 0537 clause 1): "+
			"the machines whose grants alone the change alters: "+strings.Join(grants, ", "))
	}
	if len(machines) == 0 {
		v.Warnings = append(v.Warnings, "the change touches no machine: no module it moves is assigned anywhere")
	}
	if len(fails) > 0 {
		v.State, v.Words = delivery.CompositionFail, strings.Join(fails, "; ")
		return v
	}
	v.State = delivery.CompositionPass
	return v
}

// CouldRun is, by name, every machine of the mesh not composed that is not assigned a module the change moves or adds
// (ADR 0537 clause 1): which of them could run it, the bus does not say (capabilities, settings and places are only in
// the facts snapshot), so each is named as not judged.
func CouldRun(m Mesh, c Change, composed []string) []string {
	var out []string
	for node, modules := range m.Assigned {
		if slices.Contains(composed, node) {
			continue
		}
		for name := range c.Manifests {
			if !slices.Contains(modules, name) {
				out = append(out, node)
				break
			}
		}
	}
	sort.Strings(out)
	return out
}

// grantsOf is what of a manifest makes grants: its bus declarations and the provisions it requires and offers.
func grantsOf(man catalogue.Manifest) string {
	var offers []string
	for _, o := range man.Provides {
		offers = append(offers, o.Name)
	}
	return fmt.Sprint(man.Requires, offers, man.Reads, man.State, man.Emits, man.Consumes, man.Invokes, man.Claims, man.Grants)
}

// GrantsAlone is, by name, every machine not composed whose grants alone the change alters (ADR 0537 clause 1): for a
// moved module whose grants differ from the trunk's, the machines assigned the bus's holder (whose user list carries
// every module's bus grants) and those assigned a provider of a provision it requires, before or after.
func GrantsAlone(m Mesh, c Change, composed []string) []string {
	provisions := map[string]bool{}
	altered := false
	for name, man := range c.Manifests {
		before, had := m.Manifests[name]
		if had && grantsOf(before) == grantsOf(man) {
			continue
		}
		altered = true
		for _, r := range append(slices.Clone(man.Requires), before.Requires...) {
			provisions[r] = true
		}
	}
	if !altered {
		return nil
	}
	var out []string
	for node, modules := range m.Assigned {
		if slices.Contains(composed, node) {
			continue
		}
		for _, mod := range modules {
			man := m.Manifests[mod]
			if man.ClaimsSeat("mesh-broker") || slices.ContainsFunc(man.Provides, func(o catalogue.Offer) bool { return provisions[o.Name] }) {
				out = append(out, node)
				break
			}
		}
	}
	sort.Strings(out)
	return out
}

func sortedKeys[V any](m map[string]V) []string {
	out := make([]string, 0, len(m))
	for k := range m {
		out = append(out, k)
	}
	sort.Strings(out)
	return out
}