//

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

)

// Parse block-level data.

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

// the input buffer ends with a 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 {

		//

		// ...

			continue

		}

		// block of preformatted HTML:

		//

		// <div>

		//     ...

		// </div>

		if data[0] == '<' {

				data = data[i:]

				continue

			}

		}

		// title block

		//

		// % stuff

		// % more stuff

		// % even more stuff

			if data[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 {

			continue

		}

		// fenced code block:

		//

		// func fact(n int) int {

		//     if n <= 1 {

		//         return n

		//     }

		//     return n * fact(n-1)

		// }

		// ```

				data = data[i:]

				continue

			}

		}

		// horizontal rule:

		//

		// ------

		// or

		// ******

		// or

		// ______

		if p.isHRule(data) {

			var i int

			}

			data = data[i:]

			continue

		}

		// block quote:

		//

		// > A big quote I found somewhere

		// > on the web

		if p.quotePrefix(data) > 0 {

			continue

		}

		// table:

		//

		// Name  | Age | Phone

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

		// Bob   | 31  | 555-1234

		// Alice | 27  | 555-4321

				data = data[i:]

				continue

			}

		}

		// an itemized/unordered list:

		//

		// * Item 1

		// * Item 2

		//

		// also works with + or -

		if p.uliPrefix(data) > 0 {

			continue

		}

		// a numbered/ordered list:

		//

		// 1. Item 1

		// 2. Item 2

		if p.oliPrefix(data) > 0 {

			continue

		}

		// definition lists:

		//

		// Term 1

		// :   Definition a

		// :   Definition b

		//

		// Term 2

		// :   Definition c

			if p.dliPrefix(data) > 0 {

				continue

			}

		}

		// anything else must look like a normal paragraph

	}

	p.nesting--

}

	if data[0] != '#' {

		return false

	}

		level := 0

			level++

		}

			return false

		}

	}

	return true

}

	level := 0

		level++

	}

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

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

	skip := end

	id := ""

		j, k := 0, 0

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

		}

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

		}

		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 {

		}

	}

	return skip

}

	if data[0] == '=' {

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

		i = skipChar(data, i, ' ')

			return 1

		}

	}

	if data[0] == '-' {

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

		i = skipChar(data, i, ' ')

			return 2

		}

	}

	return 0

}

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

}

	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

			return size

		}

		// check for an <hr> tag

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

		}

	}

	return i

}