//

// Blackfriday Markdown Processor

// Available at http://github.com/russross/blackfriday

//

// Copyright © 2011 Russ Ross <russ@russross.com>.

// Distributed under the Simplified BSD License.

// See README.md for details.

//

//

//

// HTML rendering backend

//

//

package blackfriday

import (

	"bytes"

	"fmt"

	"io"

	"regexp"

	"strings"

)

// HTMLFlags control optional behavior of HTML renderer.

type HTMLFlags int

// HTML renderer configuration options.

const (

	HTMLFlagsNone           HTMLFlags = 0

	SkipHTML                HTMLFlags = 1 << iota // Skip preformatted HTML blocks

	SkipImages                                    // Skip embedded images

	SkipLinks                                     // Skip all links

	Safelink                                      // Only link to trusted protocols

	NofollowLinks                                 // Only link with rel="nofollow"

	NoreferrerLinks                               // Only link with rel="noreferrer"

	NoopenerLinks                                 // Only link with rel="noopener"

	HrefTargetBlank                               // Add a blank target

	CompletePage                                  // Generate a complete HTML page

	UseXHTML                                      // Generate XHTML output instead of HTML

	FootnoteReturnLinks                           // Generate a link at the end of a footnote to return to the source

	Smartypants                                   // Enable smart punctuation substitutions

	SmartypantsFractions                          // Enable smart fractions (with Smartypants)

	SmartypantsDashes                             // Enable smart dashes (with Smartypants)

	SmartypantsLatexDashes                        // Enable LaTeX-style dashes (with Smartypants)

	SmartypantsAngledQuotes                       // Enable angled double quotes (with Smartypants) for double quotes rendering

	SmartypantsQuotesNBSP                         // Enable « French guillemets » (with Smartypants)

	TOC                                           // Generate a table of contents

)

var (

	htmlTagRe = regexp.MustCompile("(?i)^" + htmlTag)

)

const (

	htmlTag = "(?:" + openTag + "|" + closeTag + "|" + htmlComment + "|" +

		processingInstruction + "|" + declaration + "|" + cdata + ")"

	closeTag              = "</" + tagName + "\\s*[>]"

	openTag               = "<" + tagName + attribute + "*" + "\\s*/?>"

	attribute             = "(?:" + "\\s+" + attributeName + attributeValueSpec + "?)"

	attributeValue        = "(?:" + unquotedValue + "|" + singleQuotedValue + "|" + doubleQuotedValue + ")"

	attributeValueSpec    = "(?:" + "\\s*=" + "\\s*" + attributeValue + ")"

	attributeName         = "[a-zA-Z_:][a-zA-Z0-9:._-]*"

	cdata                 = "<!\\[CDATA\\[[\\s\\S]*?\\]\\]>"

	declaration           = "<![A-Z]+" + "\\s+[^>]*>"

	doubleQuotedValue     = "\"[^\"]*\""

	htmlComment           = "<!---->|<!--(?:-?[^>-])(?:-?[^-])*-->"

	processingInstruction = "[<][?].*?[?][>]"

	singleQuotedValue     = "'[^']*'"

	tagName               = "[A-Za-z][A-Za-z0-9-]*"

	unquotedValue         = "[^\"'=<>`\\x00-\\x20]+"

)

// HTMLRendererParameters is a collection of supplementary parameters tweaking

// the behavior of various parts of HTML renderer.

type HTMLRendererParameters struct {

	// Prepend this text to each relative URL.

	AbsolutePrefix string

	// Add this text to each footnote anchor, to ensure uniqueness.

	FootnoteAnchorPrefix string

	// Show this text inside the <a> tag for a footnote return link, if the

	// HTML_FOOTNOTE_RETURN_LINKS flag is enabled. If blank, the string

	// <sup>[return]</sup> is used.

	FootnoteReturnLinkContents string

	// If set, add this text to the front of each Heading ID, to ensure

	// uniqueness.

	HeadingIDPrefix string

	// If set, add this text to the back of each Heading ID, to ensure uniqueness.

	HeadingIDSuffix string

	// Increase heading levels: if the offset is 1, <h1> becomes <h2> etc.

	// Negative offset is also valid.

	// Resulting levels are clipped between 1 and 6.

	HeadingLevelOffset int

	Title string // Document title (used if CompletePage is set)

	CSS   string // Optional CSS file URL (used if CompletePage is set)

	Icon  string // Optional icon file URL (used if CompletePage is set)

	Flags HTMLFlags // Flags allow customizing this renderer's behavior

}

