package editor

import (
	"regexp"
	"strings"

	"glint/internal/theme"

	"github.com/charmbracelet/lipgloss"
)

var (
	headingRe    = regexp.MustCompile(`^\s*#{1,6}\s`)
	listRe       = regexp.MustCompile(`^\s*([-*+]|\d+\.)\s`)
	blockquoteRe = regexp.MustCompile(`^\s*>\s?`)
	refDefRe     = regexp.MustCompile(`^\s*\[[^\]]+\]:\s*`) // [ref]: url

	// Git merge-conflict markers, anchored at column 0. Git writes exactly seven
	// marker characters followed by a space and a label (or end of line).
	conflictOursRe   = regexp.MustCompile(`^<{7}( |$)`)  // <<<<<<< HEAD
	conflictBaseRe   = regexp.MustCompile(`^\|{7}( |$)`) // ||||||| base (diff3)
	conflictSepRe    = regexp.MustCompile(`^={7}\s*$`)   // =======
	conflictTheirsRe = regexp.MustCompile(`^>{7}( |$)`)  // >>>>>>> branch
)

// conflictPhase tracks which side of a merge conflict a line falls in.
type conflictPhase int

const (
	conflictNone   conflictPhase = iota
	conflictOurs                 // between <<<<<<< and ||||||| / =======
	conflictBase                 // between ||||||| and ======= (diff3)
	conflictTheirs               // between ======= and >>>>>>>
)

// applyConflictHighlight restyles conflict marker lines and tints the two
// version blocks between them, mutating spans in place. It runs as a post-pass
// over already-scanned spans so it works for both the prose and code scanners.
// Marker characters are only recognized as markers once inside a conflict block
// (opened by <<<<<<<), so a setext ===== underline or a lone ======= elsewhere
// is never mistaken for a separator. The markup-visible invariant is preserved:
// marker lines become one whole-line span, content lines only gain a background.
func applyConflictHighlight(all [][]Span, lines []string, th theme.Theme) {
	if len(all) != len(lines) {
		return
	}
	marker := lipgloss.NewStyle().Foreground(th.ConflictMarker).Bold(true)
	phase := conflictNone
	for i, line := range lines {
		switch {
		case phase == conflictNone && conflictOursRe.MatchString(line):
			phase = conflictOurs
			all[i] = wholeLine(line, marker)
		case phase != conflictNone && conflictBaseRe.MatchString(line):
			phase = conflictBase
			all[i] = wholeLine(line, marker)
		case phase != conflictNone && conflictSepRe.MatchString(line):
			phase = conflictTheirs
			all[i] = wholeLine(line, marker)
		case phase != conflictNone && conflictTheirsRe.MatchString(line):
			phase = conflictNone
			all[i] = wholeLine(line, marker)
		case phase == conflictOurs || phase == conflictBase:
			all[i] = withBackground(all[i], th.ConflictOurs)
		case phase == conflictTheirs:
			all[i] = withBackground(all[i], th.ConflictTheirs)
		}
	}
}

// blockState carries cross-line context (fenced code, leading frontmatter).
type blockState struct {
	inFence         bool
	inFrontmatter   bool
	frontmatterDone bool
}

// ScanLines styles every line, threading block state across lines. The returned
// slice is parallel to the input: out[i] are the spans for lines[i], whose
// concatenated text equals lines[i] exactly (the markup-visible invariant).
//
// Highlighting model: prose stays at Text; all markup punctuation is Muted;
// color is reserved for headings, code, links, list markers, comments, and a
// highlight background; bold/italic render as real styling in the Emphasis tone.
func ScanLines(lines []string, th theme.Theme) [][]Span {
	st := &blockState{}
	out := make([][]Span, len(lines))
	for i, ln := range lines {
		out[i] = scanLine(i, ln, st, th)
	}
	return out
}

