package markdown

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

// Afbeeldingen in Markdown. Een relatief pad wijst naar het bestand in de repo
// en wordt een /-/raw/-adres op dezelfde ref. Een .svg krijgt as=img, zodat de
// server hem als image/svg+xml in een sandbox levert; een <img> voert nooit
// script uit. Ruwe HTML blijft geëscaped, behalve een kleine, herschreven set
// tags (img, a, br, en omhullende p/div/center/picture/span zonder attributen).

var imageExts = map[string]bool{".png": true, ".jpg": true, ".jpeg": true, ".gif": true, ".webp": true, ".svg": true, ".avif": true, ".bmp": true, ".ico": true}

// splitBlobBase splitst /owner/repo/-/blob/dir/ in /owner/repo/-/blob/ en dir/.
func splitBlobBase(linkBase string) (root, dir string, ok bool) {
	const mark = "/-/blob/"
	i := strings.Index(linkBase, mark)
	if i < 0 {
		return "", "", false
	}
	return linkBase[:i+len(mark)], linkBase[i+len(mark):], true
}

// cleanRepoPath maakt van href een pad vanaf de repo-root, met dir als map van
// het document. Een leidende / is de repo-root; .. kan nooit boven de root uit.
// Een #anker blijft achteraan staan.
func cleanRepoPath(dir, href string) string {
	p, _ := cleanRepoPathFrag(dir, href)
	return p
}

func cleanRepoPathFrag(dir, href string) (string, string) {
	frag := ""
	if j := strings.IndexByte(href, '#'); j >= 0 {
		href, frag = href[:j], href[j:]
	}
	if j := strings.IndexByte(href, '?'); j >= 0 {
		href = href[:j]
	}
	if un, err := url.PathUnescape(href); err == nil {
		href = un
	}
	var p string
	if strings.HasPrefix(href, "/") {
		p = path.Clean(href)
	} else {
		p = path.Clean("/" + dir + "/" + href)
	}
	p = strings.TrimPrefix(p, "/")
	segs := strings.Split(p, "/")
	for k := range segs {
		segs[k] = url.PathEscape(segs[k])
	}
	return strings.Join(segs, "/"), frag
}

// rawBase geeft het /-/raw/-voorvoegsel en de map voor relatieve afbeeldingen.
func rawBase(linkBase, repoPath string) (root, dir string, ok bool) {
	if r, d, ok := splitBlobBase(linkBase); ok {
		return strings.TrimSuffix(r, "/-/blob/") + "/-/raw/", d, true
	}
	if repoPath != "" {
		return "/" + strings.Trim(repoPath, "/") + "/-/raw/", "", true
	}
	return "", "", false
}

// imageSrc maakt een veilig src-adres, of "" als het niet mag.
func imageSrc(src, linkBase, rev, repoPath string) string {
	src = strings.TrimSpace(src)
	src = strings.TrimSuffix(strings.TrimPrefix(src, "<"), ">")
	src = strings.ReplaceAll(src, " ", "%20")
	if src == "" || strings.ContainsAny(src, "\"'<>\\`\x00\n\r\t ") {
		return ""
	}
	lower := strings.ToLower(src)
	switch {
	case strings.HasPrefix(lower, "https://"):
		return src
	case strings.HasPrefix(lower, "data:image/") && !strings.HasPrefix(lower, "data:image/svg"):
		return src
	case strings.HasPrefix(lower, "//"), hasScheme(lower):
		// http:, javascript:, data:text/..., schema-relatief: niet laden.
		return ""
	}
	if strings.HasPrefix(src, "#") {
		return ""
	}
	root, dir, ok := rawBase(linkBase, repoPath)
	if !ok {
		// Geen repo (bv. /help): alleen relatief aan linkBase.
		if linkBase == "" {
			return ""
		}
		return linkBase + strings.TrimPrefix(src, "./")
	}
	rel := cleanRepoPath(dir, src)
	if rel == "" || rel == "." {
		return ""
	}
	q := url.Values{}
	if rev != "" {
		q.Set("rev", rev)
	}
	if strings.EqualFold(path.Ext(rel), ".svg") {
		q.Set("as", "img")
	}
	out := root + rel
	if len(q) > 0 {
		out += "?" + encodeOrdered(q)
	}
	return out
}

