//

// 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 block-level elements.

//

package blackfriday

import (

	"bytes"

	"html"

	"regexp"

	"strings"

)

const (

	charEntity = "&(?:#x[a-f0-9]{1,8}|#[0-9]{1,8}|[a-z][a-z0-9]{1,31});"

	escapable  = "[!\"#$%&'()*+,./:;<=>?@[\\\\\\]^_`{|}~-]"

)

var (

	reBackslashOrAmp      = regexp.MustCompile("[\\&]")

	reEntityOrEscapedChar = regexp.MustCompile("(?i)\\\\" + escapable + "|" + charEntity)

)

// Parse block-level data.

// Note: this function and many that it calls assume that

// the input buffer ends with a newline.

func (p *Markdown) block(data []byte) {

	// this is called recursively: enforce a maximum depth

	if p.nesting >= p.maxNesting {

		return

	}

	p.nesting++

	// parse out one block-level construct at a time

	for len(data) > 0 {

		// prefixed heading:

		//

		// # Heading 1

		// ## Heading 2

		// ...

		// ###### Heading 6

		if p.isPrefixHeading(data) {

			data = data[p.prefixHeading(data):]

			continue

		}

		// block of preformatted HTML:

		//

		// <div>

		//     ...

		// </div>

		if data[0] == '<' {

			if i := p.html(data, true); i > 0 {

				data = data[i:]

				continue

			}

		}

		// title block

		//

		// % stuff

		// % more stuff

		// % even more stuff

		if p.extensions&Titleblock != 0 {

			if data[0] == '%' {

				if i := p.titleBlock(data, true); i > 0 {

					data = data[i:]

					continue

				}

			}

		}

		// blank lines.  note: returns the # of bytes to skip

		if i := p.isEmpty(data); i > 0 {

			data = data[i:]

			continue

		}

		// indented code block:

		//

		//     func max(a, b int) int {

		//         if a > b {

		//             return a

		//         }

		//         return b

		//      }

		if p.codePrefix(data) > 0 {

			data = data[p.code(data):]

			continue

		}

		// fenced code block:

		//

		// ``` go

		// func fact(n int) int {

		//     if n <= 1 {

		//         return n

		//     }

		//     return n * fact(n-1)

		// }

		// ```

		if p.extensions&FencedCode != 0 {

			if i := p.fencedCodeBlock(data, true); i > 0 {

				data = data[i:]

				continue

			}

		}

		// horizontal rule:

		//

		// ------

		// or

		// ******

		// or

		// ______

		if p.isHRule(data) {

			p.addBlock(HorizontalRule, nil)

			var i int

			for i = 0; i < len(data) && data[i] != '\n'; i++ {

			}

			data = data[i:]

			continue

		}

		// block quote:

		//

		// > A big quote I found somewhere

		// > on the web

		if p.quotePrefix(data) > 0 {

			data = data[p.quote(data):]

			continue

		}

		// table:

		//

		// Name  | Age | Phone

		// ------|-----|---------

		// Bob   | 31  | 555-1234

		// Alice | 27  | 555-4321

		if p.extensions&Tables != 0 {

			if i := p.table(data); i > 0 {

				data = data[i:]

				continue

			}

		}

		// an itemized/unordered list:

		//

		// * Item 1

		// * Item 2

		//

		// also works with + or -

		if p.uliPrefix(data) > 0 {

			data = data[p.list(data, 0):]

			continue

		}

		// a numbered/ordered list:

		//

		// 1. Item 1

		// 2. Item 2

		if p.oliPrefix(data) > 0 {

			data = data[p.list(data, ListTypeOrdered):]

			continue

		}

		// definition lists:

		//

		// Term 1

		// :   Definition a

		// :   Definition b

		//

		// Term 2

		// :   Definition c

		if p.extensions&DefinitionLists != 0 {

			if p.dliPrefix(data) > 0 {

				data = data[p.list(data, ListTypeDefinition):]

				continue

			}

		}

		// anything else must look like a normal paragraph

		// note: this finds underlined headings, too

		data = data[p.paragraph(data):]

	}

	p.nesting--

}

func (p *Markdown) addBlock(typ NodeType, content []byte) *Node {

	p.closeUnmatchedBlocks()

	container := p.addChild(typ, 0)

	container.content = content

	return container

}

func (p *Markdown) isPrefixHeading(data []byte) bool {

	if data[0] != '#' {

		return false

	}

	if p.extensions&SpaceHeadings != 0 {

		level := 0

		for level < 6 && level < len(data) && data[level] == '#' {

			level++

		}

		if level == len(data) || data[level] != ' ' {

			return false

		}

	}

	return true

}

