// Package update is de self-update van een geïnstalleerde BlueGit.
// Het HTTP-endpoint schrijft alleen een verzoek weg en start de unit.
// Het script in packaging doet de bouw en de installatie.
package update

import (
	"context"
	"crypto/sha256"
	"crypto/subtle"
	"encoding/json"
	"errors"
	"fmt"
	"io"
	"os"
	"os/exec"
	"path/filepath"
	"regexp"
	"strings"
	"time"
)

const (
	// Unit is de enige systemd-unit die de bluegit-gebruiker mag starten.
	Unit = "bluegit-update.service"
	// TokenEnv is de sleutel. Zonder waarde is het endpoint uit.
	TokenEnv = "BLUEGIT_UPDATE_TOKEN"
	// RequestFile is één regel: leeg betekent HEAD, anders een sha of ref.
	RequestFile = "update-request"
	// StatusFile is de laatste poging, gelezen door de Info- en setup-pagina.
	StatusFile = "update-status.json"
	// LogFile is de uitvoer van de laatste run van het update-script.
	LogFile = "update.log"
	// LogTailLines is hoeveel regels GET /api/v1/admin/self-update teruggeeft.
	LogTailLines = 200
	logTailBytes = 256 * 1024
)

// ResultWaiting: aangevraagd, de updater wacht tot er geen jobs meer draaien.
const ResultWaiting = "waiting"

// Status is het resultaat dat het update-script en de webpagina delen.
type Status struct {
	Time   string `json:"time"`
	SHA    string `json:"sha"`
	Result string `json:"result"`
	Error  string `json:"error,omitempty"`
}

// Token is de geconfigureerde sleutel. Leeg betekent dat self-update uit staat.
func Token() string {
	return strings.TrimSpace(os.Getenv(TokenEnv))
}

// Enabled is false zolang er geen sleutel in de omgeving staat.
func Enabled() bool { return Token() != "" }

// Equal vergelijkt twee sleutels zonder de lengte of de inhoud te lekken
// via een vroege return. Een lege verwachte sleutel past nooit.
func Equal(secret, got string) bool {
	if secret == "" || got == "" {
		return false
	}
	sumS := sha256.Sum256([]byte(secret))
	sumG := sha256.Sum256([]byte(got))
	return subtle.ConstantTimeCompare(sumS[:], sumG[:]) == 1
}

var refPattern = regexp.MustCompile(`^[0-9A-Za-z][0-9A-Za-z._/-]{0,199}$`)

// ValidRef staat een lege ref toe (HEAD van de bare repo), een sha, of een
// branchnaam. Punt-punt en @{ zijn geen git-ref die we aan het script geven.
func ValidRef(ref string) bool {
	if ref == "" {
		return true
	}
	if strings.Contains(ref, "..") || strings.Contains(ref, "@{") {
		return false
	}
	return refPattern.MatchString(ref)
}

// WriteRequest zet de gevraagde ref klaar voor de unit.
func WriteRequest(dir, ref string) error {
	if dir == "" {
		return errors.New("state-map ontbreekt")
	}
	if err := os.MkdirAll(dir, 0o750); err != nil {
		return err
	}
	target := filepath.Join(dir, RequestFile)
	tmp, err := os.CreateTemp(dir, RequestFile+".*")
	if err != nil {
		return err
	}
	tmpName := tmp.Name()
	cleanup := true
	defer func() {
		if cleanup {
			_ = os.Remove(tmpName)
		}
	}()
	if _, err := tmp.WriteString(ref + "\n"); err != nil {
		_ = tmp.Close()
		return err
	}
	if err := tmp.Chmod(0o640); err != nil {
		_ = tmp.Close()
		return err
	}
	if err := tmp.Close(); err != nil {
		return err
	}
	if err := os.Rename(tmpName, target); err != nil {
		return err
	}
	cleanup = false
	return nil
}

