// Package markdown zet een beperkte Markdown-tekst om naar HTML.
// Ruwe HTML uit het bestand wordt geëscaped.
package markdown

import (
	"fmt"
	"html"
	"net/url"
	"strconv"
	"strings"
)

// Tasks maakt takenlijsten klikbaar. Een leeg Post-adres of CanToggle onwaar
// laat een vast vinkje zien. Count is een tekst met twee %d: af, totaal.
// Het volgnummer is de volgorde in het document, dezelfde als SetTask.
type Tasks struct {
	Post      string
	CSRF      string
	Kind      string
	ID        string
	CanToggle bool
	Count     string
	Toggle    string
}

// Render maakt HTML. Relatieve links krijgen linkBase ervoor, plus rev.
// repoPath is /owner/repo. Dan worden #12 en !5 links naar dat issue of die merge request.
func Render(src, linkBase, rev, repoPath string) string {
	return RenderTasks(src, linkBase, rev, repoPath, Tasks{})
}

// RenderTasks is Render plus aanvinkbare taken.
func RenderTasks(src, linkBase, rev, repoPath string, tasks Tasks) string {
	lines := strings.Split(strings.ReplaceAll(src, "\r\n", "\n"), "\n")
	hits := indexTasks(lines)
	var b strings.Builder
	for i := 0; i < len(lines); {
		line := lines[i]
		trim := strings.TrimSpace(line)
		if trim == "" {
			i++
			continue
		}
		if strings.HasPrefix(trim, "```") {
			var body []string
			i++
			for i < len(lines) && !strings.HasPrefix(strings.TrimSpace(lines[i]), "```") {
				body = append(body, lines[i])
				i++
			}
			if i < len(lines) {
				i++
			}
			b.WriteString("<pre><code>")
			b.WriteString(html.EscapeString(strings.Join(body, "\n")))
			b.WriteString("</code></pre>\n")
			continue
		}
		if isTableStart(lines, i) {
			b.WriteString(table(lines, &i, linkBase, rev, repoPath))
			continue
		}
		if strings.HasPrefix(trim, "#") {
			n := 0
			for n < len(trim) && trim[n] == '#' && n < 6 {
				n++
			}
			if n > 0 && (n == len(trim) || trim[n] == ' ') {
				h := strconv.Itoa(n)
				b.WriteString("<h" + h + ">")
				b.WriteString(inline(strings.TrimSpace(trim[n:]), linkBase, rev, repoPath))
				b.WriteString("</h" + h + ">\n")
				i++
				continue
			}
		}
		if isList(trim) {
			type row struct {
				text    string
				task    bool
				checked bool
				index   int
			}
			var rows []row
			done, total := 0, 0
			for i < len(lines) && isList(strings.TrimSpace(lines[i])) {
				item := strings.TrimSpace(lines[i])
				item = strings.TrimPrefix(item, "- ")
				item = strings.TrimPrefix(item, "* ")
				if hit, ok := hits[i]; ok && len(item) >= 3 {
					item = strings.TrimSpace(item[3:])
					rows = append(rows, row{text: item, task: true, checked: hit.checked, index: hit.index})
					total++
					if hit.checked {
						done++
					}
				} else {
					rows = append(rows, row{text: item})
				}
				i++
			}
			if total > 0 {
				b.WriteString(`<p class="taskcount">`)
				b.WriteString(html.EscapeString(fmt.Sprintf(taskCountFmt(tasks.Count), done, total)))
				b.WriteString("</p>\n<ul class=\"tasks\">\n")
			} else {
				b.WriteString("<ul>\n")
			}
			for _, row := range rows {
				b.WriteString("<li>")
				if row.task {
					b.WriteString(taskBox(row.checked, row.index, tasks))
				}
				b.WriteString(inline(row.text, linkBase, rev, repoPath))
				b.WriteString("</li>\n")
			}
			b.WriteString("</ul>\n")
			continue
		}
		var para []string
		for i < len(lines) && strings.TrimSpace(lines[i]) != "" && !strings.HasPrefix(strings.TrimSpace(lines[i]), "```") && !strings.HasPrefix(strings.TrimSpace(lines[i]), "#") && !isList(strings.TrimSpace(lines[i])) && !isTableStart(lines, i) {
			para = append(para, strings.TrimSpace(lines[i]))
			i++
		}
		b.WriteString("<p>")
		b.WriteString(inline(strings.Join(para, " "), linkBase, rev, repoPath))
		b.WriteString("</p>\n")
	}
	return b.String()
}

