package server

import (
	"bytes"
	"context"
	"io"
	"net/http"
	"net/url"
	"os/exec"
	"strings"
	"time"

	"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/ssrf"
	"gitlab.com/Timfa/bluegit/internal/store"
	"gitlab.com/Timfa/bluegit/internal/webhook"
)

// postReceive is de enige route voor een ref-wijziging die BlueGit zelf maakt:
// de Pipeline Editor, suggesties, een merge en een tag. mutate schrijft de refs.
// Daarna geldt hetzelfde als na een git push: pipeline, webhook en activity.
func (s *Server) postReceive(ctx context.Context, repo store.Repo, user store.User, dir string, mutate func() error) error {
	before, err := gitrepo.Refs(ctx, s.Git, dir)
	if err != nil {
		before = map[string]string{}
	}
	if err := mutate(); err != nil {
		return err
	}
	after, err := gitrepo.Refs(ctx, s.Git, dir)
	if err != nil {
		if s.Log != nil {
			s.Log.Error("post-receive", "err", err)
		}
		return nil
	}
	s.AfterPush(repo, user, before, after)
	return nil
}

// AfterPush behandelt elke nieuwe ref zoals een git push.
// git http, SSH en postReceive zijn de enige aanroepers.
func (s *Server) AfterPush(repo store.Repo, user store.User, before, after map[string]string) {
	s.refsChanged(repo)
	for ref, sha := range after {
		if b, ok := strings.CutPrefix(ref, "refs/heads/"); ok && before[ref] != sha && !isZero(sha) && s.Store != nil {
			s.refreshForkMRs(repo, user, b)
		}
	}
	if s.Store != nil && refsMoved(before, after) {
		_ = s.Store.TouchPushed(context.Background(), repo.ID, time.Now())
	}
	if after == nil {
		return
	}
	actor := user.Username
	var drop []mergedSource
	for ref, sha := range after {
		if before[ref] == sha || isZero(sha) {
			continue
		}
		commit := s.peeled(repo, sha)
		if strings.HasPrefix(ref, "refs/tags/") {
			s.startPipeline(context.Background(), repo, commit, ref, actor, "push", before[ref], nil)
			s.recordContribution(user.ID, repo.ID, "tag", ref, time.Now().UTC())
			s.pushHook(repo, actor, ref, before[ref], sha)
			continue
		}
		branch, ok := gitrepo.BranchOfRef(ref)
		if !ok {
			continue
		}
		s.recordPushContributions(repo, user, map[string]string{ref: before[ref]}, map[string]string{ref: sha})
		s.startPipeline(context.Background(), repo, commit, ref, actor, "push", before[ref], nil)
		s.startMergeRequestPipelines(context.Background(), repo, commit, branch, actor, before[ref])
		s.recordMRPushes(repo, user, branch, before[ref], sha)
		drop = append(drop, s.markContainedMRs(repo, user, branch, sha)...)
		s.rerunMergeRequestsOnTarget(context.Background(), repo, branch, actor)
		s.pushHook(repo, actor, ref, before[ref], sha)
		if branch == repo.DefaultBranch {
			s.closeIssuesOnPush(repo, user, before[ref], sha)
		}
	}
	// Een ref die in before staat en in after weg is, is verwijderd.
	// Daar hoort een push-webhook bij, zonder pipeline of activity.
	for ref, old := range before {
		if sha, ok := after[ref]; ok && !isZero(sha) {
			continue
		}
		if isZero(old) {
			continue
		}
		s.pushHook(repo, actor, ref, old, strings.Repeat("0", 40))
	}
	// Pas na de push zelf de bronbranch weghalen. Doen we dat midden in de
	// lus, dan kan dezelfde push de tak nog als nieuwe ref behandelen.
	s.dropMergedSources(repo, drop)
}

func (s *Server) pushHook(repo store.Repo, actor, ref, before, after string) {
	if isZero(before) {
		before = strings.Repeat("0", 40)
	}
	commit := after
	if isZero(commit) {
		commit = ""
	}
	name := refName(ref)
	s.Dispatch(repo.ID, webhook.Event{
		Type:    webhook.EventPush,
		Project: repo.FullPath(),
		Branch:  name,
		Ref:     ref,
		Before:  before,
		After:   after,
		Commit:  commit,
		Summary: i18n.T(i18n.EN, "hook.push", actor, name, repo.FullPath()),
		URL:     strings.TrimRight(s.Cfg.BaseURL, "/") + "/" + repo.FullPath(),
		Actor:   actor,
	})
}

