package backup

import (
	"net/http"
	"runtime/debug"
	"strconv"
	"strings"
)

// Compatibiliteit tussen BlueGit en bluegit-backup.
//
// Elke kant heeft een protocolversie (wat hij zelf spreekt) en een
// minimumversie (de oudste versie van de andere kant die hij nog
// ondersteunt). Ze zijn compatibel als elk de minimumversie van de ander
// haalt. Een kant die de koppen niet stuurt, spreekt protocol 1 (zo was het
// tot en met bluegit-backup v0.1.0).
//
// De waarden zijn strings, zodat een test-build ze met
// -ldflags "-X gitlab.com/Timfa/bluegit/internal/backup.protocolVersion=…"
// kan overschrijven.
var (
	protocolVersion   = "1"
	minBackupProtocol = "1"
)

// Koppen met de protocolversie. BlueGit zet de X-BlueGit-koppen op zijn
// verzoeken aan en antwoorden van de backup-API; de backup server zet de
// X-Backup-koppen op zijn verzoeken en antwoorden.
const (
	HeaderBlueGitProtocol    = "X-BlueGit-Protocol"
	HeaderBlueGitMinProtocol = "X-BlueGit-Min-Protocol"
	HeaderBlueGitVersion     = "X-BlueGit-Version"
	HeaderBackupProtocol     = "X-Backup-Protocol"
	HeaderBackupMinProtocol  = "X-Backup-Min-Protocol"
	HeaderBackupVersion      = "X-Backup-Version"
)

// Uitkomsten van Compat.
const (
	CompatOK            = "ok"
	CompatBlueGitTooOld = "bluegit_too_old"
	CompatBackupTooOld  = "backup_too_old"
)

func atoiMin1(s string) int {
	n, err := strconv.Atoi(strings.TrimSpace(s))
	if err != nil || n < 1 {
		return 1
	}
	return n
}

// Protocol is de protocolversie van deze BlueGit.
func Protocol() int { return atoiMin1(protocolVersion) }

// MinProtocol is de oudste protocolversie van een backup server die deze
// BlueGit ondersteunt.
func MinProtocol() int {
	if m := atoiMin1(minBackupProtocol); m <= Protocol() {
		return m
	}
	return Protocol()
}

// Version is de commit waarvan deze BlueGit gebouwd is (of "dev").
func Version() string {
	if bi, ok := debug.ReadBuildInfo(); ok {
		for _, s := range bi.Settings {
			if s.Key == "vcs.revision" && len(s.Value) >= 12 {
				return s.Value[:12]
			}
		}
	}
	return "dev"
}

// Compat vergelijkt BlueGit (protocol, minimum voor de backup server) met
// een backup server (protocol, minimum voor BlueGit).
func Compat(bluegit, bluegitMin, backup, backupMin int) string {
	switch {
	case backup < bluegitMin:
		return CompatBackupTooOld
	case bluegit < backupMin:
		return CompatBlueGitTooOld
	}
	return CompatOK
}

// Peer is wat een backup server over zijn protocol zegt.
type Peer struct {
	Protocol    int
	MinProtocol int
	Version     string
}

// PeerFromHeader leest de X-Backup-koppen. Zonder koppen is het protocol 1.
// ok is false als er geen protocolkop is.
func PeerFromHeader(h http.Header) (Peer, bool) {
	p := Peer{Protocol: 1, MinProtocol: 1}
	raw := h.Get(HeaderBackupProtocol)
	if raw == "" {
		return p, false
	}
	p.Protocol = atoiMin1(raw)
	if m := h.Get(HeaderBackupMinProtocol); m != "" {
		p.MinProtocol = atoiMin1(m)
	}
	p.Version = CleanVersion(h.Get(HeaderBackupVersion))
	return p, true
}

// CleanVersion houdt een versie kort en toonbaar.
func CleanVersion(v string) string {
	v = strings.TrimSpace(v)
	out := make([]rune, 0, len(v))
	for _, r := range v {
		if r > ' ' && r < 0x7f && r != '<' && r != '>' && r != '"' {
			out = append(out, r)
		}
		if len(out) == 40 {
			break
		}
	}
	return string(out)
}

// SetOwnHeaders zet de X-BlueGit-koppen.
func SetOwnHeaders(h http.Header) {
	h.Set(HeaderBlueGitProtocol, strconv.Itoa(Protocol()))
	h.Set(HeaderBlueGitMinProtocol, strconv.Itoa(MinProtocol()))
	h.Set(HeaderBlueGitVersion, Version())
}

// Compat zegt of deze backup server bij deze BlueGit past. Leeg als de
// backup server zich nog niet gemeld heeft.
func (c Conn) Compat() string {
	if !c.Connected() || c.PeerProtocol == 0 {
		return ""
	}
	min := c.PeerMinProtocol
	if min == 0 {
		min = 1
	}
	return Compat(Protocol(), MinProtocol(), c.PeerProtocol, min)
}

// Incompatible zegt of er iets geüpdatet moet worden.
func (c Conn) Incompatible() bool {
	r := c.Compat()
	return r == CompatBlueGitTooOld || r == CompatBackupTooOld
}

// SetPeer legt het protocol van de backup server vast. Alleen bij een
// verandering wordt backup.json herschreven.
func (m *Manager) SetPeer(id string, p Peer) {
	c, ok := m.Get(id)
	if !ok || (c.PeerProtocol == p.Protocol && c.PeerMinProtocol == p.MinProtocol && c.PeerVersion == p.Version) {
		return
	}
	_, _ = m.update(id, func(c *Conn) error {
		c.PeerProtocol, c.PeerMinProtocol, c.PeerVersion = p.Protocol, p.MinProtocol, p.Version
		return nil
	})
}

// OverrideProtocol zet protocol en minimum tijdelijk anders (alleen voor
// tests). De teruggegeven functie zet ze terug.
func OverrideProtocol(protocol, min string) (restore func()) {
	oldP, oldM := protocolVersion, minBackupProtocol
	protocolVersion, minBackupProtocol = protocol, min
	return func() { protocolVersion, minBackupProtocol = oldP, oldM }
}
