//

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

	"strings"

	"unicode"

)

// Parse block-level data.

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

// the input buffer ends with a newline.

func (p *parser) block(out *bytes.Buffer, data []byte) {

	if len(data) == 0 || data[len(data)-1] != '\n' {

		panic("block input is missing terminating newline")

	}

	// 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 header:

		//

		// # Header 1

		// ## Header 2

		// ...

		// ###### Header 6

		if p.isPrefixHeader(data) {

			data = data[p.prefixHeader(out, data):]

			continue

		}

		// block of preformatted HTML:

		//

		// <div>

		//     ...

		// </div>

		if data[0] == '<' {

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

				data = data[i:]

				continue

			}

		}

		// title block

		//

		// % stuff

		// % more stuff

		// % even more stuff

		if p.flags&EXTENSION_TITLEBLOCK != 0 {

			if data[0] == '%' {

				if i := p.titleBlock(out, 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(out, data):]

			continue

		}

		// fenced code block:

		//

		// ``` go info string here

		// func fact(n int) int {

		//     if n <= 1 {

		//         return n

		//     }

		//     return n * fact(n-1)

		// }

		// ```

		if p.flags&EXTENSION_FENCED_CODE != 0 {

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

				data = data[i:]

				continue

			}

		}

		// horizontal rule:

		//

		// ------

		// or

		// ******

		// or

		// ______

		if p.isHRule(data) {

			p.r.HRule(out)

			var i int

			for i = 0; 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(out, data):]

			continue

		}

		// table:

		//

		// Name  | Age | Phone

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

		// Bob   | 31  | 555-1234

		// Alice | 27  | 555-4321

		if p.flags&EXTENSION_TABLES != 0 {

			if i := p.table(out, 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(out, data, 0):]

			continue

		}

		// a numbered/ordered list:

		//

		// 1. Item 1

		// 2. Item 2

		if p.oliPrefix(data) > 0 {

			data = data[p.list(out, data, LIST_TYPE_ORDERED):]

			continue

		}

		// definition lists:

		//

		// Term 1

		// :   Definition a

		// :   Definition b

		//

		// Term 2

		// :   Definition c

		if p.flags&EXTENSION_DEFINITION_LISTS != 0 {

			if p.dliPrefix(data) > 0 {

				data = data[p.list(out, data, LIST_TYPE_DEFINITION):]

				continue

			}

		}

		// anything else must look like a normal paragraph

		// note: this finds underlined headers, too

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

	}

	p.nesting--

}

func (p *parser) isPrefixHeader(data []byte) bool {

	if data[0] != '#' {

		return false

	}

	if p.flags&EXTENSION_SPACE_HEADERS != 0 {

		level := 0

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

			level++

		}

		if data[level] != ' ' {

			return false

		}

	}

	return true

}

func (p *parser) prefixHeader(out *bytes.Buffer, data []byte) int {

	level := 0

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

		level++

	}

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

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

	skip := end

	id := ""

	if p.flags&EXTENSION_HEADER_IDS != 0 {

		j, k := 0, 0

		// find start/end of header id

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

		}

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

		}

		// extract header 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.flags&EXTENSION_AUTO_HEADER_IDS != 0 {

			id = SanitizedAnchorName(string(data[i:end]))

		}

		work := func() bool {

			p.inline(out, data[i:end])

			return true

		}

		p.r.Header(out, work, level, id)

	}

	return skip

}

func (p *parser) isUnderlinedHeader(data []byte) int {

	// test of level 1 header

	if data[0] == '=' {

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

		i = skipChar(data, i, ' ')

		if data[i] == '\n' {

			return 1

		} else {

			return 0

		}

	}

	// test of level 2 header

	if data[0] == '-' {

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

		i = skipChar(data, i, ' ')

		if data[i] == '\n' {

			return 2

		} else {

			return 0

		}

	}

	return 0

}

func (p *parser) titleBlock(out *bytes.Buffer, 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"))

	p.r.TitleBlock(out, data)

	return len(data)

}

func (p *parser) html(out *bytes.Buffer, 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(out, data, doRender); size > 0 {

			return size

		}

		// check for an <hr> tag

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

			return size

		}

		// check for HTML CDATA

		if size := p.htmlCDATA(out, 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--

		}

		p.r.BlockHtml(out, data[:end])

	}

	return i

}

func (p *parser) renderHTMLBlock(out *bytes.Buffer, data []byte, start int, doRender bool) int {

	// html block needs to end with a blank line

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

		size := start + i

		if doRender {

			// trim trailing newlines

			end := size

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

				end--

			}

			p.r.BlockHtml(out, data[:end])

		}

		return size

	}

	return 0

}

// HTML comment, lax form

func (p *parser) htmlComment(out *bytes.Buffer, data []byte, doRender bool) int {

	i := p.inlineHTMLComment(out, data)