// HTMLRenderer is a type that implements the Renderer interface for HTML output.

//

// Do not create this directly, instead use the NewHTMLRenderer function.

type HTMLRenderer struct {

	HTMLRendererParameters

	closeTag string // how to end singleton tags: either " />" or ">"

	// Track heading IDs to prevent ID collision in a single generation.

	headingIDs map[string]int

	lastOutputLen int

	disableTags   int

	sr *SPRenderer

}

const (

	xhtmlClose = " />"

	htmlClose  = ">"

)

// NewHTMLRenderer creates and configures an HTMLRenderer object, which

// satisfies the Renderer interface.

func NewHTMLRenderer(params HTMLRendererParameters) *HTMLRenderer {

	// configure the rendering engine

	closeTag := htmlClose

	if params.Flags&UseXHTML != 0 {

		closeTag = xhtmlClose

	}

	if params.FootnoteReturnLinkContents == "" {

	}

	return &HTMLRenderer{

		HTMLRendererParameters: params,

		closeTag:   closeTag,

		headingIDs: make(map[string]int),

		sr: NewSmartypantsRenderer(params.Flags),

	}

}

func isHTMLTag(tag []byte, tagname string) bool {

	found, _ := findHTMLTagPos(tag, tagname)

	return found

}

// Look for a character, but ignore it when it's in any kind of quotes, it

// might be JavaScript

func skipUntilCharIgnoreQuotes(html []byte, start int, char byte) int {

	inSingleQuote := false

	inDoubleQuote := false

	inGraveQuote := false

	i := start

	for i < len(html) {

		switch {

		case html[i] == char && !inSingleQuote && !inDoubleQuote && !inGraveQuote:

			return i

		case html[i] == '\'':

			inSingleQuote = !inSingleQuote

		case html[i] == '"':

			inDoubleQuote = !inDoubleQuote

		case html[i] == '`':

			inGraveQuote = !inGraveQuote

		}

		i++

	}

	return start

}

func findHTMLTagPos(tag []byte, tagname string) (bool, int) {

	i := 0

	if i < len(tag) && tag[0] != '<' {

		return false, -1

	}

	i++

	i = skipSpace(tag, i)

	if i < len(tag) && tag[i] == '/' {

		i++

	}

	i = skipSpace(tag, i)

	j := 0

	for ; i < len(tag); i, j = i+1, j+1 {

		if j >= len(tagname) {

			break

		}

		if strings.ToLower(string(tag[i]))[0] != tagname[j] {

			return false, -1

		}

	}

	if i == len(tag) {

		return false, -1

	}

	rightAngle := skipUntilCharIgnoreQuotes(tag, i, '>')

	if rightAngle >= i {

		return true, rightAngle

	}

	return false, -1

}

func skipSpace(tag []byte, i int) int {

	for i < len(tag) && isspace(tag[i]) {

		i++

	}

	return i

}

func isRelativeLink(link []byte) (yes bool) {

	// a tag begin with '#'

	if link[0] == '#' {

		return true

	}

	// link begin with '/' but not '//', the second maybe a protocol relative link

	if len(link) >= 2 && link[0] == '/' && link[1] != '/' {

		return true

	}

	// only the root '/'

	if len(link) == 1 && link[0] == '/' {

		return true

	}

	// current directory : begin with "./"

	if bytes.HasPrefix(link, []byte("./")) {

		return true

	}

	// parent directory : begin with "../"

	if bytes.HasPrefix(link, []byte("../")) {

		return true

	}

	return false

}

func (r *HTMLRenderer) ensureUniqueHeadingID(id string) string {

	for count, found := r.headingIDs[id]; found; count, found = r.headingIDs[id] {

		tmp := fmt.Sprintf("%s-%d", id, count+1)

		if _, tmpFound := r.headingIDs[tmp]; !tmpFound {

			r.headingIDs[id] = count + 1

			id = tmp

		} else {

			id = id + "-1"

		}

	}

	if _, found := r.headingIDs[id]; !found {

		r.headingIDs[id] = 0

	}

	return id

}

func (r *HTMLRenderer) addAbsPrefix(link []byte) []byte {

	if r.AbsolutePrefix != "" && isRelativeLink(link) && link[0] != '.' {

		newDest := r.AbsolutePrefix

		if link[0] != '/' {

			newDest += "/"

		}

		newDest += string(link)

		return []byte(newDest)

	}

	return link

}

