package modules

import (
	"bytes"
	"html/template"
	"path"
	"strings"

	"github.com/yuin/goldmark"
	"github.com/yuin/goldmark/ast"
	"github.com/yuin/goldmark/extension"
	"github.com/yuin/goldmark/parser"
	"github.com/yuin/goldmark/text"
)

// The options here mirror Hugo's goldmark defaults on purpose: GFM,
// typographer, and automatic heading IDs. Same renderer, same extensions,
// so a README renders identically to the same file on your blog.
//
// WithUnsafe is deliberately NOT set -- also Hugo's default. Anyone who can
// push can write a README, so raw HTML in markdown is untrusted input;
// goldmark drops it rather than passing a <script> through into the page.
var md = goldmark.New(
	goldmark.WithExtensions(extension.GFM, extension.Typographer),
	goldmark.WithParserOptions(parser.WithAutoHeadingID()),
)

// Markdown renders README source.
//
//	base — "/slug", the repository root URL
//	ref  — the ref being viewed, for building links
//	dir  — directory the source file lives in, for resolving relative links
//
// Swap this variable to change engines; nothing else imports goldmark.
var Markdown = func(src []byte, base, ref, dir string) (template.HTML, error) {
	doc := md.Parser().Parse(text.NewReader(src))
	rewriteLinks(doc, base, ref, dir)

	var buf bytes.Buffer
	if err := md.Renderer().Render(&buf, src, doc); err != nil {
		return "", err
	}
	return template.HTML(buf.String()), nil
}

// rewriteLinks points relative markdown links at the browser instead of
// leaving them dangling. A link to docs/design.md becomes the blob view;
// an image becomes /raw/, because the blob view is an HTML page and an
// <img> needs actual bytes.
func rewriteLinks(doc ast.Node, base, ref, dir string) {
	ast.Walk(doc, func(n ast.Node, entering bool) (ast.WalkStatus, error) {
		if !entering {
			return ast.WalkContinue, nil
		}
		switch v := n.(type) {
		case *ast.Link:
			if p, ok := resolve(string(v.Destination), dir); ok {
				v.Destination = []byte(base + "/blob/" + ref + "/" + p)
			}
		case *ast.Image:
			if p, ok := resolve(string(v.Destination), dir); ok {
				v.Destination = []byte(base + "/raw/" + ref + "/" + p)
			}
		}
		return ast.WalkContinue, nil
	})
}

// resolve reports whether dest is repo-relative, and if so its path from the
// repo root. Absolute URLs, protocol-relative URLs, site-absolute paths and
// bare fragments are left alone.
func resolve(dest, dir string) (string, bool) {
	if dest == "" || strings.HasPrefix(dest, "#") || strings.HasPrefix(dest, "/") ||
		strings.HasPrefix(dest, "//") || strings.Contains(dest, "://") ||
		strings.HasPrefix(dest, "mailto:") {
		return "", false
	}
	p := path.Clean(path.Join(dir, dest))
	if p == "." || strings.HasPrefix(p, "..") {
		return "", false // escapes the repo root
	}
	return p, true
}