//

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

//

//

// Functions to parse inline elements.

//

package blackfriday

import (

	"bytes"

	"regexp"

	"strconv"

)

var (

	urlRe    = `((https?|ftp):\/\/|\/)[-A-Za-z0-9+&@#\/%?=~_|!:,.;\(\)]+`

	anchorRe = regexp.MustCompile(`^(<a\shref="` + urlRe + `"(\stitle="[^"<>]+")?\s?>` + urlRe + `<\/a>)`)

	// https://www.w3.org/TR/html5/syntax.html#character-references

	// highest unicode code point in 17 planes (2^20): 1,114,112d =

	// 7 dec digits or 6 hex digits

	// named entity references can be 2-31 characters with stuff like <

	// at one end and &CounterClockwiseContourIntegral; at the other. There

	// are also sometimes numbers at the end, although this isn't inherent

	// in the specification; there are never numbers anywhere else in

	// current character references, though; see ¾ and ▒, etc.

	// https://www.w3.org/TR/html5/syntax.html#named-character-references

	//

	// entity := "&" (named group | number ref) ";"

	// named group := [a-zA-Z]{2,31}[0-9]{0,2}

	// number ref := "#" (dec ref | hex ref)

	// dec ref := [0-9]{1,7}

	// hex ref := ("x" | "X") [0-9a-fA-F]{1,6}

	htmlEntityRe = regexp.MustCompile(`&([a-zA-Z]{2,31}[0-9]{0,2}|#([0-9]{1,7}|[xX][0-9a-fA-F]{1,6}));`)

)

// Functions to parse text within a block

// Each function returns the number of chars taken care of

// data is the complete block being rendered

// offset is the number of valid chars before the current cursor

func (p *Markdown) inline(currBlock *Node, data []byte) {

	// handlers might call us recursively: enforce a maximum depth

	if p.nesting >= p.maxNesting || len(data) == 0 {

		return

	}

	p.nesting++

	beg, end := 0, 0

	for end < len(data) {

		handler := p.inlineCallback[data[end]]

		if handler != nil {

			if consumed, node := handler(p, data, end); consumed == 0 {

				// No action from the callback.

				end++

			} else {

				// Copy inactive chars into the output.

				currBlock.AppendChild(text(data[beg:end]))

				if node != nil {

					currBlock.AppendChild(node)

				}

				// Skip past whatever the callback used.

				beg = end + consumed

				end = beg

			}

		} else {

			end++

		}

	}

	if beg < len(data) {

		if data[end-1] == '\n' {

			end--

		}

		currBlock.AppendChild(text(data[beg:end]))

	}

	p.nesting--

}

// single and double emphasis parsing

func emphasis(p *Markdown, data []byte, offset int) (int, *Node) {

	data = data[offset:]

	c := data[0]

	if len(data) > 2 && data[1] != c {

		// whitespace cannot follow an opening emphasis;

		// strikethrough only takes two characters '~~'

		if c == '~' || isspace(data[1]) {

			return 0, nil

		}

		ret, node := helperEmphasis(p, data[1:], c)

		if ret == 0 {

			return 0, nil

		}

		return ret + 1, node

	}

	if len(data) > 3 && data[1] == c && data[2] != c {

		if isspace(data[2]) {

			return 0, nil

		}

		ret, node := helperDoubleEmphasis(p, data[2:], c)

		if ret == 0 {

			return 0, nil

		}

		return ret + 2, node

	}

	if len(data) > 4 && data[1] == c && data[2] == c && data[3] != c {

		if c == '~' || isspace(data[3]) {

			return 0, nil

		}

		ret, node := helperTripleEmphasis(p, data, 3, c)

		if ret == 0 {

			return 0, nil

		}

		return ret + 3, node

	}

	return 0, nil

}

func codeSpan(p *Markdown, data []byte, offset int) (int, *Node) {

	data = data[offset:]

	nb := 0

	// count the number of backticks in the delimiter

	for nb < len(data) && data[nb] == '`' {

		nb++

	}

	// find the next delimiter

	i, end := 0, 0

	for end = nb; end < len(data) && i < nb; end++ {

		if data[end] == '`' {

			i++

		} else {

			i = 0

		}

	}

	// no matching delimiter?

	if i < nb && end >= len(data) {

		return 0, nil

	}

	// trim outside whitespace

	fBegin := nb

	for fBegin < end && data[fBegin] == ' ' {

		fBegin++

	}

	fEnd := end - nb

	for fEnd > fBegin && data[fEnd-1] == ' ' {

		fEnd--

	}

	// render the code span

	if fBegin != fEnd {

		code := NewNode(Code)

		code.Literal = data[fBegin:fEnd]

		return end, code

	}

	return end, nil

}

// newline preceded by two spaces becomes <br>

