// selfupdate.go — Selbstaktualisierung aus den Releases einer Gitea-Instanz.
//
// Die Datei ist als Kopiervorlage gedacht: in ein anderes Programm übernehmen,
// den Konfigurationsblock unten anpassen, `--update` und `--check-update` in
// die Optionen hängen — fertig. Sie braucht nur die Standardbibliothek und
// bringt außer dem Block keine Namen mit, die nicht mit "selfUpdate" oder
// "update" beginnen.
//
// Vorausgesetzt wird das Ablageschema von build.sh: je Version ein Release,
// dessen Tag die nackte Nummer ist (2.1.6, ein führendes "v" ist erlaubt), und
// darin je ein Asset "<name>-<goos>-<goarch>" — also genau die Dateien aus
// ./bin. Gitea liefert unter /api/v1/repos/<owner>/<repo>/releases/latest das
// neueste Release ohne Entwurf und ohne Vorabversion; GitHub spricht dieselbe
// Route mit anderen Feldnamen und ist deshalb nicht mitgemeint.
package main

import (
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"io"
	"net/http"
	"net/url"
	"os"
	"os/exec"
	"path/filepath"
	"runtime"
	"strconv"
	"strings"
	"time"
)

// ------------------------------------------------------------ Konfiguration

var selfUpdate = selfUpdater{
	repo:    "https://git.micw.org/mike/dx",
	asset:   "dx",
	current: version, // aus main.go, per -ldflags gesetzt
	verify:  []string{"--version"},
}

type selfUpdater struct {
	repo    string   // Repo-URL wie im Browser: https://host/owner/repo
	asset   string   // Basisname der Assets, "-<goos>-<goarch>" kommt dazu
	current string   // laufende Version
	verify  []string // Probelauf des Downloads; leer lässt ihn ausfallen
}

// ------------------------------------------------------------------ Ablauf

// check sieht nur nach und fasst nichts an.
func (u selfUpdater) check(w io.Writer) error {
	rel, err := u.latest()
	if err != nil {
		return err
	}
	if updateCompare(rel.TagName, u.current) <= 0 {
		fmt.Fprintf(w, "%s %s is up to date\n", u.asset, u.current)
		return nil
	}
	fmt.Fprintf(w, "%s %s is available, running %s\n  %s\n  run '%s --update' to install it\n",
		u.asset, rel.TagName, u.current, rel.HTMLURL, u.asset)
	return nil
}

// install holt das neueste Release und ersetzt die laufende Datei damit.
func (u selfUpdater) install(w io.Writer) error {
	rel, err := u.latest()
	if err != nil {
		return err
	}
	if updateCompare(rel.TagName, u.current) <= 0 {
		fmt.Fprintf(w, "%s %s is up to date\n", u.asset, u.current)
		return nil
	}

	want := fmt.Sprintf("%s-%s-%s", u.asset, runtime.GOOS, runtime.GOARCH)
	var src *updateAsset
	for i := range rel.Assets {
		if rel.Assets[i].Name == want {
			src = &rel.Assets[i]
			break
		}
	}
	if src == nil {
		names := make([]string, len(rel.Assets))
		for i, a := range rel.Assets {
			names[i] = a.Name
		}
		return fmt.Errorf("release %s has no %q (only %s)", rel.TagName, want, strings.Join(names, ", "))
	}

	exe, err := os.Executable()
	if err != nil {
		return fmt.Errorf("cannot locate the running binary: %w", err)
	}
	// Ein installiertes dx ist oft ein Symlink nach ./bin. Ersetzt werden soll
	// die Datei dahinter, nicht der Link.
	if real, err := filepath.EvalSymlinks(exe); err == nil {
		exe = real
	}
	mode := os.FileMode(0o755)
	if st, err := os.Stat(exe); err == nil {
		mode = st.Mode().Perm()
	}

	fmt.Fprintf(w, "downloading %s %s (%s)\n", want, rel.TagName, updateSize(src.Size))
	tmp, err := u.download(src, exe, mode)
	if err != nil {
		return err
	}
	defer os.Remove(tmp) // greift nur, wenn das Umbenennen unten ausfällt

	if err := u.probe(tmp, rel.TagName); err != nil {
		return err
	}
	if err := updateReplace(tmp, exe); err != nil {
		return err
	}

	fmt.Fprintf(w, "%s %s → %s, at %s\n", u.asset, u.current, rel.TagName, exe)
	return nil
}

