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
}

func (s *Server) opMergeMR(r *http.Request, user store.User, repo store.Repo, number int64) error {
	ctx := r.Context()
	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, _ := s.Store.ProtectedPatterns(ctx, repo.ID)
	if !role.CanMerge(access.BranchProtected(patterns, mr.TargetBranch)) {
		return fail(403, i18n.E("err.targetAccess"))
	}
	blocks := s.mergeBlocks(r, repo, mr)
	force := r.FormValue("force") == "1" && role.CanManageSettings()
	if len(blocks) > 0 {
		if !force {
			return fail(409, i18n.E("err.mrBlocked", strings.Join(blocks, " ")))
		}
		if r.FormValue("confirm_force") != "1" {
			return 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 fail(500, err)
	}
	defer os.RemoveAll(work)
	msg := "Merge branch '" + mr.SourceBranch + "' into '" + mr.TargetBranch + "'"
	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, role, patterns)
	}); err != nil {
		return 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")
		_ = s.Store.AddMREvent(ctx, repo.ID, mr.ID, user.ID, "merged", "")
		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"))
	}
	return nil
}

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
}
