// aibridgepricesdiff renders a human-readable Markdown summary of the
// difference between two AI Gateway price seed files (the prices.json produced
// by aibridgepricesgen).
//
// The price refresh workflow uses it to fill the pull request body, so
// a reviewer sees at a glance which models appeared, which disappeared, and
// which repriced. Exact figures are deliberately left to the pull request
// diff, which is the source of truth.
//
// Usage:
//
//	aibridgepricesdiff -old <path> -new <path>
package main

import (
	"flag"
	"fmt"
	"io"
	"os"
	"sort"
	"strings"

	"golang.org/x/xerrors"

	"github.com/coder/coder/v2/coderd/aibridge/prices/pricebook"
)

func less(a, b pricebook.Key) bool {
	if a.Provider != b.Provider {
		return a.Provider < b.Provider
	}
	return a.Model < b.Model
}

// diff is the full comparison between two snapshots
type diff struct {
	added   []pricebook.Key
	removed []pricebook.Key
	changed []pricebook.Key
}

func (d diff) empty() bool {
	return len(d.added) == 0 && len(d.removed) == 0 && len(d.changed) == 0
}

func main() {
	oldPath := flag.String("old", "", "path to the previous prices.json (required)")
	newPath := flag.String("new", "", "path to the refreshed prices.json (required)")
	flag.Parse()
	if err := run(*oldPath, *newPath, os.Stdout); err != nil {
		_, _ = fmt.Fprintf(os.Stderr, "aibridgepricesdiff: %v\n", err)
		os.Exit(1)
	}
}

func run(oldPath, newPath string, w io.Writer) error {
	if oldPath == "" || newPath == "" {
		return xerrors.New("-old and -new are both required")
	}
	oldRows, err := readRows(oldPath)
	if err != nil {
		return xerrors.Errorf("read %s: %w", oldPath, err)
	}
	newRows, err := readRows(newPath)
	if err != nil {
		return xerrors.Errorf("read %s: %w", newPath, err)
	}
	_, err = io.WriteString(w, render(compare(oldRows, newRows)))
	return err
}

func readRows(path string) ([]pricebook.Row, error) {
	data, err := os.ReadFile(path)
	if err != nil {
		return nil, err
	}
	rows, err := pricebook.Parse(data)
	if err != nil {
		return nil, xerrors.Errorf("parse: %w", err)
	}
	return rows, nil
}

// compare classifies every model as added, removed, or changed.
func compare(oldRows, newRows []pricebook.Row) diff {
	oldByKey := make(map[pricebook.Key]pricebook.Row, len(oldRows))
	for _, r := range oldRows {
		oldByKey[r.Key()] = r
	}

	var d diff
	seen := make(map[pricebook.Key]struct{}, len(newRows))
	for _, r := range newRows {
		seen[r.Key()] = struct{}{}
		prev, ok := oldByKey[r.Key()]
		switch {
		case !ok:
			d.added = append(d.added, r.Key())
		case !prev.SamePrices(r):
			d.changed = append(d.changed, r.Key())
		}
	}
	for _, r := range oldRows {
		if _, ok := seen[r.Key()]; !ok {
			d.removed = append(d.removed, r.Key())
		}
	}

	for _, keys := range [][]pricebook.Key{d.added, d.removed, d.changed} {
		sort.Slice(keys, func(i, j int) bool { return less(keys[i], keys[j]) })
	}
	return d
}

// render writes the Markdown summary: counts, then the models in each
// category. Empty categories are omitted.
func render(d diff) string {
	var b strings.Builder
	write := func(format string, args ...any) {
		_, _ = fmt.Fprintf(&b, format, args...)
	}

	write("## Price book changes\n\n")
	if d.empty() {
		write("No price changes.\n")
		return b.String()
	}

	write("%s added, %s removed, %s changed.\n",
		plural(len(d.added), "model"),
		plural(len(d.removed), "model"),
		plural(len(d.changed), "model"),
	)

	renderList := func(heading string, keys []pricebook.Key) {
		if len(keys) == 0 {
			return
		}
		write("\n<details>\n<summary>%s</summary>\n\n", heading)
		for _, k := range keys {
			write("- %s\n", k)
		}
		write("</details>\n")
	}
	renderList("Added", d.added)
	renderList("Removed", d.removed)
	renderList("Changed", d.changed)

	return b.String()
}

func plural(n int, noun string) string {
	if n == 1 {
		return fmt.Sprintf("%d %s", n, noun)
	}
	return fmt.Sprintf("%d %ss", n, noun)
}