package server

import (
	"context"
	"html/template"
	"net/http"
	"regexp"
	"sort"
	"strconv"
	"strings"

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

// IssueBoard is de gegevensset voor de issuepagina's.
type IssueBoard struct {
	List         []IssueRow
	One          *IssueRow
	Notes        []IssueNoteRow
	Labels       []IssueChoice
	Milestones   []store.Milestone
	People       []IssueChoice
	State        string
	Query        string
	Label        string
	Assignee     string
	Milestone    string
	Due          string
	FormTitle    string
	FormBody     string
	Confidential bool
	CanCreate    bool
	CanTriage    bool
	CanEdit      bool
	CanClose     bool
	CanReopen    bool
	CanDelete    bool
	Relate       int64
	Related      []IssueRow
	Tpls         []string
	Tpl          string
}

// IssueChoice is een label of persoon in een formulier.
type IssueChoice struct {
	Name      string
	Color     string
	AvatarURL string
	On        bool
}

// IssueRow is één issue in een lijst of op de detailpagina.
type IssueRow struct {
	Number       int64
	Title        string
	Status       string
	Author       string
	AuthorURL    string
	Confidential bool
	Milestone    string
	Due          string
	When         string
	Assignees    string
	People       []AccountLink
	Labels       []store.Label
	HTML         template.HTML
}

// IssueNoteRow is een gerenderde reactie.
type IssueNoteRow struct {
	Author    string
	AuthorURL string
	When      string
	HTML      template.HTML
}

var (
	closeIssueRe = regexp.MustCompile(`(?i)(?:^|[\s:])((?:close[sd]?|fix(?:e[sd])?|resolve[sd]?|implement(?:s|ed)?))\s+#(\d+)\b`)
	fenceRe      = regexp.MustCompile("(?s)```.*?```")
	inlineCodeRe = regexp.MustCompile("`[^`\n]*`")
)

func (s *Server) issuesPage(w http.ResponseWriter, r *http.Request) {
	u, repo, role, ok := s.guard(w, r, access.RoleReadonly)
	if !ok {
		return
	}
	v := s.repoView(w, r, repo, role, "tab.issues")
	v.Title = s.tr(r, "tab.issues")
	v.Page = "issues"
	v.Wide = true
	b := s.issueBoard(r, repo, role, u)
	b.Query = strings.TrimSpace(r.URL.Query().Get("q"))
	b.Label = strings.TrimSpace(r.URL.Query().Get("label"))
	b.Assignee = strings.TrimSpace(r.URL.Query().Get("assignee"))
	list, err := s.Store.ListIssues(r.Context(), repo.ID, store.IssueFilter{
		State: "all", Label: b.Label, Assignee: b.Assignee,
		ViewerID: u.ID, Triage: role.CanTriageIssue(),
	})
	if err != nil {
		s.fail(w, r, err)
		return
	}
	v.Flow = s.flowIssues(r, repo, b, list)
	b.State = v.Flow.State
	for _, iss := range list {
		if iss.Status != b.State && b.State != "all" {
			continue
		}
		if !flowHit(b.Query, issueSearchBits(iss)...) {
			continue
		}
		b.List = append(b.List, s.issueRow(r, repo, iss))
	}
	v.Issues = b
	s.render(w, "issues", v)
}

func (s *Server) newIssue(w http.ResponseWriter, r *http.Request) {
	u, repo, role, ok := s.guard(w, r, access.RoleReadonly)
	if !ok {
		return
	}
	if u.ID == 0 || !role.CanCreateIssue() {
		http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden)
		return
	}
	v := s.repoView(w, r, repo, role, "issue.new")
	v.Title = s.tr(r, "issue.new")
	v.Page = "issuenew"
	v.Wide = true
	b := s.issueBoard(r, repo, role, u)
	s.prefillIssue(r, repo, u, role, b)
	s.fillTpl(r, repo, "issue", &b.FormBody, &b.Tpl, &b.Tpls)
	v.Issues = b
	s.render(w, "issuenew", v)
}

