// Heredoc 预处理和提取.
//
// Heredoc 是 Bash 中跨多行的特殊语法,主解析器逐行处理时难以正确处理.
// 本模块在主解析之前预处理源文本:
//  1. 扫描所有 heredoc 标记(<<EOF, <<-EOF, <<'EOF', <<"EOF")
//  2. 提取 heredoc 体(从标记后的下一行开始,到匹配的分隔符结束)
//  3. 将 heredoc 体替换为空,让主解析器只需处理 << 操作符
//
// 关键细节:
//   - <<- 变体去除体内行首的 tab
//   - 引号包裹的分隔符阻止体内的变量展开
//   - 多个 heredoc 可以在同一行声明,体按声明顺序排列
package bash

import "strings"

// HeredocInfo is the preprocessor's per-heredoc output.
//
// Tag/Body are consumed downstream (parser validates Tag, AST carries
// Body). BodyStart/BodyEnd are byte offsets into the ORIGINAL source
// string -- they let audit / security consumers locate where a heredoc
// body lives in the user's input, so "dangerous payload" warnings can
// point at "source bytes N-M" rather than a disembodied snippet.
// Invariant: source[BodyStart:BodyEnd] equals Body (modulo the synthetic
// trailing '\n' appended to non-empty bodies; see PreprocessHeredocs).
//
// StripTabs / Quoted are deliberately NOT stored here -- the parser
// recomputes them from source tokens (op == "<<-", delimiter quoting),
// which is the authoritative source of truth. Duplicating them on this
// struct only created a parallel unread surface.
//
// HeredocInfo 是预处理器对每个 heredoc 的输出.
//
// Tag/Body 下游会消费 (parser 做 Tag 校验, AST 携带 Body). BodyStart/
// BodyEnd 是 body 在**原文**中的字节偏移, 让审计 / 安全消费者能把
// "危险载荷"警告定位到"源码字节 N-M", 而不是孤立的代码片段.
// 不变量: source[BodyStart:BodyEnd] 等于 Body (非空 body 末尾会补
// 一个合成 '\n', 详见 PreprocessHeredocs).
//
// 故意不存 StripTabs / Quoted -- parser 侧由源码 token (op == "<<-",
// 分隔符引号) 重新计算, 那才是 source of truth. 在本 struct 上重复
// 存只制造了一个无人读的平行字段.
type HeredocInfo struct {
	Tag       string // 分隔符标签(去除引号后)
	Body      string // heredoc 内容
	BodyStart int    // Body 在原文中的起始字节位置. EN: byte offset of Body start within the ORIGINAL source string.
	BodyEnd   int    // Body 在原文中的结束字节位置 (半开区间). EN: byte offset of Body end (exclusive) within the ORIGINAL source string.
}

// heredocPending 表示已扫描到 << 标记但尚未提取 body 的 heredoc.
type heredocPending struct {
	tag       string
	stripTabs bool
	quoted    bool
	lineEnd   int // << 所在行的行尾位置
}