// encodeOrdered zet rev vóór as, zodat adressen voorspelbaar zijn.
func encodeOrdered(q url.Values) string {
	var parts []string
	for _, k := range []string{"rev", "as"} {
		if v := q.Get(k); v != "" {
			parts = append(parts, k+"="+url.QueryEscape(v))
		}
	}
	return strings.Join(parts, "&")
}

// imageTag schrijft een <img>; zonder geldige bron alleen de alt-tekst.
func imageTag(src, alt, title, width, height, linkBase, rev, repoPath string) string {
	u := imageSrc(src, linkBase, rev, repoPath)
	if u == "" {
		return html.EscapeString(alt)
	}
	var b strings.Builder
	b.WriteString(`<img class="mdimg" src="`)
	b.WriteString(html.EscapeString(u))
	b.WriteString(`" alt="`)
	b.WriteString(html.EscapeString(alt))
	b.WriteString(`"`)
	if title != "" {
		b.WriteString(` title="`)
		b.WriteString(html.EscapeString(title))
		b.WriteString(`"`)
	}
	if w := dimension(width); w != "" {
		b.WriteString(` width="` + w + `"`)
	}
	if h := dimension(height); h != "" {
		b.WriteString(` height="` + h + `"`)
	}
	b.WriteString(` loading="lazy" decoding="async" referrerpolicy="no-referrer">`)
	return b.String()
}

// dimension laat alleen een getal (pixels) door, maximaal vier cijfers.
func dimension(v string) string {
	v = strings.TrimSuffix(strings.TrimSpace(v), "px")
	if v == "" || len(v) > 4 {
		return ""
	}
	for _, c := range v {
		if c < '0' || c > '9' {
			return ""
		}
	}
	return v
}

// bracketLink leest [tekst](doel) vanaf s[i] == '[' met geneste haken.
func bracketLink(s string, i int) (text, dest string, n int, ok bool) {
	if i >= len(s) || s[i] != '[' {
		return "", "", 0, false
	}
	depth := 0
	j := i
	for ; j < len(s); j++ {
		switch s[j] {
		case '\\':
			j++
		case '[':
			depth++
		case ']':
			depth--
		}
		if depth == 0 {
			break
		}
	}
	if j >= len(s) || j+1 >= len(s) || s[j+1] != '(' {
		return "", "", 0, false
	}
	text = s[i+1 : j]
	k := j + 2
	pd := 1
	for ; k < len(s); k++ {
		if s[k] == '(' {
			pd++
		} else if s[k] == ')' {
			pd--
			if pd == 0 {
				break
			}
		}
	}
	if k >= len(s) {
		return "", "", 0, false
	}
	dest = strings.TrimSpace(s[j+2 : k])
	if dest == "" {
		return "", "", 0, false
	}
	return text, dest, k + 1 - i, true
}

// splitTitle haalt een "titel" achter het doel weg.
func splitTitle(dest string) (href, title string) {
	dest = strings.TrimSpace(dest)
	if sp := strings.IndexAny(dest, " \t"); sp > 0 {
		rest := strings.TrimSpace(dest[sp:])
		if len(rest) >= 2 && (rest[0] == '"' && rest[len(rest)-1] == '"' || rest[0] == '\'' && rest[len(rest)-1] == '\'') {
			return dest[:sp], rest[1 : len(rest)-1]
		}
		return dest[:sp], ""
	}
	return dest, ""
}

// plainText haalt eenvoudige Markdown-tekens uit een alt-tekst.
func plainText(s string) string {
	return strings.NewReplacer("**", "", "*", "", "`", "").Replace(s)
}

