package main

import (
	"strings"
	"unicode"

	"golang.org/x/text/width"
)

const (
	terminalMarkdownBold = 1 << iota
	terminalMarkdownDim
	terminalMarkdownItalic
	terminalMarkdownReverse
)

// TerminalMarkdownGlyph holds a character, its display width, and its style.
type TerminalMarkdownGlyph struct {
	char    rune
	columns int
	style   int
}

// terminalMarkdown renders Markdown as lines with terminal styles. Width is in
// display columns, with a default of 80. Styles end at each line boundary.
func terminalMarkdown(text string, columns int) []string {
	if columns <= 0 {
		columns = 80
	}

	lines := strings.Split(text, "\n")

	var out []string

	for index := 0; index < len(lines); index++ {
		line := lines[index]
		_, fence := markdownCodeFence(line)
		end := markdownClosingFence(lines, index, fence)
		heading := markdownHeadingText(line)
		switch {
		case end > index:
			for _, code := range lines[index+1 : end] {
				out = append(out, terminalMarkdownLines(terminalMarkdownPlain(code, terminalMarkdownDim), columns, "  ", true)...)
			}

			index = end
		case strings.TrimSpace(line) == "---":
			out = append(out, "\x1b[2m"+strings.Repeat("-", columns)+"\x1b[0m")
		case index+1 < len(lines) && terminalMarkdownSeparator(lines[index+1]) && len(terminalMarkdownCells(line)) > 1:
			rows := [][]string{terminalMarkdownCells(line)}
			index += 2
			for index < len(lines) && strings.Contains(lines[index], "|") && strings.TrimSpace(lines[index]) != "" {
				rows = append(rows, terminalMarkdownCells(lines[index]))
				index++
			}

			index--
			out = append(out, terminalMarkdownTable(rows, columns)...)
		case heading != "":
			out = append(out, terminalMarkdownLines(terminalMarkdownInline(heading, terminalMarkdownBold), columns, "", false)...)
		default:
			prefix, content := terminalMarkdownPrefix(line)
			out = append(out, terminalMarkdownLines(terminalMarkdownInline(content, 0), columns, prefix, false)...)
		}
	}

	return out
}

// terminalMarkdownLines wraps glyphs with a hanging prefix. Literal lines keep
// their spaces. When a prefix leaves no text column, a list mark gets its own
// line and a quote uses a bar without a space or indent. A quote bar and one
// glyph, or a complete list mark, can exceed a narrower width rather than lose
// text. A wide character stays whole.
func terminalMarkdownLines(glyphs []TerminalMarkdownGlyph, columns int, prefix string, literal bool) []string {
	var out []string

	if len(prefix) >= columns {
		switch {
		case literal:
			prefix = ""
		case strings.Contains(prefix, "|"):
			prefix = "|"
		default:
			out = append(out, strings.TrimSpace(prefix))
			prefix = ""
		}
	}

	available := max(1, columns-len(prefix))

	parts := terminalMarkdownWrap(glyphs, available, literal)

	for index, part := range parts {
		mark := prefix
		if index > 0 && !literal && !strings.Contains(prefix, "|") {
			mark = strings.Repeat(" ", len(prefix))
		}

		out = append(out, mark+terminalMarkdownSGR(part))
	}

	return out
}

// terminalMarkdownPlain makes display glyphs without reading inline marks.
// Control characters cannot insert terminal commands. Combining marks take no
// column and East Asian wide and fullwidth characters take two.
func terminalMarkdownPlain(text string, style int) []TerminalMarkdownGlyph {
	var glyphs []TerminalMarkdownGlyph

	for _, char := range strings.ReplaceAll(text, "\t", "    ") {
		if unicode.IsControl(char) {
			continue
		}

		columns := 1
		switch {
		case unicode.Is(unicode.Mn, char) || unicode.Is(unicode.Me, char) || char == '\u200d':
			columns = 0
		case width.LookupRune(char).Kind() == width.EastAsianWide || width.LookupRune(char).Kind() == width.EastAsianFullwidth:
			columns = 2
		}

		glyphs = append(glyphs, TerminalMarkdownGlyph{
			char:    char,
			columns: columns,
			style:   style,
		})
	}

	return glyphs
}