func (s *Server) createIssue(w http.ResponseWriter, r *http.Request) {
	u, repo, role, ok := s.guard(w, r, access.RoleReadonly)
	if !ok || !s.csrfOK(w, r) {
		return
	}
	back := repoURL(repo) + "/-/issues/new"
	if u.ID == 0 || !role.CanCreateIssue() {
		http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden)
		return
	}
	in := store.NewIssue{
		Title:        r.FormValue("title"),
		Description:  r.FormValue("description"),
		Confidential: r.FormValue("confidential") == "1",
	}
	base := quickBase{Confidential: in.Confidential}
	if triagePosted(r) {
		if !role.CanTriageIssue() {
			http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden)
			return
		}
		var err error
		in.LabelIDs, in.AssigneeIDs, in.MilestoneID, in.DueOn, err = s.triageInput(r, repo)
		if err != nil {
			s.redirect(w, r, back, "", s.trErr(r, err))
			return
		}
		base.Labels = r.Form["label"]
		base.Assignees = r.Form["assignee"]
		base.Milestone = r.FormValue("milestone")
		base.Due = in.DueOn
	}
	q, err := s.foldQuick(r.Context(), repo, in.Description, role.CanTriageIssue(), true, base)
	if err != nil {
		s.redirect(w, r, back, "", s.trErr(r, err))
		return
	}
	in.Description = q.Body
	if q.Labels {
		in.LabelIDs = q.LabelIDs
	}
	if q.Assignees {
		in.AssigneeIDs = q.AssigneeIDs
	}
	if q.Meta {
		in.MilestoneID = q.MilestoneID
		in.DueOn = q.Due
		in.Confidential = q.Confidential
	}
	iss, err := s.Store.CreateIssue(r.Context(), repo.ID, u.ID, in)
	if err != nil {
		s.redirect(w, r, back, "", s.trErr(r, err))
		return
	}
	if rel, _ := strconv.ParseInt(r.FormValue("relate"), 10, 64); rel > 0 {
		if other, err := s.Store.IssueByNumber(r.Context(), repo.ID, rel); err == nil && issueVisible(other, u, role) {
			_ = s.Store.LinkIssues(r.Context(), repo.ID, iss.ID, other.ID)
		}
	}
	s.issueHook(repo, iss.Number, u.Username, "opened", "")
	s.redirect(w, r, issuePath(repo, iss.Number), s.tr(r, "flash.issueCreated"), "")
}

func (s *Server) showIssue(w http.ResponseWriter, r *http.Request) {
	u, repo, role, ok := s.guard(w, r, access.RoleReadonly)
	if !ok {
		return
	}
	iss, ok := s.loadVisibleIssue(w, r, repo, u, role)
	if !ok {
		return
	}
	v := s.repoView(w, r, repo, role, "#"+strconv.FormatInt(iss.Number, 10))
	v.Title = "#" + strconv.FormatInt(iss.Number, 10) + " " + iss.Title
	v.Page = "issue"
	v.Wide = true
	b := s.issueBoard(r, repo, role, u)
	row := s.issueRow(r, repo, iss)
	canText := u.ID != 0 && (u.ID == iss.AuthorID || role.CanTriageIssue())
	row.HTML = template.HTML(markdown.RenderTasks(iss.Description, "", "", "/"+repo.FullPath(), s.taskOpt(r, v.CSRF, repo, "issue", strconv.FormatInt(iss.Number, 10), canText)))
	b.One = &row
	b.Confidential = iss.Confidential
	b.Milestone = iss.Milestone
	b.Due = iss.DueOn
	b.FormTitle = iss.Title
	b.FormBody = iss.Description
	b.CanEdit = u.ID != 0 && (u.ID == iss.AuthorID || role.CanTriageIssue())
	b.CanClose = iss.Status == "open" && b.CanEdit
	b.CanReopen = iss.Status == "closed" && b.CanEdit
	b.Labels = markChoices(b.Labels, labelNames(iss.Labels))
	b.People = markChoices(b.People, iss.Assignees)
	notes, _ := s.Store.ListIssueNotes(r.Context(), iss.ID)
	for _, n := range notes {
		noteURL := ""
		if n.Author != "" {
			noteURL = "/users/" + n.Author
		}
		b.Notes = append(b.Notes, IssueNoteRow{
			Author: n.Author, AuthorURL: noteURL,
			When: i18n.FormatDate(s.langOf(r), n.CreatedAt),
			HTML: template.HTML(markdown.RenderTasks(n.Body, "", "", "/"+repo.FullPath(), s.taskOpt(r, v.CSRF, repo, "issue-note", strconv.FormatInt(n.ID, 10), u.ID != 0 && u.ID == n.AuthorID))),
		})
	}
	related, _ := s.Store.RelatedIssues(r.Context(), repo.ID, iss.ID)
	for _, other := range related {
		if issueVisible(other, u, role) {
			b.Related = append(b.Related, s.issueRow(r, repo, other))
		}
	}
	v.Issues = b
	s.render(w, "issue", v)
}

