package protocol

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

// Compatibiliteit tussen BlueGit en bluegit-backup (gelijk aan
// internal/backup/compat.go in BlueGit).
//
// Elke kant heeft een protocolversie (wat hij zelf spreekt) en een
// minimumversie (de oudste versie van de andere kant die hij nog
// ondersteunt). Ze passen als elk de minimumversie van de ander haalt. Een
// kant die geen protocol meldt, spreekt protocol 1 (BlueGit vóór de
// protocolversie en bluegit-backup v0.1.0).
//
// Strings, zodat een test-build ze met -ldflags -X kan overschrijven; de
// integratietests zetten ze direct (de backup server draait in het
// testproces).
var (
	ProtocolVersion    = "1"
	MinBlueGitProtocol = "1"
)

// Koppen met de protocolversie.
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 backup server.
func Protocol() int { return atoiMin1(ProtocolVersion) }

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

// 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 BlueGit over zijn protocol zegt.
type Peer struct {
	Protocol    int    `json:"protocol"`
	MinProtocol int    `json:"min_protocol"`
	Version     string `json:"version,omitempty"`
}

// Compat beoordeelt deze backup server tegen BlueGit p.
func (p Peer) Compat() string {
	return Compat(atoiMin1(strconv.Itoa(p.Protocol)), atoiMin1(strconv.Itoa(p.MinProtocol)), Protocol(), MinProtocol())
}

// BlueGitFromHeader leest de X-BlueGit-koppen. ok is false zonder
// protocolkop; p is dan protocol 1.
func BlueGitFromHeader(h http.Header) (Peer, bool) {
	p := Peer{Protocol: 1, MinProtocol: 1}
	raw := h.Get(HeaderBlueGitProtocol)
	if raw == "" {
		return p, false
	}
	p.Protocol = atoiMin1(raw)
	if m := h.Get(HeaderBlueGitMinProtocol); m != "" {
		p.MinProtocol = atoiMin1(m)
	}
	p.Version = cleanVersion(h.Get(HeaderBlueGitVersion))
	return p, true
}

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

// SetOwnHeaders zet de X-Backup-koppen.
func SetOwnHeaders(h http.Header, version string) {
	h.Set(HeaderBackupProtocol, strconv.Itoa(Protocol()))
	h.Set(HeaderBackupMinProtocol, strconv.Itoa(MinProtocol()))
	h.Set(HeaderBackupVersion, version)
}