func scanLine(row int, line string, st *blockState, th theme.Theme) []Span {
	muted := lipgloss.NewStyle().Foreground(th.Muted)
	code := lipgloss.NewStyle().Foreground(th.Code)
	trimmed := strings.TrimSpace(line)

	// Fenced code block: delimiters muted, body entirely code-colored.
	if st.inFence {
		if strings.HasPrefix(trimmed, "```") {
			st.inFence = false
			return wholeLine(line, muted)
		}
		return wholeLine(line, code)
	}
	if strings.HasPrefix(trimmed, "```") {
		st.inFence = true
		return wholeLine(line, muted)
	}

	// Leading YAML frontmatter: only valid starting at row 0.
	if st.inFrontmatter {
		if trimmed == "---" {
			st.inFrontmatter = false
			st.frontmatterDone = true
			return wholeLine(line, muted)
		}
		return scanFrontmatter(line, th)
	}
	if row == 0 && trimmed == "---" {
		st.inFrontmatter = true
		return wholeLine(line, muted)
	}

	// Comment line: visible, not dimmed.
	if strings.HasPrefix(trimmed, "<!--") || strings.HasPrefix(trimmed, "%%") {
		return wholeLine(line, lipgloss.NewStyle().Foreground(th.Comment))
	}

	// Reference link definition: [ref]: url — dim the [ref]:, color the url.
	if loc := refDefRe.FindStringIndex(line); loc != nil {
		spans := []Span{{Text: line[:loc[1]], Style: muted}}
		if url := line[loc[1]:]; url != "" {
			spans = append(spans, Span{Text: url, Style: lipgloss.NewStyle().Foreground(th.Link)})
		}
		return spans
	}

	// Heading: dim the hashes, bold + accent the text.
	if loc := headingRe.FindStringIndex(line); loc != nil {
		spans := []Span{{Text: line[:loc[1]], Style: muted}}
		if rest := line[loc[1]:]; rest != "" {
			spans = append(spans, Span{Text: rest, Style: lipgloss.NewStyle().Foreground(th.Heading).Bold(true), Prose: true})
		}
		return spans
	}

	// Blockquote: dim the > marker, italicize the quoted text at base color.
	if loc := blockquoteRe.FindStringIndex(line); loc != nil {
		spans := []Span{{Text: line[:loc[1]], Style: muted}}
		if rest := line[loc[1]:]; rest != "" {
			spans = append(spans, Span{Text: rest, Style: lipgloss.NewStyle().Foreground(th.Text).Italic(true), Prose: true})
		}
		return spans
	}

	// List marker (colored), then inline-scan the remainder.
	if loc := listRe.FindStringIndex(line); loc != nil {
		marker := line[:loc[1]]
		rest := line[loc[1]:]
		spans := []Span{{Text: marker, Style: lipgloss.NewStyle().Foreground(th.ListMarker)}}
		return append(spans, scanInline(rest, th)...)
	}

	return scanInline(line, th)
}

// wholeLine returns a single span for the whole line, or no spans if empty.
func wholeLine(line string, style lipgloss.Style) []Span {
	if line == "" {
		return nil
	}
	return []Span{{Text: line, Style: style}}
}

// scanFrontmatter highlights one YAML frontmatter line, keeping every character
// visible. Frontmatter is metadata: keys lightly accented, values base, markers
// muted.
func scanFrontmatter(line string, th theme.Theme) []Span {
	muted := lipgloss.NewStyle().Foreground(th.Muted)
	accent := lipgloss.NewStyle().Foreground(th.Accent)
	plain := lipgloss.NewStyle().Foreground(th.Text)
	marker := lipgloss.NewStyle().Foreground(th.ListMarker)

	trimmed := strings.TrimSpace(line)

	// Comment line.
	if strings.HasPrefix(trimmed, "#") {
		return wholeLine(line, muted)
	}

	// List item: optional leading whitespace, then "- ...".
	if loc := listRe.FindStringIndex(line); loc != nil && strings.HasPrefix(trimmed, "-") {
		mk := line[:loc[1]]   // leading ws + "- "
		rest := line[loc[1]:] // item text
		spans := []Span{{Text: mk, Style: marker}}
		if rest != "" {
			spans = append(spans, Span{Text: rest, Style: plain})
		}
		return spans
	}

	// key: value — split at the first colon. Keep the colon with the key.
	if idx := strings.IndexByte(line, ':'); idx >= 0 {
		key := line[:idx+1]  // includes the colon
		rest := line[idx+1:] // remainder (may start with a space)
		spans := []Span{{Text: key, Style: accent}}
		if rest != "" {
			spans = append(spans, Span{Text: rest, Style: plain})
		}
		return spans
	}

	// Bare line (e.g. a continuation): plain text.
	return wholeLine(line, plain)
}

// scanInline emits styled spans for inline constructs, keeping all markup
// characters visible (markers Muted, content in its role color). Plain text gets
// the theme's Text foreground.
func scanInline(text string, th theme.Theme) []Span {
	plain := lipgloss.NewStyle().Foreground(th.Text)
	r := []rune(text)
	var spans []Span
	start, i := 0, 0
	flush := func(end int) {
		if end > start {
			spans = append(spans, Span{Text: string(r[start:end]), Style: plain, Prose: true})
		}
	}
	for i < len(r) {
		if toks, n, ok := matchToken(r, i, th); ok {
			flush(i)
			spans = append(spans, toks...)
			i += n
			start = i
			continue
		}
		i++
	}
	flush(len(r))
	return spans
}

