// Package access bevat de rolregels van BlueGit.
// Een repository hoort bij een gebruiker of een groep. Leden hebben
// Readonly, Developer of Maintainer. De effectieve rol is de hoogste
// van groepslidmaatschap, rechtstreeks repolidmaatschap en eigenaarschap.
// Installatiebeheer is hier geen rol: dat geeft geen toegang tot
// repositories, groepen of geheimen van anderen.
package access

import (
	"path"
	"regexp"
	"strings"

	"gitlab.com/Timfa/bluegit/internal/i18n"
)

// Role is een toegangsrol op een repository of groep.
type Role string

const (
	RoleNone       Role = ""
	RoleReadonly   Role = "readonly"
	RoleDeveloper  Role = "developer"
	RoleMaintainer Role = "maintainer"
)

// ParseRole herkent de drie rollen. Leeg is geen rol.
func ParseRole(s string) (Role, error) {
	switch Role(strings.ToLower(strings.TrimSpace(s))) {
	case RoleReadonly:
		return RoleReadonly, nil
	case RoleDeveloper:
		return RoleDeveloper, nil
	case RoleMaintainer:
		return RoleMaintainer, nil
	case RoleNone:
		return RoleNone, i18n.E("err.roleMissing")
	default:
		return RoleNone, i18n.E("err.roleUnknown", s)
	}
}

// Label is de Engelse naam. De webinterface vertaalt via i18n.
func (r Role) Label() string {
	switch r {
	case RoleReadonly:
		return "Readonly"
	case RoleDeveloper:
		return "Developer"
	case RoleMaintainer:
		return "Maintainer"
	default:
		return "None"
	}
}

// Rank geeft een volgorde. Hoger mag meer.
func (r Role) Rank() int {
	switch r {
	case RoleReadonly:
		return 1
	case RoleDeveloper:
		return 2
	case RoleMaintainer:
		return 3
	default:
		return 0
	}
}

// Max geeft de hoogste van twee rollen.
func Max(a, b Role) Role {
	if a.Rank() >= b.Rank() {
		return a
	}
	return b
}

// AtLeast meldt of de rol minstens other is.
func (r Role) AtLeast(other Role) bool {
	return r.Rank() >= other.Rank()
}

// CanRead geldt voor elke echte rol.
func (r Role) CanRead() bool { return r.AtLeast(RoleReadonly) }

// CanWriteCode geldt voor ontwikkelaar en beheerder.
// Protected branches en secrets vallen hier buiten.
func (r Role) CanWriteCode() bool { return r.AtLeast(RoleDeveloper) }

// CanManageSecrets geldt alleen voor een beheerder.
func (r Role) CanManageSecrets() bool { return r.AtLeast(RoleMaintainer) }

// CanManageSettings dekt leden, webhooks, beschermde branches en tags, en verwijderen.
func (r Role) CanManageSettings() bool { return r.AtLeast(RoleMaintainer) }

// CanPushBranch meldt of deze rol naar een branch mag schrijven.
// protected is waar als de branch op een beschermd patroon past.
func (r Role) CanPushBranch(protected bool) bool {
	if protected {
		return r.CanManageSettings()
	}
	return r.CanWriteCode()
}

// CanMerge meldt of deze rol een merge request naar target mag samenvoegen.
func (r Role) CanMerge(targetProtected bool) bool {
	return r.CanPushBranch(targetProtected)
}

// Input is alles wat meespeelt bij de effectieve rol op één repository.
// Installatiebeheer zit hier bewust niet in.
type Input struct {
	// UserOwner is waar als de repository van deze gebruiker zelf is.
	UserOwner bool
	// GroupRole is de rol in de groep die de repository bezit. Leeg als
	// de repository niet van een groep is of de gebruiker geen lid is.
	GroupRole Role
	// RepoRole is een rechtstreeks lidmaatschap op de repository.
	RepoRole Role
}