func (s *Server) peeled(repo store.Repo, sha string) string {
	if s.StoragePath() == "" || sha == "" {
		return sha
	}
	dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
	if commit := gitOne(context.Background(), s.Git, dir, "rev-parse", "--verify", sha+"^{commit}"); commit != "" {
		return commit
	}
	return sha
}

func isZero(sha string) bool {
	return strings.Trim(sha, "0") == ""
}

func (s *Server) startPipeline(ctx context.Context, repo store.Repo, sha, ref, actor, source, before string, mr *ci.MRInfo) int64 {
	if !s.Cfg.CI.Enabled || s.StoragePath() == "" {
		return 0
	}
	title, jobs, broken := s.planPipeline(ctx, repo, sha, ref, source, before, mr)
	mrID, target := int64(0), ""
	if mr != nil {
		mrID, target = mr.ID, mr.TargetSHA
	}
	if broken != nil {
		id, created, err := s.Store.RecordConfigFailure(ctx, repo.ID, sha, ref, source, broken.Error(), mrID, target)
		if err != nil && s.Log != nil {
			s.Log.Error("pipeline", "err", err)
		}
		if created && id != 0 {
			s.cancelOlder(ctx, repo.ID, ref, id)
		}
		return id
	}
	if len(jobs) == 0 {
		return 0
	}
	id, created, err := s.Store.OpenPipeline(ctx, repo.ID, sha, ref, source, actor, title, target, mrID, jobs)
	if err != nil {
		if s.Log != nil {
			s.Log.Error("pipeline", "err", err)
		}
		return 0
	}
	if created {
		s.cancelOlder(ctx, repo.ID, ref, id)
		s.expireSuperseded(ctx, repo.ID, ref, id)
	}
	return id
}

func (s *Server) cancelOlder(ctx context.Context, repoID int64, ref string, keep int64) {
	running, pipes, err := s.Store.CancelInterruptible(ctx, repoID, ref, keep)
	if err != nil {
		if s.Log != nil {
			s.Log.Error("interruptible", "err", err)
		}
		return
	}
	if s.Runner != nil {
		s.Runner.Interrupt(running)
	}
	for _, id := range pipes {
		if _, err := s.Store.RefreshPipelineStatus(ctx, id); err != nil && s.Log != nil {
			s.Log.Error("pipelinestatus", "err", err)
		}
	}
}

func gitOne(ctx context.Context, gitBin, dir string, args ...string) string {
	out, err := exec.CommandContext(ctx, gitBin, append([]string{"-C", dir}, args...)...).Output()
	if err != nil {
		return ""
	}
	return strings.TrimSpace(string(out))
}

func gitLines(ctx context.Context, gitBin, dir string, args ...string) []string {
	out := gitOne(ctx, gitBin, dir, args...)
	if out == "" {
		return []string{}
	}
	return strings.Split(out, "\n")
}

func changedFiles(ctx context.Context, gitBin, dir, sha, before string, all []string) []string {
	if before == "" || strings.Trim(before, "0") == "" {
		parent := gitOne(ctx, gitBin, dir, "rev-parse", "--verify", sha+"^")
		if parent == "" {
			return all
		}
		before = parent
	}
	out, err := exec.CommandContext(ctx, gitBin, "-C", dir, "diff", "--name-only", before, sha).Output()
	if err != nil {
		return nil
	}
	text := strings.TrimSpace(string(out))
	if text == "" {
		return []string{}
	}
	return strings.Split(text, "\n")
}

