//

// 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"

	"regexp"

	"strconv"

	"strings"

)

// Html renderer configuration options.

const (

	HTML_SKIP_HTML                 = 1 << iota // skip preformatted HTML blocks

	HTML_SKIP_STYLE                            // skip embedded <style> elements

	HTML_SKIP_IMAGES                           // skip embedded images

	HTML_SKIP_LINKS                            // skip all links

	HTML_SAFELINK                              // only link to trusted protocols

	HTML_NOFOLLOW_LINKS                        // only link with rel="nofollow"

	HTML_NOREFERRER_LINKS                      // only link with rel="noreferrer"

	HTML_HREF_TARGET_BLANK                     // add a blank target

	HTML_TOC                                   // generate a table of contents

	HTML_OMIT_CONTENTS                         // skip the main contents (for a standalone table of contents)

	HTML_COMPLETE_PAGE                         // generate a complete HTML page

	HTML_USE_XHTML                             // generate XHTML output instead of HTML

	HTML_USE_SMARTYPANTS                       // enable smart punctuation substitutions

	HTML_SMARTYPANTS_FRACTIONS                 // enable smart fractions (with HTML_USE_SMARTYPANTS)

	HTML_SMARTYPANTS_DASHES                    // enable smart dashes (with HTML_USE_SMARTYPANTS)

	HTML_SMARTYPANTS_LATEX_DASHES              // enable LaTeX-style dashes (with HTML_USE_SMARTYPANTS and HTML_SMARTYPANTS_DASHES)

	HTML_SMARTYPANTS_ANGLED_QUOTES             // enable angled double quotes (with HTML_USE_SMARTYPANTS) for double quotes rendering

	HTML_SMARTYPANTS_QUOTES_NBSP               // enable "French guillemets" (with HTML_USE_SMARTYPANTS)

	HTML_FOOTNOTE_RETURN_LINKS                 // generate a link at the end of a footnote to return to the source

)

var (

	alignments = []string{

		"left",

		"right",

		"center",

	}

	// TODO: improve this regexp to catch all possible entities:

	htmlEntity = regexp.MustCompile(`&[a-z]{2,5};`)

)

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 Header ID, to ensure

	// uniqueness.

	HeaderIDPrefix string

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

	HeaderIDSuffix string

}

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

//

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

type Html struct {

	flags    int    // HTML_* options

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

	title    string // document title

	css      string // optional css file url (used with HTML_COMPLETE_PAGE)

	parameters HtmlRendererParameters

	// table of contents data

	tocMarker    int

	headerCount  int

	currentLevel int

	toc          *bytes.Buffer

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

	headerIDs map[string]int

	smartypants *smartypantsRenderer

}

const (

	xhtmlClose = " />"

	htmlClose  = ">"

)

// HtmlRenderer creates and configures an Html object, which

// satisfies the Renderer interface.

//

// flags is a set of HTML_* options ORed together.

// title is the title of the document, and css is a URL for the document's

// stylesheet.

// title and css are only used when HTML_COMPLETE_PAGE is selected.

func HtmlRenderer(flags int, title string, css string) Renderer {

	return HtmlRendererWithParameters(flags, title, css, HtmlRendererParameters{})

}

func HtmlRendererWithParameters(flags int, title string,

	css string, renderParameters HtmlRendererParameters) Renderer {

	// configure the rendering engine

	closeTag := htmlClose

	if flags&HTML_USE_XHTML != 0 {

		closeTag = xhtmlClose

	}

	if renderParameters.FootnoteReturnLinkContents == "" {

		renderParameters.FootnoteReturnLinkContents = `<sup>[return]</sup>`

	}

	return &Html{

		flags:      flags,

		closeTag:   closeTag,

		title:      title,

		css:        css,

		parameters: renderParameters,

		headerCount:  0,

		currentLevel: 0,

		toc:          new(bytes.Buffer),

		headerIDs: make(map[string]int),

		smartypants: smartypants(flags),

	}

}

// Using if statements is a bit faster than a switch statement. As the compiler

// improves, this should be unnecessary this is only worthwhile because

// attrEscape is the single largest CPU user in normal use.

// Also tried using map, but that gave a ~3x slowdown.