func isList(trim string) bool {
	return strings.HasPrefix(trim, "- ") || strings.HasPrefix(trim, "* ")
}

type taskHit struct {
	index   int
	checked bool
}

// SetTask zet het vinkje met dit volgnummer. ok is onwaar als dat nummer er niet is.
func SetTask(src string, index int, checked bool) (string, bool) {
	if index < 0 {
		return src, false
	}
	lines := strings.Split(strings.ReplaceAll(src, "\r\n", "\n"), "\n")
	hits := indexTasks(lines)
	for i, hit := range hits {
		if hit.index != index {
			continue
		}
		lines[i] = rewriteTask(lines[i], checked)
		return strings.Join(lines, "\n"), true
	}
	return src, false
}

// indexTasks loopt dezelfde blokken als Render, zodat een hek of een tabel geen taak is.
func indexTasks(lines []string) map[int]taskHit {
	out := map[int]taskHit{}
	n := 0
	for i := 0; i < len(lines); {
		trim := strings.TrimSpace(lines[i])
		if trim == "" {
			i++
			continue
		}
		if strings.HasPrefix(trim, "```") {
			i++
			for i < len(lines) && !strings.HasPrefix(strings.TrimSpace(lines[i]), "```") {
				i++
			}
			if i < len(lines) {
				i++
			}
			continue
		}
		if isTableStart(lines, i) {
			i += 2
			for i < len(lines) && strings.Contains(lines[i], "|") && strings.TrimSpace(lines[i]) != "" {
				i++
			}
			continue
		}
		if strings.HasPrefix(trim, "#") {
			h := 0
			for h < len(trim) && trim[h] == '#' && h < 6 {
				h++
			}
			if h > 0 && (h == len(trim) || trim[h] == ' ') {
				i++
				continue
			}
		}
		if isList(trim) {
			for i < len(lines) && isList(strings.TrimSpace(lines[i])) {
				if checked, ok := taskMarker(lines[i]); ok {
					out[i] = taskHit{index: n, checked: checked}
					n++
				}
				i++
			}
			continue
		}
		for i < len(lines) && strings.TrimSpace(lines[i]) != "" && !strings.HasPrefix(strings.TrimSpace(lines[i]), "```") && !strings.HasPrefix(strings.TrimSpace(lines[i]), "#") && !isList(strings.TrimSpace(lines[i])) && !isTableStart(lines, i) {
			i++
		}
	}
	return out
}

func taskMarker(line string) (checked bool, ok bool) {
	trim := strings.TrimSpace(line)
	switch {
	case strings.HasPrefix(trim, "- "):
		trim = trim[2:]
	case strings.HasPrefix(trim, "* "):
		trim = trim[2:]
	default:
		return false, false
	}
	if strings.HasPrefix(trim, "[ ]") && markerEnd(trim) {
		return false, true
	}
	if (strings.HasPrefix(trim, "[x]") || strings.HasPrefix(trim, "[X]")) && markerEnd(trim) {
		return true, true
	}
	return false, false
}

func markerEnd(trim string) bool {
	return len(trim) == 3 || (len(trim) > 3 && trim[3] == ' ')
}

func rewriteTask(line string, checked bool) string {
	repl := "[ ]"
	if checked {
		repl = "[x]"
	}
	for _, marker := range []string{"[ ]", "[x]", "[X]"} {
		if i := strings.Index(line, marker); i >= 0 {
			return line[:i] + repl + line[i+3:]
		}
	}
	return line
}

func taskCountFmt(s string) string {
	if strings.Count(s, "%d") >= 2 {
		return s
	}
	return "%d of %d tasks completed"
}

