Show.go

// SPDX-License-Identifier: MIT
// Copyright (c) 2026 MaIII Themd

package dijkstra

import (
	"fmt"
	"io"
	"strings"
)

// Show writes a human-readable dump of the whole graph -- every vertex
// with its coordinates, cumulative weight, visited flag and outgoing
// edges -- to w. Unlike Print (which targets stdout) it works with any
// io.Writer: a file, a bytes.Buffer in a test, or a log. Use ShowFunc
// to override the per-vertex formatting.
func (g *StGraph) Show(w io.Writer) {
	g.ShowFunc(w, nil)
}

// ShowFunc writes the graph to w, formatting each vertex with the
// caller-supplied line function -- so you can customise the output
// without re-implementing the iteration or the locking. Passing nil
// uses DefaultVertexLine (the same format as Show and Print).
//
// line receives a copy of each vertex and should only format it: the
// graph's read lock is held while it runs, so do not call back into the
// graph (and do not mutate the vertex's Edges slice) from inside it.
func (g *StGraph) ShowFunc(w io.Writer, line func(v StVertex) string) {
	if line == nil {
		line = DefaultVertexLine
	}
	g.mu.RLock()
	defer g.mu.RUnlock()
	for i := range g.vertex {
		_, _ = io.WriteString(w, line(g.vertex[i]))
	}
}

// DefaultVertexLine is the formatter Show and Print use when no custom
// one is supplied. It is exported so a ShowFunc callback can reuse or
// extend it.
func DefaultVertexLine(v StVertex) string {
	var b strings.Builder
	fmt.Fprintf(&b, "Vertex %s (%.2f,%.2f), w = %.2f, visited %v\n",
		v.Name, v.X, v.Y, v.Weight, v.Visited)
	b.WriteString("\tEdge ")
	for _, e := range v.Edges {
		oneway := ""
		if e.IsOneWay {
			oneway = ", one-way"
		}
		fmt.Fprintf(&b, "(%s, %.2f%s) | ", e.ToVertexName, e.Weight, oneway)
	}
	b.WriteString("\n\n")
	return b.String()
}

// ShowDijkstra writes the post-search state of every vertex (cumulative
// weight, parent, visited) together with only the edges on the
// shortest-path tree to w. Call it after DijkstraSearch, DijkstraRun or
// an A* search.
func (g *StGraph) ShowDijkstra(w io.Writer) {
	g.mu.RLock()
	defer g.mu.RUnlock()
	for i := range g.vertex {
		v := g.vertex[i]
		fmt.Fprintf(w, "Vertex %s, w %.2f, (%.2f,%.2f), visited %v, parent %s\n",
			v.Name, v.Weight, v.X, v.Y, v.Visited, v.Parent)
		_, _ = io.WriteString(w, "\tEdge ")
		for _, e := range v.Edges {
			if e.isShort {
				fmt.Fprintf(w, "(%s, %.2f) | ", e.ToVertexName, e.Weight)
			}
		}
		_, _ = io.WriteString(w, "\n\n")
	}
}

// PathString renders a path returned by DijkstraSearch / AStarSearch as
// "A -> B -> C (cost 6)", so callers don't have to loop over the slice
// just to print a result. An empty path returns "(no path)".
func PathString(path []StPath) string {
	if len(path) == 0 {
		return "(no path)"
	}
	return fmt.Sprintf("%s (cost %g)", joinArrow(path), path[len(path)-1].Cost)
}