// terminalMarkdownSeparator tells if a line is a Markdown table separator.
func terminalMarkdownSeparator(line string) bool {
	cells := terminalMarkdownCells(line)
	if len(cells) < 2 {
		return false
	}

	for _, cell := range cells {
		cell = strings.Trim(cell, ":")
		if len(cell) < 3 || strings.Trim(cell, "-") != "" {
			return false
		}
	}

	return true
}

// terminalMarkdownCells splits a row outside code spans and escaped pipes.
func terminalMarkdownCells(line string) []string {
	line = strings.TrimSpace(line)
	line = strings.TrimPrefix(line, "|")
	if strings.HasSuffix(line, "|") && !strings.HasSuffix(line, "\\|") {
		line = strings.TrimSuffix(line, "|")
	}

	var cells []string

	start := 0
	for index := 0; index < len(line); index++ {
		switch line[index] {
		case '\\':
			index++
		case '`':
			span, found := markdownCodeSpan(line, index)
			if found {
				index = span.end - 1
			}
		case '|':
			cells = append(cells, strings.TrimSpace(line[start:index]))
			start = index + 1
		}
	}

	return append(cells, strings.TrimSpace(line[start:]))
}

// terminalMarkdownTable fits columns to the available width and wraps cells.
// When the separators and one glyph per column cannot fit, cells stack in row
// order.
func terminalMarkdownTable(rows [][]string, columns int) []string {
	count := len(rows[0])

	sizes := make([]int, count)

	minimum := make([]int, count)
	cells := make([][][]TerminalMarkdownGlyph, len(rows))
	for row, values := range rows {
		cells[row] = make([][]TerminalMarkdownGlyph, count)
		for column := range count {
			value := ""
			if column < len(values) {
				value = values[column]
			}

			style := 0
			if row == 0 {
				style = terminalMarkdownBold
			}

			cells[row][column] = terminalMarkdownInline(value, style)

			sizes[column] = max(sizes[column], terminalMarkdownColumns(cells[row][column]), 1)
			minimum[column] = max(minimum[column], 1)
			for _, glyph := range cells[row][column] {
				minimum[column] = max(minimum[column], glyph.columns)
			}
		}
	}

	required := (count - 1) * 3
	for _, size := range minimum {
		required += size
	}

	if required > columns {
		var out []string

		for _, row := range cells {
			for _, cell := range row {
				out = append(out, terminalMarkdownLines(cell, columns, "", false)...)
			}
		}

		return out
	}

	budget := columns - (count-1)*3
	for {
		total, largest := 0, 0
		for column, size := range sizes {
			total += size
			if size > minimum[column] && (sizes[largest] == minimum[largest] || size > sizes[largest]) {
				largest = column
			}
		}

		if total <= budget {
			break
		}

		sizes[largest]--
	}

	var out []string

	for row, values := range cells {
		wrapped := make([][][]TerminalMarkdownGlyph, count)
		height := 1
		for column, value := range values {
			wrapped[column] = terminalMarkdownWrap(value, sizes[column], false)
			height = max(height, len(wrapped[column]))
		}

		for line := range height {
			parts := make([]string, count)
			for column := range count {
				var glyphs []TerminalMarkdownGlyph

				if line < len(wrapped[column]) {
					glyphs = wrapped[column][line]
				}

				parts[column] = terminalMarkdownSGR(glyphs) + strings.Repeat(" ", sizes[column]-terminalMarkdownColumns(glyphs))
			}

			out = append(out, strings.Join(parts, " | "))
		}

		if row == 0 {
			rules := make([]string, count)
			for column, size := range sizes {
				rules[column] = strings.Repeat("-", size)
			}

			out = append(out, "\x1b[2m"+strings.Join(rules, "-+-")+"\x1b[0m")
		}
	}

	return out
}

