lumesh 0.18.2

use core::option::Option::None;
use detached_str::Str;
use std::{
    collections::{BTreeMap, BTreeSet, HashMap},
    rc::Rc,
};

use crate::{
    Diagnostic, Expression, Int, MAX_SYNTAX_RECURSION, SyntaxErrorKind, Token, TokenKind,
    expression::{CatchType, ChainCall, DestructurePattern, FileSize},
    tokens::{Input, Tokens},
    utils::{unescape_bytes, unescape_str},
};
use detached_str::StrSlice;
use nom::{IResult, branch::alt, combinator::*, multi::*, sequence::*};

// -- 辅助类型和常量 --

// 优先级常量
// 双目操作符
// const PREC_CONTROL: u8 = 0; // 控制结构（语句级）
const PREC_ASSIGN: u8 = 1; // 赋值 =
const PREC_REDIRECT: u8 = 2; // 重定向
const PREC_PIPE: u8 = 2; // 管道
const PREC_CATCH: u8 = 5;

const PREC_LAMBDA: u8 = 6; // lambda -> ~>
const PREC_CONDITIONAL: u8 = 7; // 条件运算符 ? :
const PREC_LOGICAL_OR: u8 = 8; // 逻辑或 ||
const PREC_LOGICAL_AND: u8 = 9; // 逻辑与 &&
const PREC_COMPARISON: u8 = 10; // 比较运算

const PREC_CMD_ARG: u8 = 11;
const PREC_FUNC_ARG: u8 = 4;

const PREC_ADD_SUB: u8 = 15; // 加减
const PREC_MUL_DIV: u8 = 16; // 乘除模 custom_op _*
const PREC_POWER: u8 = 17; // 幂运算 ^
const PREC_CUSTOM: u8 = 18; // 自定义
// 其他
const PREC_RANGE: u8 = 30; // range         ..
// prefix
const PREC_UNARY: u8 = 31; // 单目运算符     ! -
// const PREC_PRIFIX: u8 = 31; // 单目运算符     ++ --
// postfix
// const PREC_POSTFIX: u8 = 32; //             ++ --
// const PREC_CALL: u8 = 34; //                func()
// arry list
// const PREC_LIST: u8 = 35; // 数组         [1,2]
// const PREC_SLICE: u8 = 35; //               arry[]
const PREC_INDEX: u8 = 35; // 索引运算符      @ .
// group
const PREC_GROUP: u8 = 38; // 分组括号      ()

// Literal
const PREC_LITERAL: u8 = 39; //原始字面量     "x"
// cmd
// const PREC_CMD_NAME: u8 = 30;
// const PREC_FUNC_NAME: u8 = 31;

// var
// const PREC_SYMBOL: u8 = 32; //变量名         x

// -- 辅助结构 --
#[derive(Debug)]
struct OperatorInfo<'a> {
    symbol: &'a str,
    precedence: u8,
    right_associative: bool,
    // kind: OperatorKind,
}
// #[derive(Debug)]
// enum OperatorKind {
//     Prefix,
//     // Postfix,
//     Infix,
// }
impl<'a> OperatorInfo<'a> {
    #[inline]
    fn new(symbol: &'a str, precedence: u8, right_associative: bool) -> Self {
        Self {
            symbol,
            precedence,
            right_associative,
        }
    }
}
// -- Pratt 解析器核心结构 --

/// 基于优先级0
fn parse_expr(input: Tokens) -> IResult<Tokens, Expression, SyntaxErrorKind> {
    // dbg!("--parse--");
    let (input, got) = PrattParser::parse_expr_with_precedence(input, 0, 0)?;
    // dbg!(&input.slice, &got);
    Ok((input, got))
}

fn parse_expr_or_failure(
    input: Tokens<'_>,
    min_prec: u8,
    depth: usize,
) -> IResult<Tokens<'_>, Expression, SyntaxErrorKind> {
    cut(|input| PrattParser::parse_expr_with_precedence(input, min_prec, depth))(input)
}

struct PrattParser;
/// Pratt解析器增强实现, 基于优先级的表达式解析
impl PrattParser {
    // 核心表达式解析
    fn parse_expr_with_precedence(
        mut input: Tokens<'_>,
        min_prec: u8,
        mut depth: usize,
    ) -> IResult<Tokens<'_>, Expression, SyntaxErrorKind> {
        // 1. 解析前缀表达式
        // dbg!("===----prepare to prefix---===>", input, min_prec);
        let (new_input, mut lhs) = Self::parse_prefix(input, min_prec, depth)?;
        input = new_input;
        // dbg!("=======prefix=======>", input, &lhs, min_prec);
        // opt(alt((kind(TokenKind::LineBreak), eof_slice)));
        // 2. 循环处理中缀和后缀
        loop {
            //dbg!(depth, &input.get_str_slice().to_str(input.str));
            depth += 1;
            if MAX_SYNTAX_RECURSION.with(|v| depth > *v.borrow()) {
                return Err(nom::Err::Failure(SyntaxErrorKind::RecursionDepth {
                    input: input.get_str_slice(),
                    depth,
                }));
            }
            // 检查终止条件
            if input.is_empty() {
                //dbg!("---break1---");
                break;
            }

            // 获取运算符信息
            let operator_token = input.first().unwrap();
            let operator = operator_token.text(input);

            //dbg!(&operator, operator_token.kind);

            // 处理不同类型的运算符
            match operator_token.kind {
                TokenKind::LineBreak   => {
                    // dbg!("---break1.1---");
                    break;
                }
                TokenKind::OperatorInfix => {
                    // 中缀运算符 (. .. @)
                    // let (new_input, rhs) = Self::parse_prefix(input, PREC_INDEX,depth)?;
                    // input = new_input;
                    match operator {
                        "::" =>  {
                            input = input.skip_n(1);
                            match lhs {
                                Expression::Symbol(name) => {
                                    let (new_input, mut modes) = many0(terminated( parse_symbol_string,text("::")))(input)?;
                                    // separated_list0(text("::"), parse_symbol_string)(input)?;
                                    input=new_input;
                                    // let func=modes.pop().ok_or(rhs);
                                    modes.insert(0,name);
                                    // funcname
                                    let (new_input, rhs) = Self::parse_prefix(input, PREC_INDEX,depth)?;
                                    input = new_input;
                                   lhs= Expression::ModuleCall(modes, Rc::new(rhs)) ;
                                }
                                _ => {
                                    return Err(SyntaxErrorKind::failure(
                                        input.get_str_slice(),
                                        "symbol",
                                        Some(format!("{lhs:?}")),
                                        Some("module name should be a symbol"),
                                    ))
                                }
                            }

                        },

                        // "..." => {
                        //     lhs = Expression::BinaryOp("...".into(), Rc::new(lhs), Rc::new(rhs))
                        // }
                        "..." | "...=" | ".." | "..=" => {
                            if PREC_RANGE < min_prec{
                                break;
                            }
                            input = input.skip_n(1);
                            let (new_input, rhs) = Self::parse_prefix(input, PREC_RANGE,depth)?;
                            input = new_input;
                            let (nnew_input, exprs) = opt(preceded(
                                text(":"),
                                cut(alt((parse_symbol, parse_integer,parse_variable))),
                            ))(input)?;
                            input = nnew_input;
                            lhs = Expression::RangeOp(
                                operator.into(),
                                Rc::new(lhs),
                                Rc::new(rhs),
                                exprs.map(Rc::new),
                            )
                        }
                        // ".." => lhs = Expression::BinaryOp("..".into(), Rc::new(lhs), Rc::new(rhs)),
                        // "..=" => {
                        //     lhs = Expression::BinaryOp("..=".into(), Rc::new(lhs), Rc::new(rhs))
                        // }
                        _ => unreachable!(),
                    }
                }
                TokenKind::Operator => {
                    // 双目运算符 (+ - * / 等)
                    // 获取当前运算符信息
                    let op_info = match Self::get_operator_info(operator) {
                        Some(opi) => opi,
                        None => break,
                    };
                    // dbg!(&op_info);
                    if op_info.precedence < min_prec {
                        //dbg!("低于当前优先级则退出", op_info.precedence, min_prec);
                        break; // 低于当前优先级则退出
                    }

                    let next_min_prec = if op_info.right_associative {
                        op_info.precedence
                    } else {
                        op_info.precedence + 1
                    };

                    input = input.skip_n(1);

                    // dbg!("--> binOp: trying next loop", input, next_min_prec);
                    // dbg!("--> binOp: trying next loop", &lhs, &operator);
                    match operator {
                        "?." | "?+" | "??" |"?>" | "?!" | "_!" | "?~" => {
                            // dbg!("--->try catch ast:");
                            lhs = Self::build_catch_unary(op_info, lhs)?
                        }
                        // custom unary op __+ as Operator: a __+
                        opx if opx.starts_with("__") => {
                            lhs = Expression::UnaryOp(opx.into(), Rc::new(lhs), false);
                        }
                        _ => {
                            if input.is_empty() {
                                //dbg!("---break2---");
                                break;
                            }
                            // dbg!("--->try bin:", &operator, operator == "?.");
                            // inclue | "?:"
                            let (new_input, rhs) = parse_expr_or_failure(input, next_min_prec, depth+1).map_err(|e| match e {
                                nom::Err::Incomplete(_) | nom::Err::Error(_) => SyntaxErrorKind::failure(
                                    input.get_str_slice(),
                                    "some expression",
                                    None,
                                    Some("check grammar of right handside"),
                                ),
                                other => other,
                            })?;
                                // Self::parse_expr_with_precedence(input, next_min_prec, depth+1).map_err(
                                //     |e|  nom::Err::Failure(SyntaxErrorKind::CustomError(e.to_string(), input.get_str_slice())))?;
                            // dbg!("--> binOp: after next loop", &rhs);
                            input = new_input;
                            lhs = Self::build_bin_ast(input, op_info, lhs, rhs)?;
                        }
                    }
                }
                TokenKind::OperatorPostfix => {
                    // dbg!("--->post fix");
                    // dbg!(&lhs, operator, input);
                    // 后缀运算符 (函数调用、数组索引等)
                    (input, lhs) = Self::build_postfix_ast(lhs, operator.to_string(), input,depth)?;
                    // dbg!(&input, &lhs);
                }
                TokenKind::Symbol
                | TokenKind::StringLiteral
                | TokenKind::StringRaw
                | TokenKind::StringTemplate
                | TokenKind::StringSafe
                | TokenKind::Bytes
                | TokenKind::IntegerLiteral
                | TokenKind::FloatLiteral
                | TokenKind::ValueSymbol
                | TokenKind::OperatorPrefix     // $ in cmd arg goes to parse_expr_with_precedence, other ++/--/! should never comes.
                | TokenKind::Punctuation        // ( [ as first argument begin. { will course if x {} expect more {
                | TokenKind::Regex
                | TokenKind::Time
                | TokenKind::Keyword            // allow keyword as symbo in cmd arg
                // like: `handlr set .pdf zathura`
                    if min_prec < PREC_CMD_ARG =>
                {
                    // 对于Punctuation, 只接受 ( [
                    if operator_token.kind == TokenKind::Punctuation && !matches!(operator,"("|"["|"H{"|"M{"|"S{") {
                        break;
                    }
                    // 对于OperatorPrefix, 只接受 $, $x长度>1 由parse_expr_with_precedence处理。
                    // 当operator不是符号时，表示这不是双目运算，而是类似cmd a 3 c+d e.f 之类的函数调用
                    //
                    // dbg!("--> Args: trying next loop", input.len(), PREC_CMD_ARG);
                    match &lhs {
                        Expression::Symbol(_)|Expression::SymbolRaw(_)
                        |Expression::Variable(_)| Expression::String(_)
                        |Expression::Index(.. ) | Expression::Property(..)=>{}
                        // not allowed
                        Expression::Integer(_) | Expression::Float(_) | Expression::Range(.. )
                        | Expression::List(_)| Expression::BSet(_)
                        | Expression::Map(_)| Expression::HMap(_)
                        | Expression::RegexDef(_) | Expression::TimeDef(_) | Expression::FileSize(_)
                        | Expression::Bytes(_) => {
                            return Err(SyntaxErrorKind::failure(
                                input.get_str_slice(),
                                "operator or separator",
                                Some(format!("{operator}")),
                                Some("numbers/data cannot be followed by symbols without an operator"),
                            ));
                        }
                        _ => break
                    }
                    if input.len() == 1 {
                        // CMD arg1, 只有第一个参数
                        let (new_input, rhs) =
                            // cut(alt((parse_symbol, parse_literal)))(input)?;
                        Self::parse_expr_with_precedence(input, PREC_CMD_ARG, depth + 1)?;

                        // dbg!(&rhs);
                        input = new_input;
                        lhs = Expression::Command(Rc::new(lhs), Rc::new(vec![rhs]));
                    } else {
                        // CMD ... 所有参数
                        // let (new_input, rhs) = many0(|input| Self::parse_expr_with_precedence(input, PREC_CMD_ARG, depth+1))(input)?;
                        let (new_input, rhs) = cut(many0(|input| {
                            Self::parse_expr_with_precedence(input, PREC_CMD_ARG, depth+1)
                        }))(input)?;
                        //dbg!("--> Args: after next loop", &rhs,&new_input);
                        input = new_input;
                        lhs = Expression::Command(Rc::new(lhs), Rc::new(rhs));
                    }
                    // dbg!("---break3---", input.len());

                    // break;
                }
                // TokenKind::Symbol
                // | TokenKind::StringLiteral
                // | TokenKind::StringRaw
                // | TokenKind::IntegerLiteral
                // | TokenKind::FloatLiteral
                // | TokenKind::ValueSymbol => {
                //     // CMD ... arg_last 多参数的最后一个
                // //dbg!("--> Args: last", input.len());
                //     if input.len() == 1 {
                //         return alt((parse_symbol, parse_literal))(input);
                //     }
                // }
                _ => {
                    // dbg!("---break4---", input.len());
                    break;
                }
            }
            // if input.is_empty() {
            // //dbg!("---break5---");
            //     break;
            // }
        }