func taskBox(checked bool, index int, tasks Tasks) string {
	if tasks.CanToggle && tasks.Post != "" {
		val := "1"
		pressed := "false"
		class := "taskbox"
		mark := ""
		if checked {
			val = "0"
			pressed = "true"
			class = "taskbox on"
			mark = "&#10003;"
		}
		label := tasks.Toggle
		if label == "" {
			label = "Toggle task"
		}
		var b strings.Builder
		b.WriteString(`<form class="taskform" method="post" action="`)
		b.WriteString(html.EscapeString(tasks.Post))
		b.WriteString(`">`)
		writeHidden(&b, "csrf", tasks.CSRF)
		writeHidden(&b, "kind", tasks.Kind)
		writeHidden(&b, "id", tasks.ID)
		writeHidden(&b, "index", strconv.Itoa(index))
		writeHidden(&b, "checked", val)
		b.WriteString(`<button type="submit" class="`)
		b.WriteString(class)
		b.WriteString(`" aria-pressed="`)
		b.WriteString(pressed)
		b.WriteString(`" aria-label="`)
		b.WriteString(html.EscapeString(label))
		b.WriteString(`">`)
		b.WriteString(mark)
		b.WriteString(`</button></form>`)
		return b.String()
	}
	if checked {
		return `<input class="tasktick" type="checkbox" disabled checked> `
	}
	return `<input class="tasktick" type="checkbox" disabled> `
}

func writeHidden(b *strings.Builder, name, value string) {
	b.WriteString(`<input type="hidden" name="`)
	b.WriteString(html.EscapeString(name))
	b.WriteString(`" value="`)
	b.WriteString(html.EscapeString(value))
	b.WriteString(`">`)
}

func isTableStart(lines []string, i int) bool {
	if i+1 >= len(lines) || !strings.Contains(lines[i], "|") {
		return false
	}
	return isRule(lines[i+1])
}

func isRule(line string) bool {
	cells := splitRow(line)
	if len(cells) == 0 {
		return false
	}
	for _, c := range cells {
		c = strings.TrimSpace(c)
		if c == "" {
			return false
		}
		for _, r := range c {
			if r != '-' && r != ':' && r != ' ' {
				return false
			}
		}
		if !strings.Contains(c, "-") {
			return false
		}
	}
	return true
}

func splitRow(line string) []string {
	line = strings.TrimSpace(line)
	line = strings.Trim(line, "|")
	if strings.TrimSpace(line) == "" {
		return nil
	}
	parts := strings.Split(line, "|")
	for i := range parts {
		parts[i] = strings.TrimSpace(parts[i])
	}
	return parts
}

func table(lines []string, i *int, linkBase, rev, repoPath string) string {
	head := splitRow(lines[*i])
	*i += 2
	var rows [][]string
	for *i < len(lines) && strings.Contains(lines[*i], "|") && strings.TrimSpace(lines[*i]) != "" {
		rows = append(rows, splitRow(lines[*i]))
		*i++
	}
	var b strings.Builder
	b.WriteString("<table class=\"md\">\n<thead><tr>")
	for _, c := range head {
		b.WriteString("<th>")
		b.WriteString(inline(c, linkBase, rev, repoPath))
		b.WriteString("</th>")
	}
	b.WriteString("</tr></thead>\n<tbody>\n")
	for _, row := range rows {
		b.WriteString("<tr>")
		for _, c := range row {
			b.WriteString("<td>")
			b.WriteString(inline(c, linkBase, rev, repoPath))
			b.WriteString("</td>")
		}
		b.WriteString("</tr>\n")
	}
	b.WriteString("</tbody></table>\n")
	return b.String()
}