func (u selfUpdater) download(a *updateAsset, exe string, mode os.FileMode) (string, error) {
	// Die neue Datei entsteht neben der alten: dasselbe Dateisystem, also ist
	// das Umbenennen am Ende ein atomarer Schritt und kein halber Kopiervorgang.
	// Sie entsteht auch vor dem ersten Byte — ein fehlendes Schreibrecht soll
	// auffallen, bevor ein paar Megabyte durch die Leitung sind.
	dir := filepath.Dir(exe)
	f, err := os.CreateTemp(dir, "."+filepath.Base(exe)+".new")
	if err != nil {
		var pe *os.PathError // der Pfad steht schon in der Meldung
		if errors.As(err, &pe) {
			err = pe.Err
		}
		return "", fmt.Errorf("cannot write to %s: %w", dir, err)
	}
	tmp := f.Name()

	resp, err := updateGet(a.URL)
	if err != nil {
		f.Close()
		os.Remove(tmp)
		return "", err
	}
	defer resp.Body.Close()

	n, err := io.Copy(f, resp.Body)
	if cerr := f.Close(); err == nil {
		err = cerr
	}
	if err == nil && a.Size > 0 && n != a.Size {
		err = fmt.Errorf("got %d of %d bytes from %s", n, a.Size, a.URL)
	}
	if err == nil {
		err = os.Chmod(tmp, mode)
	}
	if err != nil {
		os.Remove(tmp)
		return "", err
	}
	return tmp, nil
}

// probe ruft den frisch geladenen Läufer einmal auf. Das fängt eine
// abgeschnittene, für die falsche Plattform gebaute oder gar nicht erst
// ausführbare Datei ab, bevor sie die laufende ersetzt.
func (u selfUpdater) probe(path, tag string) error {
	if len(u.verify) == 0 {
		return nil
	}
	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
	defer cancel()

	out, err := exec.CommandContext(ctx, path, u.verify...).CombinedOutput()
	if err != nil {
		return fmt.Errorf("the downloaded binary does not run: %w", err)
	}
	if !strings.Contains(string(out), strings.TrimPrefix(tag, "v")) {
		return fmt.Errorf("the downloaded binary reports %q, expected %s",
			strings.TrimSpace(string(out)), tag)
	}
	return nil
}

// updateReplace tauscht die laufende Datei gegen die neue.
func updateReplace(tmp, exe string) error {
	if err := os.Rename(tmp, exe); err == nil {
		return nil
	}
	// Unix überschreibt die Datei eines laufenden Programms klaglos, Windows
	// nicht: dort muss die alte erst aus dem Weg. Löschen lässt sie sich
	// frühestens, wenn dieser Prozess endet — das Aufräumen darf also scheitern.
	old := exe + ".old"
	os.Remove(old)
	if err := os.Rename(exe, old); err != nil {
		return fmt.Errorf("cannot replace %s: %w", exe, err)
	}
	if err := os.Rename(tmp, exe); err != nil {
		os.Rename(old, exe) // zurück auf den alten Stand
		return fmt.Errorf("cannot replace %s: %w", exe, err)
	}
	os.Remove(old)
	return nil
}

// -------------------------------------------------------------------- Gitea

type updateRelease struct {
	TagName string        `json:"tag_name"`
	HTMLURL string        `json:"html_url"`
	Assets  []updateAsset `json:"assets"`
}

type updateAsset struct {
	Name string `json:"name"`
	Size int64  `json:"size"`
	URL  string `json:"browser_download_url"`
}

func (u selfUpdater) latest() (updateRelease, error) {
	base, err := u.apiBase()
	if err != nil {
		return updateRelease{}, err
	}
	resp, err := updateGet(base + "/releases/latest")
	if err != nil {
		return updateRelease{}, err
	}
	defer resp.Body.Close()

	var rel updateRelease
	if err := json.NewDecoder(resp.Body).Decode(&rel); err != nil {
		return updateRelease{}, fmt.Errorf("unexpected answer from %s: %w", base, err)
	}
	if rel.TagName == "" {
		return updateRelease{}, fmt.Errorf("%s has no releases", u.repo)
	}
	return rel, nil
}

