package server

import (
	"context"
	"net/http"
	"os"
	"strings"

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

func (s *Server) opCreateMR(ctx context.Context, user store.User, repo store.Repo, title, description, source, target string, draft bool) (store.MergeRequest, error) {
	role, err := s.repoRole(ctx, user, repo)
	if err != nil {
		return store.MergeRequest{}, err
	}
	if !role.CanWriteCode() {
		return store.MergeRequest{}, fail(403, i18n.E("err.forbidden"))
	}
	source = safeRev(source, "")
	target = safeRev(target, repo.DefaultBranch)
	if source == "" || source == target {
		return store.MergeRequest{}, fail(400, i18n.E("err.branches"))
	}
	mr, err := s.Store.CreateMergeRequest(ctx, repo.ID, user.ID, title, description, source, target)
	if err != nil {
		return store.MergeRequest{}, fail(400, err)
	}
	if draft {
		_ = s.Store.SetDraft(ctx, mr.ID, true)
		mr.Draft = true
	}
	dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
	if sha := gitOne(ctx, s.Git, dir, "rev-parse", "--verify", "refs/heads/"+source); sha != "" {
		s.startOneMergePipeline(ctx, repo, sha, user.Username, "", mr)
	}
	s.mrHook(repo, mr, user.Username, "opened", "")
	s.recordContribution(user.ID, repo.ID, "merge_request", mrRef(mr.ID), mr.CreatedAt)
	return mr, nil
}

func (s *Server) opUpdateMR(ctx context.Context, user store.User, repo store.Repo, number int64, title, description, labels string) (store.MergeRequest, error) {
	role, err := s.repoRole(ctx, user, repo)
	if err != nil {
		return store.MergeRequest{}, err
	}
	mr, err := s.Store.MergeRequestByNumber(ctx, repo.ID, number)
	if err != nil {
		return store.MergeRequest{}, notFound(err)
	}
	if mr.Status != "open" || (user.ID != mr.AuthorID && !role.CanWriteCode()) {
		return store.MergeRequest{}, fail(403, i18n.E("err.forbidden"))
	}
	title = strings.TrimSpace(title)
	labels = normalizeLabels(labels)
	if err := s.Store.UpdateMergeRequest(ctx, mr.ID, title, description, labels); err != nil {
		return store.MergeRequest{}, fail(400, err)
	}
	if title != mr.Title {
		_ = s.Store.AddMREvent(ctx, repo.ID, mr.ID, user.ID, "retitled", title)
	}
	if labels != normalizeLabels(mr.Labels) {
		_ = s.Store.AddMREvent(ctx, repo.ID, mr.ID, user.ID, "relabeled", labels)
	}
	mr.Title, mr.Description, mr.Labels = title, description, labels
	return mr, nil
}

func (s *Server) opAddNote(r *http.Request, user store.User, repo store.Repo, number int64, body, path string, start, end int, parent int64) (store.Note, error) {
	ctx := r.Context()
	role, err := s.repoRole(ctx, user, repo)
	if err != nil {
		return store.Note{}, err
	}
	if !role.AtLeast(access.RoleReadonly) {
		return store.Note{}, fail(403, i18n.E("err.forbidden"))
	}
	mr, err := s.Store.MergeRequestByNumber(ctx, repo.ID, number)
	if err != nil {
		return store.Note{}, notFound(err)
	}
	path, pathOK := repoPath(path)
	if !pathOK {
		return store.Note{}, fail(400, i18n.E("err.sugFile"))
	}
	if path == "" {
		if parent > 0 {
			note, err := s.Store.AddReply(ctx, repo.ID, mr.ID, user.ID, parent, body)
			if err != nil {
				return store.Note{}, fail(400, err)
			}
			s.mrHook(repo, mr, user.Username, "commented", body)
			return note, nil
		}
		note, err := s.Store.AddNote(ctx, repo.ID, mr.ID, user.ID, body)
		if err != nil {
			return store.Note{}, fail(400, err)
		}
		s.mrHook(repo, mr, user.Username, "commented", body)
		return note, nil
	}
	dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
	blob, err := gitrepo.BlobText(ctx, s.Git, dir, mr.SourceBranch, path)
	if err != nil {
		return store.Note{}, fail(400, i18n.E("err.sugFile"))
	}
	lines := gitrepo.SplitLines(blob)
	if start < 1 || end < start || end > len(lines) {
		return store.Note{}, fail(400, i18n.E("err.sugLines"))
	}
	base := strings.Join(lines[start-1:end], "\n")
	suggestion, _ := gitrepo.ParseSuggestion(body)
	note, err := s.Store.AddLineNote(ctx, repo.ID, mr.ID, user.ID, body, path, start, end, suggestion, base)
	if err != nil {
		return store.Note{}, fail(400, err)
	}
	s.noteRequestsChanges(r, repo, mr, user.ID, suggestion)
	s.mrHook(repo, mr, user.Username, "commented", body)
	return note, nil
}

func (s *Server) opReview(ctx context.Context, user store.User, repo store.Repo, number int64, status string) error {
	role, err := s.repoRole(ctx, user, repo)
	if err != nil {
		return err
	}
	if !role.CanWriteCode() {
		return fail(403, i18n.E("err.forbidden"))
	}
	mr, err := s.Store.MergeRequestByNumber(ctx, repo.ID, number)
	if err != nil || mr.Status != "open" {
		return notFound(err)
	}
	switch status {
	case "approved", "changes", "rejected":
	default:
		return fail(400, i18n.E("rev.bad"))
	}
	if status == "approved" {
		if user.ID == mr.AuthorID {
			return fail(400, i18n.E("rev.own"))
		}
		pol, _, err := s.Store.EffectiveApproval(ctx, repo)
		if err != nil || !approvalCounts(role, pol) {
			return fail(403, i18n.E("err.forbidden"))
		}
	}
	if err := s.Store.UpsertReview(ctx, repo.ID, mr.ID, user.ID, status); err != nil {
		return fail(400, err)
	}
	return nil
}

func (s *Server) opDismissReview(ctx context.Context, user store.User, repo store.Repo, number, targetUser int64) error {
	role, err := s.repoRole(ctx, user, repo)
	if err != nil {
		return err
	}
	if !role.CanManageSettings() {
		return fail(403, i18n.E("err.forbidden"))
	}
	mr, err := s.Store.MergeRequestByNumber(ctx, repo.ID, number)
	if err != nil {
		return notFound(err)
	}
	if targetUser == 0 {
		return fail(400, i18n.E("rev.bad"))
	}
	if err := s.Store.UpsertReview(ctx, repo.ID, mr.ID, targetUser, "dismissed"); err != nil {
		return fail(400, err)
	}
	return nil
}

func (s *Server) opApplySuggestions(ctx context.Context, user store.User, repo store.Repo, number int64, title, description string, ids []int64) error {
	role, err := s.repoRole(ctx, user, repo)
	if err != nil {
		return err
	}
	mr, err := s.Store.MergeRequestByNumber(ctx, repo.ID, number)
	if err != nil || mr.Status != "open" {
		return notFound(err)
	}
	patterns, err := s.Store.ProtectedPatterns(ctx, repo.ID)
	if err != nil {
		return fail(400, err)
	}
	if !role.CanPushBranch(access.BranchProtected(patterns, mr.SourceBranch)) {
		return fail(403, i18n.E("err.sugBranch", mr.SourceBranch))
	}
	title = strings.TrimSpace(title)
	if title == "" || strings.ContainsAny(title, "\r\n") {
		return fail(400, i18n.E("err.sugTitle"))
	}
	notes, err := s.Store.ListNotes(ctx, mr.ID)
	if err != nil {
		return fail(400, err)
	}
	byID := map[int64]store.Note{}
	for _, n := range notes {
		byID[n.ID] = n
	}
	var edits []gitrepo.SuggestionEdit
	seen := map[int64]bool{}
	for _, id := range ids {
		if seen[id] {
			continue
		}
		seen[id] = true
		n, ok := byID[id]
		if !ok || n.Suggestion == "" || n.FilePath == "" {
			return fail(400, i18n.E("err.sugGone"))
		}
		edits = append(edits, gitrepo.SuggestionEdit{
			Path: n.FilePath, Start: n.LineStart, End: n.LineEnd, Base: n.BaseText, Replacement: n.Suggestion,
		})
	}
	if len(edits) == 0 {
		return fail(400, i18n.E("err.sugEmpty"))
	}
	dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
	files := map[string]string{}
	for _, e := range edits {
		if _, ok := files[e.Path]; ok {
			continue
		}
		body, err := gitrepo.BlobText(ctx, s.Git, dir, mr.SourceBranch, e.Path)
		if err != nil {
			return fail(400, i18n.E("err.sugConflict", e.Path, e.Start, e.End))
		}
		files[e.Path] = body
	}
	updated, err := gitrepo.ApplySuggestions(files, edits)
	if err != nil {
		return fail(400, err)
	}
	branch := safeRev(mr.SourceBranch, "")
	if branch == "" {
		return fail(400, i18n.E("err.sugBranch", mr.SourceBranch))
	}
	work, err := s.scratchDir("suggest")
	if err != nil {
		return fail(500, err)
	}
	defer os.RemoveAll(work)
	if err := s.postReceive(ctx, repo, user, dir, func() error {
		return gitrepo.CommitOnBranch(ctx, s.Git, dir, work, branch, user.Username, userEmail(user.Username), title, description, updated, role, patterns)
	}); err != nil {
		return fail(400, err)
	}
	return nil
}

// mergeChoice is de keuze uit het formulier of de API.
// FromForm betekent dat een browser de vakjes postte: een ontbrekend vakje staat uit.
// De API laat FromForm uit en gebruikt de pointers. nil houdt de opgeslagen waarde.
type mergeChoice struct {
	FromForm bool
	Remove   *bool
	Squash   *bool
	Message  *string
	Force    bool
	Confirm  bool
}

// mergeOutcome vertelt de pagina en de API wat er na de merge met de bronbranch gebeurde.
type mergeOutcome struct {
	Notice  string
	Arg     string
	Removed bool
	Skip    string
}

func applyMergeChoice(mr store.MergeRequest, choice mergeChoice) (remove, squash bool, message string) {
	remove, squash, message = mr.RemoveSourceBranch, mr.Squash, mr.SquashMessage
	if choice.FromForm {
		remove, squash, message = false, false, ""
	}
	if choice.Remove != nil {
		remove = *choice.Remove
	}
	if choice.Squash != nil {
		squash = *choice.Squash
	}
	if choice.Message != nil {
		message = *choice.Message
	}
	return remove, squash, message
}

func (s *Server) opMergeMR(r *http.Request, user store.User, repo store.Repo, number int64, choice mergeChoice) (mergeOutcome, error) {
	ctx := r.Context()
	role, err := s.repoRole(ctx, user, repo)
	if err != nil {
		return mergeOutcome{}, err
	}
	mr, err := s.Store.MergeRequestByNumber(ctx, repo.ID, number)
	if err != nil || mr.Status != "open" {
		return mergeOutcome{}, notFound(err)
	}
	patterns, _ := s.Store.ProtectedPatterns(ctx, repo.ID)
	if !role.CanMerge(access.BranchProtected(patterns, mr.TargetBranch)) {
		return mergeOutcome{}, fail(403, i18n.E("err.targetAccess"))
	}
	remove, squash, message := applyMergeChoice(mr, choice)
	if err := s.Store.SetMergeOptions(ctx, mr.ID, remove, squash, message); err != nil {
		return mergeOutcome{}, fail(400, err)
	}
	mr.RemoveSourceBranch, mr.Squash, mr.SquashMessage = remove, squash, message
	blocks := s.mergeBlocks(r, repo, mr)
	force := choice.Force && role.CanManageSettings()
	if len(blocks) > 0 {
		if !force {
			return mergeOutcome{}, fail(409, i18n.E("err.mrBlocked", strings.Join(blocks, " ")))
		}
		if !choice.Confirm {
			return mergeOutcome{}, fail(409, i18n.E("mr.force.need"))
		}
	}
	texts := s.mergeCloseTexts(r, repo, mr)
	dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
	work, err := s.scratchDir("merge")
	if err != nil {
		return mergeOutcome{}, fail(500, err)
	}
	defer os.RemoveAll(work)
	msg := "Merge branch '" + mr.SourceBranch + "' into '" + mr.TargetBranch + "'"
	if squash {
		msg = strings.TrimSpace(message)
		if msg == "" {
			msg = mr.Title
		}
	}
	s.mergingMR.Store(mr.ID, true)
	defer s.mergingMR.Delete(mr.ID)
	if err := s.postReceive(ctx, repo, user, dir, func() error {
		return gitrepo.Merge(ctx, s.Git, dir, work, mr.SourceBranch, mr.TargetBranch, user.Username, userEmail(user.Username), msg, squash, role, patterns)
	}); err != nil {
		return mergeOutcome{}, fail(400, err)
	}
	fresh, ferr := s.Store.MergeRequestByNumber(ctx, repo.ID, mr.Number)
	if ferr != nil || fresh.Status != "merged" {
		_ = s.Store.SetMergeRequestStatus(ctx, mr.ID, "merged")
		sha := gitOne(ctx, s.Git, dir, "rev-parse", "--verify", "refs/heads/"+mr.TargetBranch)
		body := ""
		if shaLike(sha) {
			body = sha
		}
		_ = s.Store.AddMREvent(ctx, repo.ID, mr.ID, user.ID, "merged", body)
		mr.Status = "merged"
		s.mrHook(repo, mr, user.Username, "merged", "")
		s.closeIssueNumbers(ctx, repo, user, closingNumbers(texts...))
	}
	if force && len(blocks) > 0 {
		_ = s.Store.AddMREvent(ctx, repo.ID, mr.ID, user.ID, "forced", strings.Join(blocks, "\n"))
	}
	if !remove {
		return mergeOutcome{Notice: "flash.merged", Skip: "disabled"}, nil
	}
	skip, deleted := s.deleteMergedSource(ctx, user, role, repo, mr.SourceBranch)
	return mergedNotice(deleted, skip, mr.SourceBranch), nil
}

// sourceDeleteSkip zegt waarom de bronbranch moet blijven.
// Een lege tekst betekent dat verwijderen mag.
func sourceDeleteSkip(role access.Role, defaultBranch, name string, exists, protected bool) string {
	if name == "" || !exists {
		return "missing"
	}
	if name == defaultBranch {
		return "default"
	}
	if protected {
		return "protected"
	}
	if !role.CanWriteCode() {
		return "forbidden"
	}
	return ""
}

// mergedSource is een bronbranch die na een gedetecteerde merge weg mag.
type mergedSource struct {
	user store.User
	role access.Role
	name string
}

// mergedSourcePlan zegt of deze merge de bronbranch hoort te verwijderen.
// De voorwaarden zijn dezelfde als bij de mergeknop: de tak staat in deze
// repo, is niet protected of de default, en de pusher mag code schrijven.
func (s *Server) mergedSourcePlan(ctx context.Context, repo store.Repo, user store.User, mr store.MergeRequest) (mergedSource, bool) {
	if !mr.RemoveSourceBranch || user.ID == 0 {
		return mergedSource{}, false
	}
	name := strings.TrimSpace(mr.SourceBranch)
	if name == "" || name == strings.TrimSpace(mr.TargetBranch) {
		return mergedSource{}, false
	}
	role, err := s.repoRole(ctx, user, repo)
	if err != nil {
		return mergedSource{}, false
	}
	return mergedSource{user: user, role: role, name: name}, true
}

// dropMergedSources verwijdert bronbranches nadat de push zelf klaar is.
func (s *Server) dropMergedSources(repo store.Repo, list []mergedSource) {
	seen := map[string]bool{}
	ctx := context.Background()
	for _, item := range list {
		if item.name == "" || seen[item.name] {
			continue
		}
		seen[item.name] = true
		s.deleteMergedSource(ctx, item.user, item.role, repo, item.name)
	}
}

// deleteMergedSource haalt de bronbranch weg na een geslaagde merge.
// Dat is een eigen push, zodat een mislukte verwijdering de merge-webhook niet uitwist.
func (s *Server) deleteMergedSource(ctx context.Context, user store.User, role access.Role, repo store.Repo, name string) (skip string, deleted bool) {
	name = strings.TrimSpace(name)
	dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
	exists := gitOne(ctx, s.Git, dir, "rev-parse", "--verify", "--quiet", "refs/heads/"+name) != ""
	patterns, _ := s.Store.ProtectedPatterns(ctx, repo.ID)
	if skip = sourceDeleteSkip(role, repo.DefaultBranch, name, exists, access.BranchProtected(patterns, name)); skip != "" {
		return skip, false
	}
	if err := s.postReceive(ctx, repo, user, dir, func() error {
		return gitrepo.DeleteBranch(ctx, s.Git, dir, name)
	}); err != nil {
		return "error", false
	}
	return "", true
}

func mergedNotice(deleted bool, skip, branch string) mergeOutcome {
	if deleted {
		return mergeOutcome{Notice: "flash.mergedDeleted", Arg: branch, Removed: true}
	}
	key := map[string]string{
		"protected": "flash.mergedKeptProtected",
		"default":   "flash.mergedKeptDefault",
		"forbidden": "flash.mergedKeptRights",
		"missing":   "flash.mergedKeptMissing",
		"error":     "flash.mergedKeptError",
	}[skip]
	if key == "" {
		return mergeOutcome{Notice: "flash.merged", Skip: skip}
	}
	return mergeOutcome{Notice: key, Arg: branch, Skip: skip}
}

func (s *Server) opCloseMR(ctx context.Context, user store.User, repo store.Repo, number int64, reopen bool) error {
	role, err := s.repoRole(ctx, user, repo)
	if err != nil {
		return err
	}
	mr, err := s.Store.MergeRequestByNumber(ctx, repo.ID, number)
	if err != nil {
		return notFound(err)
	}
	if user.ID != mr.AuthorID && !role.CanManageSettings() {
		return fail(403, i18n.E("err.forbidden"))
	}
	want, kind := "closed", "closed"
	if reopen {
		if mr.Status != "closed" {
			return notFound(nil)
		}
		want, kind = "open", "reopened"
	}
	if err := s.Store.SetMergeRequestStatus(ctx, mr.ID, want); err != nil {
		return fail(400, err)
	}
	_ = s.Store.AddMREvent(ctx, repo.ID, mr.ID, user.ID, kind, "")
	return nil
}