func inline(s, linkBase, rev, repoPath string) string {
	var b strings.Builder
	anchors := 0
	for i := 0; i < len(s); {
		if s[i] == '`' {
			if j := strings.IndexByte(s[i+1:], '`'); j >= 0 {
				b.WriteString("<code>")
				b.WriteString(html.EscapeString(s[i+1 : i+1+j]))
				b.WriteString("</code>")
				i += j + 2
				continue
			}
		}
		if strings.HasPrefix(s[i:], "**") {
			if j := strings.Index(s[i+2:], "**"); j >= 0 {
				b.WriteString("<strong>")
				b.WriteString(inline(s[i+2:i+2+j], linkBase, rev, repoPath))
				b.WriteString("</strong>")
				i += j + 4
				continue
			}
		}
		if s[i] == '*' {
			if j := strings.IndexByte(s[i+1:], '*'); j > 0 {
				b.WriteString("<em>")
				b.WriteString(inline(s[i+1:i+1+j], linkBase, rev, repoPath))
				b.WriteString("</em>")
				i += j + 2
				continue
			}
		}
		if s[i] == '!' && i+1 < len(s) && s[i+1] == '[' {
			if text, dest, n, ok := bracketLink(s, i+1); ok {
				src, title := splitTitle(dest)
				b.WriteString(imageTag(src, plainText(text), title, "", "", linkBase, rev, repoPath))
				i += n + 1
				continue
			}
		}
		if s[i] == '[' {
			if text, dest, n, ok := bracketLink(s, i); ok {
				href, _ := splitTitle(dest)
				b.WriteString(`<a href="`)
				b.WriteString(html.EscapeString(resolveLink(href, linkBase, rev)))
				b.WriteString(`">`)
				b.WriteString(inline(text, linkBase, rev, repoPath))
				b.WriteString("</a>")
				i += n
				continue
			}
		}
		if s[i] == '<' {
			if out, n, ok := htmlTag(s[i:], linkBase, rev, repoPath, &anchors); ok {
				b.WriteString(out)
				i += n
				continue
			}
		}
		if s[i] == 'h' && (i == 0 || !isIdent(s[i-1]) && s[i-1] != '/' && s[i-1] != '"' && s[i-1] != '\'') {
			if out, n, ok := bareImage(s[i:], linkBase, rev, repoPath); ok {
				b.WriteString(out)
				i += n
				continue
			}
		}
		if href, label, n, ok := refLink(s, i, repoPath); ok {
			b.WriteString(`<a href="`)
			b.WriteString(html.EscapeString(href))
			b.WriteString(`">`)
			b.WriteString(html.EscapeString(label))
			b.WriteString("</a>")
			i += n
			continue
		}
		b.WriteString(html.EscapeString(s[i : i+1]))
		i++
	}
	for ; anchors > 0; anchors-- {
		b.WriteString("</a>")
	}
	return b.String()
}

func refLink(s string, i int, repoPath string) (href, label string, n int, ok bool) {
	if repoPath == "" || i >= len(s) {
		return "", "", 0, false
	}
	if s[i] != '#' && s[i] != '!' {
		return "", "", 0, false
	}
	if i > 0 && isIdent(s[i-1]) {
		return "", "", 0, false
	}
	j := i + 1
	if j >= len(s) || s[j] < '0' || s[j] > '9' {
		return "", "", 0, false
	}
	for j < len(s) && s[j] >= '0' && s[j] <= '9' {
		j++
	}
	if j < len(s) && isIdent(s[j]) {
		return "", "", 0, false
	}
	kind := "issues"
	if s[i] == '!' {
		kind = "merge-requests"
	}
	base := strings.Trim(repoPath, "/")
	return "/" + base + "/-/" + kind + "/" + s[i+1:j], s[i:j], j - i, true
}

func isIdent(c byte) bool {
	return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') || c == '_'
}

func resolveLink(href, linkBase, rev string) string {
	href = strings.TrimSpace(href)
	lower := strings.ToLower(href)
	if strings.HasPrefix(lower, "https://") || strings.HasPrefix(lower, "http://") || strings.HasPrefix(lower, "mailto:") {
		return href
	}
	if strings.HasPrefix(href, "#") || strings.HasPrefix(href, "//") {
		return href
	}
	if hasScheme(lower) {
		// javascript:, data:, vbscript: en andere schema's worden geen link.
		return "#"
	}
	if root, dir, ok := splitBlobBase(linkBase); ok {
		p, frag := cleanRepoPathFrag(dir, href)
		out := root + p
		if rev != "" {
			out += "?rev=" + url.QueryEscape(rev)
		}
		return out + frag
	}
	href = strings.TrimPrefix(href, "./")
	out := linkBase + href
	if rev != "" {
		out += "?rev=" + url.QueryEscape(rev)
	}
	return out
}