func (s *Server) Dispatch(repoID int64, ev webhook.Event) {
	ctx := context.Background()
	repo, err := s.Store.RepoByID(ctx, repoID)
	if err != nil {
		return
	}
	if ev.Project == "" {
		ev.Project = repo.FullPath()
	}
	if !strings.HasPrefix(ev.URL, "http") {
		ev.URL = strings.TrimRight(s.Cfg.BaseURL, "/") + ev.URL
	}
	if repo.OwnerKind == "group" {
		if g, err := s.Store.GroupByID(ctx, repo.OwnerID); err == nil {
			ev.Group = g.Path
		}
	}
	ev = s.enrichEvent(ctx, repo, ev)
	patterns, _ := s.Store.ProtectedPatterns(ctx, repo.ID)
	protected := access.BranchProtected(patterns, ev.Branch)
	s.deliver(ctx, "repo", repo.ID, ev, protected, repo)
	if repo.OwnerKind == "group" {
		s.deliver(ctx, "group", repo.OwnerID, ev, protected, repo)
	}
	if ev.Type == webhook.EventPipelineFailure {
		s.queueFailureMail(repo, ev)
	}
}

func (s *Server) deliver(ctx context.Context, kind string, scopeID int64, ev webhook.Event, refProtected bool, repo store.Repo) {
	hooks, err := s.Store.ListWebhooks(ctx, kind, scopeID)
	if err != nil {
		return
	}
	secrets, err := s.hookSecrets(ctx, kind, scopeID, refProtected, repo)
	if err != nil {
		s.Log.Error("geheimen voor webhook", "err", err)
		return
	}
	client := ssrf.NewClient(10 * time.Second)
	for _, h := range hooks {
		if !h.Active {
			continue
		}
		ok, err := webhook.Allows(webhook.Hook{Preset: h.Preset, Events: h.Events, BranchFilter: h.BranchFilter}, ev)
		if err != nil {
			_ = s.Store.AddDelivery(ctx, h.ID, ev.Type, 0, err.Error())
			continue
		}
		if !ok {
			continue
		}
		rawURL, err := webhook.Expand(h.URLTemplate, ev, secrets)
		if err != nil {
			_ = s.Store.AddDelivery(ctx, h.ID, ev.Type, 0, err.Error())
			continue
		}
		target, err := urlParse(rawURL)
		if err != nil {
			_ = s.Store.AddDelivery(ctx, h.ID, ev.Type, 0, err.Error())
			continue
		}
		if err := ssrf.ValidateURL(target); err != nil {
			_ = s.Store.AddDelivery(ctx, h.ID, ev.Type, 0, err.Error())
			continue
		}
		headers, err := webhook.RenderHeaders(h.Preset, h.Headers, ev, secrets)
		if err != nil {
			_ = s.Store.AddDelivery(ctx, h.ID, ev.Type, 0, err.Error())
			continue
		}
		body, err := webhook.RenderBody(h.BodyTemplate, ev, secrets)
		if err != nil {
			_ = s.Store.AddDelivery(ctx, h.ID, ev.Type, 0, err.Error())
			continue
		}
		if s.hookSink != nil {
			s.hookSink(body)
			_ = s.Store.AddDelivery(ctx, h.ID, ev.Type, 0, "")
			continue
		}
		method := h.Method
		if method == "" {
			method = http.MethodPost
		}
		req, err := http.NewRequestWithContext(ctx, method, rawURL, bytes.NewReader(body))
		if err != nil {
			_ = s.Store.AddDelivery(ctx, h.ID, ev.Type, 0, err.Error())
			continue
		}
		for k, v := range headers {
			if strings.ContainsAny(k, "\r\n") || strings.ContainsAny(v, "\r\n") {
				continue
			}
			req.Header.Set(k, v)
		}
		res, err := client.Do(req)
		if err != nil {
			_ = s.Store.AddDelivery(ctx, h.ID, ev.Type, 0, err.Error())
			continue
		}
		_, _ = io.Copy(io.Discard, io.LimitReader(res.Body, 1<<20))
		res.Body.Close()
		_ = s.Store.AddDelivery(ctx, h.ID, ev.Type, res.StatusCode, "")
	}
}

func urlParse(raw string) (*url.URL, error) {
	u, err := url.Parse(raw)
	if err != nil {
		return nil, i18n.E("err.whURL")
	}
	return u, nil
}