func (s *Server) postIssue(w http.ResponseWriter, r *http.Request) {
	u, repo, role, ok := s.guard(w, r, access.RoleReadonly)
	if !ok || !s.csrfOK(w, r) {
		return
	}
	iss, ok := s.loadVisibleIssue(w, r, repo, u, role)
	if !ok {
		return
	}
	back := issuePath(repo, iss.Number)
	if u.ID == 0 {
		http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden)
		return
	}
	switch r.FormValue("action") {
	case "note":
		if !role.CanCreateIssue() {
			http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden)
			return
		}
		q, err := s.foldQuick(r.Context(), repo, r.FormValue("body"), role.CanTriageIssue(), false, quickFromIssue(iss))
		if err != nil {
			s.redirect(w, r, back, "", s.trErr(r, err))
			return
		}
		if err := s.persistQuick(r.Context(), repo, iss.ID, q); err != nil {
			s.redirect(w, r, back, "", s.trErr(r, err))
			return
		}
		if strings.TrimSpace(q.Body) == "" {
			if !q.touched() {
				s.redirect(w, r, back, "", s.tr(r, "err.issueNote"))
				return
			}
			s.issueHook(repo, iss.Number, u.Username, "updated", "")
			s.redirect(w, r, back, s.tr(r, "flash.issueUpdated"), "")
			return
		}
		if _, err := s.Store.AddIssueNote(r.Context(), repo.ID, iss.ID, u.ID, q.Body); err != nil {
			s.redirect(w, r, back, "", s.trErr(r, err))
			return
		}
		s.issueHook(repo, iss.Number, u.Username, "commented", strings.TrimSpace(q.Body))
		s.redirect(w, r, back, s.tr(r, "flash.note"), "")
	case "close", "reopen":
		if u.ID != iss.AuthorID && !role.CanTriageIssue() {
			http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden)
			return
		}
		status := "closed"
		flash := "flash.issueClosed"
		action := "closed"
		if r.FormValue("action") == "reopen" {
			status, flash, action = "open", "flash.issueReopened", "reopened"
		}
		changed, err := s.Store.SetIssueState(r.Context(), iss.ID, status)
		if err != nil {
			s.redirect(w, r, back, "", s.trErr(r, err))
			return
		}
		if changed {
			s.issueHook(repo, iss.Number, u.Username, action, "")
		}
		s.redirect(w, r, back, s.tr(r, flash), "")
	case "update":
		if u.ID != iss.AuthorID && !role.CanTriageIssue() {
			http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden)
			return
		}
		q, err := s.foldQuick(r.Context(), repo, r.FormValue("description"), role.CanTriageIssue(), false, quickFromIssue(iss))
		if err != nil {
			s.redirect(w, r, back, "", s.trErr(r, err))
			return
		}
		if err := s.Store.UpdateIssueText(r.Context(), iss.ID, r.FormValue("title"), q.Body); err != nil {
			s.redirect(w, r, back, "", s.trErr(r, err))
			return
		}
		if err := s.persistQuick(r.Context(), repo, iss.ID, q); err != nil {
			s.redirect(w, r, back, "", s.trErr(r, err))
			return
		}
		s.issueHook(repo, iss.Number, u.Username, "updated", "")
		s.redirect(w, r, back, s.tr(r, "flash.issueUpdated"), "")
	case "meta":
		if !role.CanTriageIssue() {
			http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden)
			return
		}
		labels, assignees, milestoneID, due, err := s.triageInput(r, repo)
		if err != nil {
			s.redirect(w, r, back, "", s.trErr(r, err))
			return
		}
		if err := s.Store.SetIssueLabels(r.Context(), repo.ID, iss.ID, labels); err != nil {
			s.redirect(w, r, back, "", s.trErr(r, err))
			return
		}
		if err := s.Store.SetIssueAssignees(r.Context(), repo.ID, iss.ID, assignees); err != nil {
			s.redirect(w, r, back, "", s.trErr(r, err))
			return
		}
		if err := s.Store.SetIssueMeta(r.Context(), repo.ID, iss.ID, milestoneID, r.FormValue("confidential") == "1", due); err != nil {
			s.redirect(w, r, back, "", s.trErr(r, err))
			return
		}
		s.issueHook(repo, iss.Number, u.Username, "updated", "")
		s.redirect(w, r, back, s.tr(r, "flash.issueUpdated"), "")
	case "delete":
		if !role.CanManageSettings() {
			http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden)
			return
		}
		if err := s.Store.DeleteIssue(r.Context(), repo.ID, iss.ID); err != nil {
			s.redirect(w, r, back, "", s.trErr(r, err))
			return
		}
		s.redirect(w, r, repoURL(repo)+"/-/issues", s.tr(r, "flash.issueDeleted"), "")
	default:
		http.Error(w, s.tr(r, "err.badForm"), http.StatusBadRequest)
	}
}