func escapeSingleChar(char byte) (string, bool) {

	if char == '"' {

		return """, true

	}

	if char == '&' {

		return "&", true

	}

	if char == '<' {

		return "<", true

	}

	if char == '>' {

		return ">", true

	}

	return "", false

}

func attrEscape(out *bytes.Buffer, src []byte) {

	org := 0

	for i, ch := range src {

		if entity, ok := escapeSingleChar(ch); ok {

			if i > org {

				// copy all the normal characters since the last escape

				out.Write(src[org:i])

			}

			org = i + 1

			out.WriteString(entity)

		}

	}

	if org < len(src) {

		out.Write(src[org:])

	}

}

func entityEscapeWithSkip(out *bytes.Buffer, src []byte, skipRanges [][]int) {

	end := 0

	for _, rang := range skipRanges {

		attrEscape(out, src[end:rang[0]])

		out.Write(src[rang[0]:rang[1]])

		end = rang[1]

	}

	attrEscape(out, src[end:])

}

func (options *Html) GetFlags() int {

	return options.flags

}

func (options *Html) TitleBlock(out *bytes.Buffer, text []byte) {

	text = bytes.TrimPrefix(text, []byte("% "))

	text = bytes.Replace(text, []byte("\n% "), []byte("\n"), -1)

	out.WriteString("<h1 class=\"title\">")

	out.Write(text)

	out.WriteString("\n</h1>")

}

func (options *Html) Header(out *bytes.Buffer, text func() bool, level int, id string) {

	marker := out.Len()

	doubleSpace(out)

	if id == "" && options.flags&HTML_TOC != 0 {

		id = fmt.Sprintf("toc_%d", options.headerCount)

	}

	if id != "" {

		id = options.ensureUniqueHeaderID(id)

		if options.parameters.HeaderIDPrefix != "" {

			id = options.parameters.HeaderIDPrefix + id

		}

		if options.parameters.HeaderIDSuffix != "" {

			id = id + options.parameters.HeaderIDSuffix

		}

		out.WriteString(fmt.Sprintf("<h%d id=\"%s\">", level, id))

	} else {

		out.WriteString(fmt.Sprintf("<h%d>", level))

	}

	tocMarker := out.Len()

	if !text() {

		out.Truncate(marker)

		return

	}

	// are we building a table of contents?

	if options.flags&HTML_TOC != 0 {

		options.TocHeaderWithAnchor(out.Bytes()[tocMarker:], level, id)

	}

	out.WriteString(fmt.Sprintf("</h%d>\n", level))

}

func (options *Html) BlockHtml(out *bytes.Buffer, text []byte) {

	if options.flags&HTML_SKIP_HTML != 0 {

		return

	}

	doubleSpace(out)

	out.Write(text)

	out.WriteByte('\n')

}

func (options *Html) HRule(out *bytes.Buffer) {

	doubleSpace(out)

	out.WriteString("<hr")

	out.WriteString(options.closeTag)

	out.WriteByte('\n')

}

func (options *Html) BlockCode(out *bytes.Buffer, text []byte, info string) {

	doubleSpace(out)

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

	if endOfLang < 0 {

		endOfLang = len(info)

	}

	lang := info[:endOfLang]

	if len(lang) == 0 || lang == "." {

		out.WriteString("<pre><code>")

	} else {

		out.WriteString("<pre><code class=\"language-")

		attrEscape(out, []byte(lang))

		out.WriteString("\">")

	}

	attrEscape(out, text)

	out.WriteString("</code></pre>\n")

}

func (options *Html) BlockQuote(out *bytes.Buffer, text []byte) {

	doubleSpace(out)

	out.WriteString("<blockquote>\n")

	out.Write(text)

	out.WriteString("</blockquote>\n")

}

func (options *Html) Table(out *bytes.Buffer, header []byte, body []byte, columnData []int) {

	doubleSpace(out)

	out.WriteString("<table>\n<thead>\n")

	out.Write(header)

	out.WriteString("</thead>\n\n<tbody>\n")

	out.Write(body)

	out.WriteString("</tbody>\n</table>\n")

}

func (options *Html) TableRow(out *bytes.Buffer, text []byte) {

	doubleSpace(out)

	out.WriteString("<tr>\n")

	out.Write(text)

	out.WriteString("\n</tr>\n")

}

func (options *Html) TableHeaderCell(out *bytes.Buffer, text []byte, align int) {

	doubleSpace(out)

	switch align {

	case TABLE_ALIGNMENT_LEFT:

		out.WriteString("<th align=\"left\">")

	case TABLE_ALIGNMENT_RIGHT:

		out.WriteString("<th align=\"right\">")

	case TABLE_ALIGNMENT_CENTER:

		out.WriteString("<th align=\"center\">")

	default:

		out.WriteString("<th>")

	}

	out.Write(text)

	out.WriteString("</th>")

}

func (options *Html) TableCell(out *bytes.Buffer, text []byte, align int) {

	doubleSpace(out)

	switch align {

	case TABLE_ALIGNMENT_LEFT:

		out.WriteString("<td align=\"left\">")

	case TABLE_ALIGNMENT_RIGHT:

		out.WriteString("<td align=\"right\">")

	case TABLE_ALIGNMENT_CENTER:

		out.WriteString("<td align=\"center\">")

	default:

		out.WriteString("<td>")

	}

	out.Write(text)

	out.WriteString("</td>")

}

func (options *Html) Footnotes(out *bytes.Buffer, text func() bool) {

	out.WriteString("<div class=\"footnotes\">\n")

	options.HRule(out)

	options.List(out, text, LIST_TYPE_ORDERED)

	out.WriteString("</div>\n")

}

func (options *Html) FootnoteItem(out *bytes.Buffer, name, text []byte, flags int) {

	if flags&LIST_ITEM_CONTAINS_BLOCK != 0 || flags&LIST_ITEM_BEGINNING_OF_LIST != 0 {

		doubleSpace(out)

	}

	slug := slugify(name)

	out.WriteString(`<li id="`)

	out.WriteString(`fn:`)

	out.WriteString(options.parameters.FootnoteAnchorPrefix)

	out.Write(slug)

	out.WriteString(`">`)

	out.Write(text)

	if options.flags&HTML_FOOTNOTE_RETURN_LINKS != 0 {

		out.WriteString(` <a class="footnote-return" href="#`)

		out.WriteString(`fnref:`)

		out.WriteString(options.parameters.FootnoteAnchorPrefix)

		out.Write(slug)

		out.WriteString(`">`)

		out.WriteString(options.parameters.FootnoteReturnLinkContents)

		out.WriteString(`</a>`)

	}

	out.WriteString("</li>\n")

}

func (options *Html) List(out *bytes.Buffer, text func() bool, flags int) {

	marker := out.Len()

	doubleSpace(out)

	if flags&LIST_TYPE_DEFINITION != 0 {

		out.WriteString("<dl>")

	} else if flags&LIST_TYPE_ORDERED != 0 {

		out.WriteString("<ol>")

	} else {

		out.WriteString("<ul>")

	}

	if !text() {

		out.Truncate(marker)

		return

	}

	if flags&LIST_TYPE_DEFINITION != 0 {

		out.WriteString("</dl>\n")

	} else if flags&LIST_TYPE_ORDERED != 0 {

		out.WriteString("</ol>\n")

	} else {

		out.WriteString("</ul>\n")

	}

}

func (options *Html) ListItem(out *bytes.Buffer, text []byte, flags int) {

	if (flags&LIST_ITEM_CONTAINS_BLOCK != 0 && flags&LIST_TYPE_DEFINITION == 0) ||

		flags&LIST_ITEM_BEGINNING_OF_LIST != 0 {

		doubleSpace(out)

	}

	if flags&LIST_TYPE_TERM != 0 {

		out.WriteString("<dt>")

	} else if flags&LIST_TYPE_DEFINITION != 0 {

		out.WriteString("<dd>")

	} else {

		out.WriteString("<li>")

	}

	out.Write(text)

	if flags&LIST_TYPE_TERM != 0 {

		out.WriteString("</dt>\n")

	} else if flags&LIST_TYPE_DEFINITION != 0 {

		out.WriteString("</dd>\n")

	} else {

		out.WriteString("</li>\n")

	}

}

func (options *Html) Paragraph(out *bytes.Buffer, text func() bool) {