// Package desctpl leest beschrijvingssjablonen uit de standaardbranch
// en vult de variabelen van een merge request in.
package desctpl

import (
	"context"
	"regexp"
	"sort"
	"strings"

	"gitlab.com/Timfa/bluegit/internal/gitrepo"
)

// Template is één Markdown-bestand zonder het achtervoegsel .md.
type Template struct {
	Name string
	Body string
}

// Commit is een bericht op de bronbranch, oudste eerst.
type Commit struct {
	Subject string
	Body    string
	Author  string
	Email   string
	Merge   bool
}

// Vars zijn de waarden voor %{...} bij het aanmaken van een merge request.
type Vars struct {
	Source  string
	Target  string
	Commits []Commit
}

const hugeBody = 10000

var (
	closesBranch = regexp.MustCompile(`^(\d+)-`)
	coAuthor     = regexp.MustCompile(`(?m)^Co-authored-by: .+$`)
)

// List leest .bluegit/<kind>_templates en valt terug op .gitlab/.
// Een gelijke naam uit .bluegit wint. kind is issue of mr.
// Ontbreken beide mappen, dan is de lijst leeg. Dat is geen fout en er wordt niets aangemaakt.
func List(ctx context.Context, gitBin, dir, rev, kind string) ([]Template, error) {
	sub, err := subdir(kind)
	if err != nil {
		return nil, err
	}
	found := map[string]Template{}
	var order []string
	for _, root := range []string{".bluegit", ".gitlab"} {
		entries, err := gitrepo.Tree(ctx, gitBin, dir, rev, root+"/"+sub)
		if err != nil {
			continue
		}
		for _, e := range entries {
			if e.Type != "blob" || !strings.HasSuffix(e.Name, ".md") {
				continue
			}
			name := strings.TrimSuffix(e.Name, ".md")
			if !validName(name) {
				continue
			}
			if _, ok := found[name]; ok {
				continue
			}
			text, binary, err := gitrepo.Blob(ctx, gitBin, dir, rev, root+"/"+sub+"/"+e.Name, 100000)
			if err != nil || binary {
				continue
			}
			if len(text) > 20000 {
				text = text[:20000]
			}
			found[name] = Template{Name: name, Body: text}
			order = append(order, name)
		}
	}
	list := make([]Template, 0, len(order))
	for _, name := range order {
		list = append(list, found[name])
	}
	sort.SliceStable(list, func(i, j int) bool {
		di := strings.EqualFold(list[i].Name, "Default")
		dj := strings.EqualFold(list[j].Name, "Default")
		if di != dj {
			return di
		}
		return strings.ToLower(list[i].Name) < strings.ToLower(list[j].Name)
	})
	return list, nil
}

// Find zoekt een sjabloon op naam. Een hoofdletterverschil telt alleen als er één kandidaat is.
func Find(list []Template, name string) (Template, bool) {
	name = strings.TrimSpace(name)
	if name == "" {
		return Template{}, false
	}
	for _, t := range list {
		if t.Name == name {
			return t, true
		}
	}
	var hit Template
	n := 0
	for _, t := range list {
		if strings.EqualFold(t.Name, name) {
			hit = t
			n++
		}
	}
	if n == 1 {
		return hit, true
	}
	return Template{}, false
}

// Default is Default.md, ongeacht hoofdletters. Een exacte naam wint.
func Default(list []Template) (Template, bool) {
	var loose Template
	looseOK := false
	for _, t := range list {
		if t.Name == "Default" {
			return t, true
		}
		if !looseOK && strings.EqualFold(t.Name, "Default") {
			loose = t
			looseOK = true
		}
	}
	return loose, looseOK
}

// Expand vervangt de variabelen. Een merge-commit en een heel lang bericht
// tellen niet mee voor de commitlijsten. Er worden hooguit 100 commits gebruikt.
func Expand(body string, v Vars) string {
	commits := v.Commits
	if len(commits) > 100 {
		commits = commits[:100]
	}
	repl := map[string]string{
		"%{source_branch}":          v.Source,
		"%{target_branch}":          v.Target,
		"%{first_commit}":           firstCommit(commits),
		"%{all_commits}":            allCommits(commits),
		"%{co_authored_by}":         coAuthored(commits),
		"%{first_multiline_commit}": firstMultiline(commits),
		"%{closes_issue}":           closesIssue(v.Source),
	}
	for token, value := range repl {
		body = strings.ReplaceAll(body, token, value)
	}
	return body
}

func closesIssue(branch string) string {
	m := closesBranch.FindStringSubmatch(branch)
	if m == nil {
		return ""
	}
	return "Closes #" + m[1]
}

func usable(c Commit) bool {
	return !c.Merge && len(c.Subject) <= hugeBody && len(c.Body) <= hugeBody
}

func message(c Commit) string {
	if c.Body == "" {
		return c.Subject
	}
	return c.Subject + "\n\n" + c.Body
}

func firstCommit(commits []Commit) string {
	for _, c := range commits {
		if usable(c) {
			return message(c)
		}
	}
	return ""
}

func firstMultiline(commits []Commit) string {
	for _, c := range commits {
		if usable(c) && c.Body != "" {
			return message(c)
		}
	}
	return ""
}

func allCommits(commits []Commit) string {
	var parts []string
	for _, c := range commits {
		if !usable(c) {
			continue
		}
		parts = append(parts, message(c))
	}
	return strings.Join(parts, "\n\n")
}

func coAuthored(commits []Commit) string {
	seen := map[string]bool{}
	var lines []string
	for _, c := range commits {
		if len(c.Body) > hugeBody {
			continue
		}
		for _, line := range coAuthor.FindAllString(c.Body, -1) {
			if seen[line] {
				continue
			}
			seen[line] = true
			lines = append(lines, line)
		}
	}
	return strings.Join(lines, "\n")
}

func subdir(kind string) (string, error) {
	switch kind {
	case "issue":
		return "issue_templates", nil
	case "mr":
		return "merge_request_templates", nil
	default:
		return "", errKind
	}
}

type kindError struct{}

func (kindError) Error() string { return "onbekend sjabloon" }

var errKind kindError

func validName(name string) bool {
	if name == "" || name == "." || name == ".." {
		return false
	}
	return !strings.ContainsAny(name, "/\\")
}