func (s *Server) createIssueLabel(w http.ResponseWriter, r *http.Request) {
	u, repo, role, ok := s.guard(w, r, access.RoleReadonly)
	if !ok || !s.csrfOK(w, r) {
		return
	}
	if u.ID == 0 || !role.CanManageSettings() {
		http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden)
		return
	}
	back := repoURL(repo) + "/-/issues"
	if _, err := s.Store.UpsertLabel(r.Context(), repo.ID, r.FormValue("name"), r.FormValue("color")); err != nil {
		s.redirect(w, r, back, "", s.trErr(r, err))
		return
	}
	s.redirect(w, r, back, s.tr(r, "flash.label"), "")
}

func (s *Server) createIssueMilestone(w http.ResponseWriter, r *http.Request) {
	u, repo, role, ok := s.guard(w, r, access.RoleReadonly)
	if !ok || !s.csrfOK(w, r) {
		return
	}
	if u.ID == 0 || !role.CanManageSettings() {
		http.Error(w, s.tr(r, "err.forbidden"), http.StatusForbidden)
		return
	}
	back := repoURL(repo) + "/-/issues"
	if _, err := s.Store.UpsertMilestone(r.Context(), repo.ID, r.FormValue("title"), r.FormValue("due_on")); err != nil {
		s.redirect(w, r, back, "", s.trErr(r, err))
		return
	}
	s.redirect(w, r, back, s.tr(r, "flash.milestone"), "")
}

func (s *Server) loadVisibleIssue(w http.ResponseWriter, r *http.Request, repo store.Repo, u store.User, role access.Role) (store.Issue, bool) {
	n, err := strconv.ParseInt(r.PathValue("number"), 10, 64)
	if err != nil || n < 1 {
		http.NotFound(w, r)
		return store.Issue{}, false
	}
	iss, err := s.Store.IssueByNumber(r.Context(), repo.ID, n)
	if err != nil || !issueVisible(iss, u, role) {
		if err == nil && iss.Confidential && isCrawler(r) {
			s.writeLockedCard(w, r)
		} else {
			http.NotFound(w, r)
		}
		return store.Issue{}, false
	}
	return iss, true
}