        // dbg!("---returning---", input);

        Ok((input, lhs))
    }

    // 前缀表达式解析
    fn parse_prefix(
        input: Tokens<'_>,
        min_prec: u8,
        depth: usize,
    ) -> IResult<Tokens<'_>, Expression, SyntaxErrorKind> {
        SyntaxErrorKind::empty_back(input)?;

        let first = input.first().unwrap();
        // dbg!(&first);
        match first.kind {
            TokenKind::OperatorPrefix => {
                let op = first.text(input);
                match op {
                    "$" => cut(parse_variable)(input),
                    "." => cut(parse_pipe_method)(input),
                    "@" => cut(parse_fn_declare)(input),
                    // "--" if min_prec == PREC_CMD_ARG => {
                    //     let input = input.skip_n(1);
                    //     // TODO add more: --color=red
                    //     let (input, arg) = cut(parse_symbol_string)(input)?;
                    //     Ok((input, Expression::String(format!("--{})", arg))))
                    // }
                    "-" | "+" if min_prec == PREC_CMD_ARG => {
                        let input = input.skip_n(1);
                        // ls -1 need parse_integer
                        let (input, arg) = cut(alt((
                            parse_symbol_string,
                            map(kind(TokenKind::IntegerLiteral), |t| {
                                t.to_str(input.str).to_string()
                            }),
                        )))(input)?;
                        Ok((input, Expression::String(format!("{}{}", op, arg))))
                    }
                    "!" | "-" => {
                        let prec = PREC_UNARY;
                        if prec < min_prec {
                            return Err(nom::Err::Error(SyntaxErrorKind::PrecedenceTooLow(
                                input.get_str_slice(),
                            )));
                        }

                        let input = input.skip_n(1);
                        let (input, expr) = parse_expr_or_failure(input, prec, depth + 1)?;
                        // let (input, expr) = Self::parse_prefix(input, prec)?;
                        Ok((input, Expression::UnaryOp(op.into(), Rc::new(expr), true)))
                    }
                    ".." | "..=" => {
                        // ..b   ..b:2
                        let input = input.skip_n(1);
                        let (input, rhs) = Self::parse_prefix(input, PREC_RANGE, depth + 1)?;

                        let (input, steps) = opt(preceded(
                            text(":"),
                            cut(alt((parse_symbol, parse_integer, parse_variable))),
                        ))(input)?;
                        Ok((
                            input,
                            Expression::RangeOp(
                                op.to_string(),
                                Rc::new(Expression::Blank),
                                Rc::new(rhs),
                                steps.map(Rc::new),
                            ),
                        ))
                    }
                    ":" => {
                        // :2 as range
                        let input = input.skip_n(1);

                        let (input, steps) =
                            cut(alt((parse_symbol, parse_integer, parse_variable)))(input)?;
                        Ok((
                            input,
                            Expression::RangeOp(
                                "..".to_string(),
                                Rc::new(Expression::Blank),
                                Rc::new(Expression::Blank),
                                Some(Rc::new(steps)),
                            ),
                        ))
                    }
                    _ => {
                        return Err(nom::Err::Failure(SyntaxErrorKind::UnknownOperator(
                            op.to_string(),
                            input.get_str_slice(),
                        )));
                    }
                }
            }
            TokenKind::Symbol => parse_symbol(input),
            TokenKind::StringLiteral if PREC_LITERAL >= min_prec => parse_string(input),
            TokenKind::StringRaw if PREC_LITERAL >= min_prec => parse_string_raw(input),
            TokenKind::StringTemplate if PREC_LITERAL >= min_prec => parse_string_template(input),
            TokenKind::StringSafe if PREC_LITERAL >= min_prec => parse_string_safe(input),
            TokenKind::Bytes if PREC_LITERAL >= min_prec => parse_bytes(input),
            TokenKind::IntegerLiteral if PREC_LITERAL >= min_prec => parse_integer(input),
            TokenKind::FloatLiteral if PREC_LITERAL >= min_prec => parse_float(input),
            TokenKind::Radix2 | TokenKind::Radix8 | TokenKind::Radix16
                if PREC_LITERAL >= min_prec =>
            {
                parse_radix(first.kind)(input)
            }
            TokenKind::ValueSymbol if PREC_LITERAL >= min_prec => parse_value_symbol(input),
            TokenKind::Regex if PREC_LITERAL >= min_prec => parse_regex(input),
            TokenKind::Time if PREC_LITERAL >= min_prec => parse_time(input),
            TokenKind::Punctuation if PREC_GROUP >= min_prec => {
                let op = first.text(input);
                match op {
                    "(" => {
                        if has_lambda_arrow(input) {
                            cut(parse_lambda_param)(input)
                        } else {
                            cut(parse_group)(input)
                        }
                    }
                    // "(" => {
                    //     // 分组{表达式 (expr)
                    //     cut(alt((parse_lambda_param, parse_group)))(input).map_err(|_| {
                    //         SyntaxErrorKind::failure(
                    //             input.get_str_slice(),
                    //             "some expression",
                    //             None,
                    //             Some("write entire expr or remove this `(`"),
                    //         )
                    //     })
                    // }
                    // "`" => {
                    //     parse_subcommand(input)
                    // }
                    "[" => {
                        // 数组字面量 [expr, ...]
                        cut(parse_list)(input)
                    }
                    "H{" => cut(parse_hashmap)(input),
                    "M{" => cut(parse_bmap)(input),
                    "S{" => cut(parse_bset)(input),
                    "%{" => cut(parse_domain_block)(input),
                    "{" => {
                        if looks_like_map(input) {
                            cut(parse_map)(input) // 确认是 map，失败直接报错，不尝试 block
                        } else {
                            cut(parse_block)(input)
                        }
                    }
                    // "{" => cut(alt((parse_map, cut(parse_block_as_sequence))))(input),
                    // opx if opx.starts_with("__") => map(parse_operator(input),TokenKind::OperatorPrefix),
                    _ => Err(nom::Err::Error(SyntaxErrorKind::UnknownOperator(
                        op.to_string(),
                        input.get_str_slice(),
                    ))), //其余的操作符，不在前缀中处理
                }
            }
            TokenKind::Keyword if min_prec == PREC_CMD_ARG => map(kind(TokenKind::Keyword), |t| {
                Expression::Symbol(t.to_str(input.str).to_string())
            })(input), //keyword as symbo in cmd arg
            TokenKind::Keyword => parse_control_flow(input),
            TokenKind::LineBreak => Err(nom::Err::Error(SyntaxErrorKind::CustomError(
                "line ended too early".to_string(),
                input.get_str_slice(),
            ))),

            TokenKind::OperatorInfix | TokenKind::OperatorPostfix => {
                Err(nom::Err::Error(SyntaxErrorKind::UnExpectedToken(
                    first.text(input).to_string(),
                    input.get_str_slice(),
                )))
            }
            TokenKind::Operator => Err(nom::Err::Error(SyntaxErrorKind::UnExpectedToken(
                first.text(input).to_string(),
                input.get_str_slice(),
            ))),
            _ => Err(nom::Err::Error(SyntaxErrorKind::CustomError(
                format!("Unexpected token kind: {:?}", first.kind),
                input.get_str_slice(),
            ))),
        }
    }
    // 后缀表达式构建
    fn build_postfix_ast(
        lhs: Expression,
        op: String,
        input: Tokens<'_>,
        depth: usize,
    ) -> IResult<Tokens<'_>, Expression, SyntaxErrorKind> {
        match op.as_str() {
            "(" => {
                // 函数调用
                // let (input, args) =
                //     terminated(separated_list0(text(","), parse_expr), text(")"))(input)?;
                let (input, args) = parse_args(input, depth)?;
                // dbg!(&lhs, &args);
                Ok((input, Expression::Apply(Rc::new(lhs), Rc::new(args))))
            }
            // .链式调用
            "." => parse_chaind_call_or_property(input, lhs, depth),
            "!" => {
                let (input, args) = many0(|inp| {
                    PrattParser::parse_expr_with_precedence(inp, PREC_CMD_ARG, depth + 1)
                })(input.skip_n(1))?;
                Ok((input, Expression::Apply(Rc::new(lhs), Rc::new(args))))
            }
            "^" => match lhs {
                Expression::Symbol(s) => Ok((input.skip_n(1), Expression::SymbolRaw(s))),
                _ => Err(SyntaxErrorKind::failure(
                    input.get_str_slice(),
                    "symbol",
                    Some(format!("{lhs:?}")),
                    Some("only symbol need to skip eval"),
                )),
            },
            "[" => {
                // 数组索引或切片
                parse_index(lhs, input, depth)
            }
            ".." => {
                // a..   a..:2
                let (input, steps) = opt(preceded(
                    text(":"),
                    cut(alt((parse_symbol, parse_integer, parse_variable))),
                ))(input.skip_n(1))?;
                Ok((
                    input,
                    Expression::RangeOp(
                        op,
                        Rc::new(lhs),
                        Rc::new(Expression::Blank),
                        steps.map(Rc::new),
                    ),
                ))
            }
            // "++" | "--" => {
            //     // 后置自增/自减
            //     Ok((
            //         input.skip_n(1),
            //         Expression::UnaryOp(op, Rc::new(lhs), false),
            //     ))
            // }
            // custom unary op __+ as OperatorPostfix: 'xx'__+
            // opx if opx.starts_with("__") => {
            //     // 后置自定义
            //     // dbg!(&opx, &lhs);
            //     Ok((
            //         input.skip_n(1),
            //         Expression::UnaryOp(opx.into(), Rc::new(lhs), false),
            //     ))
            // }
            "K" | "M" | "G" | "T" | "P" | "B" => {
                let fs = match lhs {
                    Expression::Integer(s) => FileSize::from(s as u64, &op),
                    Expression::Float(s) => FileSize::from_float(s, &op),
                    _ => FileSize::from_bytes(0),
                };
                Ok((input.skip_n(1), Expression::FileSize(fs)))
            }
            "%" => {
                let f = match lhs {
                    Expression::Integer(s) => s as f64,
                    Expression::Float(s) => s,
                    _ => 0.0,
                };
                Ok((input.skip_n(1), Expression::Float(f / 100.0)))
            }

            _ => Err(nom::Err::Error(SyntaxErrorKind::UnknownOperator(
                op.to_string(),
                input.get_str_slice(),
            ))),
        }
    }

    // 运算符元数据
    fn get_operator_info(op: &str) -> Option<OperatorInfo<'_>> {
        match op {
            // 赋值运算符（右结合）
            "=" | ":=" | "+=" | "-=" | "*=" | "/=" => {
                Some(OperatorInfo::new(op, PREC_ASSIGN, true))
            }
            // lambda
            "->" => Some(OperatorInfo::new(op, PREC_LAMBDA, true)),
            // range
            // ".." => Some(OperatorInfo::new("..", PREC_RANGE, false)),

            // 加减运算符
            "+" | "-" => Some(OperatorInfo::new(op, PREC_ADD_SUB, false)),
            // 乘除模运算符
            "*" | "/" | "%" => Some(OperatorInfo::new(op, PREC_MUL_DIV, false)),
            // 幂运算符
            "^" => Some(OperatorInfo::new("^", PREC_POWER, true)),
            // 单目前缀运算符
            // "!" | "++" | "--" => Some(OperatorInfo::new(
            //     op,
            //     PREC_UNARY,
            //     false,
            //     OperatorKind::Prefix,
            // )),
            // 逻辑运算符
            "&&" => Some(OperatorInfo::new("&&", PREC_LOGICAL_AND, false)),
            "||" => Some(OperatorInfo::new("||", PREC_LOGICAL_OR, false)),
            // 比较运算符
            "==" | "===" | "!=" | "!==" | ">" | "<" | ">=" | "<=" => {
                Some(OperatorInfo::new(op, PREC_COMPARISON, false))
            }
            // 匹配
            "~:" | "!~:" => Some(OperatorInfo::new(op, PREC_COMPARISON, false)),
            // 三目
            "?" => Some(OperatorInfo::new(
                "?",
                PREC_CONDITIONAL, // 优先级设为2
                true,             // 右结合
            )),
            ":" => Some(OperatorInfo::new(
                ":",
                PREC_CONDITIONAL,
                true, //important
            )),
            // ... 管道操作符 ...
            "|" | "|>" | "|^" => Some(OperatorInfo::new(
                op, PREC_PIPE, // 例如设为 4（低于逻辑运算符）
                false,
            )),
            // ... 重定向操作符 ...
            "<<" | ">>" | ">!" => Some(OperatorInfo::new(op, PREC_REDIRECT, false)),
            // opa if opa.starts_with("__") => Some(OperatorInfo::new(
            //     opa,
            //     PREC_UNARY,
            //     false,
            //     OperatorKind::Prefix,
            // )),
            "?." | "?+" | "??" | "?>" | "?!" | "_!" | "?~" | "?:" | "&:" | "_:" => {
                Some(OperatorInfo::new(op, PREC_CATCH, false))
            }

            opa if opa.starts_with("..+") => Some(OperatorInfo::new(opa, PREC_ADD_SUB, false)),
            ops if ops.starts_with("..*") => Some(OperatorInfo::new(ops, PREC_MUL_DIV, false)),
            opo if opo.starts_with("..") => Some(OperatorInfo::new(opo, PREC_CUSTOM, false)),
            opo if opo.starts_with("__") => Some(OperatorInfo::new(opo, PREC_CUSTOM, false)),
            _ => None,
        }
    }

    fn build_bin_ast(
        input: Tokens,
        op: OperatorInfo,
        lhs: Expression,
        rhs: Expression,
    ) -> Result<Expression, nom::Err<SyntaxErrorKind>> {
        match op.symbol {
            "+" | "-" | "*" | "/" | "%" | "^" => Ok(Expression::BinaryOp(
                op.symbol.into(),
                Rc::new(lhs),
                Rc::new(rhs),
            )),
            //     Box::new(rhs),
            // )),
            "&&" | "||" => Ok(Expression::BinaryOp(
                op.symbol.into(),
                Rc::new(lhs),
                Rc::new(rhs),
            )),
            "=" => {
                // 确保左侧是符号
                match lhs.to_symbol() {
                    Ok(name) => Ok(Expression::Assign(name.to_string(), Rc::new(rhs))),
                    _ => {
                        // eprintln!("invalid left-hand-side: {:?}", lhs);
                        Err(SyntaxErrorKind::failure(
                            input.get_str_slice(),
                            "symbol",
                            Some(format!("{lhs:?}")),
                            Some("only assign to symbol allowed"),
                        ))
                    }
                }
            }
            "==" | "!=" | ">" | "<" | ">=" | "<=" | "!==" | "===" | "~:" | "!~:" => Ok(
                Expression::BinaryOp(op.symbol.into(), Rc::new(lhs), Rc::new(rhs)),
            ),

            // "->" => {
            //     // 参数处理
            //     match lhs.to_symbol() {
            //         // .expect("Lambda参数必须是符号");
            //         Ok(name) => {
            //             // 解析体部分（强制解析为代码块）
            //             let body = match rhs {
            //                 Expression::Group(boxed_expr) => {
            //                     // 如果体是分组表达式，尝试解析为代码块
            //                     if let Expression::Do(statements) = *boxed_expr {
            //                         statements
            //                     } else {
            //                         vec![*boxed_expr]
            //                     }
            //                 }
            //                 _ => vec![rhs],
            //             };
            //             Ok(Expression::Lambda(
            //                 name.to_string(),
            //                 Box::new(Expression::Do(body)),
            //                 Environment::new(),
            //             ))
            //         }
            //         _ => {
            //             eprintln!("invalid lambda-param {:?}", lhs);

            //             Err(SyntaxErrorKind::expected(
            //                 input.get_str_slice(),
            //                 "symbol",
            //                 Some(lhs.to_string()),
            //                 "lambda params must be symbol".into(),
            //             ))
            //         }
            //     }

            //     // 解析体部分
            //     // Expression::Lambda(name.to_string(), Box::new(rhs), Environment::new())
            // }
            "->" => {
                // 解析参数列表
                let params = match lhs {
                    // 处理括号包裹的参数列表 (x,y,z)
                    Expression::Group(boxed_expr) => match boxed_expr.as_ref() {
                        Expression::List(elements) => elements
                            .as_ref()
                            .iter()
                            .map(|e| e.to_symbol().map(|s| s.to_string()))
                            .collect::<Result<Vec<_>, _>>(),
                        // 处理单个参数 (x)
                        // expr => match expr {
                        // Expression::List(s) => return Ok(Expression::List(s)),
                        Expression::Symbol(s) => Ok(vec![s.to_owned()]),
                        _ => {
                            return Err(SyntaxErrorKind::failure(
                                input.get_str_slice(),
                                "symbol in parameter list",
                                Some(boxed_expr.type_name().to_string()),
                                "put only valid symbols in lambda param list".into(),
                            ));
                        } // },
                    },
                    // 处理无括号单参数
                    Expression::Symbol(name) => Ok(vec![name]),
                    Expression::Blank => Ok(vec![]),
                    _ => {
                        return Err(SyntaxErrorKind::failure(
                            input.get_str_slice(),
                            "symbol or parameter list",
                            Some(lhs.to_string()),
                            "Lambda requires valid parameter list".into(),
                        ));
                    }
                };

                // 自动包装body为代码块
                let body = match rhs {
                    // 已有代码块保持原样
                    Expression::Block(_) => rhs,
                    // Sequence改写为Block
                    Expression::Sequence(seq) => Expression::Block(Rc::new(seq)),
                    // 分组表达式展开
                    Expression::Group(boxed_expr) => boxed_expr.as_ref().clone(),
                    // 其他表达式自动包装
                    _ => Expression::Block(Rc::new(vec![rhs])),
                };

                // 构建Lambda表达式
                Ok(Expression::Lambda(params.unwrap(), Rc::new(body), None))
            }

            "?" => {
                // dbg!("?+--->", &lhs, &rhs);
                let (true_expr, false_expr) = match rhs {
                    Expression::BinaryOp(op, t, f) if op == ":" => (t, f),
                    _ => {
                        // eprintln!("invalid conditional ?: {:?}", rhs);
                        return Err(SyntaxErrorKind::failure(
                            input.get_str_slice(),
                            "conditional values after `?`",
                            Some(rhs.to_string()),
                            "add something like `t:f`".into(),
                        ));
                    }
                };
                Ok(Expression::If(Rc::new(lhs), true_expr, false_expr))
            }
            ":" => {
                // dbg!(":---->", &lhs, &rhs);
                Ok(Expression::BinaryOp(":".into(), Rc::new(lhs), Rc::new(rhs)))
            }

            ":=" => {
                // 确保左侧是符号
                match lhs.to_symbol() {
                    Ok(name) => Ok(Expression::Assign(
                        name.to_string(),
                        Rc::new(Expression::Quote(Rc::new(rhs))),
                    )),
                    _ => {
                        // eprintln!("invalid left-hide-side {:?}", lhs);
                        Err(SyntaxErrorKind::failure(
                            input.get_str_slice(),
                            "symbol",
                            Some(lhs.to_string()),
                            "only assign to symbol allowed".into(),
                        ))
                    }
                }
            }
            "+=" | "-=" | "*=" | "/=" => Ok(Expression::BinaryOp(
                op.symbol.into(),
                Rc::new(lhs),
                Rc::new(rhs),
            )),
            // {

            //         let base_op = op.symbol.trim_end_matches('=');
            //         let new_rhs =
            //             Expression::BinaryOp(base_op.into(), Box::new(lhs.clone()), Box::new(rhs));
            //         Ok(Expression::Assign(lhs.to_string(), Box::new(new_rhs)))
            //     }
            "|" | "|>" | "|^" => Ok(Expression::Pipe(
                op.symbol.into(),
                Rc::new(lhs),
                Rc::new(rhs),
            )),

            "<<" | ">>" | ">!" => Ok(Expression::Pipe(
                op.symbol.into(),
                Rc::new(lhs),
                Rc::new(rhs),
            )),
            "?:" => Ok(Expression::Catch(
                Rc::new(lhs),
                CatchType::OnError,
                Some(Rc::new(rhs)),
            )),
            "&:" => Ok(Expression::Catch(
                Rc::new(lhs),
                CatchType::OnSuccess,
                Some(Rc::new(rhs)),
            )),
            "_:" => Ok(Expression::Catch(
                Rc::new(lhs),
                CatchType::OnEmpty,
                Some(Rc::new(rhs)),
            )),
            opx if opx.starts_with("..") => {
                Ok(Expression::BinaryOp(opx.into(), Rc::new(lhs), Rc::new(rhs)))
            }
            _ => {
                unreachable!()
            }
        }
    }

    fn build_catch_unary(
        op: OperatorInfo,
        lhs: Expression,
    ) -> Result<Expression, nom::Err<SyntaxErrorKind>> {
        // dbg!("--->catch ast:", &op);
        Ok(match op.symbol {
            "?." => Expression::Catch(Rc::new(lhs), CatchType::Ignore, None),
            "?+" => Expression::Catch(Rc::new(lhs), CatchType::PrintStd, None),
            "??" => Expression::Catch(Rc::new(lhs), CatchType::PrintErr, None),
            "?>" => Expression::Catch(Rc::new(lhs), CatchType::PrintOver, None),
            "?!" => Expression::Catch(Rc::new(lhs), CatchType::TerminateOnErr, None),
            "_!" => Expression::Catch(Rc::new(lhs), CatchType::TerminateOnEmpty, None),
            "?~" => Expression::Catch(Rc::new(lhs), CatchType::ToBoolean, None),
            // "&:" => Expression::Catch(Rc::new(lhs), CatchType::OnSuccess, None),
            // "_:" => Expression::Catch(Rc::new(lhs), CatchType::OnEmpty, None),
            // "?:" => Expression::Catch(Rc::new(lhs), CatchType::Deel, None),
            _ => unreachable!(),
        })
    }
}
// 统一控制流解析（适用于语句和表达式）
fn parse_control_flow(input: Tokens<'_>) -> IResult<Tokens<'_>, Expression, SyntaxErrorKind> {
    let keyword = input
        .first()
        .map(|t| t.text(input))
        .ok_or_else(|| nom::Err::Error(SyntaxErrorKind::NoExpression))?;

    match keyword {
        "if" => parse_if_flow(input),
        "match" => parse_match_flow(input),
        "for" => parse_for_flow(input),
        "while" => parse_while_flow(input),
        "loop" => parse_loop_flow(input),
        "break" => parse_break(input),
        "continue" => parse_continue(input),
        "return" => parse_return(input),
        "shift" => parse_shift(input),
        _ => Err(nom::Err::Error(SyntaxErrorKind::NoExpression)),
    }
}

/// -- expr with cmd
/// a b c as expr
/// a as cmd
/// 如果是单独的symbol，则包装为命令
// fn parse_expr_with_single_cmd(
//     input: Tokens<'_>,
// ) -> IResult<Tokens<'_>, Expression, SyntaxErrorKind> {
//     // dbg!("---parse_single_expr");
//     let (input, expr) = parse_expr(input)?;
//     if let Expression::Symbol(s) = expr {
//         Ok((
//             input,
//             Expression::Command(Rc::new(Expression::Symbol(s)), Rc::new(vec![])),
//         ))
//     } else {
//         Ok((input, expr))
//     }
// }
// -- 子命令 --
// fn parse_subcommand(input: Tokens<'_>) -> IResult<Tokens<'_>, Expression, SyntaxErrorKind> {
//     // dbg!(input);
//     // let (input, sub) = delimited(text("`"), parse_command_call, text_close("`"))(input)?;
//     // 需要允许 && | 等操作，不能只是单独的命令。
//     let (input, sub) = delimited(text("`"), parse_expr_with_single_cmd, text_close("`"))(input)?;
//     // dbg!(input, &sub);
//     Ok((input, sub))
// }
// -- 分组 --
fn parse_group(input: Tokens<'_>) -> IResult<Tokens<'_>, Expression, SyntaxErrorKind> {
    delimited(
        terminated(text("("), opt(kind(TokenKind::LineBreak))),
        map(
            |inp| {
                parse_expr(inp).map_err(|e| match e {
                    nom::Err::Error(_) => SyntaxErrorKind::failure(
                        inp.get_str_slice(),
                        "some expression",
                        None,
                        Some("check grammar in this group"),
                    ),
                    other => other,
                })
            },
            |e| Expression::Group(Rc::new(e)),
        ),
        // map(alt((parse_math, parse_command_call)), |e| {
        //     Expression::Group(Box::new(e))
        // }),
        cut(preceded(opt(kind(TokenKind::LineBreak)), text_close(")"))),
    )(input)
}

fn parse_list(input: Tokens<'_>) -> IResult<Tokens<'_>, Expression, SyntaxErrorKind> {
    delimited(
        terminated(text("["), opt(kind(TokenKind::LineBreak))),
        terminated(
            map(
                separated_list0(
                    terminated(text(","), opt(kind(TokenKind::LineBreak))),
                    |inp| PrattParser::parse_expr_with_precedence(inp, PREC_FUNC_ARG, 0),
                    // parse_expr,
                ),
                Expression::from,
            ),
            opt(alt((
                map(text(","), |_| {}),
                map(kind(TokenKind::LineBreak), |_| {}),
            ))),
        ),
        cut(text_close("]")),
    )(input)
}

fn parse_pipe_method(input: Tokens<'_>) -> IResult<Tokens<'_>, Expression, SyntaxErrorKind> {
    let (input, _) = text(".")(input)?;
    let (input, method_name) = cut(parse_symbol_string)(input)?;
    let (input, args_opt) = opt(|input| parse_args(input, 0))(input)?;

    // 创建一个特殊的管道方法表达式
    match args_opt {
        Some(args) => Ok((input, Expression::PipeMethod(method_name, Rc::new(args)))),
        // _ => Ok((input, Expression::PipeMethod(method_name, Rc::new(vec![])))),
        // fallback to string if no () found. for filename like .config
        _ => Ok((input, Expression::String(format!(".{}", method_name)))),
    }
}

fn parse_chaind_call_or_property(
    input: Tokens<'_>,
    lhs: Expression,
    depth: usize,
) -> IResult<Tokens<'_>, Expression, SyntaxErrorKind> {
    // 解析方法名
    //dbg!("dot");
    let (input, method_name) = cut(parse_symbol_string)(input.skip_n(1))?;
    //dbg!(&method_name);
    // 检查是否有参数列表
    match input.first() {
        Some(s) if s.text(input) == "(" => {
            //dbg!("is chaincall");

            // 解析参数列表
            let (input, args) = parse_args(input, depth)?;
            //dbg!(&args, &input);

            // 创建链式调用
            let chain_call = ChainCall {
                method: method_name,
                args,
            };

            // 如果 lhs 已经是链式调用，则扩展它
            match lhs {
                Expression::Chain(base, mut calls) => {
                    calls.push(chain_call);
                    Ok((input, Expression::Chain(base, calls)))
                }
                _ => Ok((input, Expression::Chain(Rc::new(lhs), vec![chain_call]))),
            }
        }
        _ => {
            //dbg!("is index");

            // 无参数的属性访问，转换为索引操作
            Ok((
                input,
                Expression::Property(Rc::new(lhs), Rc::new(Expression::String(method_name))),
            ))
        }
    }
}

fn parse_args(
    input: Tokens<'_>,
    depth: usize,
) -> IResult<Tokens<'_>, Vec<Expression>, SyntaxErrorKind> {
    delimited(
        terminated(text("("), opt(kind(TokenKind::LineBreak))),
        cut(terminated(
            separated_list0(
                terminated(text(","), opt(kind(TokenKind::LineBreak))),
                |inp| {
                    PrattParser::parse_expr_with_precedence(inp, PREC_FUNC_ARG, depth + 1)
                    // PrattParser::parse_expr_with_precedence(inp, PREC_CMD_ARG, 0)
                },
            ),
            opt(kind(TokenKind::LineBreak)),
        )),
        cut(text_close(")")),
    )(input)
}

// 参数解析函数
fn parse_param(
    input: Tokens<'_>,
) -> IResult<Tokens<'_>, (String, Option<Expression>), SyntaxErrorKind> {
    alt((
        // 带默认值的参数解析分支
        map(
            separated_pair(
                parse_symbol_string,
                text("="),
                // 限制只能解析基本类型表达式
                cut(parse_literal),
            ),
            |(name, expr)| (name, Some(expr)), // 将结果包装为Some
        ),
        // map(preceded(text("*"), parse_symbol_string), |s| {
        //     (s, None, true)
        // }),
        // 普通参数解析分支
        map(parse_symbol_string, |s| (s, None)), // , 1+2 also match first symbol, so failed in ) parser.
    ))(input)
}

// 函数参数列表解析
#[allow(clippy::type_complexity)]
fn parse_param_list(
    input: Tokens<'_>,
) -> IResult<Tokens<'_>, (Vec<(String, Option<Expression>)>, Option<String>), SyntaxErrorKind> {
    let (input, _) = cut(text("("))(input).map_err(|_| {
        SyntaxErrorKind::failure(
            input.get_str_slice(),
            "params declaration",
            None,
            Some("declare params like (x,y,z=0)"),
        )
    })?;
    let (input, _) = opt(kind(TokenKind::LineBreak))(input)?; //允许可选回车
    let (input, params) = separated_list0(
        terminated(text(","), opt(kind(TokenKind::LineBreak))),
        parse_param,
    )(input)?;
    // let mut params = vec![];
    // let mut param_collector: Option<String> = None;
    // for (p, dvalue, is_colllector) in x {
    //     if is_colllector {
    //         param_collector = Some(p);
    //     } else {
    //         params.push((p, dvalue));
    //     }
    // }
    let (input, param_collector) = opt(preceded(
        terminated(text(","), opt(kind(TokenKind::LineBreak))),
        preceded(text("*"), parse_symbol_string),
    ))(input)?;
    // 如果还有其他字符，应报错
    // dbg!(&input, &params);
    // if !input.is_empty() {
    //     match input.first() {
    //         Some(&token) if token.text(input) != ")" => {
    //             // dbg!(token.text(input));
    //             return Err(SyntaxErrorKind::failure(
    //                 input.get_str_slice(),
    //                 "valid function params declare",
    //                 None,
    //                 Some("params should like (x,y=0)"),
    //             ));
    //         }
    //         _ => {}
    //     }
    // }
    let (input, _) = cut(text_close(")"))(input)?;
    Ok((input, (params, param_collector)))
}
// lambda参数
fn parse_lambda_param(input: Tokens<'_>) -> IResult<Tokens<'_>, Expression, SyntaxErrorKind> {
    let (input, expr) = delimited(
        text("("),
        // alt((
        // 参数列表特殊处理
        map(separated_list0(text(","), parse_symbol), |symbols| {
            Expression::from(symbols)
        }),
        //     parse_expr, // 常规表达式
        // )),
        |input| {
            text_close(")")(input).map_err(|_| {
                SyntaxErrorKind::failure(
                    input.get_str_slice(),
                    "valid lambda parameters",
                    None,
                    Some("lambda parameters must be comma-separated symbols: (x, y) -> body"),
                )
            })
        },
    )(input)?;
    // if input.first().is_some_and(|c| c.text(input) == "->") {
    Ok((input, Expression::Group(Rc::new(expr))))
    // } else {
    //     Err(nom::Err::Error(SyntaxErrorKind::NoExpression))
    // }
}
// 函数定义解析
fn parse_fn_declare(input: Tokens<'_>) -> IResult<Tokens<'_>, Expression, SyntaxErrorKind> {
    let (input, _) = opt(many0(kind(TokenKind::LineBreak)))(input)?;
    SyntaxErrorKind::empty_back(input)?;

    let (input, decos) = many0(preceded(
        text("@"),
        terminated(
            tuple((parse_symbol_string, opt(|input| parse_args(input, 0)))),
            kind(TokenKind::LineBreak),
        ),
    ))(input)?;

    let (input, _) = text("fn")(input)?;
    // dbg!("---parse_fn_declare");

    let (input, name) = cut(parse_symbol_string)(input).map_err(|_| {
        // eprintln!("mising fn name?");
        // dbg!(input, input.get_str_slice());
        SyntaxErrorKind::failure(
            input.get_str_slice(),
            "function name",
            None,
            Some("add a name"),
        )
    })?;
    let (input, (params, param_collector)) = cut(parse_param_list)(input)?; // 使用新参数列表
    let (input, _) = opt(kind(TokenKind::LineBreak))(input)?; //允许可选回车

    // 无函数体应报错
    // dbg!(&input, &params);
    if match input.first() {
        Some(&token) if token.text(input).ne("{") => true,
        None => true,
        _ => false,
    } {
        return Err(SyntaxErrorKind::failure(
            input.get_str_slice(),
            "function body",
            None,
            Some("add a body like {...}"),
        ));
    }
    let (input, body) = cut(parse_block)(input)?;
    // catch
    let (input, handler_options) = opt(alt((
        map(text("?."), |_| (CatchType::Ignore, None)),
        map(text("?+"), |_| (CatchType::PrintStd, None)),
        map(text("??"), |_| (CatchType::PrintErr, None)),
        map(text("?>"), |_| (CatchType::PrintOver, None)),
        map(text("?!"), |_| (CatchType::TerminateOnErr, None)),
        map(text("_!"), |_| (CatchType::TerminateOnEmpty, None)),
        map(text("?~"), |_| (CatchType::ToBoolean, None)),
        map(preceded(text("?:"), cut(parse_expr)), |e| {
            (CatchType::OnError, Some(Rc::new(e)))
        }),
        map(preceded(text("&:"), cut(parse_expr)), |e| {
            (CatchType::OnSuccess, Some(Rc::new(e)))
        }),
        map(preceded(text("_:"), cut(parse_expr)), |e| {
            (CatchType::OnEmpty, Some(Rc::new(e)))
        }),
    )))(input)?;

    let last_body = match handler_options {
        Some((ctyp, handler)) => Rc::new(Expression::Catch(Rc::new(body), ctyp, handler)),
        _ => Rc::new(body),
    };
    Ok((
        input,
        Expression::Function(name, params, param_collector, last_body, decos),
    ))
}
// return statement
fn parse_return(input: Tokens<'_>) -> IResult<Tokens<'_>, Expression, SyntaxErrorKind> {
    let (input, _) = text("return")(input)?;
    let (input, expr) = opt(parse_expr)(input)?;
    Ok((
        input,
        Expression::Return(Rc::new(expr.unwrap_or(Expression::None))),
    ))
}
fn parse_shift(input: Tokens<'_>) -> IResult<Tokens<'_>, Expression, SyntaxErrorKind> {
    let (input, _) = text("shift")(input)?;
    Ok((input, Expression::Shift))
}
fn parse_break(input: Tokens<'_>) -> IResult<Tokens<'_>, Expression, SyntaxErrorKind> {
    let (input, _) = text("break")(input)?;
    let (input, expr) = opt(parse_expr)(input)?;
    Ok((
        input,
        Expression::Break(Rc::new(expr.unwrap_or(Expression::None))),
    ))
}
fn parse_continue(input: Tokens<'_>) -> IResult<Tokens<'_>, Expression, SyntaxErrorKind> {
    let (input, _) = text("continue")(input)?;
    Ok((input, Expression::Continue))
}
// fn parse_command_call(input: Tokens<'_>) -> IResult<Tokens<'_>, Expression, SyntaxErrorKind> {
//     // 如果第二个token为operator,则不是命令。如 a = 3,
//     // dbg!(input.len());
//     // if input.len() > 1
//     //     && input
//     //         .skip_n(1)
//     //         .first()
//     //         .is_some_and(|x| x.kind == TokenKind::Operator)
//     // // && !["`", "("].contains(&x.text(input)))
//     // {
//     //     // dbg!("--->cmd escape---");

//     //     return Err(nom::Err::Error(SyntaxErrorKind::NoExpression));
//     // }
//     // dbg!("--->cmd call---");
//     let (input, ident) = PrattParser::parse_expr_with_precedence(input, PREC_CMD_NAME, 0)?;
//     let (input, args) =
//         many0(|inp| PrattParser::parse_expr_with_precedence(inp, PREC_CMD_ARG, 0))(input)?;
//     Ok((input, Expression::Command(Box::new(ident), args)))
// }

// -- 其他辅助函数保持与用户提供代码一致 --
#[inline]
fn kind(kind: TokenKind) -> impl Fn(Tokens<'_>) -> IResult<Tokens<'_>, StrSlice, SyntaxErrorKind> {
    move |input: Tokens<'_>| match input.first() {
        Some(&token) if token.kind == kind => Ok((input.skip_n(1), token.range)),
        _ => Err(nom::Err::Error(SyntaxErrorKind::CustomError(
            format!("expect token kind: {kind:?}"),
            input.get_str_slice(),
        ))),
    }
}

#[inline]
fn text<'a>(text: &'a str) -> impl Fn(Tokens<'a>) -> IResult<Tokens<'a>, Token, SyntaxErrorKind> {
    move |input: Tokens<'a>| match input.first() {
        Some(&token) if token.text(input) == text => Ok((input.skip_n(1), token)),
        _ => Err(nom::Err::Error(SyntaxErrorKind::CustomError(
            format!("expect {text:?}"),
            input.get_str_slice(),
        ))), // _ => Err(nom::Err::Error(SyntaxErrorKind::Expected {
             //     expected: "some text",
             //     input: input.get_str_slice(),
             //     found: None,
             //     hint: None,
             // })),
             // _ => Err(nom::Err::Error(SyntaxErrorKind::InternalError(format!(
             //     "expect text {}",
             //     text
             // )))),
    }
}
// fn text_starts_with<'a>(
//     text: &'a str,
// ) -> impl Fn(Tokens<'a>) -> IResult<Tokens<'a>, Token, SyntaxErrorKind> {
//     move |input: Tokens<'a>| match input.first() {
//         Some(&token) if token.text(input).starts_with(text) => Ok((input.skip_n(1), token)),
//         _ => Err(nom::Err::Error(SyntaxErrorKind::InternalError)),
//     }
// }
#[inline]
fn text_close<'a>(
    text: &'static str,
) -> impl Fn(Tokens<'a>) -> IResult<Tokens<'a>, Token, SyntaxErrorKind> {
    move |input: Tokens<'a>| match input.first() {
        Some(&token) if token.text(input) == text => Ok((input.skip_n(1), token)),
        _ => Err(SyntaxErrorKind::unclosed_delimiter(
            input.get_str_slice(),
            text,
        )),
    }
}

#[inline]
fn parse_symbol(input: Tokens<'_>) -> IResult<Tokens<'_>, Expression, SyntaxErrorKind> {
    map(kind(TokenKind::Symbol), |t| {
        Expression::Symbol(t.to_str(input.str).to_string())
    })(input)
}
#[inline]
fn parse_symbol_string(input: Tokens<'_>) -> IResult<Tokens<'_>, String, SyntaxErrorKind> {
    map(kind(TokenKind::Symbol), |t| t.to_str(input.str).to_string())(input)
}
#[inline]
fn parse_variable(input: Tokens<'_>) -> IResult<Tokens<'_>, Expression, SyntaxErrorKind> {
    preceded(text("$"), map(parse_symbol_string, Expression::Variable))(input)
}

fn parse_string_literal_inner(
    input: Tokens<'_>,
    kind: TokenKind,
) -> IResult<Tokens<'_>, String, SyntaxErrorKind> {
    let token = input
        .first()
        .filter(|t| t.kind == kind)
        .ok_or(nom::Err::Error(SyntaxErrorKind::CustomError(
            format!("expect token kind: {:?}", kind),
            input.get_str_slice(),
        )))?;

    let cs = token.text_inner(input);

    let r = if token.open_len > 2 {
        // raw 模式，跳过引号转义
        unescape_str(cs, true)
    } else {
        // " "  ` ` 模式，转义所有
        unescape_str(cs, false)
    };
    Ok((input.skip_n(1), r))
}

fn parse_string(input: Tokens<'_>) -> IResult<Tokens<'_>, Expression, SyntaxErrorKind> {
    let (input, r) = parse_string_literal_inner(input, TokenKind::StringLiteral)?;
    Ok((input, Expression::String(r)))
}

fn parse_strings_via_kind(
    input: Tokens<'_>,
    kind: TokenKind,
) -> IResult<Tokens<'_>, String, SyntaxErrorKind> {
    let token = input
        .first()
        .filter(|t| t.kind == kind)
        .ok_or(nom::Err::Error(SyntaxErrorKind::CustomError(
            format!("expect token kind: {:?}", kind),
            input.get_str_slice(),
        )))?;

    let cs = token.text_inner(input);

    let r = if token.open_len > 2 {
        // r#'...' 无需转义
        cs.to_string()
    } else {
        // 对'...'进行简单转义
        cs.replace("\\'", "'")
            .replace("\\\"", "\"")
            .replace("\\\\", "\\")
    };
    Ok((input.skip_n(1), r))
}

fn parse_string_raw_inner(input: Tokens<'_>) -> IResult<Tokens<'_>, String, SyntaxErrorKind> {
    parse_strings_via_kind(input, TokenKind::StringRaw)
}

fn parse_string_raw(input: Tokens<'_>) -> IResult<Tokens<'_>, Expression, SyntaxErrorKind> {
    let (input, r) = parse_string_raw_inner(input)?;
    Ok((input, Expression::String(r)))
}

fn parse_regex(input: Tokens<'_>) -> IResult<Tokens<'_>, Expression, SyntaxErrorKind> {
    let (input, r) = parse_strings_via_kind(input, TokenKind::Regex)?;
    Ok((input, Expression::RegexDef(r)))
}
fn parse_time(input: Tokens<'_>) -> IResult<Tokens<'_>, Expression, SyntaxErrorKind> {
    let (input, r) = parse_strings_via_kind(input, TokenKind::Time)?;
    Ok((input, Expression::TimeDef(r)))
}
fn parse_string_safe(input: Tokens<'_>) -> IResult<Tokens<'_>, Expression, SyntaxErrorKind> {
    let (input, r) = parse_strings_via_kind(input, TokenKind::StringSafe)?;
    Ok((input, Expression::StringSafe(r)))
}
fn parse_bytes(input: Tokens<'_>) -> IResult<Tokens<'_>, Expression, SyntaxErrorKind> {
    let (input, r) = parse_strings_via_kind(input, TokenKind::Bytes)?;
    let r = unescape_bytes(&r);
    Ok((input, Expression::Bytes(r)))
}

// #[inline]
// fn parse_string_template(input: Tokens<'_>) -> IResult<Tokens<'_>, Expression, SyntaxErrorKind> {
//     let (input, r) = parse_string_common(input, TokenKind::StringTemplate, true, true)?;
//     Ok((input, Expression::StringTemplate(r.into())))
// }
/// 将模板字符串内容分解为表达式片段列表
/// 从 start 位置开始，找到匹配的 '}' 的字节位置
fn find_matching_brace(s: &str, start: usize) -> Option<usize> {
    let mut depth = 1usize;
    let mut i = start;
    for ch in s[start..].chars() {
        match ch {
            '{' => depth += 1,
            '}' => {
                depth -= 1;
                if depth == 0 {
                    return Some(i);
                }
            }
            _ => {}
        }
        i += ch.len_utf8();
    }
    None
}
/// 从 start（'{' 之后的位置）解析花括号内的表达式
/// prefix 用于解析失败时还原原始文本（"$" 或 ""）
fn parse_brace_segment(template: &str, start: usize, prefix: &str) -> Option<(Expression, usize)> {
    let end = find_matching_brace(template, start)?;
    let inner = &template[start..end];

    let expr = match parse_script(inner) {
        Ok(expr) => expr,
        Err(_) => Expression::String(format!("{prefix}{{{inner}}}")),
    };

    Some((expr, end + 1)) // end + 1 跳过 '}'
}
/// 将模板字符串内容分解为表达式片段列表
/// 支持三种插值语法：
///   $var      — 简单变量查找（直接 env.get，不走 parse）
///   {expr}    — 表达式求值（parse + eval）
///   ${expr}   — 同上，bash 风格别名
fn split_template_segments(template: &str) -> Vec<Expression> {
    let mut segments: Vec<Expression> = Vec::new();
    let mut literal = String::new();
    let mut i = 0usize;

    while i < template.len() {
        let c = match template[i..].chars().next() {
            Some(c) => c,
            None => break,
        };
        let char_len = c.len_utf8();

        match c {
            '\\' => {
                // 转义：\{ \$ 输出字面量，其余保留反斜杠
                if let Some(next) = template[i + char_len..].chars().next() {
                    match next {
                        '{' | '$' | '}' => {
                            literal.push(next);
                            i += char_len + next.len_utf8();
                        }
                        _ => {
                            literal.push('\\');
                            i += char_len;
                        }
                    }
                } else {
                    literal.push('\\');
                    i += char_len;
                }
            }
            '$' => {
                let rest = &template[i + char_len..];
                if let Some(next) = rest.chars().next() {
                    if next == '{' {
                        // ${expr} — start 跳过 '$' 和 '{'
                        let start = i + char_len + next.len_utf8();
                        if let Some((expr, next_i)) = parse_brace_segment(template, start, "$") {
                            if !literal.is_empty() {
                                segments.push(Expression::String(std::mem::take(&mut literal)));
                            }
                            segments.push(expr);
                            i = next_i;
                        } else {
                            literal.push('$');
                            i += char_len;
                        }
                    } else if next.is_alphanumeric() || next == '_' {
                        // $var 形式：直接作为 Variable，不走 parse
                        if !literal.is_empty() {
                            segments.push(Expression::String(std::mem::take(&mut literal)));
                        }
                        let var_start = i + char_len;
                        let mut var_end = var_start;
                        for ch in template[var_start..].chars() {
                            if ch.is_alphanumeric() || ch == '_' || ch == '.' || ch == '-' {
                                var_end += ch.len_utf8();
                            } else {
                                break;
                            }
                        }
                        segments.push(Expression::Variable(
                            template[var_start..var_end].to_string(),
                        ));
                        i = var_end;
                    } else {
                        literal.push('$');
                        i += char_len;
                    }
                }
            }
            '{' => {
                // {expr} — start 跳过 '{'
                let start = i + char_len;
                if let Some((expr, next_i)) = parse_brace_segment(template, start, "") {
                    if !literal.is_empty() {
                        segments.push(Expression::String(std::mem::take(&mut literal)));
                    }
                    segments.push(expr);
                    i = next_i;
                } else {
                    // 无匹配 '}'，作为字面量
                    literal.push('{');
                    i += char_len;
                }
            }
            _ => {
                literal.push(c);
                i += char_len;
            }
        }
    }

    if !literal.is_empty() {
        segments.push(Expression::String(literal));
    }
    segments
}

fn parse_string_template(input: Tokens<'_>) -> IResult<Tokens<'_>, Expression, SyntaxErrorKind> {
    let (input, r) = parse_string_literal_inner(input, TokenKind::StringTemplate)?;
    let segments = split_template_segments(&r);
    Ok((input, Expression::StringTemplate(segments)))
}
// -- 字面量解析 --

fn parse_literal(input: Tokens<'_>) -> IResult<Tokens<'_>, Expression, SyntaxErrorKind> {
    alt((
        parse_integer,
        parse_float,
        parse_string,
        parse_string_raw,
        parse_string_template,
        parse_value_symbol,
        parse_regex,
        parse_time,
        parse_radix(TokenKind::Radix2),
        parse_radix(TokenKind::Radix8),
        parse_radix(TokenKind::Radix16),
    ))(input)
}

fn parse_set_inner<'a>(input: Tokens<'a>) -> IResult<Tokens<'a>, Vec<Expression>, SyntaxErrorKind> {
    let (input, _) = terminated(text("S{"), opt(kind(TokenKind::LineBreak)))(input)?;
    let (input, pairs) = separated_list0(
        terminated(text(","), opt(kind(TokenKind::LineBreak))),
        |inp| {
            alt((
                parse_literal,
                parse_variable,
                parse_symbol,
                parse_list,
                parse_bmap,
                parse_hashmap,
                parse_map,
                parse_bset,
            ))(inp)
            .map_err(|e| match e {
                // Failure 来自内部 cut（如未闭合的列表），直接透传保留具体错误
                nom::Err::Failure(inner) => nom::Err::Failure(inner),
                // Error 表示完全没识别出任何元素（如遇到 `}`），转为 Error 而非 Failure
                // 这样 separated_list0 才能回退，允许末尾逗号
                _ => SyntaxErrorKind::expected(
                    inp.get_str_slice(),
                    "a value",
                    None,
                    Some("add a value for this item"),
                ),
            })
        },
    )(input)?;

    let (input, comma) = opt(text(","))(input)?;
    let (input, _) = opt(kind(TokenKind::LineBreak))(input)?;
    let (input, _) = text_close("}")(input).map_err(|_| {
        SyntaxErrorKind::failure(
            input.get_str_slice(),
            if comma.is_some() { "`}`" } else { "`}` or `,`" },
            input.first().map(|t| t.text(input).to_string()),
            if comma.is_some() {
                Some("unclosed Set?")
            } else {
                Some("missing comma between items?")
            },
        )
    })?;
    Ok((input, pairs))
}

fn parse_map_inner<'a>(
    input: Tokens<'a>,
    tag: &'static str,
) -> IResult<Tokens<'a>, Vec<(String, Option<Expression>)>, SyntaxErrorKind> {
    let (input, _) = terminated(text(tag), opt(kind(TokenKind::LineBreak)))(input)?;
    let (input, pairs) = separated_list0(
        terminated(text(","), opt(kind(TokenKind::LineBreak))),
        tuple((
            |inp| {
                alt((
                    parse_symbol_string,
                    map(kind(TokenKind::StringRaw), |t| {
                        t.to_str(input.str).to_string()
                    }),
                    map(kind(TokenKind::StringLiteral), |t| {
                        t.to_str(input.str).to_string()
                    }),
                ))(inp)
                .map_err(|e| match e {
                    // Failure 来自内部 cut（如未闭合的列表），直接透传保留具体错误
                    nom::Err::Failure(inner) => nom::Err::Failure(inner),
                    // Error 表示完全没识别出任何元素（如遇到 `}`），转为 Error 而非 Failure
                    // 这样 separated_list0 才能回退，允许末尾逗号
                    _ => SyntaxErrorKind::expected(
                        inp.get_str_slice(),
                        "a value",
                        None,
                        Some("add a symbol/string as key"),
                    ),
                })
            },
            opt(preceded(
                terminated(text(":"), opt(kind(TokenKind::LineBreak))),
                cut(|inp| {
                    PrattParser::parse_expr_with_precedence(inp, PREC_FUNC_ARG, 0)
                        // alt((
                        //     parse_literal,
                        //     parse_variable,
                        //     parse_symbol,
                        //     parse_list,
                        //     parse_bmap,
                        //     parse_hashmap,
                        //     parse_map,
                        //     parse_bset,
                        // ))(inp)
                        .map_err(|e| match e {
                            // Failure 来自内部 cut（如未闭合的列表），直接透传保留具体错误
                            nom::Err::Failure(inner) => nom::Err::Failure(inner),
                            // Error 表示完全没识别出任何元素（如遇到 `}`），转为 Error 而非 Failure
                            // 这样 separated_list0 才能回退，允许末尾逗号
                            _ => SyntaxErrorKind::failure(
                                inp.get_str_slice(),
                                "a value",
                                None,
                                Some("add a value for this item"),
                            ),
                        })
                }),
            )),
        )),
    )(input)?;

    // dbg!(&input, &pairs);
    let (input, comma) = opt(text(","))(input)?;
    // if tag == "{"
    //     && (pairs.is_empty() || comma.is_none() && pairs.len() < 2 && pairs[0].1.is_none())
    // {
    //     return Err(nom::Err::Error(SyntaxErrorKind::NoExpression)); //return err and try parse_block
    // }
    let (input, _) = opt(kind(TokenKind::LineBreak))(input)?;

    // 确认是map上下文后，把 Error 转为 Failure，防止回退到 parse_block
    // 错误位置指向当前 input（缺少逗号的地方），而非 k3
    let (input, _) = text_close("}")(input).map_err(|_| {
        SyntaxErrorKind::failure(
            input.get_str_slice(), // ← 当前位置，即 k3 前（v2 后）
            if comma.is_some() { "`}`" } else { "`}` or `,`" },
            input.first().map(|t| t.text(input).to_string()),
            if comma.is_some() {
                Some("unclosed Map?")
            } else {
                Some("missing comma between map entries?")
            },
        )
    })?;

    Ok((input, pairs))
}

// src/parser.rs，新增辅助函数
/// 前瞻检查：从 `(` 开始，找到匹配的 `)` 后下一个 token 是否为 `->`
fn has_lambda_arrow(input: Tokens<'_>) -> bool {
    // input 当前指向 `(`
    let mut depth = 0usize;
    for (i, token) in input.slice.iter().enumerate() {
        match token.range.to_str(input.str) {
            "(" => depth += 1,
            ")" => {
                depth -= 1;
                if depth == 0 {
                    return input
                        .slice
                        .get(i + 1)
                        .is_some_and(|t| t.range.to_str(input.str) == "->");
                }
            }
            _ => {}
        }
    }
    false
}

/// 前瞻检查：`{` 之后是否像 map（key: 或 key,）
///
// 输入	前瞻结果	行为
// {}	false（第二 token 是 }）	直接走 block ✓
// {if ...}	false（first 是 Keyword）	直接走 block ✓
// {a b}	false（second 是 Symbol）	直接走 block ✓
// {a = 1}	false（second 是 =）	直接走 block ✓
// {a: v}	true	先尝试 map ✓
// {a, b}	true	先尝试 map ✓
// {"k": v}	true	先尝试 map ✓
fn looks_like_map(input: Tokens<'_>) -> bool {
    // input 当前指向 `{`，从第 1 个 token 开始（跳过 `{`）
    let mut i = 1;
    // 跳过可能的换行
    while input
        .slice
        .get(i)
        .is_some_and(|t| t.kind == TokenKind::LineBreak)
    {
        i += 1;
    }
    let first = input.slice.get(i);
    let second = input.slice.get(i + 1);
    match (first, second) {
        (Some(f), Some(s)) => {
            let is_key = matches!(
                f.kind,
                TokenKind::Symbol | TokenKind::StringLiteral | TokenKind::StringRaw
            );
            let s_text = s.range.to_str(input.str);
            is_key && (s_text == ":" || s_text == ",")
        }
        _ => false,
    }
}

/// BtreeMap 映射解析
fn parse_map(input: Tokens<'_>) -> IResult<Tokens<'_>, Expression, SyntaxErrorKind> {
    // 不能用cut，防止map识别失败时，影响后面的block解析。
    let (input, pairs) = parse_map_inner(input, "{")?;

    let map: BTreeMap<String, Expression> = pairs
        .into_iter()
        .map(|(k, v)| match v {
            Some(ex) => (k, ex),
            None => (k.clone(), Expression::Variable(k)),
        })
        .collect();
    Ok((input, Expression::from(map)))
}

fn parse_bmap(input: Tokens<'_>) -> IResult<Tokens<'_>, Expression, SyntaxErrorKind> {
    // 不能用cut，防止map识别失败时，影响后面的block解析。
    let (input, pairs) = parse_map_inner(input, "M{")?;

    let map: BTreeMap<String, Expression> = pairs
        .into_iter()
        .map(|(k, v)| match v {
            Some(ex) => (k, ex),
            None => (k.clone(), Expression::Variable(k)),
        })
        .collect();
    Ok((input, Expression::from(map)))
}

/// HashMap
fn parse_hashmap(input: Tokens<'_>) -> IResult<Tokens<'_>, Expression, SyntaxErrorKind> {
    let (input, pairs) = parse_map_inner(input, "H{")?;

    let map: HashMap<String, Expression> = pairs
        .into_iter()
        .map(|(k, v)| match v {
            Some(ex) => (k, ex),
            None => (k.clone(), Expression::Variable(k)),
        })
        .collect();
    Ok((input, Expression::from(map)))
}

fn parse_bset(input: Tokens<'_>) -> IResult<Tokens<'_>, Expression, SyntaxErrorKind> {
    let (input, pairs) = parse_set_inner(input)?;

    let mut map = BTreeSet::new();
    for e in pairs {
        map.insert(e);
    }
    Ok((input, Expression::BSet(Rc::new(map))))
}

#[inline]
fn parse_integer(input: Tokens<'_>) -> IResult<Tokens<'_>, Expression, SyntaxErrorKind> {
    let (input, num) = kind(TokenKind::IntegerLiteral)(input)?;
    let num = num
        .to_str(input.str)
        .replace('_', "")
        .parse::<Int>()
        .map_err(|e| SyntaxErrorKind::failure(num, "Integer", Some(format!("error: {e}")), None))?;
    Ok((input, Expression::Integer(num)))
}

#[inline]
fn parse_float(input: Tokens<'_>) -> IResult<Tokens<'_>, Expression, SyntaxErrorKind> {
    let (input, num) = kind(TokenKind::FloatLiteral)(input)?;
    let num = num
        .to_str(input.str)
        .replace('_', "")
        .parse::<f64>()
        .map_err(|e| {
            SyntaxErrorKind::failure(
                num,
                "float",
                Some(format!("error: {e}")),
                Some("valid floats can be written like 1.0 or 5.23"),
            )
        })?;
    Ok((input, Expression::Float(num)))
}

fn parse_radix(
    kind: TokenKind,
) -> impl Fn(Tokens<'_>) -> IResult<Tokens<'_>, Expression, SyntaxErrorKind> {
    move |input: Tokens<'_>| {
        let token = input
            .first()
            .filter(|t| t.kind == kind)
            .ok_or(nom::Err::Error(SyntaxErrorKind::CustomError(
                format!("expect token kind: {:?}", kind),
                input.get_str_slice(),
            )))?;
        let cs = token.text_inner(input).replace("_", "");
        let parsed = match kind {
            TokenKind::Radix2 => Int::from_str_radix(&cs, 2),
            TokenKind::Radix8 => Int::from_str_radix(&cs, 8),
            TokenKind::Radix16 => Int::from_str_radix(&cs, 16),
            _ => unreachable!(),
        };

        let value = parsed.map_err(|e| {
            SyntaxErrorKind::failure(
                input.get_str_slice(),
                "Radix Integer",
                Some(format!("error: {e}")),
                None,
            )
        })?;

        Ok((input.skip_n(1), Expression::Integer(value)))
    }
}

#[inline]
fn parse_value_symbol(input: Tokens<'_>) -> IResult<Tokens<'_>, Expression, SyntaxErrorKind> {
    map(kind(TokenKind::ValueSymbol), |s| {
        match s.to_str(input.str) {
            "true" => Expression::Boolean(true),
            "false" => Expression::Boolean(false),
            "_" => Expression::Blank,
            // "None" => Expression::None,
            _ => Expression::None,
        }
    })(input)
}
#[inline]
fn parse_blank(input: Tokens<'_>) -> IResult<Tokens<'_>, Expression, SyntaxErrorKind> {
    let (input, v) = kind(TokenKind::ValueSymbol)(input)?;

    if v.to_str(input.str) == "_" {
        return Ok((input, Expression::Blank));
    }
    Err(nom::Err::Error(SyntaxErrorKind::NoExpression))
}

fn normalize_linebreaks(tokens: &mut Vec<Token>) {
    let mut i = 0;
    while i < tokens.len() {
        if tokens[i].kind == TokenKind::LineBreak {
            // 查找连续的 LineBreak 的数量
            let mut j = i + 1;
            while j < tokens.len() && tokens[j].kind == TokenKind::LineBreak {
                j += 1;
            }

            // 如果有多个连续的 LineBreak，则删除从 i+1 到 j-1 的所有 LineBreak
            if j > i + 1 {
                tokens.drain(i + 1..j);
                // 保持 i 不变，因为当前索引仍指向第一个 LineBreak
            } else {
                i += 1; // 只有一个 LineBreak，移动到下一个
            }
        } else {
            i += 1;
        }
    }
}

// -- 脚本解析 --
pub fn tokenize_source(input: &Str) -> Result<Vec<Token>, nom::Err<SyntaxErrorKind>> {
    #[cfg(windows)]
    let input: Str = input.trim_matches('\0').into();
    #[cfg(windows)]
    let tokenization_input = Input::new(&input);
    // 词法分析阶段
    #[cfg(unix)]
    let tokenization_input = Input::new(input);
    let (mut token_vec, mut diagnostics) = super::parse_tokens(tokenization_input);

    // 错误处理
    diagnostics.retain(|d| d != &Diagnostic::Valid);
    if !diagnostics.is_empty() {
        // dbg!(&token_vec);
        return Err(nom::Err::Failure(SyntaxErrorKind::TokenizationErrors(
            diagnostics.into_boxed_slice(),
        )));
    }

    // remove whitespace
    token_vec.retain(|t| {
        !matches!(
            t.kind,
            TokenKind::Whitespace | TokenKind::Comment | TokenKind::ModeTip
        )
    });
    normalize_linebreaks(&mut token_vec);
    Ok(token_vec)
}
// -- 模块导入 入口函数 --
pub fn use_script(input: &str) -> Result<ModuleInfo, nom::Err<SyntaxErrorKind>> {
    let str: Str = input.into();
    let token_vec = tokenize_source(&str)?;
    let (_, parsed) = parse_module_selective(Tokens {
        str: &str,
        slice: token_vec.as_slice(),
    })?;
    Ok(parsed)
}
// -- 入口函数 --
pub fn parse_script(input: &str) -> Result<Expression, nom::Err<SyntaxErrorKind>> {
    let str: Str = input.into();
    let token_vec = tokenize_source(&str)?;
    let (_, parsed) = parse_script_tokens(Tokens {
        str: &str,
        slice: token_vec.as_slice(),
    })?;
    Ok(parsed)
}
// ================== 控制结构解析 ==================
// 核心解析流程架构
pub fn parse_script_tokens(
    input: Tokens<'_>,
    // require_eof: bool,
) -> IResult<Tokens<'_>, Expression, SyntaxErrorKind> {
    if input.is_empty() {
        return Ok((input, Expression::None));
    }
    // dbg!("---------parse_script_tokens");

    // 阶段1：解析语句序列（控制结构在此处理）
    // dbg!("------>1", input);
    // let (input, mut functions) = many0(parse_statement)(input)?;
    let (input, module) = terminated(
        parse_module,
        opt(alt((kind(TokenKind::LineBreak), eof_slice))), // 允许换行符作为语句分隔
    )(input)?;
    // blank lines on the end
    let (input, _) = opt(many0(kind(TokenKind::LineBreak)))(input)?;

    if !input.is_empty() {
        // dbg!("-----==>Remaining:", &input.slice, &functions);
        // eprintln!(
        //     "unrecognized satement. \nremaining:{:?}\nrecognized:{:?}",
        //     &input.slice, &module
        // );
        return Err(nom::Err::Failure(SyntaxErrorKind::TokenizationErrors(
            Box::new([Diagnostic::NotTokenized(input.get_str_slice())]),
        )));
    }

    // dbg!("==========", &functions);
    match module.len() {
        0 => Err(nom::Err::Error(SyntaxErrorKind::NoExpression)),
        1 => {
            let s = module.first().unwrap();
            Ok((input, s.clone()))
        }
        _ => Ok((input, Expression::Sequence(module))),
    }
}
/// 函数解析（顶层结构）
fn parse_module(input: Tokens<'_>) -> IResult<Tokens<'_>, Vec<Expression>, SyntaxErrorKind> {
    // dbg!("---parse_functions");

    let (input, module) = cut(many0(alt((
        terminated(
            parse_use_statement,
            opt(kind(TokenKind::LineBreak)), // 允许换行符作为语句分隔
        ),
        // parse_import,        // 模块导入（仅语句级）
        terminated(
            parse_fn_declare,
            opt(kind(TokenKind::LineBreak)), // 允许换行符作为语句分隔
        ), // 函数声明（顶级）
        terminated(
            // parse_statement_with_better_errors,
            parse_statement,
            opt(kind(TokenKind::LineBreak)), // 允许换行符作为语句分隔
        ), // 函数声明（顶级）
    ))))(input)?;
    // let (input, _) = opt(kind(TokenKind::LineBreak))(input)?; // 消费换行符

    // dbg!(&input, &module);
    Ok((input, module))
}
// 语句块解析器（顶层结构）
// fn parse_statement_with_better_errors(
//     mut input: Tokens<'_>,
// ) -> IResult<Tokens<'_>, Expression, SyntaxErrorKind> {
//     (input, _) = opt(kind(TokenKind::LineBreak))(input)?;

//     let mut best_error = None;
//     // let mut furthest_position = 0;

//     // 尝试每个解析器，保留最好的错误
//     for parser in [
//         parse_fn_declare,
//         parse_lazy_assign,
//         parse_declare,
//         parse_alias,
//         parse_del,
//         parse_single_expr,
//     ] {
//         match parser(input) {
//             Ok(result) => return Ok(result),
//             Err(nom::Err::Error(e)) => {
//                 // let pos = get_error_position(&e);
//                 // if pos >= furthest_position || is_better_error(&e, &best_error) {
//                 //     best_error = Some(e);
//                 //     furthest_position = pos;
//                 // }
//                 eprintln!("[E] \x1b[31m[ERROR]\x1b[0m {:?}", e);
//                 best_error = Some(e);
//             }
//             Err(other) => return Err(other), // Failure 或 Incomplete 直接返回
//         };
//     }

//     Err(nom::Err::Error(
//         best_error.unwrap(), //     best_error.unwrap_or(SyntaxErrorKind::NoExpression),
//     ))
// }

fn parse_statement(mut input: Tokens<'_>) -> IResult<Tokens<'_>, Expression, SyntaxErrorKind> {
    // dbg!("---parse_statement");
    // dbg!(input);
    (input, _) = opt(many0(kind(TokenKind::LineBreak)))(input)?;
    // if input.is_empty() {
    //     // dbg!("---break prefix---");
    //     return Err(nom::Err::Error(SyntaxErrorKind::NoExpression));
    // }
    // SyntaxErrorKind::empty_back(input)?;

    let keyword = input
        .first()
        .map(|t| t.text(input))
        .ok_or_else(|| nom::Err::Error(SyntaxErrorKind::NoExpression))?;
    match keyword {
        "fn" => parse_fn_declare(input), // 函数声明（仅语句级）这里的作用是允许函数嵌套
        "use" => parse_use_statement(input), //允许语句中间按需use
        // 1.声明语句
        "let" => parse_lets(input),
        "set" => parse_set(input),
        "alias" => parse_alias(input),
        "export" => parse_export(input),
        "del" => parse_del(input),
        // 2.控制流语句
        // parse_control_flow,
        // 3.运算语句: !3, 1+2, must before flat_call,
        // or discard this, only allow `let a=3+2` => parse_declare
        // or discard this, only allow `a=3+2` => parse_expr
        // parse_direct_print,
        // parse_math,
        // 4.执行语句: ls -l, add(x)
        // parse_func_call,
        // parse_direct_fn_call,
        // parse_cmd_or_math,
        // parse_command_call,
        // 便捷控制台打印
        // 5.单语句： 字面量和单独的symbol：[2,3] 4 "5" ls x
        _ => parse_single_expr(input),
    }
}
///命令或数学运算。
// ///语句开始，等号后，括号中：应匹配 cmd call，match compute.
// /// 便捷控制台打印
//         TokenKind::IntegerLiteral
//         | TokenKind::FloatLiteral
//         | TokenKind::Operator
//         | TokenKind::StringLiteral
//         | TokenKind::StringRaw
//         | TokenKind::OperatorPrefix => {
//             parse_expr(input) // 完整表达式
//             // terminated(
//             //     opt(alt((
//             //         // 必须包含语句终止符
//             //         kind(TokenKind::LineBreak),
//             //         eof_slice, // 允许文件末尾无终止符
//             //     ))),
//             // )(input)
//         }
//         TokenKind::Symbol
//             if input.len() > 1
//                 && input
//                     .skip_n(1)
//                     .first()
//                     .is_some_and(|x| x.kind == TokenKind::Operator) =>
//         {
//             parse_expr(input)
//         }
//         _ => Err(nom::Err::Error(SyntaxErrorKind::NoExpression)),
//     }
// }
/// 单独语句
fn parse_single_expr(input: Tokens<'_>) -> IResult<Tokens<'_>, Expression, SyntaxErrorKind> {
    // dbg!("---parse_single_expr");
    // let is_single_cmd = input.len() == 1;
    let (input, expr) = terminated(
        parse_expr, // 完整表达式
        opt(alt((
            // 必须包含语句终止符
            kind(TokenKind::LineBreak),
            eof_slice, // 允许文件末尾无终止符
        ))),
    )(input)?;
    // if is_single_cmd && input.is_empty() {

    Ok((input, expr))
}

// IF语句解析（支持else if链）
fn parse_if_flow(input: Tokens<'_>) -> IResult<Tokens<'_>, Expression, SyntaxErrorKind> {
    let (input, _) = text("if")(input)?;
    let (input, cond) = cut(parse_expr)(input)?;
    let (input, then_block) = alt((
        parse_domain_block, // 优先识别 %{...} 块
        parse_block_as_sequence, // 优先识别 {...} 块
                            // parse_expr,  // 单行表达式（如 x > y ? a : b）
    ))(input)
    .map_err(|e| match e {
        nom::Err::Error(_) => SyntaxErrorKind::failure(
            input.get_str_slice(),
            "a block `{...}`",
            input.first().map(|t| t.text(input).to_string()),
            Some("if condition must be followed by a block: `if cond { ... }`"),
        ),
        // nom::Err::Failure(f) => nom::Err::Failure(f),
        other => other,
    })?; //must have block to differ with condition
    // 解析else分支
    let (input, else_branch) = opt(preceded(
        text("else"),
        cut(alt((
            parse_if_flow,       // else if
            parse_block_or_expr, // else
        ))),
    ))(input)
    .map_err(|_| {
        SyntaxErrorKind::failure(
            input.get_str_slice(),
            "some body",
            None,
            Some("add a body for `else`"),
        )
    })?;

    Ok((
        input,
        Expression::If(
            Rc::new(cond),
            Rc::new(then_block),
            Rc::new(else_branch.unwrap_or(Expression::None)),
        ),
    ))
}

// WHILE循环解析
fn parse_while_flow(input: Tokens<'_>) -> IResult<Tokens<'_>, Expression, SyntaxErrorKind> {
    let (input, _) = text("while")(input)?;
    let (input, cond) = cut(parse_expr)(input)?;
    let (input, body) = cut(parse_block)(input)?;

    Ok((input, Expression::While(Rc::new(cond), Rc::new(body))))
}
// LOOP循环解析
fn parse_loop_flow(input: Tokens<'_>) -> IResult<Tokens<'_>, Expression, SyntaxErrorKind> {
    let (input, _) = text("loop")(input)?;
    let (input, body) = cut(parse_block)(input)?;

    Ok((input, Expression::Loop(Rc::new(body))))
}

// FOR循环解析
fn parse_for_flow(input: Tokens<'_>) -> IResult<Tokens<'_>, Expression, SyntaxErrorKind> {
    let (input, _) = text("for")(input)?;
    let (input, pat_ind) = opt(terminated(parse_symbol_string, text(",")))(input)?;
    let (input, pat_var) = cut(parse_symbol_string)(input).map_err(|_| {
        SyntaxErrorKind::failure(
            input.get_str_slice(),
            "loop variable",
            input.first().map(|t| t.text(input).to_string()),
            Some("add a variable name"),
        )
    })?;
    let (input, _) = cut(text("in"))(input)?;
    let (input, iterable) = cut(parse_expr)(input).map_err(|_| {
        SyntaxErrorKind::failure(
            input.get_str_slice(),
            "loop target",
            input.first().map(|t| t.text(input).to_string()),
            Some("add a iterable expression"),
        )
    })?;
    let (input, body) = cut(parse_block)(input)?;

    Ok((
        input,
        Expression::For(pat_var, pat_ind, Rc::new(iterable), Rc::new(body)),
    ))
}

// MATCH表达式解析
fn parse_match_flow(input: Tokens<'_>) -> IResult<Tokens<'_>, Expression, SyntaxErrorKind> {
    let (input, _) = text("match")(input)?;
    let (input, target) = cut(parse_expr)(input)?;
    let (input, _) = cut(terminated(text("{"), opt(kind(TokenKind::LineBreak))))(input)?;

    // 解析多个匹配分支
    let (input, expr_map) = cut(separated_list1(
        kind(TokenKind::LineBreak),
        separated_pair(
            parse_pattern,
            cut(terminated(text("=>"), opt(kind(TokenKind::LineBreak)))),
            cut(|inp| {
                parse_expr(inp).map_err(|e| match e {
                    // Failure 是内部已有具体位置信息的错误，直接透传保留
                    // nom::Err::Failure(inner) => nom::Err::Failure(inner),
                    // Error 表示完全没识别出表达式，此时才用上下文消息
                    nom::Err::Error(_) => SyntaxErrorKind::failure(
                        inp.get_str_slice(),
                        "invalid arm action",
                        inp.first().map(|t| t.text(inp).to_string()),
                        Some("check grammar of this arm action"),
                    ),
                    other => other,
                })
            }),
        ),
    ))(input)?;
    // let (input, _) = opt(text(","))(input)?;
    let (input, _) = opt(kind(TokenKind::LineBreak))(input)?;
    let (input, _) = cut(terminated(text_close("}"), opt(kind(TokenKind::LineBreak))))(input)?;
    let branches = expr_map.into_iter().collect::<Vec<_>>();
    Ok((input, Expression::Match(Rc::new(target), Rc::new(branches))))
}

// ================== 辅助函数 ==================
// 动态识别块或表达式
fn parse_block_or_expr(input: Tokens<'_>) -> IResult<Tokens<'_>, Expression, SyntaxErrorKind> {
    alt((
        parse_domain_block,      // 优先识别 %{...} 块
        parse_block_as_sequence, // 优先识别 {...} 块
        parse_expr,              // 单行表达式（如 x > y ? a : b）
    ))(input)
}
// 解析代码块（明确的隔离作用域）
fn parse_domain_block(input: Tokens<'_>) -> IResult<Tokens<'_>, Expression, SyntaxErrorKind> {
    let (input, block) = delimited(
        terminated(text("%{"), opt(many0(kind(TokenKind::LineBreak)))),
        map(
            many0(terminated(
                parse_statement,
                opt(many0(kind(TokenKind::LineBreak))),
            )),
            |stmts| Expression::Block(Rc::new(stmts)),
        ),
        cut(text_close("}")),
    )(input)?;
    Ok((input, block))
}
// 解析代码块（作为独立作用域）
fn parse_block(input: Tokens<'_>) -> IResult<Tokens<'_>, Expression, SyntaxErrorKind> {
    let (input, block) = delimited(
        terminated(text("{"), opt(many0(kind(TokenKind::LineBreak)))),
        map(
            many0(terminated(
                parse_statement,
                opt(many0(kind(TokenKind::LineBreak))),
            )),
            |stmts| Expression::Block(Rc::new(stmts)),
        ),
        cut(text_close("}")),
    )(input)?;
    Ok((input, block))
}

/// 解析代码块（作为序列，非独立作用域）
fn parse_block_as_sequence(input: Tokens<'_>) -> IResult<Tokens<'_>, Expression, SyntaxErrorKind> {
    let (input, block) = delimited(
        terminated(text("{"), opt(many0(kind(TokenKind::LineBreak)))),
        map(
            many0(terminated(
                parse_statement,
                opt(many0(kind(TokenKind::LineBreak))),
            )),
            Expression::Sequence,
        ),
        cut(text_close("}")),
    )(input)?;
    Ok((input, block))
}

fn parse_array_destructure(
    input: Tokens<'_>,
) -> IResult<Tokens<'_>, Vec<DestructurePattern>, SyntaxErrorKind> {
    delimited(
        text("["),
        cut(separated_list1(
            text(","),
            alt((
                map(preceded(text("*"), cut(parse_symbol_string)), |s| {
                    DestructurePattern::Rest(s)
                }),
                map(cut(parse_symbol_string), |s| {
                    DestructurePattern::Identifier(s)
                }),
            )),
        )),
        cut(text_close("]")),
    )(input)
}

fn parse_map_destructure(
    input: Tokens<'_>,
) -> IResult<Tokens<'_>, Vec<DestructurePattern>, SyntaxErrorKind> {
    delimited(
        text("{"),
        cut(separated_list1(
            text(","),
            alt((
                // {key: newName} 语法
                map(
                    separated_pair(parse_symbol_string, text(":"), cut(parse_symbol_string)),
                    |(i, n)| DestructurePattern::Renamed((i, n)),
                ),
                // {key} 简写语法
                map(cut(parse_symbol_string), |s| {
                    DestructurePattern::Identifier(s)
                }),
            )),
        )),
        cut(text_close("}")),
    )(input)
}

// 别名解析逻辑
fn parse_alias(input: Tokens<'_>) -> IResult<Tokens<'_>, Expression, SyntaxErrorKind> {
    let (input, _) = text("alias")(input)?;
    let (input, symbol) = cut(parse_symbol_string)(input)?;
    let (input, _) = cut(text("="))(input)?;
    let (input, expr) = cut(parse_expr)(input)?;
    // dbg!(&expr);
    Ok((input, Expression::AliasDef(symbol, Rc::new(expr))))
}
fn parse_export(input: Tokens<'_>) -> IResult<Tokens<'_>, Expression, SyntaxErrorKind> {
    let (input, _) = text("export")(input)?;
    let (input, name) = cut(parse_symbol_string)(input)?;
    let (input, expr_op) = opt(preceded(text("="), parse_expr))(input)?;
    if let Some(expr) = expr_op {
        Ok((input, Expression::Export(name, Some(Rc::new(expr)))))
    } else {
        Ok((input, Expression::Export(name, None)))
    }
}
fn parse_set(input: Tokens<'_>) -> IResult<Tokens<'_>, Expression, SyntaxErrorKind> {
    let (input, _) = text("set")(input)?;
    let (input, name) = cut(parse_symbol_string)(input)?;
    let (input, _) = cut(text("="))(input)?;
    let (input, expr) = cut(parse_expr)(input)?;

    Ok((input, Expression::SetParent(name, Rc::new(expr))))
}
fn parse_lets(input: Tokens<'_>) -> IResult<Tokens<'_>, Expression, SyntaxErrorKind> {
    let (input, _) = text("let")(input)?;
    let keyword = input
        .first()
        .map(|t| t.text(input))
        .ok_or_else(|| nom::Err::Error(SyntaxErrorKind::NoExpression))?;
    let (input, pattern) = match keyword {
        "[" => parse_array_destructure(input)?,
        "{" => parse_map_destructure(input)?,
        _ => return alt((parse_lazy_assign, parse_declare))(input),
    };

    let (input, exprs) = preceded(
        text("="),
        cut(|input| {
            parse_expr(input).map_err(|e| match e {
                nom::Err::Error(_) => SyntaxErrorKind::failure(
                    input.get_str_slice(),
                    "a value expression",
                    input.first().map(|t| t.text(input).to_string()),
                    Some("check grammar after `=`"),
                ),
                // nom::Err::Failure(f) => nom::Err::Failure(f),
                other => other,
            })
        }),
    )(input)?;
    Ok((
        input,
        Expression::DestructureAssign(pattern, Rc::new(exprs)),
    ))
}
// 延迟赋值解析逻辑
fn parse_lazy_assign(input: Tokens<'_>) -> IResult<Tokens<'_>, Expression, SyntaxErrorKind> {
    // let (input, _) = text("let")(input)?;
    let (input, symbol) = parse_symbol_string(input)?;
    let (input, _) = text(":=")(input)?; // 使用:=作为延迟赋值符号
    let (input, expr) = cut(parse_expr)(input)?;
    // dbg!(&expr);
    Ok((
        input,
        Expression::Declare(symbol, Rc::new(Expression::Quote(Rc::new(expr)))),
    ))
}

fn parse_declare(input: Tokens<'_>) -> IResult<Tokens<'_>, Expression, SyntaxErrorKind> {
    // let (input, _) = text("let")(input)?;
    // dbg!("parse_declare");
    // 解析逗号分隔的多个符号, 允许重载操作符,自定义操作符
    let (input, symbols) = separated_list1(
        text(","),
        alt((
            parse_symbol_string,
            parse_operator,
            parse_custom_postfix_operator,
        )),
    )(input)
    .map_err(|_| {
        SyntaxErrorKind::failure(
            input.get_str_slice(),
            "comma separated var name",
            None,
            Some("try: `let x, y = 1`"),
        )
    })?;

    // 解析等号和多表达式
    let (input, value_expr) = opt(preceded(
        text("="),
        cut(|input| {
            parse_expr(input).map_err(|e| match e {
                nom::Err::Error(_) => SyntaxErrorKind::failure(
                    input.get_str_slice(),
                    "a value expression",
                    input.first().map(|t| t.text(input).to_string()),
                    Some("check grammar after `=`"),
                ),
                // nom::Err::Failure(f) => nom::Err::Failure(f),
                other => other,
            })
        }),
    ))(input)?;

    // 构建右侧表达式
    let value = value_expr.map_or(Rc::new(Expression::None), |v| Rc::new(v));
    return if symbols.len() == 1 {
        Ok((input, Expression::Declare(symbols[0].clone(), value)))
    } else {
        let assignments = (0..symbols.len())
            .map(|i| Expression::Declare(symbols[i].clone(), value.clone()))
            .collect();
        Ok((input, Expression::Sequence(assignments)))
    };
}

fn parse_del(input: Tokens<'_>) -> IResult<Tokens<'_>, Expression, SyntaxErrorKind> {
    let (input, _) = text("del")(input)?;
    let (input, symbol) = cut(parse_symbol_string)(input).map_err(|_| {
        SyntaxErrorKind::failure(
            input.get_str_slice(),
            "symbol",
            Some("no symbol".into()),
            Some("you can only del symbol"),
        )
    })?;
    Ok((input, Expression::Del(symbol)))
}

#[inline]
fn parse_operator(input: Tokens<'_>) -> IResult<Tokens<'_>, String, SyntaxErrorKind> {
    map(kind(TokenKind::Operator), |t| {
        t.to_str(input.str).to_string()
    })(input)
}
#[inline]
fn parse_custom_postfix_operator(
    input: Tokens<'_>,
) -> IResult<Tokens<'_>, String, SyntaxErrorKind> {
    map(kind(TokenKind::OperatorPostfix), |t| {
        t.to_str(input.str).to_string()
    })(input)
}
// 模式匹配解析（简化示例）
fn parse_pattern(input: Tokens<'_>) -> IResult<Tokens<'_>, Vec<Expression>, SyntaxErrorKind> {
    let (input, pat) = separated_list1(
        text(","),
        alt((
            parse_num_range,
            parse_string,
            parse_string_raw,
            parse_value_symbol,
            parse_symbol,
            parse_regex,
            parse_time,
            parse_integer,
            parse_float,
        )),
    )(input)
    .map_err(|_| {
        SyntaxErrorKind::expected(
            input.get_str_slice(),
            "match pattern",
            input.first().map(|t| t.text(input).to_string()),
            Some("add a string/symbol/regex/number/range/time"),
        )
    })?;
    Ok((input, pat))
}
// only used for match arm
fn parse_num_range(input: Tokens<'_>) -> IResult<Tokens<'_>, Expression, SyntaxErrorKind> {
    let (input, start) = alt((parse_integer, parse_blank))(input)?;
    let (new_input, optoken) = alt((text("..="), text("..")))(input)?;
    let operator = optoken.text(input);
    let input = new_input;

    let (input, stop) = alt((parse_integer, parse_blank))(input)?;
    let (input, step) = opt(preceded(text(":"), cut(alt((parse_integer, parse_blank)))))(input)?;

    let r = Expression::RangeOp(
        operator.to_string(),
        Rc::new(start),
        Rc::new(stop),
        step.map(Rc::new),
    );

    Ok((input, r))
}
// 自定义EOF解析器，返回StrSlice类型
#[inline]
fn eof_slice(input: Tokens<'_>) -> IResult<Tokens<'_>, StrSlice, SyntaxErrorKind> {
    if input.is_empty() {
        Ok((input, StrSlice::default()))
    } else {
        Err(nom::Err::Error(SyntaxErrorKind::Expected {
            input: input.get_str_slice(),
            expected: "end of input",
            found: None,
            hint: Some("Check your input"),
        }))
    }
}

// 索引/切片解析
fn parse_index(
    target: Expression,
    input: Tokens<'_>,
    depth: usize,
) -> IResult<Tokens<'_>, Expression, SyntaxErrorKind> {
    let (input, expr) = delimited(
        text("["),
        |inp| PrattParser::parse_expr_with_precedence(inp, PREC_ADD_SUB, depth + 1),
        cut(text_close("]")),
    )(input)?;

    Ok((input, Expression::Index(Rc::new(target), Rc::new(expr))))
}

#[derive(Debug, Clone)]
pub struct ModuleInfo {
    pub use_statements: Vec<(Option<String>, String)>, // (path, alias)
    pub functions: HashMap<String, Expression>,
}

// 优化的模块解析器 - 只解析 fn 和 use
fn parse_module_selective(input: Tokens<'_>) -> IResult<Tokens<'_>, ModuleInfo, SyntaxErrorKind> {
    let mut use_statements = Vec::new();
    let mut functions = HashMap::new();
    let mut remaining = input;

    while !remaining.is_empty() {
        // 尝试解析 use 语句
        match parse_use_statement(remaining) {
            Ok((rest, use_stmt)) => {
                if let Expression::Use(alias, path) = use_stmt {
                    use_statements.push((alias, path));
                }
                remaining = rest;
                continue;
            }
            Err(nom::Err::Failure(e)) => return Err(nom::Err::Failure(e)), // 硬错误直接向上传播
            Err(_) => {} // 可回溯错误，继续尝试下一种解析器
        }

        // 尝试解析函数声明
        match parse_fn_declare(remaining) {
            Ok((rest, func)) => {
                if let Expression::Function(name, ..) = &func {
                    functions.insert(name.clone(), func);
                }
                remaining = rest;
                continue;
            }
            Err(nom::Err::Failure(e)) => return Err(nom::Err::Failure(e)), // 硬错误直接向上传播
            Err(_) => {} // 可回溯错误，继续尝试下一种解析器
        }

        let mut place = 0;
        for token in remaining.iter() {
            place += 1;
            if token.kind == TokenKind::LineBreak {
                break;
            }
        }
        remaining = remaining.skip_n(place);
    }

    Ok((
        remaining,
        ModuleInfo {
            use_statements,
            functions,
        },
    ))
}

fn parse_use_statement(input: Tokens<'_>) -> IResult<Tokens<'_>, Expression, SyntaxErrorKind> {
    let (input, _) = text("use")(input)?;
    let (input, module_path) = cut(alt((parse_symbol_string, parse_string_raw_inner)))(input)?;
    let (input, alias) = opt(preceded(text("as"), parse_symbol_string))(input)?;

    // 暂时创建空环境，后续会被替换
    Ok((input, Expression::Use(alias, module_path)))
}