// PreprocessHeredocs 预处理源文本中的所有 heredoc.
//
// 返回处理后的文本(heredoc 体被移除,只保留 << 操作符行)和提取的 heredoc 列表.
// 处理后的文本中,heredoc 的 << 操作符行保持不变,但其后的 body 行被移除.
//
// 算法:
//  1. 逐行扫描,识别 << 标记
//  2. 遇到换行时,如果有待处理的 heredoc,向下扫描 body
//  3. body 从 << 行之后开始,直到遇到匹配的分隔符独占一行
func PreprocessHeredocs(source string) (string, []HeredocInfo) {
	// 精妙之处(CLEVER): 快速路径--绝大多数命令不含 heredoc,这个前置检查避免了
	// 对所有输入做 strings.Split + 逐行扫描的开销.简单的 Contains 检查就能跳过 99%+ 的输入.
	if !strings.Contains(source, "<<") {
		return source, nil
	}

	var heredocs []HeredocInfo
	var result strings.Builder
	result.Grow(len(source))

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

	// Pre-compute the byte offset of each line in the ORIGINAL source.
	// lineStart[i] is the index into source where lines[i] begins. Used
	// to fill HeredocInfo.BodyStart/BodyEnd so they address the original
	// source (not the processed output), enabling downstream consumers
	// to locate heredoc bodies for audit / security diagnostics.
	//
	// 预算每行在原文中的字节起始位置. lineStart[i] 是 lines[i] 在
	// source 中的起始下标. 用于填 HeredocInfo.BodyStart/BodyEnd 让
	// 它们指向原文 (不是处理后的输出), 下游审计 / 安全消费者可据此
	// 定位 heredoc body 在用户输入的位置.
	lineStart := make([]int, len(lines))
	offset := 0
	for i, l := range lines {
		lineStart[i] = offset
		offset += len(l) + 1 // +1 for the '\n' between lines (harmless overshoot on the last line; never indexed).
	}

	i := 0
	for i < len(lines) {
		line := lines[i]

		// 扫描当前行中的所有 heredoc 标记
		pending := scanHeredocMarkers(line)

		if len(pending) == 0 {
			// 普通行,直接输出
			result.WriteString(line)
			if i < len(lines)-1 {
				result.WriteByte('\n')
			}
			i++
			continue
		}

		// 有 heredoc 标记的行:输出该行
		result.WriteString(line)
		if i < len(lines)-1 {
			result.WriteByte('\n')
		}
		i++

		// 为每个 pending heredoc 提取 body
		for _, p := range pending {
			// Body starts at the next line in the original source.
			// Body 在原文中的起始 = 下一行在原文的起始位置.
			bodyStart := 0
			if i < len(lines) {
				bodyStart = lineStart[i]
			} else {
				bodyStart = len(source)
			}

			var bodyLines []string
			found := false

			for i < len(lines) {
				bodyLine := lines[i]

				// 检查是否匹配分隔符
				trimmed := bodyLine
				if p.stripTabs {
					trimmed = strings.TrimLeft(bodyLine, "\t")
				}
				if trimmed == p.tag {
					found = true
					break
				}

				bodyLines = append(bodyLines, bodyLine)
				i++
			}

			// Body ends just before the tag line (or at source end when
			// unterminated). We peek lineStart[i] BEFORE advancing past
			// the tag line so the offset points to tag-line start, i.e.
			// exclusive end of the body content.
			//
			// Body 结束位置 = tag 行开头 (未闭合时 = 原文末尾).
			// 在跳过 tag 行前读 lineStart[i] 取"tag 行开始"作为 body 的
			// 半开区间结束.
			var bodyEnd int
			if i < len(lines) {
				bodyEnd = lineStart[i]
			} else {
				bodyEnd = len(source)
			}
			if found {
				i++ // 跳过 tag 行
			}

			body := strings.Join(bodyLines, "\n")
			if len(bodyLines) > 0 && found {
				body += "\n" // 闭合 heredoc body 以换行结尾 (synthetic, matches bodyEnd-bodyStart).
			}

			if !found {
				// 未闭合 (宽容处理): body 无 trailing '\n', 长度 = bodyEnd-bodyStart - (若 lines 间缺尾换行则无差) - 以实际 join 结果为准.
				body = strings.Join(bodyLines, "\n")
			}

			heredocs = append(heredocs, HeredocInfo{
				Tag:       p.tag,
				Body:      body,
				BodyStart: bodyStart,
				BodyEnd:   bodyEnd,
			})
		}
	}

	return result.String(), heredocs
}

// ExtractHeredocs 从源文本中提取所有 heredoc(不修改源文本).
func ExtractHeredocs(source string) []HeredocInfo {
	_, heredocs := PreprocessHeredocs(source)
	return heredocs
}