func (s *Server) issueBoard(r *http.Request, repo store.Repo, role access.Role, u store.User) *IssueBoard {
	labels, _ := s.Store.ListLabels(r.Context(), repo.ID)
	miles, _ := s.Store.ListMilestones(r.Context(), repo.ID)
	b := &IssueBoard{
		Labels:     []IssueChoice{},
		Milestones: miles,
		People:     []IssueChoice{},
		CanCreate:  u.ID != 0 && role.CanCreateIssue(),
		CanTriage:  role.CanTriageIssue(),
		CanDelete:  role.CanManageSettings(),
	}
	if b.Milestones == nil {
		b.Milestones = []store.Milestone{}
	}
	for _, l := range labels {
		b.Labels = append(b.Labels, IssueChoice{Name: l.Name, Color: l.Color})
	}
	for _, p := range s.issueCandidates(r.Context(), repo) {
		b.People = append(b.People, IssueChoice{Name: p.Username, AvatarURL: p.AvatarURL})
	}
	return b
}

func (s *Server) issueRow(r *http.Request, repo store.Repo, iss store.Issue) IssueRow {
	url := ""
	if iss.Author != "" {
		url = "/users/" + iss.Author
	}
	var people []AccountLink
	for _, name := range iss.Assignees {
		name = strings.TrimSpace(name)
		if name == "" {
			continue
		}
		link := AccountLink{Name: name}
		if u, err := s.Store.UserByUsername(r.Context(), name); err == nil && u.ID != 0 {
			if display := strings.TrimSpace(u.DisplayName); display != "" {
				link.Name = display
			} else {
				link.Name = u.Username
			}
			link.URL = "/users/" + u.Username
		}
		people = append(people, link)
	}
	return IssueRow{
		Number: iss.Number, Title: iss.Title, Status: iss.Status, Author: iss.Author, AuthorURL: url,
		Confidential: iss.Confidential, Milestone: iss.Milestone, Due: iss.DueOn,
		When: i18n.FormatDate(s.langOf(r), iss.CreatedAt), Assignees: strings.Join(iss.Assignees, ", "),
		People: people,
		Labels: iss.Labels, HTML: template.HTML(markdown.Render(iss.Description, "", "", "/"+repo.FullPath())),
	}
}

func (s *Server) prefillIssue(r *http.Request, repo store.Repo, u store.User, role access.Role, b *IssueBoard) {
	if rel, err := strconv.ParseInt(r.URL.Query().Get("relate"), 10, 64); err == nil && rel > 0 {
		if iss, err := s.Store.IssueByNumber(r.Context(), repo.ID, rel); err == nil && issueVisible(iss, u, role) {
			b.Relate = rel
		}
	}
	if r.URL.Query().Get("from") != "mr" {
		return
	}
	n, err := strconv.ParseInt(r.URL.Query().Get("mr"), 10, 64)
	if err != nil || n < 1 {
		return
	}
	mr, err := s.Store.MergeRequestByNumber(r.Context(), repo.ID, n)
	if err != nil {
		return
	}
	ref := "!" + strconv.FormatInt(n, 10)
	b.FormBody = ref
	noteID, _ := strconv.ParseInt(r.URL.Query().Get("note"), 10, 64)
	if noteID == 0 {
		return
	}
	notes, err := s.Store.ListNotes(r.Context(), mr.ID)
	if err != nil {
		return
	}
	for _, note := range notes {
		if note.ID == noteID {
			b.FormBody = strings.TrimSpace(note.Body) + "\n\n" + ref
			return
		}
	}
}