// terminalMarkdownInline uses the shared marks, so unclosed marks stay as text.
// Strikethrough stays as text because the terminal styles exclude it.
func terminalMarkdownInline(line string, style int) []TerminalMarkdownGlyph {
	var out []TerminalMarkdownGlyph

	for index := 0; index < len(line); {
		if line[index] == '\\' && index+1 < len(line) && strings.IndexByte(markdownPunctuation, line[index+1]) >= 0 {
			out = append(out, terminalMarkdownPlain(line[index+1:index+2], style)...)
			index += 2

			continue
		}

		span, found := markdownMarkSpan(line, index)
		if !found || span.kind == "strikethrough" {
			end := index + 1
			for end < len(line) && !strings.ContainsRune("\\`[*_~", rune(line[end])) {
				end++
			}

			out = append(out, terminalMarkdownPlain(line[index:end], style)...)
			index = end

			continue
		}

		mark := 0
		switch span.kind {
		case "bold":
			mark = terminalMarkdownBold
		case "italic":
			mark = terminalMarkdownItalic
		case "code":
			mark = terminalMarkdownReverse
		}

		var content []TerminalMarkdownGlyph

		if span.kind == "code" {
			content = terminalMarkdownPlain(span.content, style|mark)
		} else {
			content = terminalMarkdownInline(span.content, style|mark)
		}

		out = append(out, content...)
		if span.kind == "text_link" && terminalMarkdownGlyphText(content) != span.url {
			out = append(out, terminalMarkdownPlain(" ("+span.url+")", style)...)
		}

		index = span.end
	}

	return out
}

// terminalMarkdownPrefix returns the hanging mark of a quote or a list item.
func terminalMarkdownPrefix(line string) (string, string) {
	trimmed := strings.TrimLeft(line, " ")
	indent := line[:len(line)-len(trimmed)]
	if strings.HasPrefix(trimmed, ">") {
		return indent + "| ", strings.TrimPrefix(strings.TrimPrefix(trimmed, ">"), " ")
	}

	if len(trimmed) > 1 && strings.ContainsRune("-*+", rune(trimmed[0])) && trimmed[1] == ' ' {
		return indent + "- ", trimmed[2:]
	}

	digits := 0
	for digits < len(trimmed) && trimmed[digits] >= '0' && trimmed[digits] <= '9' {
		digits++
	}

	if digits > 0 && digits+1 < len(trimmed) && strings.ContainsRune(".)", rune(trimmed[digits])) && trimmed[digits+1] == ' ' {
		return indent + trimmed[:digits+2], trimmed[digits+2:]
	}

	return "", line
}

// terminalMarkdownWrap splits at spaces when possible and otherwise at glyph
// boundaries. It always makes progress, even for a single wide glyph.
func terminalMarkdownWrap(glyphs []TerminalMarkdownGlyph, columns int, literal bool) [][]TerminalMarkdownGlyph {
	var out [][]TerminalMarkdownGlyph

	for len(glyphs) > 0 {
		end, used, space := 0, 0, -1
		for end < len(glyphs) && (used+glyphs[end].columns <= columns || end == 0) {
			if glyphs[end].char == ' ' {
				space = end
			}

			used += glyphs[end].columns
			end++
		}

		next := end
		if !literal && end < len(glyphs) && glyphs[end].char != ' ' && space > 0 {
			end = space
			next = space + 1
		}

		out = append(out, glyphs[:end])
		glyphs = glyphs[next:]
		if !literal {
			for len(glyphs) > 0 && glyphs[0].char == ' ' {
				glyphs = glyphs[1:]
			}
		}
	}

	if len(out) == 0 {
		out = append(out, nil)
	}

	return out
}

// terminalMarkdownSGR writes only the selected SGR styles and a final reset.
func terminalMarkdownSGR(glyphs []TerminalMarkdownGlyph) string {
	var out strings.Builder

	style := 0
	for _, glyph := range glyphs {
		if glyph.style != style {
			if style != 0 {
				out.WriteString("\x1b[0m")
			}

			for bit, code := range []string{"1", "2", "3", "7"} {
				if glyph.style&(1<<bit) != 0 {
					out.WriteString("\x1b[" + code + "m")
				}
			}

			style = glyph.style
		}

		out.WriteRune(glyph.char)
	}

	if style != 0 {
		out.WriteString("\x1b[0m")
	}

	return out.String()
}

// terminalMarkdownColumns returns the display width without SGR commands.
func terminalMarkdownColumns(glyphs []TerminalMarkdownGlyph) int {
	columns := 0
	for _, glyph := range glyphs {
		columns += glyph.columns
	}

	return columns
}

// terminalMarkdownGlyphText returns the text without its styles.
func terminalMarkdownGlyphText(glyphs []TerminalMarkdownGlyph) string {
	var out strings.Builder

	for _, glyph := range glyphs {
		out.WriteRune(glyph.char)
	}

	return out.String()
}