// bareImage maakt van een los https-adres naar een afbeelding een <img> met link.
func bareImage(s, linkBase, rev, repoPath string) (string, int, bool) {
	if !strings.HasPrefix(strings.ToLower(s), "https://") {
		return "", 0, false
	}
	end := strings.IndexAny(s, " \t<>\"'`")
	if end < 0 {
		end = len(s)
	}
	u := strings.TrimRight(s[:end], ".,;:!?)")
	p := u
	if q := strings.IndexAny(p, "?#"); q >= 0 {
		p = p[:q]
	}
	if !imageExts[strings.ToLower(path.Ext(p))] {
		return "", 0, false
	}
	parsed, err := url.Parse(u)
	if err != nil || parsed.Host == "" {
		return "", 0, false
	}
	img := imageTag(u, path.Base(parsed.Path), "", "", "", linkBase, rev, repoPath)
	return `<a href="` + html.EscapeString(u) + `" rel="noopener noreferrer">` + img + `</a>`, len(u), true
}

// htmlTag herschrijft een toegestane HTML-tag. Al het andere blijft tekst.
func htmlTag(s, linkBase, rev, repoPath string, anchors *int) (string, int, bool) {
	end := strings.IndexByte(s, '>')
	if end < 0 || end > 4000 {
		return "", 0, false
	}
	raw := s[1:end]
	closing := strings.HasPrefix(raw, "/")
	raw = strings.TrimPrefix(raw, "/")
	raw = strings.TrimSuffix(strings.TrimSpace(raw), "/")
	name := raw
	if sp := strings.IndexAny(raw, " \t\n"); sp >= 0 {
		name = raw[:sp]
	}
	name = strings.ToLower(name)
	attrs, okAttrs := parseAttrs(raw[len(name):])
	if !okAttrs {
		return "", 0, false
	}
	n := end + 1
	switch name {
	case "img":
		if closing {
			return "", n, true
		}
		return imageTag(attrs["src"], attrs["alt"], attrs["title"], attrs["width"], attrs["height"], linkBase, rev, repoPath), n, true
	case "br":
		return "<br>", n, true
	case "a":
		if closing {
			if *anchors == 0 {
				return "", n, true
			}
			*anchors--
			return "</a>", n, true
		}
		href, ok := attrs["href"]
		if !ok {
			return "", 0, false
		}
		h := strings.TrimSpace(href)
		lower := strings.ToLower(h)
		if strings.Contains(lower, ":") && !strings.HasPrefix(lower, "https://") && !strings.HasPrefix(lower, "http://") && !strings.HasPrefix(lower, "mailto:") {
			return "", 0, false
		}
		*anchors++
		return `<a href="` + html.EscapeString(resolveLink(h, linkBase, rev)) + `" rel="noopener noreferrer">`, n, true
	case "p", "div", "center", "picture", "span", "source", "sup", "sub":
		// Omhulsels (vaak <p align="center">) vallen weg; de inhoud blijft.
		return "", n, true
	}
	return "", 0, false
}

// parseAttrs leest name="waarde"-paren. Ongeldige syntaxis geeft ok=false.
func parseAttrs(s string) (map[string]string, bool) {
	out := map[string]string{}
	i := 0
	for {
		for i < len(s) && (s[i] == ' ' || s[i] == '\t' || s[i] == '\n') {
			i++
		}
		if i >= len(s) {
			return out, true
		}
		j := i
		for j < len(s) && (isIdent(s[j]) || s[j] == '-' || s[j] == ':') {
			j++
		}
		if j == i {
			return nil, false
		}
		key := strings.ToLower(s[i:j])
		i = j
		if i < len(s) && s[i] == '=' {
			i++
			if i < len(s) && (s[i] == '"' || s[i] == '\'') {
				q := s[i]
				k := strings.IndexByte(s[i+1:], q)
				if k < 0 {
					return nil, false
				}
				out[key] = html.UnescapeString(s[i+1 : i+1+k])
				i += k + 2
			} else {
				k := i
				for k < len(s) && s[k] != ' ' && s[k] != '\t' && s[k] != '\n' {
					k++
				}
				out[key] = html.UnescapeString(s[i:k])
				i = k
			}
		} else {
			out[key] = ""
		}
	}
}

// hasScheme ziet een "schema:" vóór de eerste /, ? of #.
func hasScheme(s string) bool {
	c := strings.IndexByte(s, ':')
	if c < 0 {
		return false
	}
	if k := strings.IndexAny(s, "/?#"); k >= 0 && k < c {
		return false
	}
	return true
}
