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

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

// Render maakt HTML. Relatieve links krijgen linkBase ervoor, plus rev.
func Render(src, linkBase, rev string) string {
	lines := strings.Split(strings.ReplaceAll(src, "\r\n", "\n"), "\n")
	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))
			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))
				b.WriteString("</h" + h + ">\n")
				i++
				continue
			}
		}
		if isList(trim) {
			b.WriteString("<ul>\n")
			for i < len(lines) && isList(strings.TrimSpace(lines[i])) {
				item := strings.TrimSpace(lines[i])
				item = strings.TrimPrefix(item, "- ")
				item = strings.TrimPrefix(item, "* ")
				b.WriteString("<li>")
				b.WriteString(inline(item, linkBase, rev))
				b.WriteString("</li>\n")
				i++
			}
			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))
		b.WriteString("</p>\n")
	}
	return b.String()
}

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

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 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))
		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))
			b.WriteString("</td>")
		}
		b.WriteString("</tr>\n")
	}
	b.WriteString("</tbody></table>\n")
	return b.String()
}

func inline(s, linkBase, rev string) string {
	var b strings.Builder
	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))
				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))
				b.WriteString("</em>")
				i += j + 2
				continue
			}
		}
		if s[i] == '[' {
			if mid := strings.Index(s[i:], "]("); mid > 0 {
				if end := strings.IndexByte(s[i+mid:], ')'); end > 2 {
					text := s[i+1 : i+mid]
					href := s[i+mid+2 : i+mid+end]
					b.WriteString(`<a href="`)
					b.WriteString(html.EscapeString(resolveLink(href, linkBase, rev)))
					b.WriteString(`">`)
					b.WriteString(inline(text, linkBase, rev))
					b.WriteString("</a>")
					i += mid + end + 1
					continue
				}
			}
		}
		b.WriteString(html.EscapeString(s[i : i+1]))
		i++
	}
	return b.String()
}

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.Contains(href, "://") || strings.HasPrefix(href, "//") {
		return href
	}
	href = strings.TrimPrefix(href, "./")
	out := linkBase + href
	if rev != "" {
		out += "?rev=" + url.QueryEscape(rev)
	}
	return out
}