func (s *Server) issueCandidates(ctx context.Context, repo store.Repo) []store.Member {
	seen := map[string]store.Member{}
	add := func(list []store.Member) {
		for _, m := range list {
			if m.Pending || m.UserID == 0 || m.Username == "" {
				continue
			}
			seen[m.Username] = m
		}
	}
	if repo.OwnerKind == "user" {
		if u, err := s.Store.UserByID(ctx, repo.OwnerID); err == nil {
			seen[u.Username] = store.Member{UserID: u.ID, Username: u.Username, AvatarURL: u.AvatarURL, Role: access.RoleMaintainer}
		}
	}
	if members, err := s.Store.ListMembers(ctx, "repo", repo.ID); err == nil {
		add(members)
	}
	if repo.OwnerKind == "group" {
		if members, err := s.Store.ListMembers(ctx, "group", repo.OwnerID); err == nil {
			add(members)
		}
	}
	out := make([]store.Member, 0, len(seen))
	for _, m := range seen {
		out = append(out, m)
	}
	sort.Slice(out, func(i, j int) bool { return out[i].Username < out[j].Username })
	return out
}

func (s *Server) triageInput(r *http.Request, repo store.Repo) (labels, assignees []int64, milestoneID int64, due string, err error) {
	labels, err = s.resolveLabels(r.Context(), repo.ID, r.Form["label"])
	if err != nil {
		return nil, nil, 0, "", err
	}
	assignees, err = s.resolveAssignees(r.Context(), repo, r.Form["assignee"])
	if err != nil {
		return nil, nil, 0, "", err
	}
	milestoneID, err = s.resolveMilestone(r.Context(), repo.ID, r.FormValue("milestone"))
	if err != nil {
		return nil, nil, 0, "", err
	}
	due = strings.TrimSpace(r.FormValue("due_on"))
	if err := store.ValidDue(due); err != nil {
		return nil, nil, 0, "", err
	}
	return labels, assignees, milestoneID, due, nil
}

func (s *Server) resolveLabels(ctx context.Context, repoID int64, names []string) ([]int64, error) {
	ids := []int64{}
	seen := map[int64]bool{}
	for _, name := range names {
		name = strings.TrimSpace(name)
		if name == "" {
			continue
		}
		if err := store.ValidLabelName(name); err != nil {
			return nil, err
		}
		lab, err := s.Store.LabelByName(ctx, repoID, name)
		if err != nil {
			return nil, i18n.E("err.labelMissing", name)
		}
		if seen[lab.ID] {
			continue
		}
		seen[lab.ID] = true
		ids = append(ids, lab.ID)
	}
	return ids, nil
}

func (s *Server) resolveAssignees(ctx context.Context, repo store.Repo, names []string) ([]int64, error) {
	cand := map[string]int64{}
	for _, m := range s.issueCandidates(ctx, repo) {
		cand[m.Username] = m.UserID
	}
	ids := []int64{}
	seen := map[int64]bool{}
	for _, name := range names {
		name = strings.ToLower(strings.TrimSpace(strings.TrimPrefix(name, "@")))
		if name == "" {
			continue
		}
		id, ok := cand[name]
		if !ok {
			return nil, i18n.E("err.assignee", name)
		}
		if seen[id] {
			continue
		}
		seen[id] = true
		ids = append(ids, id)
	}
	return ids, nil
}

func (s *Server) resolveMilestone(ctx context.Context, repoID int64, title string) (int64, error) {
	title = strings.TrimSpace(title)
	if title == "" {
		return 0, nil
	}
	m, err := s.Store.MilestoneByTitle(ctx, repoID, title)
	if err != nil {
		return 0, i18n.E("err.milestone")
	}
	return m.ID, nil
}