// markContainedMRs zet open merge requests op merged wanneer de bron-head
// al in de zojuist gepushte doelbranch zit. Dat is dezelfde regel als GitLab
// na een merge die buiten de knop om is gepusht.
func (s *Server) markContainedMRs(repo store.Repo, user store.User, branch, sha string) []mergedSource {
	if s.Store == nil || s.StoragePath() == "" || branch == "" || isZero(sha) {
		return nil
	}
	ctx := context.Background()
	mrs, err := s.Store.OpenMergeRequestsByTarget(ctx, repo.ID, branch)
	if err != nil {
		return nil
	}
	dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
	var drop []mergedSource
	for _, mr := range mrs {
		if item, ok := s.markIfContained(ctx, repo, user, dir, mr, sha, true); ok {
			drop = append(drop, item)
		}
	}
	return drop
}

// absorbMergedMRs doet dezelfde controle bij het openen van een pagina,
// zodat een merge die al gepusht was voordat deze code draaide alsnog merged wordt.
func (s *Server) absorbMergedMRs(ctx context.Context, repo store.Repo) {
	if s.Store == nil || s.StoragePath() == "" {
		return
	}
	mrs, err := s.Store.ListMergeRequests(ctx, repo.ID)
	if err != nil {
		return
	}
	dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
	for _, mr := range mrs {
		if mr.Status != "open" {
			continue
		}
		s.markIfContained(ctx, repo, store.User{}, dir, mr, "", false)
	}
}

func (s *Server) markIfContained(ctx context.Context, repo store.Repo, user store.User, dir string, mr store.MergeRequest, targetSHA string, deferDrop bool) (mergedSource, bool) {
	if targetSHA == "" {
		targetSHA = gitOne(ctx, s.Git, dir, "rev-parse", "--verify", "refs/heads/"+mr.TargetBranch)
	}
	src := gitOne(ctx, s.Git, dir, "rev-parse", "--verify", "refs/heads/"+mr.SourceBranch)
	if src == "" || targetSHA == "" || !gitrepo.IsAncestor(ctx, s.Git, dir, src, targetSHA) {
		return mergedSource{}, false
	}
	if user.ID == 0 {
		if pushers, err := s.Store.PushersBySHA(ctx, repo.ID, []string{targetSHA}); err == nil {
			if p, ok := pushers[targetSHA]; ok && p.UserID != 0 {
				user = store.User{ID: p.UserID, Username: p.Username}
			}
		}
	}
	if err := s.Store.SetMergeRequestStatus(ctx, mr.ID, "merged"); err != nil {
		return mergedSource{}, false
	}
	body := ""
	if shaLike(targetSHA) {
		body = targetSHA
	}
	_ = s.Store.AddMREvent(ctx, repo.ID, mr.ID, user.ID, "merged", body)
	mr.Status = "merged"
	s.mrHook(repo, mr, user.Username, "merged", "")
	s.closeMergedMR(ctx, repo, user, mr)
	plan, ok := s.mergedSourcePlan(ctx, repo, user, mr)
	if !ok {
		return mergedSource{}, false
	}
	if _, merging := s.mergingMR.Load(mr.ID); merging {
		return mergedSource{}, false
	}
	if deferDrop {
		return plan, true
	}
	s.deleteMergedSource(ctx, plan.user, plan.role, repo, plan.name)
	return mergedSource{}, false
}

func (s *Server) closeMergedMR(ctx context.Context, repo store.Repo, user store.User, mr store.MergeRequest) {
	texts := []string{mr.Description}
	if s.StoragePath() != "" {
		dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
		commits, err := gitrepo.RangeLog(ctx, s.Git, dir, mr.TargetBranch, mr.SourceBranch)
		if err == nil {
			for i, c := range commits {
				if i >= 50 {
					break
				}
				texts = append(texts, commitText(c))
			}
		}
	}
	s.closeIssueNumbers(ctx, repo, user, closingNumbers(texts...))
}

func gitSHA(r *http.Request, gitBin, dir, rev string) (string, error) {
	out, err := exec.CommandContext(r.Context(), gitBin, "-C", dir, "rev-parse", "--verify", rev+"^{commit}").Output()
	if err != nil {
		return "", err
	}
	return strings.TrimSpace(string(out)), nil
}

// refsMoved meldt of een push werkelijk een ref veranderde.
func refsMoved(before, after map[string]string) bool {
	for ref, sha := range after {
		if before[ref] != sha {
			return true
		}
	}
	for ref := range before {
		if _, ok := after[ref]; !ok && after != nil {
			return true
		}
	}
	return false
}