// matchToken tries to match an inline construct starting at r[i], returning its
// spans (markup Muted, content in its role color), the rune length, and whether
// matched. The spans' concatenated text equals the original token exactly.
func matchToken(r []rune, i int, th theme.Theme) ([]Span, int, bool) {
	muted := lipgloss.NewStyle().Foreground(th.Muted)

	// Inline code: `...`
	if r[i] == '`' {
		if j := indexRune(r, '`', i+1); j > i {
			return wrap("`", string(r[i+1:j]), "`", muted,
				lipgloss.NewStyle().Foreground(th.Code)), j + 1 - i, true
		}
	}
	// Highlight: ==...==
	if r[i] == '=' && i+1 < len(r) && r[i+1] == '=' {
		if j := indexSeq(r, "==", i+2); j >= 0 {
			return wrapProse("==", string(r[i+2:j]), "==", muted,
				lipgloss.NewStyle().Foreground(th.Text).Background(th.Highlight)), j + 2 - i, true
		}
	}
	// Wikilink: [[...]]
	if r[i] == '[' && i+1 < len(r) && r[i+1] == '[' {
		if j := indexSeq(r, "]]", i+2); j >= 0 {
			return wrap("[[", string(r[i+2:j]), "]]", muted,
				lipgloss.NewStyle().Foreground(th.Link)), j + 2 - i, true
		}
	}
	// Link: [text](url) — the readable text is the colored reference, the url is
	// dimmed (it's the address), brackets dimmed.
	if r[i] == '[' {
		link := lipgloss.NewStyle().Foreground(th.Link)
		if c := indexRune(r, ']', i+1); c > i && c+1 < len(r) {
			// [text](url)
			if r[c+1] == '(' {
				if p := indexRune(r, ')', c+2); p > c {
					spans := []Span{{Text: "[", Style: muted}}
					if text := string(r[i+1 : c]); text != "" {
						spans = append(spans, Span{Text: text, Style: link})
					}
					spans = append(spans, Span{Text: "](", Style: muted})
					if url := string(r[c+2 : p]); url != "" {
						spans = append(spans, Span{Text: url, Style: muted})
					}
					spans = append(spans, Span{Text: ")", Style: muted})
					return spans, p + 1 - i, true
				}
			}
			// Reference link: [text][ref]
			if r[c+1] == '[' {
				if e := indexRune(r, ']', c+2); e > c+1 {
					spans := []Span{{Text: "[", Style: muted}}
					if text := string(r[i+1 : c]); text != "" {
						spans = append(spans, Span{Text: text, Style: link})
					}
					spans = append(spans, Span{Text: "][", Style: muted})
					if ref := string(r[c+2 : e]); ref != "" {
						spans = append(spans, Span{Text: ref, Style: muted})
					}
					spans = append(spans, Span{Text: "]", Style: muted})
					return spans, e + 1 - i, true
				}
			}
		}
	}
	// Bold: ** or __
	for _, d := range []string{"**", "__"} {
		if hasPrefixRunes(r, i, d) {
			if j := indexSeq(r, d, i+2); j >= 0 {
				return wrapProse(d, string(r[i+2:j]), d, muted,
					lipgloss.NewStyle().Foreground(th.Emphasis).Bold(true)), j + 2 - i, true
			}
		}
	}
	// Italic: * or _
	if r[i] == '*' || r[i] == '_' {
		if j := indexRune(r, r[i], i+1); j > i {
			m := string(r[i])
			return wrapProse(m, string(r[i+1:j]), m, muted,
				lipgloss.NewStyle().Foreground(th.Emphasis).Italic(true)), j + 1 - i, true
		}
	}
	return nil, 0, false
}

// wrap builds [open(markup), content(role), close(markup)] spans, dropping an
// empty content span. The texts concatenate to open+content+close.
func wrap(open, content, closing string, markup, role lipgloss.Style) []Span {
	spans := []Span{{Text: open, Style: markup}}
	if content != "" {
		spans = append(spans, Span{Text: content, Style: role})
	}
	return append(spans, Span{Text: closing, Style: markup})
}

// wrapProse is wrap for constructs whose content is natural-language prose
// (bold, italic, ==highlight==), tagging the content span so spellcheck examines
// it. The markup delimiters stay non-prose.
func wrapProse(open, content, closing string, markup, role lipgloss.Style) []Span {
	spans := wrap(open, content, closing, markup, role)
	for i := range spans {
		if spans[i].Text == content && content != "" {
			spans[i].Prose = true
		}
	}
	return spans
}

func indexRune(r []rune, c rune, from int) int {
	for i := from; i < len(r); i++ {
		if r[i] == c {
			return i
		}
	}
	return -1
}

func indexSeq(r []rune, seq string, from int) int {
	s := []rune(seq)
	for i := from; i+len(s) <= len(r); i++ {
		match := true
		for k := range s {
			if r[i+k] != s[k] {
				match = false
				break
			}
		}
		if match {
			return i
		}
	}
	return -1
}

func hasPrefixRunes(r []rune, i int, prefix string) bool {
	p := []rune(prefix)
	if i+len(p) > len(r) {
		return false
	}
	for k := range p {
		if r[i+k] != p[k] {
			return false
		}
	}
	return true
}