// scanHeredocMarkers 扫描一行中的所有 heredoc 标记.
//
// 识别以下变体:
//   - <<EOF      标准 heredoc
//   - <<-EOF     去除行首 tab
//   - <<'EOF'    单引号(阻止展开)
//   - <<"EOF"    双引号(阻止展开)
//   - <<\EOF     转义(阻止展开)
//
// 需要正确跳过引号内的 <<(不是 heredoc 标记).
func scanHeredocMarkers(line string) []heredocPending {
	var result []heredocPending

	inSingleQuote := false
	inDoubleQuote := false
	i := 0

	for i < len(line) {
		ch := line[i]

		// 跳过转义字符
		if ch == '\\' && i+1 < len(line) && !inSingleQuote {
			i += 2
			continue
		}

		// 引号状态
		if ch == '\'' && !inDoubleQuote {
			inSingleQuote = !inSingleQuote
			i++
			continue
		}
		if ch == '"' && !inSingleQuote {
			inDoubleQuote = !inDoubleQuote
			i++
			continue
		}

		// 在引号内不识别 heredoc
		if inSingleQuote || inDoubleQuote {
			i++
			continue
		}

		// 精妙之处(CLEVER): 正确区分 $(( )) 中的 << 位移操作符和 heredoc.
		// 例如 `echo $((1 << 3))` 中的 << 不是 heredoc.
		// 需要追踪嵌套括号深度才能正确跳过整个算术展开,这是一个容易被忽略的细节.
		if ch == '$' && i+1 < len(line) && line[i+1] == '(' && i+2 < len(line) && line[i+2] == '(' {
			// 跳到匹配的 )) - 简化处理:找到 )) 即可
			depth := 1
			i += 3
			for i < len(line) && depth > 0 {
				if line[i] == '(' && i+1 < len(line) && line[i+1] == '(' {
					depth++
					i += 2
					continue
				}
				if line[i] == ')' && i+1 < len(line) && line[i+1] == ')' {
					depth--
					i += 2
					continue
				}
				i++
			}
			continue
		}

		// 检查 <<
		if ch == '<' && i+1 < len(line) && line[i+1] == '<' {
			// 排除 <<< (here-string)
			if i+2 < len(line) && line[i+2] == '<' {
				i += 3
				continue
			}

			i += 2 // 跳过 <<

			// 检查 <<- 变体
			stripTabs := false
			if i < len(line) && line[i] == '-' {
				stripTabs = true
				i++
			}

			// 跳过空白
			for i < len(line) && (line[i] == ' ' || line[i] == '\t') {
				i++
			}

			if i >= len(line) {
				continue // 行尾没有分隔符,忽略
			}

			// 解析分隔符
			tag, quoted, newI := parseHeredocTag(line, i)
			if tag == "" {
				continue
			}
			i = newI

			result = append(result, heredocPending{
				tag:       tag,
				stripTabs: stripTabs,
				quoted:    quoted,
			})
			continue
		}

		i++
	}

	return result
}

// parseHeredocTag 从位置 i 开始解析 heredoc 分隔符.
//
// 支持以下形式:
//   - EOF         → tag="EOF", quoted=false
//   - 'EOF'       → tag="EOF", quoted=true
//   - "EOF"       → tag="EOF", quoted=true
//   - \EOF        → tag="EOF", quoted=true(转义等同引号)
//   - MY_TAG123   → tag="MY_TAG123", quoted=false
//
// 返回 (tag, quoted, newI),tag 为空表示解析失败.
func parseHeredocTag(line string, i int) (string, bool, int) {
	if i >= len(line) {
		return "", false, i
	}

	ch := line[i]

	// 单引号包裹
	if ch == '\'' {
		i++ // 跳过开头引号
		start := i
		for i < len(line) && line[i] != '\'' {
			i++
		}
		if i >= len(line) {
			return "", false, i // 未闭合
		}
		tag := line[start:i]
		i++ // 跳过结尾引号
		return tag, true, i
	}

	// 双引号包裹
	if ch == '"' {
		i++ // 跳过开头引号
		start := i
		for i < len(line) && line[i] != '"' {
			i++
		}
		if i >= len(line) {
			return "", false, i // 未闭合
		}
		tag := line[start:i]
		i++ // 跳过结尾引号
		return tag, true, i
	}

	// 反斜杠转义的分隔符
	if ch == '\\' {
		i++ // 跳过反斜杠
		start := i
		for i < len(line) && isHeredocDelimChar(line[i]) {
			i++
		}
		if i == start {
			return "", false, i
		}
		return line[start:i], true, i
	}

	// 无引号的标识符
	start := i
	for i < len(line) && isHeredocDelimChar(line[i]) {
		i++
	}
	if i == start {
		return "", false, i
	}
	return line[start:i], false, i
}

// isHeredocDelimChar 判断字符是否可作为 heredoc 分隔符的一部分.
//
// Bash 对 heredoc 分隔符字符比较宽松:几乎所有非元字符都可以.
// 停止字符:空白,重定向,管道,列表操作符,引号,括号.
func isHeredocDelimChar(ch byte) bool {
	switch ch {
	case ' ', '\t', '\n', '\r',
		'<', '>', '|', '&', ';',
		'(', ')',
		'\'', '"', '`', '\\',
		'$': // $ 不应出现在未引号的分隔符中
		return false
	}
	return ch > 0x20 // 排除控制字符
}