// Resolve kiest de effectieve rol.
// De persoonlijke eigenaar is beheerder. Een groepsbeheerder blijft
// beheerder van elke repository van de groep. Een expliciete
// repositoryrol vervangt een lagere groepsrol, zodat de standaardrol
// van de groep op een nieuwe repository kan gelden. Zonder
// repositoryrol blijft de groepsrol van kracht.
func Resolve(in Input) Role {
	if in.UserOwner {
		return RoleMaintainer
	}
	if in.GroupRole == RoleMaintainer {
		return RoleMaintainer
	}
	if in.RepoRole != RoleNone {
		return in.RepoRole
	}
	return in.GroupRole
}

// BranchProtected meldt of branch op een van de patronen past.
// Een patroon is exact, of een glob waarin * één padsegment is
// (path.Match). "release/*" past dus op "release/1.2" en niet op
// "release/1.2/rc".
func BranchProtected(patterns []string, branch string) bool {
	for _, p := range patterns {
		p = strings.TrimSpace(p)
		if p == "" {
			continue
		}
		if p == branch {
			return true
		}
		ok, err := path.Match(p, branch)
		if err == nil && ok {
			return true
		}
	}
	return false
}

// RefUpdate is één regel uit een pre-receive-hook.
type RefUpdate struct {
	Old string
	New string
	Ref string
}

// AuthorizeUpdate keurt één ref-update goed of af.
// Een beschermde branch of een tag die op een beschermd patroon past
// mag alleen een beheerder schrijven. Alleen-lezen mag niets schrijven.
func AuthorizeUpdate(role Role, patterns, tagPatterns []string, u RefUpdate) error {
	if !role.CanWriteCode() {
		return i18n.E("err.hook.nowrite", u.Ref)
	}
	const tags = "refs/tags/"
	if strings.HasPrefix(u.Ref, tags) {
		name := strings.TrimPrefix(u.Ref, tags)
		if name == "" || strings.HasPrefix(name, "-") || strings.HasPrefix(name, "/") || strings.HasSuffix(name, "/") || strings.Contains(name, "..") {
			return i18n.E("err.tag", name)
		}
		if BranchProtected(tagPatterns, name) && !role.CanManageSettings() {
			return i18n.E("err.hook.tag", name)
		}
		return nil
	}
	const heads = "refs/heads/"
	if !strings.HasPrefix(u.Ref, heads) {
		return nil
	}
	branch := strings.TrimPrefix(u.Ref, heads)
	if branch == "" || strings.Contains(branch, "..") {
		return i18n.E("err.hook.branch", branch)
	}
	if BranchProtected(patterns, branch) && !role.CanPushBranch(true) {
		return i18n.E("err.hook.protected", branch)
	}
	return nil
}

// AuthorizeUpdates keurt een hele push goed. De eerste fout stopt.
func AuthorizeUpdates(role Role, patterns, tagPatterns []string, updates []RefUpdate) error {
	if len(updates) == 0 {
		return i18n.E("err.hook.empty")
	}
	for _, u := range updates {
		if err := AuthorizeUpdate(role, patterns, tagPatterns, u); err != nil {
			return err
		}
	}
	return nil
}

// InjectSecret meldt of een CI-job dit geheim als omgevingsvariabele krijgt.
// Een beschermd geheim gaat alleen mee als de pipeline op een beschermde
// branch draait. Onbeschermde geheimen gaan met elke job mee.
// Dit is onafhankelijk van de UI: een ontwikkelaar leest geheimen nooit
// terug, ook al belanden ze in een job die zijn pipeline startte.
func InjectSecret(secretProtected, refProtected bool) bool {
	if secretProtected {
		return refProtected
	}
	return true
}

// secretNameRE is dezelfde vorm als een GitLab-variabele: een letter of
// underscore, daarna letters, cijfers en underscores. Hoofdletters en
// kleine letters zijn allebei geldig.
var secretNameRE = regexp.MustCompile(`^[A-Za-z_][A-Za-z0-9_]*$`)

// ValidSecretName eist een omgevingsvariabelenaam.
func ValidSecretName(name string) error {
	if name == "" || len(name) > 80 {
		return i18n.E("err.secretLen")
	}
	if !secretNameRE.MatchString(name) {
		return i18n.E("err.secretForm", name)
	}
	return nil
}
