package fejkdata

import (
	"fmt"
	"sort"
	"strings"
)

// drawSet is one render's reference draws: the unnamed group's, and each named group's.
type drawSet struct {
	unnamed draws
	named   map[string]*draws
}

// drawScope is where a render reads its reference paths: a draw set, in the group of the
// template rendering.
type drawScope struct {
	set   *drawSet
	group string
}

// newDrawSet makes the unnamed group's maps where the set is declared, keeping them on that frame's
// stack for a render that reads through them; a zero drawSet makes them on its first read instead.
func newDrawSet() drawSet {
	return drawSet{unnamed: draws{variant: map[string]node{}, value: map[string]draw{}}}
}

// renderOnce renders n as one render, over draws of its own.
func renderOnce(s *session, n node) string {
	var set drawSet
	return render(s, n, drawScope{set: &set})
}

// in is the scope t renders in: its group where it names one, else its caller's.
func (sc drawScope) in(t *template) drawScope {
	if t.groupKey != "" {
		sc.group = t.groupKey
	}
	return sc
}

// draws is the set's draws for sc's group.
func (sc drawScope) draws() *draws {
	if sc.group == "" {
		return &sc.set.unnamed
	}
	d, drew := sc.set.named[sc.group]
	if !drew {
		if sc.set.named == nil {
			sc.set.named = map[string]*draws{}
		}
		d = &draws{variant: map[string]node{}, value: map[string]draw{}}
		sc.set.named[strings.Clone(sc.group)] = d // a key from sc would leak sc, and with it every render's draw set, to the heap
	}
	return d
}

// groupOf reads a template's "group" (default ""), which a repeat cannot carry: each iteration
// renders in no group.
func groupOf(m map[string]any, repeat int) (string, error) {
	v, ok := m["group"]
	if !ok {
		return "", nil
	}
	name, ok := v.(string)
	switch {
	case !ok:
		return "", fmt.Errorf("group must be a string, got %T", v)
	case name == "":
		return "", fmt.Errorf(`group "" is the default, so it has no effect; drop it`)
	case repeat > 1:
		return "", fmt.Errorf("group %q on a repeat names nothing, since each iteration is a render of its own; drop it", name)
	}
	return name, nil
}

// keyGroup keys t's group by the category t sits in, "" for an inline template, so a group name is
// local to its category.
func (t *template) keyGroup(category string) {
	if t.group != "" {
		t.groupKey = category + "/" + t.group
	}
}

// checkNestedGroup refuses a template beneath one drawing in group that names group again, short of
// a repeat or another group.
func checkNestedGroup(fields map[string]node, group string) error {
	if group == "" {
		return nil
	}
	var walk func(path string, n node) error
	walk = func(path string, n node) error {
		t, isTemplate := n.(*template)
		switch {
		case isTemplate && t.group == group:
			return fmt.Errorf("%q names group %q, the group this template draws in already; drop it", path, group)
		case isTemplate && (t.group != "" || t.repeat > 1):
			return nil
		}
		for _, c := range contained(n) {
			if err := walk(join(path, c.name), c.node); err != nil {
				return err
			}
		}
		return nil
	}
	for _, name := range sortedNames(fields) {
		if err := walk(name, fields[name]); err != nil {
			return err
		}
	}
	return nil
}

// drawCheck fences each template of a scope as a render of its own, remembering which nodes read a
// reference path.
type drawCheck struct {
	reads map[node]bool
}

// checkGroup refuses a group that splits nothing: one whose render reads no reference path short of
// a repeat.
func (c *drawCheck) checkGroup(path string, n node) error {
	if t, ok := n.(*template); ok && t.group != "" && !c.readsPath(t) {
		return fmt.Errorf("%s: group %q splits nothing, since nothing it renders reads a reference path; drop it", path, t.group)
	}
	return nil
}

func (c *drawCheck) checkDraws(path string, n node) error {
	t, ok := n.(*template)
	if !ok || !c.readsPath(t) {
		return nil
	}
	w := newDrawWalk(nil)
	for _, e := range renderEdges(t) {
		w.edge(t, e, drawAt{group: t.groupKey, route: drawRoute{e.reached(), e.label}})
	}
	if err := w.check(); err != nil {
		return fmt.Errorf("%s: %w", path, err)
	}
	return nil
}

// readsPath reports whether rendering n reads a reference path, short of a repeat, which renders over
// draws of its own.
func (c *drawCheck) readsPath(n node) bool {
	if r, done := c.reads[n]; done {
		return r
	}
	r := false
	for _, e := range renderEdges(n) {
		if a, _, isRef := refRead(n, e.label); (isRef && len(a.tail) > 0) || (!repeats(e.to) && c.readsPath(e.to)) {
			r = true
			break
		}
	}
	if c.reads == nil {
		c.reads = map[node]bool{}
	}
	c.reads[n] = r
	return r
}

func repeats(n node) bool {
	t, isTemplate := n.(*template)
	return isTemplate && t.repeat > 1
}

// refRead is the reference an edge of n reads, and the node it is bound to; false when the edge
// reads none.
func refRead(n node, label string) (arm, node, bool) {
	t, isTemplate := n.(*template)
	if !isTemplate {
		return arm{}, nil, false
	}
	a := splitArm(label, t.refs)
	return a, t.fields[a.key], isRef(a.key)
}