func maybeLineBreak(p *Markdown, data []byte, offset int) (int, *Node) {

	origOffset := offset

	for offset < len(data) && data[offset] == ' ' {

		offset++

	}

	if offset < len(data) && data[offset] == '\n' {

		if offset-origOffset >= 2 {

			return offset - origOffset + 1, NewNode(Hardbreak)

		}

		return offset - origOffset, nil

	}

	return 0, nil

}

// newline without two spaces works when HardLineBreak is enabled

func lineBreak(p *Markdown, data []byte, offset int) (int, *Node) {

	if p.extensions&HardLineBreak != 0 {

		return 1, NewNode(Hardbreak)

	}

	return 0, nil

}

type linkType int

const (

	linkNormal linkType = iota

	linkImg

	linkDeferredFootnote

	linkInlineFootnote

)

func isReferenceStyleLink(data []byte, pos int, t linkType) bool {

	if t == linkDeferredFootnote {

		return false

	}

	return pos < len(data)-1 && data[pos] == '[' && data[pos+1] != '^'

}

func maybeImage(p *Markdown, data []byte, offset int) (int, *Node) {

	if offset < len(data)-1 && data[offset+1] == '[' {

		return link(p, data, offset)

	}

	return 0, nil

}

func maybeInlineFootnote(p *Markdown, data []byte, offset int) (int, *Node) {

	if offset < len(data)-1 && data[offset+1] == '[' {

		return link(p, data, offset)

	}

	return 0, nil

}

// '[': parse a link or an image or a footnote

func link(p *Markdown, data []byte, offset int) (int, *Node) {

	// no links allowed inside regular links, footnote, and deferred footnotes

	if p.insideLink && (offset > 0 && data[offset-1] == '[' || len(data)-1 > offset && data[offset+1] == '^') {

		return 0, nil

	}

	var t linkType

	switch {

	// special case: ![^text] == deferred footnote (that follows something with

	// an exclamation point)

	case p.extensions&Footnotes != 0 && len(data)-1 > offset && data[offset+1] == '^':

		t = linkDeferredFootnote

	// ![alt] == image

	case offset >= 0 && data[offset] == '!':

		t = linkImg

		offset++

	// ^[text] == inline footnote

	// [^refId] == deferred footnote

	case p.extensions&Footnotes != 0:

		if offset >= 0 && data[offset] == '^' {

			t = linkInlineFootnote

			offset++

		} else if len(data)-1 > offset && data[offset+1] == '^' {

			t = linkDeferredFootnote

		}

	// [text] == regular link

	default:

		t = linkNormal

	}

	data = data[offset:]

	var (

		i                       = 1

		noteID                  int

		title, link, altContent []byte

		textHasNl               = false

	)

	if t == linkDeferredFootnote {

		i++

	}

	// look for the matching closing bracket

	for level := 1; level > 0 && i < len(data); i++ {

		switch {

		case data[i] == '\n':

			textHasNl = true

			continue

		case data[i] == '[':

			level++

		case data[i] == ']':

			level--

			if level <= 0 {

				i-- // compensate for extra i++ in for loop

			}

		}

	}

	if i >= len(data) {

		return 0, nil

	}

	txtE := i

	i++

	var footnoteNode *Node

	// skip any amount of whitespace or newline

	// (this is much more lax than original markdown syntax)

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

		i++

	}

	// inline style link

	switch {

	case i < len(data) && data[i] == '(':

		// skip initial whitespace

		i++

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

			i++

		}

		linkB := i

		// look for link end: ' " )

	findlinkend:

		for i < len(data) {

			switch {

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

				i += 2

			case data[i] == ')' || data[i] == '\'' || data[i] == '"':

				break findlinkend

			default:

				i++

			}

		}

		if i >= len(data) {

			return 0, nil

		}

		linkE := i

		// look for title end if present

		titleB, titleE := 0, 0

		if data[i] == '\'' || data[i] == '"' {

			i++

			titleB = i

		findtitleend:

			for i < len(data) {

				switch {

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

					i += 2

				case data[i] == ')':

					break findtitleend

				default:

					i++

				}

			}

			if i >= len(data) {

				return 0, nil

			}

			// skip whitespace after title

			titleE = i - 1

			for titleE > titleB && isspace(data[titleE]) {

				titleE--

			}

			// check for closing quote presence

			if data[titleE] != '\'' && data[titleE] != '"' {

				titleB, titleE = 0, 0

				linkE = i

			}

		}

		// remove whitespace at the end of the link

		for linkE > linkB && isspace(data[linkE-1]) {

			linkE--

		}

		// remove optional angle brackets around the link

		if data[linkB] == '<' {

			linkB++

		}

		if data[linkE-1] == '>' {

			linkE--

		}

		// build escaped link and title

		if linkE > linkB {

			link = data[linkB:linkE]

		}

		if titleE > titleB {

			title = data[titleB:titleE]

		}

		i++

	// reference style link

	case isReferenceStyleLink(data, i, t):

		var id []byte

		altContentConsidered := false