func (p *Markdown) prefixHeading(data []byte) int {

	level := 0

	for level < 6 && level < len(data) && data[level] == '#' {

		level++

	}

	i := skipChar(data, level, ' ')

	end := skipUntilChar(data, i, '\n')

	skip := end

	id := ""

	if p.extensions&HeadingIDs != 0 {

		j, k := 0, 0

		// find start/end of heading id

		for j = i; j < end-1 && (data[j] != '{' || data[j+1] != '#'); j++ {

		}

		for k = j + 1; k < end && data[k] != '}'; k++ {

		}

		// extract heading id iff found

		if j < end && k < end {

			id = string(data[j+2 : k])

			end = j

			skip = k + 1

			for end > 0 && data[end-1] == ' ' {

				end--

			}

		}

	}

	for end > 0 && data[end-1] == '#' {

		if isBackslashEscaped(data, end-1) {

			break

		}

		end--

	}

	for end > 0 && data[end-1] == ' ' {

		end--

	}

	if end > i {

		if id == "" && p.extensions&AutoHeadingIDs != 0 {

		}

		block := p.addBlock(Heading, data[i:end])

		block.HeadingID = id

		block.Level = level

	}

	return skip

}

func (p *Markdown) isUnderlinedHeading(data []byte) int {

	// test of level 1 heading

	if data[0] == '=' {

		i := skipChar(data, 1, '=')

		i = skipChar(data, i, ' ')

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

			return 1

		}

		return 0

	}

	// test of level 2 heading

	if data[0] == '-' {

		i := skipChar(data, 1, '-')

		i = skipChar(data, i, ' ')

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

			return 2

		}

		return 0

	}

	return 0

}

func (p *Markdown) titleBlock(data []byte, doRender bool) int {

	if data[0] != '%' {

		return 0

	}

	splitData := bytes.Split(data, []byte("\n"))

	var i int

	for idx, b := range splitData {

		if !bytes.HasPrefix(b, []byte("%")) {

			i = idx // - 1

			break

		}

	}

	data = bytes.Join(splitData[0:i], []byte("\n"))

	consumed := len(data)

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

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

	block := p.addBlock(Heading, data)

	block.Level = 1

	block.IsTitleblock = true

	return consumed

}

func (p *Markdown) html(data []byte, doRender bool) int {

	var i, j int

	// identify the opening tag

	if data[0] != '<' {

		return 0

	}

	curtag, tagfound := p.htmlFindTag(data[1:])

	// handle special cases

	if !tagfound {

		// check for an HTML comment

		if size := p.htmlComment(data, doRender); size > 0 {

			return size

		}

		// check for an <hr> tag

		if size := p.htmlHr(data, doRender); size > 0 {

			return size

		}

		// no special case recognized

		return 0

	}

	// look for an unindented matching closing tag

	// followed by a blank line

	found := false

	/*

		closetag := []byte("\n</" + curtag + ">")

		j = len(curtag) + 1

		for !found {

			// scan for a closing tag at the beginning of a line

			if skip := bytes.Index(data[j:], closetag); skip >= 0 {

				j += skip + len(closetag)

			} else {

				break

			}

			// see if it is the only thing on the line

			if skip := p.isEmpty(data[j:]); skip > 0 {

				// see if it is followed by a blank line/eof

				j += skip

				if j >= len(data) {

					found = true

					i = j

				} else {

					if skip := p.isEmpty(data[j:]); skip > 0 {

						j += skip

						found = true

						i = j

					}

				}

			}

		}

	*/

	// if not found, try a second pass looking for indented match

	// but not if tag is "ins" or "del" (following original Markdown.pl)

	if !found && curtag != "ins" && curtag != "del" {

		i = 1

		for i < len(data) {

			i++

			for i < len(data) && !(data[i-1] == '<' && data[i] == '/') {

				i++

			}

			if i+2+len(curtag) >= len(data) {

				break

			}

			j = p.htmlFindEnd(curtag, data[i-1:])

			if j > 0 {

				i += j - 1

				found = true

				break

			}

		}

	}

	if !found {

		return 0

	}

	// the end of the block has been found

	if doRender {

		// trim newlines

		end := i

		for end > 0 && data[end-1] == '\n' {

			end--

		}

		finalizeHTMLBlock(p.addBlock(HTMLBlock, data[:end]))

	}

	return i

}

func finalizeHTMLBlock(block *Node) {

	block.Literal = block.content