// checkColumnDraws fences a record's columns as one render.
func checkColumnDraws(t *template, columns []string) error {
	w := newDrawWalk(t)
	for _, name := range columns {
		w.walk(t.fields[name], drawAt{group: t.groupKey, route: drawRoute{spelling: fmt.Sprintf("column %q", name)}})
	}
	return w.check()
}

// drawWalk gathers what one render reads by reference and what it draws afresh, each by group, for
// check to compare. record is set for a record's columns, which may not read the record back.
type drawWalk struct {
	record *template
	reads  []pathRead
	read   map[drawKey]bool
	fresh  []freshDraw
	seen   map[drawVisit]bool
	err    error
}

// drawAt is where a walk stands: the group it draws in, how the render's root reached it, the
// reference it last crossed, and whether it renders inside a reference path's draw.
type drawAt struct {
	group string
	route drawRoute
	via   string
	held  bool
}

// drawRoute is how a render reaches a draw: as its author spells it, and the root edge's label.
type drawRoute struct{ spelling, label string }

// pathRead is one reference a render reads: a path, or a bare reference with no tail.
type pathRead struct {
	at     drawAt
	a      arm
	target node
}

type freshDraw struct {
	at drawAt
	n  node
}

type drawVisit struct {
	n     node
	group string
	held  bool
}

type drawKey struct {
	group string
	key   any
}

func newDrawWalk(record *template) *drawWalk {
	return &drawWalk{record: record, read: map[drawKey]bool{}, seen: map[drawVisit]bool{}}
}

// walk follows what rendering n renders. A repeat renders over draws of its own, so the walk stops
// there.
func (w *drawWalk) walk(n node, at drawAt) {
	v := drawVisit{n, at.group, at.held}
	if w.seen[v] || w.err != nil {
		return
	}
	w.seen[v] = true
	if !at.held {
		w.fresh = append(w.fresh, freshDraw{at, n})
	}
	if repeats(n) {
		return
	}
	if t, isTemplate := n.(*template); isTemplate && t.groupKey != "" {
		at.group = t.groupKey
	}
	for _, e := range renderEdges(n) {
		w.edge(n, e, at)
	}
}

func (w *drawWalk) edge(from node, e renderEdge, at drawAt) {
	a, target, reads := refRead(from, e.label)
	switch {
	case !reads:
		w.walk(e.to, at)
		return
	case w.record != nil && target == node(w.record):
		w.err = fmt.Errorf("%s reads {%s}, which points back at this record; a column cannot read another column — move the shared value into its own category and reference that", at.route.spelling, a.name)
		return
	}
	if k := (drawKey{at.group, a.path}); !w.read[k] {
		w.read[k] = true
		w.reads = append(w.reads, pathRead{at, a, target})
	}
	at.via, at.held = a.name, len(a.tail) > 0
	w.walk(e.to, at)
}

// check refuses what one draw per reference path cannot answer for, reads compared in path order so
// which pair is reported does not vary.
func (w *drawWalk) check() error {
	if w.err != nil {
		return w.err
	}
	sort.SliceStable(w.reads, func(i, j int) bool {
		if w.reads[i].at.group != w.reads[j].at.group {
			return w.reads[i].at.group < w.reads[j].at.group
		}
		return w.reads[i].a.path < w.reads[j].a.path
	})
	if err := w.checkOverlaps(); err != nil {
		return err
	}
	return w.checkFreshDraws()
}

// checkOverlaps refuses a read of a level beside a path another read takes into it.
func (w *drawWalk) checkOverlaps() error {
	for i, level := range w.reads {
		for _, into := range w.reads[i+1:] {
			if into.at.group == level.at.group && strings.HasPrefix(into.a.path, level.a.path+".") {
				return overlapError(level.at.route, level.a.name, into)
			}
		}
	}
	return nil
}

// checkFreshDraws refuses a node drawn afresh where a reference path's draw holds it.
func (w *drawWalk) checkFreshDraws() error {
	pins := map[drawKey]pathRead{}
	for _, r := range w.reads {
		if len(r.a.tail) == 0 {
			continue
		}
		held := map[node]bool{}
		coverPath(r.target, r.a.tail, held)
		for n := range held {
			if _, pinned := pins[drawKey{r.at.group, n}]; !pinned {
				pins[drawKey{r.at.group, n}] = r
			}
		}
	}
	for _, f := range w.fresh {
		if r, pinned := pins[drawKey{f.at.group, f.n}]; pinned {
			return overlapError(f.at.route, f.at.via, r)
		}
	}
	return nil
}

func overlapError(route drawRoute, ref string, into pathRead) error {
	return fmt.Errorf("%s renders a level that %s reads a path into; name the fields you want instead, or draw them apart with a group", route.spelled(ref), into.at.route.spelled(into.a.name))
}

// spelled names the route, and the reference it reaches a draw by where its root edge is not that
// reference.
func (r drawRoute) spelled(ref string) string {
	if ref == "" || ref == r.label {
		return r.spelling
	}
	return fmt.Sprintf("%s with {%s}", r.spelling, ref)
}