// apiBase macht aus https://host/owner/repo die API-Wurzel des Repos.
func (u selfUpdater) apiBase() (string, error) {
	bad := fmt.Errorf("repo %q: expected https://host/owner/repo", u.repo)

	ref, err := url.Parse(strings.TrimSuffix(strings.TrimSuffix(u.repo, "/"), ".git"))
	if err != nil || ref.Host == "" {
		return "", bad
	}
	parts := strings.Split(strings.Trim(ref.Path, "/"), "/")
	if len(parts) != 2 || parts[0] == "" || parts[1] == "" {
		return "", bad
	}
	return fmt.Sprintf("%s://%s/api/v1/repos/%s/%s", ref.Scheme, ref.Host, parts[0], parts[1]), nil
}

// Ein Zeitlimit für alles zusammen: die Suche kostet ein paar hundert
// Millisekunden, der Download ein paar Megabyte — beides darf hängen bleiben,
// aber nicht ewig.
var updateClient = &http.Client{Timeout: 5 * time.Minute}

func updateGet(target string) (*http.Response, error) {
	req, err := http.NewRequest(http.MethodGet, target, nil)
	if err != nil {
		return nil, err
	}
	req.Header.Set("User-Agent", "selfupdate.go (+"+runtime.GOOS+"/"+runtime.GOARCH+")")

	resp, err := updateClient.Do(req)
	if err != nil {
		return nil, err
	}
	if resp.StatusCode != http.StatusOK {
		resp.Body.Close()
		return nil, fmt.Errorf("GET %s: %s", target, resp.Status)
	}
	return resp, nil
}

// ------------------------------------------------------------------ Nummern

// updateCompare vergleicht zwei Versionen komponentenweise numerisch, damit
// 2.1.10 hinter 2.1.9 landet und nicht davor. Ein führendes "v" zählt nicht,
// fehlende Stellen gelten als 0 (2.1 == 2.1.0), und ein Suffix am Zahlenrest
// macht die Version älter, nicht neuer (2.1.6-rc1 < 2.1.6). Ergebnis wie bei
// strings.Compare: -1, 0, 1.
func updateCompare(a, b string) int {
	as := strings.Split(strings.TrimPrefix(a, "v"), ".")
	bs := strings.Split(strings.TrimPrefix(b, "v"), ".")

	for i := 0; i < len(as) || i < len(bs); i++ {
		x, y := "0", "0"
		if i < len(as) {
			x = as[i]
		}
		if i < len(bs) {
			y = bs[i]
		}
		if c := updateComparePart(x, y); c != 0 {
			return c
		}
	}
	return 0
}

func updateComparePart(a, b string) int {
	na, ra := updateSplitNum(a)
	nb, rb := updateSplitNum(b)
	switch {
	case na != nb:
		if na < nb {
			return -1
		}
		return 1
	case ra == rb:
		return 0
	case ra == "": // 2.1.6 ist fertig, 2.1.6-rc1 noch nicht
		return 1
	case rb == "":
		return -1
	}
	return strings.Compare(ra, rb)
}

// updateSplitNum trennt "10-rc1" in 10 und "-rc1".
func updateSplitNum(s string) (int, string) {
	i := 0
	for i < len(s) && s[i] >= '0' && s[i] <= '9' {
		i++
	}
	n, _ := strconv.Atoi(s[:i])
	return n, s[i:]
}

// updateSize ist bewusst eine eigene kleine Formatierung und nicht formSize aus
// main.go — die Datei soll für sich alleine stehen.
func updateSize(b int64) string {
	const k = 1024
	switch {
	case b > k*k:
		return fmt.Sprintf("%.1f MB", float64(b)/k/k)
	case b > k:
		return fmt.Sprintf("%.1f KB", float64(b)/k)
	default:
		return fmt.Sprintf("%d B", b)
	}
}