func (s *Server) issueHook(repo store.Repo, number int64, actor, action, comment string) {
	if s.Store == nil {
		return
	}
	iss, err := s.Store.IssueByNumber(context.Background(), repo.ID, number)
	if err != nil {
		return
	}
	num := strconv.FormatInt(iss.Number, 10)
	page := strings.TrimRight(s.Cfg.BaseURL, "/") + issuePath(repo, iss.Number)
	key := "hook.issueOpened"
	switch action {
	case "updated":
		key = "hook.issueUpdated"
	case "closed":
		key = "hook.issueClosed"
	case "reopened":
		key = "hook.issueReopened"
	case "commented":
		key = "hook.issueComment"
	}
	summary := i18n.T(i18n.EN, key, num)
	if action != "commented" {
		summary = i18n.T(i18n.EN, key, num, iss.Title)
	}
	s.Dispatch(repo.ID, webhook.Event{
		Type: webhook.EventIssue, Project: repo.FullPath(), Actor: actor,
		Summary: summary, URL: page, Comment: comment,
		Issue: &webhook.IssueInfo{
			ID: iss.Number, Title: iss.Title, Description: iss.Description,
			Status: iss.Status, Confidential: iss.Confidential, Author: iss.Author,
			Assignees: iss.Assignees, Labels: labelNames(iss.Labels),
			Milestone: iss.Milestone, DueDate: iss.DueOn, Action: action, URL: page,
		},
	})
}

func (s *Server) closeIssueNumbers(ctx context.Context, repo store.Repo, actor store.User, numbers []int64) {
	if s.Store == nil {
		return
	}
	for _, n := range numbers {
		iss, err := s.Store.IssueByNumber(ctx, repo.ID, n)
		if err != nil || iss.Status == "closed" {
			continue
		}
		changed, err := s.Store.SetIssueState(ctx, iss.ID, "closed")
		if err != nil || !changed {
			continue
		}
		s.issueHook(repo, n, actor.Username, "closed", "")
	}
}

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

func (s *Server) closeIssuesOnPush(repo store.Repo, user store.User, before, after string) {
	if s.Store == nil || s.StoragePath() == "" {
		return
	}
	dir := gitrepo.Dir(s.StoragePath(), repo.OwnerPath, repo.Name)
	commits, err := gitrepo.RangeLog(context.Background(), s.Git, dir, before, after)
	if err != nil {
		return
	}
	var texts []string
	for i, c := range commits {
		if i >= 50 {
			break
		}
		texts = append(texts, commitText(c))
	}
	s.closeIssueNumbers(context.Background(), repo, user, closingNumbers(texts...))
}

func closingNumbers(texts ...string) []int64 {
	seen := map[int64]bool{}
	var out []int64
	for _, text := range texts {
		text = fenceRe.ReplaceAllString(text, " ")
		text = inlineCodeRe.ReplaceAllString(text, " ")
		for _, m := range closeIssueRe.FindAllStringSubmatch(text, -1) {
			n, err := strconv.ParseInt(m[2], 10, 64)
			if err != nil || n < 1 || seen[n] {
				continue
			}
			seen[n] = true
			out = append(out, n)
		}
	}
	return out
}

func issueVisible(iss store.Issue, u store.User, role access.Role) bool {
	if !iss.Confidential {
		return true
	}
	if role.CanTriageIssue() {
		return true
	}
	return u.ID != 0 && u.ID == iss.AuthorID
}

func triagePosted(r *http.Request) bool {
	if r.Form == nil {
		return false
	}
	_, label := r.Form["label"]
	_, assignee := r.Form["assignee"]
	_, milestone := r.Form["milestone"]
	_, due := r.Form["due_on"]
	return label || assignee || milestone || due
}

func markChoices(list []IssueChoice, selected []string) []IssueChoice {
	on := map[string]bool{}
	for _, name := range selected {
		on[name] = true
	}
	for i := range list {
		list[i].On = on[list[i].Name]
	}
	return list
}

func labelNames(labels []store.Label) []string {
	out := []string{}
	for _, l := range labels {
		out = append(out, l.Name)
	}
	return out
}

func issuePath(repo store.Repo, n int64) string {
	return repoURL(repo) + "/-/issues/" + strconv.FormatInt(n, 10)
}

func (s *Server) fail(w http.ResponseWriter, r *http.Request, err error) {
	http.Error(w, s.trErr(r, err), http.StatusInternalServerError)
}
