package server

import (
	"context"
	"strings"

	"gitlab.com/Timfa/bluegit/internal/access"
	"gitlab.com/Timfa/bluegit/internal/ci"
	"gitlab.com/Timfa/bluegit/internal/gitrepo"
	"gitlab.com/Timfa/bluegit/internal/i18n"
	"gitlab.com/Timfa/bluegit/internal/store"
)

// checkReplace: mag deze job de bestaande release met deze tag vervangen?
// Alle regels moeten gelden:
//   - alleen met een job-token (het eigen project is al gecontroleerd);
//   - de pipeline draait op een branch, niet op forks/*, en die branch is
//     niet beschermd (master e.d. dus nooit);
//   - de tag past niet op een beschermd tagpatroon;
//   - de pipeline is veroorzaakt door (actor) een maintainer of hoger van
//     het project (of een instance-admin);
//   - de bestaande release is door een job gemaakt, in een pipeline op
//     dezelfde branch. Een release met de hand of van een andere ref blijft.
func (s *Server) checkReplace(ctx context.Context, repo store.Repo, job store.Job, tag string) (store.Release, error) {
	if job.ID == 0 {
		return store.Release{}, fail(403, i18n.E("err.replaceToken"))
	}
	p, err := s.Store.PipelineByID(ctx, repo.ID, job.PipelineID)
	if err != nil {
		return store.Release{}, fail(403, i18n.E("err.replaceRef"))
	}
	if !strings.HasPrefix(p.Ref, "refs/heads/") {
		return store.Release{}, fail(403, i18n.E("err.replaceRef"))
	}
	branch := strings.TrimPrefix(p.Ref, "refs/heads/")
	if branch == "" || strings.HasPrefix(branch, ci.ForkBranchPrefix) {
		return store.Release{}, fail(403, i18n.E("err.replaceRef"))
	}
	pat, err := s.Store.ProtectedPatterns(ctx, repo.ID)
	if err != nil || access.BranchProtected(pat, branch) {
		return store.Release{}, fail(403, i18n.E("err.replaceRef"))
	}
	tpat, err := s.Store.ProtectedTagPatterns(ctx, repo.ID)
	if err != nil || access.BranchProtected(tpat, tag) {
		return store.Release{}, fail(403, i18n.E("err.tagProtected", tag))
	}
	if p.Actor == "" {
		return store.Release{}, fail(403, i18n.E("err.replaceActor"))
	}
	actor, err := s.Store.UserByUsername(ctx, p.Actor)
	if err != nil || actor.ID == 0 {
		return store.Release{}, fail(403, i18n.E("err.replaceActor"))
	}
	if !actor.InstanceAdmin {
		role, err := s.Store.EffectiveRole(ctx, actor.ID, repo.ID)
		if err != nil || !role.AtLeast(access.RoleMaintainer) {
			return store.Release{}, fail(403, i18n.E("err.replaceActor"))
		}
	}
	rel, err := s.Store.ReleaseByTag(ctx, repo.ID, tag)
	if err != nil {
		// Alleen een tag, geen release: niet van een job, dus blijven.
		return store.Release{}, fail(409, i18n.E("err.replaceOrigin", tag))
	}
	jid, err := s.Store.ReleaseJobID(ctx, rel.ID)
	if err != nil || jid == 0 {
		return store.Release{}, fail(409, i18n.E("err.replaceOrigin", tag))
	}
	oj, err := s.Store.JobByID(ctx, repo.ID, jid)
	if err != nil {
		return store.Release{}, fail(409, i18n.E("err.replaceOrigin", tag))
	}
	op, err := s.Store.PipelineByID(ctx, repo.ID, oj.PipelineID)
	if err != nil || op.Ref != p.Ref {
		return store.Release{}, fail(409, i18n.E("err.replaceOrigin", tag))
	}
	return rel, nil
}

// doReplace verwijdert de oude release, assets en tag, met een auditregel.
func (s *Server) doReplace(ctx context.Context, repo store.Repo, job store.Job, rel store.Release, newCommit string) error {
	paths, err := s.Store.DeleteRelease(ctx, rel.ID)
	if err != nil {
		return fail(500, err)
	}
	for _, p := range paths {
		s.removeAssetFile(p)
	}
	dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
	if err := gitrepo.DeleteTag(ctx, s.Git, dir, rel.Tag); err != nil {
		return fail(400, err)
	}
	s.refsChanged(repo)
	actor, ref := "", ""
	if p, err := s.Store.PipelineByID(ctx, repo.ID, job.PipelineID); err == nil {
		actor, ref = p.Actor, p.Ref
	}
	if s.Log != nil {
		s.Log.Info("release audit", "action", "replace", "repo", repo.FullPath(), "tag", rel.Tag,
			"old_commit", rel.CommitSHA, "new_commit", newCommit, "job", job.ID, "pipeline", job.PipelineID, "ref", ref, "actor", actor)
	}
	return nil
}