// ReadStatus leest de laatste update. Een ontbrekend bestand is geen fout.
func ReadStatus(dir string) (Status, error) {
	if dir == "" {
		return Status{}, nil
	}
	raw, err := os.ReadFile(filepath.Join(dir, StatusFile))
	if err != nil {
		if errors.Is(err, os.ErrNotExist) {
			return Status{}, nil
		}
		return Status{}, err
	}
	var st Status
	if err := json.Unmarshal(raw, &st); err != nil {
		return Status{}, nil
	}
	return st, nil
}

// WriteStatus is voor tests en voor een mislukte start vanuit het proces.
func WriteStatus(dir string, st Status) error {
	if dir == "" {
		return errors.New("state-map ontbreekt")
	}
	if st.Time == "" {
		st.Time = time.Now().UTC().Format(time.RFC3339)
	}
	raw, err := json.Marshal(st)
	if err != nil {
		return err
	}
	raw = append(raw, '\n')
	if err := os.MkdirAll(dir, 0o750); err != nil {
		return err
	}
	target := filepath.Join(dir, StatusFile)
	tmp, err := os.CreateTemp(dir, StatusFile+".*")
	if err != nil {
		return err
	}
	tmpName := tmp.Name()
	cleanup := true
	defer func() {
		if cleanup {
			_ = os.Remove(tmpName)
		}
	}()
	if _, err := tmp.Write(raw); err != nil {
		_ = tmp.Close()
		return err
	}
	if err := tmp.Chmod(0o644); err != nil {
		_ = tmp.Close()
		return err
	}
	if err := tmp.Close(); err != nil {
		return err
	}
	if err := os.Rename(tmpName, target); err != nil {
		return err
	}
	cleanup = false
	return nil
}

// ReadLogTail leest de laatste regels van het update-log.
// Een ontbrekend bestand is geen fout: de geïnstalleerde updater schrijft
// het pas nadat deze versie geïnstalleerd is.
func ReadLogTail(dir string, lines int) (string, error) {
	if dir == "" || lines <= 0 {
		return "", nil
	}
	f, err := os.Open(filepath.Join(dir, LogFile))
	if err != nil {
		if errors.Is(err, os.ErrNotExist) {
			return "", nil
		}
		return "", err
	}
	defer f.Close()
	info, err := f.Stat()
	if err != nil {
		return "", err
	}
	start := int64(0)
	if info.Size() > logTailBytes {
		start = info.Size() - logTailBytes
	}
	if _, err := f.Seek(start, io.SeekStart); err != nil {
		return "", err
	}
	raw, err := io.ReadAll(io.LimitReader(f, logTailBytes+1))
	if err != nil {
		return "", err
	}
	text := string(raw)
	if start > 0 {
		if i := strings.IndexByte(text, '\n'); i >= 0 {
			text = text[i+1:]
		}
	}
	return lastLines(text, lines), nil
}

func lastLines(text string, n int) string {
	text = strings.TrimRight(text, "\n")
	if text == "" || n <= 0 {
		return ""
	}
	parts := strings.Split(text, "\n")
	if len(parts) > n {
		parts = parts[len(parts)-n:]
	}
	return strings.Join(parts, "\n")
}

// FreshRunning is waar als een update nog bezig hoort te zijn.
func FreshRunning(st Status, now time.Time, window time.Duration) bool {
	if st.Result != "running" || st.Time == "" {
		return false
	}
	t, err := time.Parse(time.RFC3339, st.Time)
	if err != nil {
		return false
	}
	return now.Sub(t) < window && now.Sub(t) > -time.Minute
}

// StartSystemd start de oneshot zonder erop te wachten. De aanroepende
// CI-job moet kunnen eindigen, anders wacht de updater eeuwig op zichzelf.
func StartSystemd(ctx context.Context) error {
	cmd := exec.CommandContext(ctx, "systemctl", "start", "--no-block", Unit)
	out, err := cmd.CombinedOutput()
	if err != nil {
		msg := strings.TrimSpace(string(out))
		if len(msg) > 200 {
			msg = msg[:200]
		}
		if msg == "" {
			return err
		}
		return fmt.Errorf("systemctl: %s", msg)
	}
	return nil
}