func appendLinkAttrs(attrs []string, flags HTMLFlags, link []byte) []string {

	if isRelativeLink(link) {

		return attrs

	}

	val := []string{}

	if flags&NofollowLinks != 0 {

		val = append(val, "nofollow")

	}

	if flags&NoreferrerLinks != 0 {

		val = append(val, "noreferrer")

	}

	if flags&NoopenerLinks != 0 {

		val = append(val, "noopener")

	}

	if flags&HrefTargetBlank != 0 {

		attrs = append(attrs, "target=\"_blank\"")

	}

	if len(val) == 0 {

		return attrs

	}

	attr := fmt.Sprintf("rel=%q", strings.Join(val, " "))

	return append(attrs, attr)

}

func isMailto(link []byte) bool {

	return bytes.HasPrefix(link, []byte("mailto:"))

}

func needSkipLink(flags HTMLFlags, dest []byte) bool {

	if flags&SkipLinks != 0 {

		return true

	}

	return flags&Safelink != 0 && !isSafeLink(dest) && !isMailto(dest)

}

func isSmartypantable(node *Node) bool {

	pt := node.Parent.Type

	return pt != Link && pt != CodeBlock && pt != Code

}

func appendLanguageAttr(attrs []string, info []byte) []string {

	if len(info) == 0 {

		return attrs

	}

	endOfLang := bytes.IndexAny(info, "\t ")

	if endOfLang < 0 {

		endOfLang = len(info)

	}

	return append(attrs, fmt.Sprintf("class=\"language-%s\"", info[:endOfLang]))

}

func (r *HTMLRenderer) tag(w io.Writer, name []byte, attrs []string) {

	w.Write(name)

	if len(attrs) > 0 {

		w.Write(spaceBytes)

		w.Write([]byte(strings.Join(attrs, " ")))

	}

	w.Write(gtBytes)

	r.lastOutputLen = 1

}

func footnoteRef(prefix string, node *Node) []byte {

	urlFrag := prefix + string(slugify(node.Destination))

	anchor := fmt.Sprintf(`<a href="#fn:%s">%d</a>`, urlFrag, node.NoteID)

	return []byte(fmt.Sprintf(`<sup class="footnote-ref" id="fnref:%s">%s</sup>`, urlFrag, anchor))

}

func footnoteItem(prefix string, slug []byte) []byte {

	return []byte(fmt.Sprintf(`<li id="fn:%s%s">`, prefix, slug))

}

func footnoteReturnLink(prefix, returnLink string, slug []byte) []byte {

	const format = ` <a class="footnote-return" href="#fnref:%s%s">%s</a>`

	return []byte(fmt.Sprintf(format, prefix, slug, returnLink))

}

func itemOpenCR(node *Node) bool {

	if node.Prev == nil {

		return false

	}

	ld := node.Parent.ListData

	return !ld.Tight && ld.ListFlags&ListTypeDefinition == 0

}

func skipParagraphTags(node *Node) bool {

	grandparent := node.Parent.Parent

	if grandparent == nil || grandparent.Type != List {

		return false

	}

	tightOrTerm := grandparent.Tight || node.Parent.ListFlags&ListTypeTerm != 0

	return grandparent.Type == List && tightOrTerm

}

func cellAlignment(align CellAlignFlags) string {

	switch align {

	case TableAlignmentLeft:

		return "left"

	case TableAlignmentRight:

		return "right"

	case TableAlignmentCenter:

		return "center"

	default:

		return ""

	}

}

func (r *HTMLRenderer) out(w io.Writer, text []byte) {

	if r.disableTags > 0 {

		w.Write(htmlTagRe.ReplaceAll(text, []byte{}))

	} else {

		w.Write(text)

	}

	r.lastOutputLen = len(text)

}

func (r *HTMLRenderer) cr(w io.Writer) {

	if r.lastOutputLen > 0 {

		r.out(w, nlBytes)

	}

}

var (

	nlBytes    = []byte{'\n'}

	gtBytes    = []byte{'>'}

	spaceBytes = []byte{' '}

)

var (

	brTag              = []byte("<br>")

	brXHTMLTag         = []byte("<br />")

	emTag              = []byte("<em>")

	emCloseTag         = []byte("</em>")

	strongTag          = []byte("<strong>")