package main

import (
	"bufio"
	"crypto/sha256"
	"encoding/hex"
	"os"
	"path/filepath"
	"strings"
)

// serversFile is where a runner remembers what it attached to, so appendix E's line needs no flag.
func serversFile() (string, error) {
	dir, err := os.UserConfigDir()
	if err != nil {
		return "", err
	}
	return filepath.Join(dir, "forge", "servers"), nil
}

// tokenKey is a hash, because the file names which server a token belongs to and never the token.
func tokenKey(tok string) string {
	sum := sha256.Sum256([]byte(tok))
	return hex.EncodeToString(sum[:8])
}

// rememberServer records where a token attached, after it worked, so a bad url is never kept.
func rememberServer(tok, server string) {
	path, err := serversFile()
	if err != nil {
		return
	}
	key := tokenKey(tok)
	lines := readServers(path)
	out := make([]string, 0, len(lines)+1)
	for _, line := range lines {
		if k, _, ok := strings.Cut(line, " "); !ok || k != key {
			out = append(out, line)
		}
	}
	out = append(out, key+" "+server)
	if err := os.MkdirAll(filepath.Dir(path), 0o700); err != nil {
		return
	}
	// A failure here costs the next run a flag, which is not worth failing a build over.
	os.WriteFile(path, []byte(strings.Join(out, "\n")+"\n"), 0o600)
}

// recallServer answers where this token attached last time, or nothing.
func recallServer(tok string) string {
	path, err := serversFile()
	if err != nil {
		return ""
	}
	key := tokenKey(tok)
	for _, line := range readServers(path) {
		if k, server, ok := strings.Cut(line, " "); ok && k == key {
			return server
		}
	}
	return ""
}

func readServers(path string) []string {
	f, err := os.Open(path)
	if err != nil {
		return nil
	}
	defer f.Close()
	var out []string
	sc := bufio.NewScanner(f)
	for sc.Scan() {
		if line := strings.TrimSpace(sc.Text()); line != "" {
			out = append(out, line)
		}
	}
	return out
}