#include "debug_printer.hpp"
#include <sstream>

namespace lsp::language::ast
{
    // ===== 辅助函数实现 =====

    void DebugPrinter::Print(const ASTNode* node)
    {
        if (!node)
        {
            os_ << GetColor(Color::Gray) << "<null>" << GetColor(Color::Reset) << "\n";
            return;
        }
        const_cast<ASTNode*>(node)->Accept(*this);
    }

    void DebugPrinter::PrintStatements(const std::vector<StatementPtr>& statements)
    {
        for (size_t i = 0; i < statements.size(); ++i)
        {
            bool is_last = (i == statements.size() - 1);
            is_last_child_stack_.push_back(is_last);
            PrintStatement(statements[i].get(), "", is_last);
            is_last_child_stack_.pop_back();
        }
    }

    void DebugPrinter::PrintParseResult(const ParseResult& result)
    {
        if (result.HasErrors())
        {
            os_ << GetColor(Color::BrightRed) << "Parse Errors:\n"
                << GetColor(Color::Reset);
            for (const auto& error : result.errors)
            {
                PrintError(error);
            }
            os_ << "\n";
        }

        if (result.root)
        {
            Print(result.root.get());
        }
    }

    // ===== 缩进和树形结构 =====

    void DebugPrinter::PrintIndent(std::optional<bool> is_last)
    {
        if (!options_.use_tree_chars)
        {
            os_ << std::string(current_indent_, ' ');
            return;
        }

        bool is_last_val = is_last.value_or(
            !is_last_child_stack_.empty() ? is_last_child_stack_.back() : false);

        for (size_t i = 0; i < is_last_child_stack_.size(); ++i)
        {
            if (i == is_last_child_stack_.size() - 1)
            {
                os_ << (is_last_val ? "└─ " : "├─ ");
            }
            else
            {
                os_ << (is_last_child_stack_[i] ? "   " : "│  ");
            }
        }
    }

    void DebugPrinter::PrintTreePrefix(bool is_last)
    {
        if (!options_.use_tree_chars)
        {
            os_ << std::string(current_indent_, ' ');
            return;
        }

        for (size_t i = 0; i < is_last_child_stack_.size(); ++i)
        {
            os_ << (is_last_child_stack_[i] ? "   " : "│  ");
        }
        os_ << (is_last ? "└─ " : "├─ ");
    }

    std::string DebugPrinter::GetIndent() const
    {
        return std::string(current_indent_, ' ');
    }

    // ===== 颜色辅助 =====

    const char* DebugPrinter::GetColor(const char* color) const
    {
        return options_.use_colors ? color : "";
    }

    void DebugPrinter::PrintColored(const std::string& text, const char* color)
    {
        os_ << GetColor(color) << text << GetColor(Color::Reset);
    }

    // ===== 节点信息输出 =====

    void DebugPrinter::PrintNodeHeader(const std::string& type_name, const Location& loc)
    {
        PrintIndent();
        PrintColored(type_name, Color::BrightCyan);

        if (options_.show_location)
        {
            os_ << " ";
            PrintLocation(loc);
        }

        if (options_.show_source_code)
        {
            PrintSourceSnippet(loc);
        }

        os_ << "\n";
    }

    void DebugPrinter::PrintLocation(const Location& loc)
    {
        os_ << GetColor(Color::Gray) << "["
            << loc.start_line << ":" << loc.start_column << " - "
            << loc.end_line << ":" << loc.end_column << "]"
            << GetColor(Color::Reset);
    }

    void DebugPrinter::PrintSourceSnippet(const Location& loc)
    {
        if (!source_code_)
            return;

        std::string snippet = GetSourceText(loc);
        if (snippet.empty())
            return;

        snippet = TruncateString(snippet, options_.max_source_length);
        snippet = EscapeString(snippet);

        os_ << "\n";
        PrintTreePrefix(false);
        os_ << GetColor(Color::Dim) << "  Source: \"" << snippet << "\""
            << GetColor(Color::Reset);
    }

    void DebugPrinter::PrintKeyValue(const std::string& key, const std::string& value, const Location& location, const char* value_color)
    {
        PrintIndent();
        PrintColored(key + ": ", Color::Yellow);
        PrintColored(value, value_color ? value_color : Color::Green);

        if (options_.show_location)
        {
            os_ << " ";
            PrintLocation(location);
        }

        os_ << "\n";
    }

    void DebugPrinter::PrintKeyValue(const std::string& key, const std::string& value, const char* value_color)
    {
        PrintIndent();
        PrintColored(key + ": ", Color::Yellow);
        PrintColored(value, value_color ? value_color : Color::Green);
        os_ << "\n";
    }

    void DebugPrinter::PrintKeyValue(const std::string& key, int value)
    {
        PrintIndent();
        PrintColored(key + ": ", Color::Yellow);
        os_ << value << "\n";
    }

    void DebugPrinter::PrintKeyValue(const std::string& key, bool value)
    {
        PrintIndent();
        PrintColored(key + ": ", Color::Yellow);
        PrintColored(value ? "true" : "false", value ? Color::BrightGreen : Color::BrightRed);
        os_ << "\n";
    }

    // ===== 表达式和语句打印 =====

    void DebugPrinter::PrintExpression(const Expression* expr, const std::string& label, bool is_last)
    {
        if (!expr)
        {
            PrintIndent();
            if (!label.empty())
            {
                PrintColored(label + ": ", Color::Yellow);
            }
            PrintColored("<null>", Color::Gray);
            os_ << "\n";
            return;
        }

        if (!label.empty())
        {
            PrintIndent();
            PrintColored(label + ":", Color::Yellow);
            os_ << "\n";
            IncreaseIndent();
        }

        is_last_child_stack_.push_back(is_last);
        const_cast<Expression*>(expr)->Accept(*this);
        is_last_child_stack_.pop_back();

        if (!label.empty())
        {
            DecreaseIndent();
        }
    }

    void DebugPrinter::PrintStatement(const Statement* stmt, const std::string& label, bool is_last)
    {
        if (!stmt)
        {
            PrintIndent();
            if (!label.empty())
            {
                PrintColored(label + ": ", Color::Yellow);
            }
            PrintColored("<null>", Color::Gray);
            os_ << "\n";
            return;
        }

        if (!label.empty())
        {
            PrintIndent();
            PrintColored(label + ":", Color::Yellow);
            os_ << "\n";
            IncreaseIndent();
        }

        is_last_child_stack_.push_back(is_last);
        const_cast<Statement*>(stmt)->Accept(*this);
        is_last_child_stack_.pop_back();

        if (!label.empty())
        {
            DecreaseIndent();
        }
    }

    void DebugPrinter::PrintParameter(const Parameter& param, bool is_last)
    {
        PrintIndent(is_last);
        PrintColored("Parameter: ", Color::Cyan);
        PrintColored("\"" + param.name + "\"", Color::Green);

        if (param.type)
        {
            os_ << " : ";
            PrintColored(param.type->name, Color::BrightYellow);
        }

        if (param.is_var)
        {
            os_ << " " << GetColor(Color::Magenta) << "(var)" << GetColor(Color::Reset);
        }

        if (param.is_out)
        {
            os_ << " " << GetColor(Color::Magenta) << "(out)" << GetColor(Color::Reset);
        }

        if (param.default_value)
        {
            os_ << " = <expr>";
        }

        os_ << "\n";
    }

    void DebugPrinter::PrintLeftHandSide(const LValue& lhs, const std::string& label, bool is_last)
    {
        std::visit([&](auto&& value) {
            using T = std::decay_t<decltype(value)>;

            if constexpr (std::is_same_v<T, std::monostate>)
            {
                PrintIndent();
                if (!label.empty())
                {
                    PrintColored(label + ": ", Color::Yellow);
                }
                PrintColored("<empty>", Color::Gray);
                os_ << "\n";
            }
            else if constexpr (std::is_same_v<T, ExpressionPtr>)
            {
                PrintExpression(value.get(), label, is_last);
            }
            else if constexpr (std::is_same_v<T, std::unique_ptr<Identifier>> ||
                               std::is_same_v<T, std::unique_ptr<AttributeExpression>> ||
                               std::is_same_v<T, std::unique_ptr<SubscriptExpression>> ||
                               std::is_same_v<T, std::unique_ptr<ColumnReference>>)
            {
                if (!label.empty())
                {
                    PrintIndent();
                    PrintColored(label + ":", Color::Yellow);
                    os_ << "\n";
                    IncreaseIndent();
                }

                is_last_child_stack_.push_back(is_last);
                if (value)
                    value->Accept(*this);
                is_last_child_stack_.pop_back();

                if (!label.empty())
                {
                    DecreaseIndent();
                }
            }
            else if constexpr (std::is_same_v<T, std::unique_ptr<UnpackPattern>>)
            {
                if (!label.empty())
                {
                    PrintIndent();
                    PrintColored(label + ":", Color::Yellow);
                    os_ << "\n";
                    IncreaseIndent();
                }

                is_last_child_stack_.push_back(is_last);
                if (value)
                    value->Accept(*this);
                is_last_child_stack_.pop_back();

                if (!label.empty())
                {
                    DecreaseIndent();
                }
            }
        },
                   lhs);
    }

    // ===== 枚举值打印 =====

    void DebugPrinter::PrintOperator(BinaryOperator op)
    {
        PrintColored(GetBinaryOperatorSymbol(op), Color::BrightMagenta);
    }

    void DebugPrinter::PrintOperator(AssignmentOperator op)
    {
        PrintColored(GetAssignmentOperatorSymbol(op), Color::BrightMagenta);
    }

    void DebugPrinter::PrintLiteralKind(LiteralKind kind)
    {
        const char* kind_str = "";
        switch (kind)
        {
        case LiteralKind::kNumber:
            kind_str = "Number";
            break;
        case LiteralKind::kString:
            kind_str = "String";
            break;
        case LiteralKind::kChar:
            kind_str = "Char";
            break;
        case LiteralKind::kBoolean:
            kind_str = "Boolean";
            break;
        case LiteralKind::kNil:
            kind_str = "Nil";
            break;
        case LiteralKind::kNan:
            kind_str = "NaN";
            break;
        case LiteralKind::kInfinity:
            kind_str = "Infinity";
            break;
        }
        PrintColored(kind_str, Color::BrightYellow);
    }

    void DebugPrinter::PrintAccessModifier(AccessModifier modifier)
    {
        const char* mod_str = "";
        switch (modifier)
        {
        case AccessModifier::kPublic:
            mod_str = "public";
            break;
        case AccessModifier::kProtected:
            mod_str = "protected";
            break;
        case AccessModifier::kPrivate:
            mod_str = "private";
            break;
        }
        PrintColored(mod_str, Color::BrightYellow);
    }

    void DebugPrinter::PrintMethodModifier(MethodModifier modifier)
    {
        const char* mod_str = "";
        switch (modifier)
        {
        case MethodModifier::kNone:
            mod_str = "none";
            break;
        case MethodModifier::kVirtual:
            mod_str = "virtual";
            break;
        case MethodModifier::kOverride:
            mod_str = "override";
            break;
        case MethodModifier::kOverload:
            mod_str = "overload";
            break;
        }
        PrintColored(mod_str, Color::BrightYellow);
    }

    void DebugPrinter::PrintMethodType(MethodType type)
    {
        const char* type_str = "";
        switch (type)
        {
        case MethodType::kNormal:
            type_str = "normal";
            break;
        case MethodType::kConstructor:
            type_str = "constructor";
            break;
        case MethodType::kDestructor:
            type_str = "destructor";
            break;
        case MethodType::kOperatorOverload:
            type_str = "operator";
            break;
        }
        PrintColored(type_str, Color::BrightYellow);
    }

    void DebugPrinter::PrintReferenceModifier(ReferenceModifier modifier)
    {
        const char* mod_str = "";
        switch (modifier)
        {
        case ReferenceModifier::kNone:
            return;
        case ReferenceModifier::kWeakRef:
            mod_str = "weakref";
            break;
        case ReferenceModifier::kAutoRef:
            mod_str = "autoref";
            break;
        }
        PrintColored(mod_str, Color::Magenta);
    }

    void DebugPrinter::PrintConditionalCompilationType(ConditionalCompilationType type)
    {
        const char* type_str = "";
        switch (type)
        {
        case ConditionalCompilationType::kIfDef:
            type_str = "ifdef";
            break;
        case ConditionalCompilationType::kIfNDef:
            type_str = "ifndef";
            break;
        case ConditionalCompilationType::kDefine:
            type_str = "define";
            break;
        case ConditionalCompilationType::kUndef:
            type_str = "undef";
            break;
        }
        PrintColored(type_str, Color::BrightYellow);
    }

    void DebugPrinter::PrintTSSQLExpressionType(TSSQLExpressionType type)
    {
        const char* type_str = "";
        switch (type)
        {
        case TSSQLExpressionType::kSelect:
            type_str = "select";
            break;
        case TSSQLExpressionType::kSSelect:
            type_str = "sselect";
            break;
        case TSSQLExpressionType::kVSelect:
            type_str = "vselect";
            break;
        case TSSQLExpressionType::kMSelect:
            type_str = "mselect";
            break;
        case TSSQLExpressionType::kUpdate:
            type_str = "update";
            break;
        case TSSQLExpressionType::kDelete:
            type_str = "delete";
            break;
        case TSSQLExpressionType::kInsert:
            type_str = "insert";
            break;
        }
        PrintColored(type_str, Color::BrightYellow);
    }

    void DebugPrinter::PrintError(const ParseError& error)
    {
        os_ << GetColor(Color::BrightRed) << "  Error: " << GetColor(Color::Reset)
            << error.message << "\n";
        os_ << GetColor(Color::Gray) << "  Location: ["
            << error.location.start_line << ":" << error.location.start_column << " - "
            << error.location.end_line << ":" << error.location.end_column << "]"
            << GetColor(Color::Reset) << "\n";
    }

    // ===== 工具函数 =====

    std::string DebugPrinter::EscapeString(const std::string& str) const
    {
        std::string result;
        for (char c : str)
        {
            switch (c)
            {
            case '\n':
                result += "\\n";
                break;
            case '\r':
                result += "\\r";
                break;
            case '\t':
                result += "\\t";
                break;
            case '"':
                result += "\\\"";
                break;
            case '\\':
                result += "\\\\";
                break;
            default:
                result += c;
                break;
            }
        }
        return result;
    }

    std::string DebugPrinter::TruncateString(const std::string& str, size_t max_len) const
    {
        if (str.length() <= max_len)
            return str;
        return str.substr(0, max_len - 3) + "...";
    }

    std::string DebugPrinter::GetSourceText(const Location& loc) const
    {
        if (!source_code_)
            return "";
        if (loc.start_byte >= source_code_->length())
            return "";

        size_t length = loc.end_byte - loc.start_byte;
        if (loc.start_byte + length > source_code_->length())
        {
            length = source_code_->length() - loc.start_byte;
        }

        return source_code_->substr(loc.start_byte, length);
    }

    std::string DebugPrinter::GetNodeKindName(NodeKind kind) const
    {
        switch (kind)
        {
        case NodeKind::kIdentifier:
            return "kIdentifier";
        case NodeKind::kLiteral:
            return "kLiteral";
        case NodeKind::kArrayExpression:
            return "kArrayExpression";
        case NodeKind::kParenthesizedExpression:
            return "kParenthesizedExpression";
        case NodeKind::kAttributeExpression:
            return "kAttributeExpression";
        case NodeKind::kSubscriptExpression:
            return "kSubscriptExpression";
        case NodeKind::kCallExpression:
            return "kCallExpression";
        case NodeKind::kUnaryPlusExpression:
            return "kUnaryPlusExpression";
        case NodeKind::kUnaryMinusExpression:
            return "kUnaryMinusExpression";
        case NodeKind::kPrefixIncrementExpression:
            return "kPrefixIncrementExpression";
        case NodeKind::kPrefixDecrementExpression:
            return "kPrefixDecrementExpression";
        case NodeKind::kPostfixIncrementExpression:
            return "kPostfixIncrementExpression";
        case NodeKind::kPostfixDecrementExpression:
            return "kPostfixDecrementExpression";
        case NodeKind::kLogicalNotExpression:
            return "kLogicalNotExpression";
        case NodeKind::kBitwiseNotExpression:
            return "kBitwiseNotExpression";
        case NodeKind::kDerivativeExpression:
            return "kDerivativeExpression";
        case NodeKind::kFunctionPointerExpression:
            return "kFunctionPointerExpression";
        case NodeKind::kMatrixTransposeExpression:
            return "kMatrixTransposeExpression";
        case NodeKind::kExprOperatorExpression:
            return "kExprOperatorExpression";
        case NodeKind::kBinaryExpression:
            return "kBinaryExpression";
        case NodeKind::kTernaryExpression:
            return "kTernaryExpression";
        case NodeKind::kAssignmentExpression:
            return "kAssignmentExpression";
        case NodeKind::kAnonymousFunctionExpression:
            return "kAnonymousFunctionExpression";
        case NodeKind::kNewExpression:
            return "kNewExpression";
        case NodeKind::kEchoExpression:
            return "kEchoExpression";
        case NodeKind::kRaiseExpression:
            return "kRaiseExpression";
        case NodeKind::kInheritedExpression:
            return "kInheritedExpression";
        case NodeKind::kTSSQLExpression:
            return "kTSSQLExpression";
        case NodeKind::kColumnReference:
            return "kColumnReference";
        case NodeKind::kUnpackPattern:
            return "kUnpackPattern";
        case NodeKind::kParameter:
            return "kParameter";
        case NodeKind::kVarDeclaration:
            return "kVarDeclaration";
        case NodeKind::kStaticDeclaration:
            return "kStaticDeclaration";
        case NodeKind::kGlobalDeclaration:
            return "kGlobalDeclaration";
        case NodeKind::kConstDeclaration:
            return "kConstDeclaration";
        case NodeKind::kFieldDeclaration:
            return "kFieldDeclaration";
        case NodeKind::kExpressionStatement:
            return "kExpressionStatement";
        case NodeKind::kBlockStatement:
            return "kBlockStatement";
        case NodeKind::kIfStatement:
            return "kIfStatement";
        case NodeKind::kForInStatement:
            return "kForInStatement";
        case NodeKind::kForToStatement:
            return "kForToStatement";
        case NodeKind::kWhileStatement:
            return "kWhileStatement";
        case NodeKind::kRepeatStatement:
            return "kRepeatStatement";
        case NodeKind::kCaseStatement:
            return "kCaseStatement";
        case NodeKind::kTryStatement:
            return "kTryStatement";
        case NodeKind::kBreakStatement:
            return "kBreakStatement";
        case NodeKind::kContinueStatement:
            return "kContinueStatement";
        case NodeKind::kReturnStatement:
            return "kReturnStatement";
        case NodeKind::kUsesStatement:
            return "kUsesStatement";
        case NodeKind::kFunctionDeclaration:
            return "kFunctionDeclaration";
        case NodeKind::kFunctionDefinition:
            return "kFunctionDefinition";
        case NodeKind::kMethodDeclaration:
            return "kMethodDeclaration";
        case NodeKind::kPropertyDeclaration:
            return "kPropertyDeclaration";
        case NodeKind::kClassMember:
            return "kClassMember";
        case NodeKind::kClassDefinition:
            return "kClassDefinition";
        case NodeKind::kExternalMethodDefinition:
            return "kExternalMethodDefinition";
        case NodeKind::kUnitDefinition:
            return "kUnitDefinition";
        case NodeKind::kMatrixIterationStatement:
            return "kMatrixIterationStatement";
        case NodeKind::kCompilerDirective:
            return "kCompilerDirective";
        case NodeKind::kConditionalBlock:
            return "kConditionalBlock";
        case NodeKind::kConditionalDirective:
            return "kConditionalDirective";
        case NodeKind::kTSLXBlock:
            return "kTSLXBlock";
        case NodeKind::kProgram:
            return "kProgram";
        default:
            return "kUnknown";
        }
    }

    // ===== Visitor 实现 - 基础节点 =====

    void DebugPrinter::VisitProgram(Program& node)
    {
        PrintNodeHeader("Program", node.span);

        if (options_.show_node_kind)
        {
            IncreaseIndent();
            PrintKeyValue("Kind", GetNodeKindName(node.kind));
            DecreaseIndent();
        }

        IncreaseIndent();
        PrintStatements(node.statements);
        DecreaseIndent();
    }

    void DebugPrinter::VisitUnitDefinition(UnitDefinition& node)
    {
        PrintIndent();
        PrintColored("UnitDefinition: ", Color::BrightCyan);
        PrintColored("\"" + node.name + "\"", Color::Green);

        if (options_.show_location)
        {
            os_ << " ";
            PrintLocation(node.location);
        }
        os_ << "\n";

        IncreaseIndent();

        if (!node.interface_statements.empty())
        {
            PrintIndent();
            PrintColored("Interface:", Color::Yellow);
            os_ << "\n";
            IncreaseIndent();
            PrintStatements(node.interface_statements);
            DecreaseIndent();
        }

        if (!node.implementation_statements.empty())
        {
            PrintIndent();
            PrintColored("Implementation:", Color::Yellow);
            os_ << "\n";
            IncreaseIndent();
            PrintStatements(node.implementation_statements);
            DecreaseIndent();
        }

        if (!node.initialization_statements.empty())
        {
            PrintIndent();
            PrintColored("Initialization:", Color::Yellow);
            os_ << "\n";
            IncreaseIndent();
            PrintStatements(node.initialization_statements);
            DecreaseIndent();
        }

        if (!node.finalization_statements.empty())
        {
            PrintIndent();
            PrintColored("Finalization:", Color::Yellow);
            os_ << "\n";
            IncreaseIndent();
            PrintStatements(node.finalization_statements);
            DecreaseIndent();
        }

        DecreaseIndent();
    }

    void DebugPrinter::VisitClassDefinition(ClassDefinition& node)
    {
        PrintIndent();
        PrintColored("ClassDefinition: ", Color::BrightCyan);
        PrintColored("\"" + node.name + "\"", Color::Green);

        if (options_.show_location)
        {
            os_ << " ";
            PrintLocation(node.location);
        }
        os_ << "\n";

        IncreaseIndent();

        if (!node.parent_classes.empty())
        {
            PrintIndent();
            PrintColored("Parents:", Color::Yellow);
            os_ << "\n";
            IncreaseIndent();
            for (const auto& parent : node.parent_classes)
            {
                PrintIndent();

                // 如果有qualifier，先显示
                if (parent.qualifier)
                {
                    PrintColored(*parent.qualifier + ".", Color::Magenta);
                }

                PrintColored(parent.name, Color::Green);
                os_ << "\n";
            }
            DecreaseIndent();
        }

        if (node.uses)
        {
            is_last_child_stack_.push_back(false);
            node.uses->Accept(*this);
            is_last_child_stack_.pop_back();
        }

        if (!node.members.empty())
        {
            PrintIndent();
            PrintColored("Members:", Color::Yellow);
            os_ << "\n";
            IncreaseIndent();
            for (size_t i = 0; i < node.members.size(); ++i)
            {
                is_last_child_stack_.push_back(i == node.members.size() - 1);
                if (node.members[i])
                    node.members[i]->Accept(*this);
                is_last_child_stack_.pop_back();
            }
            DecreaseIndent();
        }

        DecreaseIndent();
    }

    void DebugPrinter::VisitClassMember(ClassMember& node)
    {
        PrintIndent();
        PrintColored("ClassMember", Color::BrightCyan);

        if (node.access_modifier != AccessModifier::kPublic)
        {
            os_ << " (";
            PrintAccessModifier(node.access_modifier);
            os_ << ")";
        }

        os_ << "\n";

        IncreaseIndent();

        // 处理 member variant
        std::visit([this](auto&& member_ptr) {
            if (member_ptr)
            {
                is_last_child_stack_.push_back(true);
                member_ptr->Accept(*this);
                is_last_child_stack_.pop_back();
            }
        },
                   node.member);

        DecreaseIndent();
    }

    void DebugPrinter::VisitMethodDeclaration(MethodDeclaration& node)
    {
        PrintIndent();
        PrintColored("MethodDeclaration: ", Color::BrightCyan);
        PrintColored("\"" + node.name + "\"", Color::Green);

        if (options_.show_location)
        {
            os_ << " ";
            PrintLocation(node.location);
        }
        os_ << "\n";

        IncreaseIndent();

        if (node.modifier != MethodModifier::kNone)
        {
            PrintIndent();
            PrintColored("Modifier: ", Color::Yellow);
            PrintMethodModifier(node.modifier);
            os_ << "\n";
        }

        if (node.method_type != MethodType::kNormal)
        {
            PrintIndent();
            PrintColored("Type: ", Color::Yellow);
            PrintMethodType(node.method_type);
            os_ << "\n";
        }

        if (node.is_class_method)
        {
            PrintKeyValue("ClassMethod", true);
        }

        if (!node.parameters.empty())
        {
            PrintIndent();
            PrintColored("Parameters:", Color::Yellow);
            os_ << "\n";
            IncreaseIndent();
            for (size_t i = 0; i < node.parameters.size(); ++i)
            {
                if (node.parameters[i])
                {
                    PrintParameter(*node.parameters[i], i == node.parameters.size() - 1);
                }
            }
            DecreaseIndent();
        }

        if (node.return_type)
        {
            PrintKeyValue("ReturnType", node.return_type->name);
        }

        if (node.body)
        {
            is_last_child_stack_.push_back(true);
            PrintStatement(node.body.get(), "Body", true);
            is_last_child_stack_.pop_back();
        }

        DecreaseIndent();
    }

    void DebugPrinter::VisitPropertyDeclaration(PropertyDeclaration& node)
    {
        PrintIndent();
        PrintColored("PropertyDeclaration: ", Color::BrightCyan);
        PrintColored("\"" + node.name + "\"", Color::Green);

        if (options_.show_location)
        {
            os_ << " ";
            PrintLocation(node.location);
        }
        os_ << "\n";

        IncreaseIndent();

        if (node.type)
        {
            PrintKeyValue("Type", node.type->name);
        }

        if (node.index)
        {
            PrintExpression(node.index.value().get(), "Index", false);
        }

        if (node.read_accessor)
        {
            PrintIndent();
            PrintColored("Read: ", Color::Yellow);
            PrintColored("\"" + node.read_accessor.value() + "\"", Color::Green);
            if (options_.show_location && node.read_location)
            {
                os_ << " ";
                PrintLocation(node.read_location.value());
            }
            os_ << "\n";
        }

        if (node.write_accessor)
        {
            PrintIndent();
            PrintColored("Write: ", Color::Yellow);
            PrintColored("\"" + node.write_accessor.value() + "\"", Color::Green);
            if (options_.show_location && node.write_location)
            {
                os_ << " ";
                PrintLocation(node.write_location.value());
            }
            os_ << "\n";
        }

        DecreaseIndent();
    }

    void DebugPrinter::VisitExternalMethodDefinition(ExternalMethodDefinition& node)
    {
        PrintIndent();
        PrintColored("ExternalMethodDefinition: ", Color::BrightCyan);
        PrintColored(node.owner_class.name + "::" + node.name, Color::Green);

        if (options_.show_location)
        {
            os_ << " ";
            PrintLocation(node.location);
        }
        os_ << "\n";

        IncreaseIndent();

        if (node.modifier != MethodModifier::kNone)
        {
            PrintIndent();
            PrintColored("Modifier: ", Color::Yellow);
            PrintMethodModifier(node.modifier);
            os_ << "\n";
        }

        if (node.method_type != MethodType::kNormal)
        {
            PrintIndent();
            PrintColored("Type: ", Color::Yellow);
            PrintMethodType(node.method_type);
            os_ << "\n";
        }

        if (!node.parameters.empty())
        {
            PrintIndent();
            PrintColored("Parameters:", Color::Yellow);
            os_ << "\n";
            IncreaseIndent();
            for (size_t i = 0; i < node.parameters.size(); ++i)
            {
                if (node.parameters[i])
                {
                    PrintParameter(*node.parameters[i], i == node.parameters.size() - 1);
                }
            }
            DecreaseIndent();
        }

        if (node.return_type)
        {
            PrintKeyValue("ReturnType", node.return_type->name);
        }

        if (node.body)
        {
            PrintStatement(node.body.get(), "Body", true);
        }

        DecreaseIndent();
    }

    // ===== 基础表达式 =====

    void DebugPrinter::VisitIdentifier(Identifier& node)
    {
        PrintIndent();
        PrintColored("Identifier: ", Color::BrightCyan);
        PrintColored("\"" + node.name + "\"", Color::Green);

        if (options_.show_location)
        {
            os_ << " ";
            PrintLocation(node.location);
        }
        os_ << "\n";
    }

    void DebugPrinter::VisitLiteral(Literal& node)
    {
        PrintIndent();
        PrintColored("Literal: ", Color::BrightCyan);
        PrintColored("\"" + node.name + "\"", Color::Green);
        os_ << " (";
        PrintLiteralKind(node.literal_kind);
        os_ << ")";

        if (options_.show_location)
        {
            os_ << " ";
            PrintLocation(node.location);
        }
        os_ << "\n";
    }

    void DebugPrinter::VisitArrayExpression(ArrayExpression& node)
    {
        PrintIndent();
        PrintColored("ArrayExpression", Color::BrightCyan);

        if (options_.show_location)
        {
            os_ << " ";
            PrintLocation(node.span);
        }
        os_ << "\n";

        if (!node.elements.empty())
        {
            IncreaseIndent();
            for (size_t i = 0; i < node.elements.size(); ++i)
            {
                const auto& elem = node.elements[i];
                bool is_last = (i == node.elements.size() - 1);

                if (elem.key)
                {
                    PrintIndent();
                    PrintColored("Element:", Color::Yellow);
                    os_ << "\n";
                    IncreaseIndent();
                    PrintExpression(elem.key->get(), "Key", false);
                    PrintExpression(elem.value.get(), "Value", true);
                    DecreaseIndent();
                }
                else
                {
                    PrintExpression(elem.value.get(), "", is_last);
                }
            }
            DecreaseIndent();
        }
    }

    void DebugPrinter::VisitParenthesizedExpression(ParenthesizedExpression& node)
    {
        PrintIndent();
        PrintColored("ParenthesizedExpression", Color::BrightCyan);

        if (options_.show_location)
        {
            os_ << " ";
            PrintLocation(node.span);
        }
        os_ << "\n";

        IncreaseIndent();
        for (size_t i = 0; i < node.elements.size(); ++i)
        {
            const auto& elem = node.elements[i];
            bool is_last = (i == node.elements.size() - 1);

            if (elem.key.has_value())
            {
                PrintIndent();
                PrintColored("Element (key-value):", Color::Yellow);
                os_ << "\n";
                IncreaseIndent();
                PrintExpression(elem.key.value().get(), "Key", false);
                PrintExpression(elem.value.get(), "Value", is_last);
                DecreaseIndent();
            }
            else
            {
                PrintExpression(elem.value.get(), "", is_last);
            }
        }
        DecreaseIndent();
    }

    // ===== 访问表达式 =====

    void DebugPrinter::VisitCallExpression(CallExpression& node)
    {
        PrintIndent();
        PrintColored("CallExpression", Color::BrightCyan);

        if (options_.show_location)
        {
            os_ << " ";
            PrintLocation(node.span);
        }
        os_ << "\n";

        IncreaseIndent();

        PrintExpression(node.function.get(), "Function", node.arguments.empty());

        if (!node.arguments.empty())
        {
            PrintIndent();
            PrintColored("Arguments:", Color::Yellow);
            os_ << "\n";
            IncreaseIndent();
            for (size_t i = 0; i < node.arguments.size(); ++i)
            {
                bool is_last = (i == node.arguments.size() - 1);
                const auto& arg = node.arguments[i];

                std::string label = "Argument";
                if (arg.name)
                {
                    label += " (" + arg.name.value() + ")";
                }
                if (arg.is_const)
                {
                    label += " [const]";
                }

                is_last_child_stack_.push_back(is_last);
                PrintExpression(arg.value.get(), label, is_last);
                is_last_child_stack_.pop_back();
            }
            DecreaseIndent();
        }

        DecreaseIndent();
    }

    void DebugPrinter::VisitAttributeExpression(AttributeExpression& node)
    {
        PrintIndent();
        PrintColored("AttributeExpression", Color::BrightCyan);

        if (options_.show_location)
        {
            os_ << " ";
            PrintLocation(node.span);
        }
        os_ << "\n";

        IncreaseIndent();
        PrintExpression(node.object.get(), "Object", false);
        PrintExpression(node.attribute.get(), "Attribute", true);
        DecreaseIndent();
    }

    void DebugPrinter::VisitSubscriptExpression(SubscriptExpression& node)
    {
        PrintIndent();
        PrintColored("SubscriptExpression", Color::BrightCyan);

        if (options_.show_location)
        {
            os_ << " ";
            PrintLocation(node.span);
        }
        os_ << "\n";

        IncreaseIndent();

        PrintExpression(node.base.get(), "Base", node.indices.empty());

        if (!node.indices.empty())
        {
            PrintIndent();
            PrintColored("Indices:", Color::Yellow);
            os_ << "\n";
            IncreaseIndent();
            for (size_t i = 0; i < node.indices.size(); ++i)
            {
                bool is_last = (i == node.indices.size() - 1);
                const auto& idx = node.indices[i];

                PrintIndent();
                PrintColored("Index " + std::to_string(i), Color::Yellow);
                if (idx.is_slice)
                {
                    PrintColored(" (slice)", Color::Gray);
                }
                if (idx.is_empty_slice)
                {
                    PrintColored(" (empty)", Color::Gray);
                }
                os_ << "\n";

                IncreaseIndent();
                if (idx.start)
                {
                    is_last_child_stack_.push_back(false);
                    PrintExpression(idx.start.get(), "Start", !idx.end && !idx.step);
                    is_last_child_stack_.pop_back();
                }
                if (idx.end)
                {
                    is_last_child_stack_.push_back(false);
                    PrintExpression(idx.end.get(), "End", !idx.step);
                    is_last_child_stack_.pop_back();
                }
                if (idx.step)
                {
                    is_last_child_stack_.push_back(is_last);
                    PrintExpression(idx.step.get(), "Step", true);
                    is_last_child_stack_.pop_back();
                }
                DecreaseIndent();
            }
            DecreaseIndent();
        }

        DecreaseIndent();
    }

    // ===== 一元表达式 =====

    void DebugPrinter::VisitUnaryPlusExpression(UnaryPlusExpression& node)
    {
        PrintIndent();
        PrintColored("UnaryPlusExpression", Color::BrightCyan);

        if (options_.show_location)
        {
            os_ << " ";
            PrintLocation(node.span);
        }
        os_ << "\n";

        IncreaseIndent();
        PrintExpression(node.argument.get(), "Operand", true);
        DecreaseIndent();
    }

    void DebugPrinter::VisitUnaryMinusExpression(UnaryMinusExpression& node)
    {
        PrintIndent();
        PrintColored("UnaryMinusExpression", Color::BrightCyan);

        if (options_.show_location)
        {
            os_ << " ";
            PrintLocation(node.span);
        }
        os_ << "\n";

        IncreaseIndent();
        PrintExpression(node.argument.get(), "Operand", true);
        DecreaseIndent();
    }

    void DebugPrinter::VisitPrefixIncrementExpression(PrefixIncrementExpression& node)
    {
        PrintIndent();
        PrintColored("PrefixIncrementExpression", Color::BrightCyan);

        if (options_.show_location)
        {
            os_ << " ";
            PrintLocation(node.span);
        }
        os_ << "\n";

        IncreaseIndent();
        PrintExpression(node.argument.get(), "Operand", true);
        DecreaseIndent();
    }

    void DebugPrinter::VisitPrefixDecrementExpression(PrefixDecrementExpression& node)
    {
        PrintIndent();
        PrintColored("PrefixDecrementExpression", Color::BrightCyan);

        if (options_.show_location)
        {
            os_ << " ";
            PrintLocation(node.span);
        }
        os_ << "\n";

        IncreaseIndent();
        PrintExpression(node.argument.get(), "Operand", true);
        DecreaseIndent();
    }

    void DebugPrinter::VisitPostfixIncrementExpression(PostfixIncrementExpression& node)
    {
        PrintIndent();
        PrintColored("PostfixIncrementExpression", Color::BrightCyan);

        if (options_.show_location)
        {
            os_ << " ";
            PrintLocation(node.span);
        }
        os_ << "\n";

        IncreaseIndent();
        PrintExpression(node.argument.get(), "Operand", true);
        DecreaseIndent();
    }

    void DebugPrinter::VisitPostfixDecrementExpression(PostfixDecrementExpression& node)
    {
        PrintIndent();
        PrintColored("PostfixDecrementExpression", Color::BrightCyan);

        if (options_.show_location)
        {
            os_ << " ";
            PrintLocation(node.span);
        }
        os_ << "\n";

        IncreaseIndent();
        PrintExpression(node.argument.get(), "Operand", true);
        DecreaseIndent();
    }

    void DebugPrinter::VisitLogicalNotExpression(LogicalNotExpression& node)
    {
        PrintIndent();
        PrintColored("LogicalNotExpression", Color::BrightCyan);

        if (options_.show_location)
        {
            os_ << " ";
            PrintLocation(node.span);
        }
        os_ << "\n";

        IncreaseIndent();
        PrintExpression(node.argument.get(), "Operand", true);
        DecreaseIndent();
    }

    void DebugPrinter::VisitBitwiseNotExpression(BitwiseNotExpression& node)
    {
        PrintIndent();
        PrintColored("BitwiseNotExpression", Color::BrightCyan);

        if (options_.show_location)
        {
            os_ << " ";
            PrintLocation(node.span);
        }
        os_ << "\n";

        IncreaseIndent();
        PrintExpression(node.argument.get(), "Operand", true);
        DecreaseIndent();
    }

    void DebugPrinter::VisitDerivativeExpression(DerivativeExpression& node)
    {
        PrintIndent();
        PrintColored("DerivativeExpression", Color::BrightCyan);

        if (options_.show_location)
        {
            os_ << " ";
            PrintLocation(node.span);
        }
        os_ << "\n";

        IncreaseIndent();
        PrintExpression(node.argument.get(), "Operand", true);
        DecreaseIndent();
    }

    void DebugPrinter::VisitFunctionPointerExpression(FunctionPointerExpression& node)
    {
        PrintIndent();
        PrintColored("FunctionPointerExpression", Color::BrightCyan);

        if (options_.show_location)
        {
            os_ << " ";
            PrintLocation(node.span);
        }
        os_ << "\n";

        IncreaseIndent();
        PrintExpression(node.argument.get(), "Argument", true);
        DecreaseIndent();
    }

    void DebugPrinter::VisitMatrixTransposeExpression(MatrixTransposeExpression& node)
    {
        PrintIndent();
        PrintColored("MatrixTransposeExpression", Color::BrightCyan);

        if (options_.show_location)
        {
            os_ << " ";
            PrintLocation(node.span);
        }
        os_ << "\n";

        IncreaseIndent();
        PrintExpression(node.argument.get(), "Operand", true);
        DecreaseIndent();
    }

    void DebugPrinter::VisitExprOperatorExpression(ExprOperatorExpression& node)
    {
        PrintIndent();
        PrintColored("ExprOperatorExpression", Color::BrightCyan);

        if (options_.show_location)
        {
            os_ << " ";
            PrintLocation(node.span);
        }
        os_ << "\n";

        IncreaseIndent();
        PrintExpression(node.argument.get(), "Operand", true);
        DecreaseIndent();
    }

    // ===== 二元和三元表达式 =====

    void DebugPrinter::VisitBinaryExpression(BinaryExpression& node)
    {
        PrintIndent();
        PrintColored("BinaryExpression: ", Color::BrightCyan);
        PrintOperator(node.op);

        if (options_.show_location)
        {
            os_ << " ";
            PrintLocation(node.span);
        }
        os_ << "\n";

        IncreaseIndent();
        PrintExpression(node.left.get(), "Left", false);
        PrintExpression(node.right.get(), "Right", true);
        DecreaseIndent();
    }

    void DebugPrinter::VisitTernaryExpression(TernaryExpression& node)
    {
        PrintIndent();
        PrintColored("TernaryExpression", Color::BrightCyan);

        if (options_.show_location)
        {
            os_ << " ";
            PrintLocation(node.span);
        }
        os_ << "\n";

        IncreaseIndent();
        PrintExpression(node.condition.get(), "Condition", false);
        PrintExpression(node.consequence.get(), "Consequence", false);
        PrintExpression(node.alternative.get(), "Alternative", true);
        DecreaseIndent();
    }

    void DebugPrinter::VisitAssignmentExpression(AssignmentExpression& node)
    {
        PrintIndent();
        PrintColored("AssignmentExpression: ", Color::BrightCyan);
        PrintOperator(node.op);

        if (options_.show_location)
        {
            os_ << " ";
            PrintLocation(node.span);
        }
        os_ << "\n";

        IncreaseIndent();
        PrintLeftHandSide(node.left, "Left", false);
        PrintExpression(node.right.get(), "Right", true);
        DecreaseIndent();
    }

    // ===== 特殊表达式 =====

    void DebugPrinter::VisitAnonymousFunctionExpression(AnonymousFunctionExpression& node)
    {
        PrintIndent();
        PrintColored("AnonymousFunctionExpression", Color::BrightCyan);

        if (node.is_static)
        {
            os_ << " " << GetColor(Color::Magenta) << "(static)" << GetColor(Color::Reset);
        }

        if (options_.show_location)
        {
            os_ << " ";
            PrintLocation(node.span);
        }
        os_ << "\n";

        IncreaseIndent();

        if (!node.parameters.empty())
        {
            PrintIndent();
            PrintColored("Parameters:", Color::Yellow);
            os_ << "\n";
            IncreaseIndent();
            for (size_t i = 0; i < node.parameters.size(); ++i)
            {
                if (node.parameters[i])
                {
                    PrintParameter(*node.parameters[i], i == node.parameters.size() - 1);
                }
            }
            DecreaseIndent();
        }

        if (node.return_type)
        {
            PrintKeyValue("ReturnType", node.return_type->name);
        }

        if (node.body)
        {
            PrintStatement(node.body.get(), "Body", true);
        }

        DecreaseIndent();
    }

    void DebugPrinter::VisitNewExpression(NewExpression& node)
    {
        PrintIndent();
        PrintColored("NewExpression", Color::BrightCyan);

        if (options_.show_location)
        {
            os_ << " ";
            PrintLocation(node.span);
        }
        os_ << "\n";

        if (node.class_expr)
        {
            IncreaseIndent();
            PrintExpression(node.class_expr.get(), "Class", true);
            DecreaseIndent();
        }
    }

    void DebugPrinter::VisitEchoExpression(EchoExpression& node)
    {
        PrintIndent();
        PrintColored("EchoExpression", Color::BrightCyan);

        if (options_.show_location)
        {
            os_ << " ";
            PrintLocation(node.span);
        }
        os_ << "\n";

        if (!node.expressions.empty())
        {
            IncreaseIndent();
            for (size_t i = 0; i < node.expressions.size(); ++i)
            {
                PrintExpression(node.expressions[i].get(), "", i == node.expressions.size() - 1);
            }
            DecreaseIndent();
        }
    }

    void DebugPrinter::VisitRaiseExpression(RaiseExpression& node)
    {
        PrintIndent();
        PrintColored("RaiseExpression", Color::BrightCyan);

        if (options_.show_location)
        {
            os_ << " ";
            PrintLocation(node.span);
        }
        os_ << "\n";

        IncreaseIndent();
        PrintExpression(node.exception.get(), "Exception", true);
        DecreaseIndent();
    }

    void DebugPrinter::VisitInheritedExpression(InheritedExpression& node)
    {
        PrintIndent();
        PrintColored("InheritedExpression", Color::BrightCyan);

        if (options_.show_location)
        {
            os_ << " ";
            PrintLocation(node.span);
        }
        os_ << "\n";

        if (node.call)
        {
            IncreaseIndent();
            PrintExpression(node.call.get(), "Call", true);
            DecreaseIndent();
        }
    }

    void DebugPrinter::VisitTSSQLExpression(TSSQLExpression& node)
    {
        PrintIndent();
        PrintColored("TSSQLExpression: ", Color::BrightCyan);
        PrintTSSQLExpressionType(node.sql_type);

        if (options_.show_location)
        {
            os_ << " ";
            PrintLocation(node.span);
        }
        os_ << "\n";

        IncreaseIndent();

        PrintIndent();
        PrintColored("SQL: ", Color::Yellow);
        PrintColored("\"" + EscapeString(TruncateString(node.raw_sql, 100)) + "\"", Color::Green);
        os_ << "\n";

        if (options_.show_location)
        {
            PrintIndent();
            PrintColored("SQL Location: ", Color::Yellow);
            PrintLocation(node.sql_location);
            os_ << "\n";
        }

        DecreaseIndent();
    }

    void DebugPrinter::VisitColumnReference(ColumnReference& node)
    {
        PrintIndent();
        PrintColored("ColumnReference", Color::BrightCyan);

        if (options_.show_location)
        {
            os_ << " ";
            PrintLocation(node.span);
        }
        os_ << "\n";

        if (node.value)
        {
            IncreaseIndent();
            PrintExpression(node.value.get(), "Value", true);
            DecreaseIndent();
        }
    }

    // ===== 模式 =====

    void DebugPrinter::VisitParameter(Parameter& node)
    {
        PrintIndent();
        PrintColored("Parameter: ", Color::Cyan);
        PrintColored("\"" + node.name + "\"", Color::Green);

        if (node.type)
        {
            os_ << " : ";
            PrintColored(node.type->name, Color::BrightYellow);
        }

        if (node.is_var)
        {
            os_ << " " << GetColor(Color::Magenta) << "(var)" << GetColor(Color::Reset);
        }

        if (node.is_out)
        {
            os_ << " " << GetColor(Color::Magenta) << "(out)" << GetColor(Color::Reset);
        }

        if (options_.show_location)
        {
            os_ << " ";
            PrintLocation(node.location);
        }

        os_ << "\n";

        if (node.default_value)
        {
            IncreaseIndent();
            PrintExpression(node.default_value.get(), "DefaultValue", true);
            DecreaseIndent();
        }
    }

    void DebugPrinter::VisitUnpackPattern(UnpackPattern& node)
    {
        PrintIndent();
        PrintColored("UnpackPattern", Color::BrightCyan);

        if (options_.show_location)
        {
            os_ << " ";
            PrintLocation(node.span);
        }
        os_ << "\n";

        if (!node.elements.empty())
        {
            IncreaseIndent();
            for (size_t i = 0; i < node.elements.size(); ++i)
            {
                bool is_last = (i == node.elements.size() - 1);
                PrintLeftHandSide(node.elements[i], "Element", is_last);
            }
            DecreaseIndent();
        }
    }

    // ===== 语句 =====

    void DebugPrinter::VisitExpressionStatement(ExpressionStatement& node)
    {
        PrintIndent();
        PrintColored("ExpressionStatement", Color::BrightCyan);

        if (options_.show_location)
        {
            os_ << " ";
            PrintLocation(node.span);
        }
        os_ << "\n";

        IncreaseIndent();
        PrintExpression(node.expression.get(), "", true);
        DecreaseIndent();
    }

    void DebugPrinter::VisitBlockStatement(BlockStatement& node)
    {
        PrintIndent();
        PrintColored("BlockStatement", Color::BrightCyan);

        if (options_.show_location)
        {
            os_ << " ";
            PrintLocation(node.span);
        }
        os_ << "\n";

        IncreaseIndent();
        PrintStatements(node.statements);
        DecreaseIndent();
    }

    void DebugPrinter::VisitIfStatement(IfStatement& node)
    {
        PrintIndent();
        PrintColored("IfStatement", Color::BrightCyan);

        if (options_.show_location)
        {
            os_ << " ";
            PrintLocation(node.span);
        }
        os_ << "\n";

        IncreaseIndent();

        // Print all if/elseif branches
        for (size_t i = 0; i < node.branches.size(); ++i)
        {
            const auto& branch = node.branches[i];
            bool is_last_branch = (i == node.branches.size() - 1) && !node.else_body;

            PrintIndent();
            PrintColored(i == 0 ? "If Branch:" : "ElseIf Branch:", Color::Yellow);
            os_ << "\n";

            IncreaseIndent();
            PrintExpression(branch.condition.get(), "Condition", false);
            PrintStatement(branch.body.get(), "Body", is_last_branch);
            DecreaseIndent();
        }

        // Print else branch if exists
        if (node.else_body)
        {
            PrintIndent();
            PrintColored("Else Branch:", Color::Yellow);
            os_ << "\n";
            IncreaseIndent();
            PrintStatement(node.else_body.get(), "Body", true);
            DecreaseIndent();
        }

        DecreaseIndent();
    }

    void DebugPrinter::VisitForInStatement(ForInStatement& node)
    {
        PrintIndent();
        PrintColored("ForInStatement", Color::BrightCyan);

        if (options_.show_location)
        {
            os_ << " ";
            PrintLocation(node.span);
        }
        os_ << "\n";

        IncreaseIndent();
        PrintKeyValue("Key", node.key);
        PrintKeyValue("Value", node.value);
        PrintExpression(node.collection.get(), "Collection", false);
        PrintStatement(node.body.get(), "Body", true);
        DecreaseIndent();
    }

    void DebugPrinter::VisitForToStatement(ForToStatement& node)
    {
        PrintIndent();
        PrintColored("ForToStatement", Color::BrightCyan);

        if (options_.show_location)
        {
            os_ << " ";
            PrintLocation(node.span);
        }
        os_ << "\n";

        IncreaseIndent();
        PrintKeyValue("Counter", node.counter);
        PrintKeyValue("IsDownto", node.is_downto);
        PrintExpression(node.start.get(), "Start", false);
        PrintExpression(node.end.get(), "End", !node.step && !node.body);
        if (node.step)
        {
            PrintExpression(node.step.get(), "Step", !node.body);
        }
        if (node.body)
        {
            PrintStatement(node.body.get(), "Body", true);
        }
        DecreaseIndent();
    }

    void DebugPrinter::VisitWhileStatement(WhileStatement& node)
    {
        PrintIndent();
        PrintColored("WhileStatement", Color::BrightCyan);

        if (options_.show_location)
        {
            os_ << " ";
            PrintLocation(node.span);
        }
        os_ << "\n";

        IncreaseIndent();
        PrintExpression(node.condition.get(), "Condition", false);
        PrintStatement(node.body.get(), "Body", true);
        DecreaseIndent();
    }

    void DebugPrinter::VisitRepeatStatement(RepeatStatement& node)
    {
        PrintIndent();
        PrintColored("RepeatStatement", Color::BrightCyan);

        if (options_.show_location)
        {
            os_ << " ";
            PrintLocation(node.span);
        }
        os_ << "\n";

        IncreaseIndent();

        // Print body statements
        PrintIndent();
        PrintColored("Body:", Color::Yellow);
        os_ << "\n";
        IncreaseIndent();
        for (size_t i = 0; i < node.body.size(); ++i)
        {
            PrintStatement(node.body[i].get(), "", i == node.body.size() - 1);
        }
        DecreaseIndent();

        PrintExpression(node.condition.get(), "Condition", true);
        DecreaseIndent();
    }

    void DebugPrinter::VisitCaseStatement(CaseStatement& node)
    {
        PrintIndent();
        PrintColored("CaseStatement", Color::BrightCyan);

        if (options_.show_location)
        {
            os_ << " ";
            PrintLocation(node.span);
        }
        os_ << "\n";

        IncreaseIndent();
        PrintExpression(node.discriminant.get(), "Discriminant", false);

        for (size_t i = 0; i < node.branches.size(); ++i)
        {
            const auto& branch = node.branches[i];
            bool is_last_branch = (i == node.branches.size() - 1) && !node.else_body;

            PrintIndent();
            PrintColored("Branch:", Color::Yellow);
            os_ << "\n";

            IncreaseIndent();

            PrintIndent();
            PrintColored("Values:", Color::Yellow);
            os_ << "\n";
            IncreaseIndent();
            for (size_t j = 0; j < branch.values.size(); ++j)
            {
                PrintExpression(branch.values[j].get(), "", j == branch.values.size() - 1);
            }
            DecreaseIndent();

            if (branch.body)
            {
                is_last_child_stack_.push_back(is_last_branch);
                PrintStatement(branch.body.get(), "Body", is_last_branch);
                is_last_child_stack_.pop_back();
            }

            DecreaseIndent();
        }

        if (node.else_body)
        {
            PrintStatement(node.else_body.get(), "Else", true);
        }

        DecreaseIndent();
    }

    void DebugPrinter::VisitTryStatement(TryStatement& node)
    {
        PrintIndent();
        PrintColored("TryStatement", Color::BrightCyan);

        if (options_.show_location)
        {
            os_ << " ";
            PrintLocation(node.span);
        }
        os_ << "\n";

        IncreaseIndent();

        if (node.try_body)
        {
            PrintStatement(node.try_body.get(), "Try", !node.except_body);
        }

        if (node.except_body)
        {
            PrintStatement(node.except_body.get(), "Except", true);
        }

        DecreaseIndent();
    }

    void DebugPrinter::VisitBreakStatement(BreakStatement& node)
    {
        PrintIndent();
        PrintColored("BreakStatement", Color::BrightCyan);

        if (options_.show_location)
        {
            os_ << " ";
            PrintLocation(node.span);
        }
        os_ << "\n";
    }

    void DebugPrinter::VisitContinueStatement(ContinueStatement& node)
    {
        PrintIndent();
        PrintColored("ContinueStatement", Color::BrightCyan);

        if (options_.show_location)
        {
            os_ << " ";
            PrintLocation(node.span);
        }
        os_ << "\n";
    }

    void DebugPrinter::VisitReturnStatement(ReturnStatement& node)
    {
        PrintIndent();
        PrintColored("ReturnStatement", Color::BrightCyan);

        if (options_.show_location)
        {
            os_ << " ";
            PrintLocation(node.span);
        }
        os_ << "\n";

        if (node.value)
        {
            IncreaseIndent();
            PrintExpression(node.value.get(), "", true);
            DecreaseIndent();
        }
    }

    void DebugPrinter::VisitUsesStatement(UsesStatement& node)
    {
        PrintIndent();
        PrintColored("UsesStatement", Color::BrightCyan);

        if (options_.show_location)
        {
            os_ << " ";
            PrintLocation(node.span);
        }
        os_ << "\n";

        IncreaseIndent();
        for (size_t i = 0; i < node.units.size(); ++i)
        {
            PrintIndent(i == node.units.size() - 1);
            PrintColored("\"" + node.units[i].name + "\"", Color::Green);
            if (options_.show_location)
            {
                os_ << " ";
                PrintLocation(node.units[i].location);
            }
            os_ << "\n";
        }
        DecreaseIndent();
    }

    void DebugPrinter::VisitMatrixIterationStatement(MatrixIterationStatement& node)
    {
        PrintIndent();
        PrintColored("MatrixIterationStatement", Color::BrightCyan);

        if (options_.show_location)
        {
            os_ << " ";
            PrintLocation(node.span);
        }
        os_ << "\n";

        IncreaseIndent();
        PrintExpression(node.target.get(), "Target", false);
        PrintStatement(node.body.get(), "Body", true);
        DecreaseIndent();
    }

    // ===== 函数和声明 =====

    void DebugPrinter::VisitFunctionDefinition(FunctionDefinition& node)
    {
        PrintIndent();
        PrintColored("FunctionDefinition: ", Color::BrightCyan);
        PrintColored("\"" + node.name + "\"", Color::Green);

        if (options_.show_location)
        {
            os_ << " ";
            PrintLocation(node.location);
        }
        os_ << "\n";

        IncreaseIndent();

        if (!node.parameters.empty())
        {
            PrintIndent();
            PrintColored("Parameters:", Color::Yellow);
            os_ << "\n";
            IncreaseIndent();
            for (size_t i = 0; i < node.parameters.size(); ++i)
            {
                if (node.parameters[i])
                {
                    PrintParameter(*node.parameters[i], i == node.parameters.size() - 1);
                }
            }
            DecreaseIndent();
        }

        PrintIndent();
        std::string overload = node.is_overload ? "true" : "false";
        PrintColored("Overload: " + overload, Color::Cyan);
        os_ << "\n";
        DecreaseIndent();

        if (node.return_type)
            PrintKeyValue("ReturnType", node.return_type->name);

        if (node.body)
            PrintStatement(node.body.get(), "Body", true);

        DecreaseIndent();
    }

    void DebugPrinter::VisitFunctionDeclaration(FunctionDeclaration& node)
    {
        PrintIndent();
        PrintColored("FunctionDeclaration: ", Color::BrightCyan);
        PrintColored("\"" + node.name + "\"", Color::Green);

        if (options_.show_location)
        {
            os_ << " ";
            PrintLocation(node.span);
        }
        os_ << "\n";

        IncreaseIndent();

        if (!node.parameters.empty())
        {
            PrintIndent();
            PrintColored("Parameters:", Color::Yellow);
            os_ << "\n";
            IncreaseIndent();
            for (size_t i = 0; i < node.parameters.size(); ++i)
            {
                if (node.parameters[i])
                {
                    PrintParameter(*node.parameters[i], i == node.parameters.size() - 1);
                }
            }
            DecreaseIndent();
        }

        if (node.return_type)
        {
            PrintKeyValue("ReturnType", node.return_type->name);
        }

        DecreaseIndent();
    }

    void DebugPrinter::VisitVarDeclaration(VarDeclaration& node)
    {
        PrintIndent();
        PrintColored("VarDeclaration: ", Color::BrightCyan);
        PrintColored("\"" + node.name + "\"", Color::Green);

        if (options_.show_location)
        {
            os_ << " ";
            PrintLocation(node.location);
        }
        os_ << "\n";

        IncreaseIndent();

        if (node.type)
        {
            PrintKeyValue("Type", node.type->name);
        }

        if (node.initial_value)
        {
            PrintExpression(node.initial_value.get(), "InitialValue", true);
        }

        DecreaseIndent();
    }

    void DebugPrinter::VisitStaticDeclaration(StaticDeclaration& node)
    {
        PrintIndent();
        PrintColored("StaticDeclaration: ", Color::BrightCyan);
        PrintColored("\"" + node.name + "\"", Color::Green);

        if (options_.show_location)
        {
            os_ << " ";
            PrintLocation(node.location);
        }
        os_ << "\n";

        IncreaseIndent();

        if (node.type)
        {
            PrintKeyValue("Type", node.type->name);
        }

        if (node.initial_value)
        {
            PrintExpression(node.initial_value.get(), "Initializer", true);
        }

        DecreaseIndent();
    }

    void DebugPrinter::VisitGlobalDeclaration(GlobalDeclaration& node)
    {
        PrintIndent();
        PrintColored("GlobalDeclaration: ", Color::BrightCyan);
        PrintColored("\"" + node.name + "\"", Color::Green);

        if (options_.show_location)
        {
            os_ << " ";
            PrintLocation(node.location);
        }
        os_ << "\n";

        IncreaseIndent();

        if (node.type)
        {
            PrintKeyValue("Type", node.type->name);
        }

        if (node.initial_value)
        {
            PrintExpression(node.initial_value.get(), "Initializer", true);
        }

        DecreaseIndent();
    }

    void DebugPrinter::VisitConstDeclaration(ConstDeclaration& node)
    {
        PrintIndent();
        PrintColored("ConstDeclaration: ", Color::BrightCyan);
        PrintColored("\"" + node.name + "\"", Color::Green);

        if (options_.show_location)
        {
            os_ << " ";
            PrintLocation(node.location);
        }
        os_ << "\n";

        IncreaseIndent();

        if (node.type)
        {
            PrintKeyValue("Type", node.type->name);
        }

        if (node.value)
        {
            PrintExpression(node.value.get(), "Value", true);
        }

        DecreaseIndent();
    }

    void DebugPrinter::VisitFieldDeclaration(FieldDeclaration& node)
    {
        PrintIndent();
        PrintColored("FieldDeclaration: ", Color::BrightCyan);
        PrintColored("\"" + node.name + "\"", Color::Green);

        if (options_.show_location)
        {
            os_ << " ";
            PrintLocation(node.location);
        }
        os_ << "\n";

        IncreaseIndent();

        if (node.type)
        {
            PrintKeyValue("Type", node.type->name);
        }

        if (node.initial_value)
        {
            PrintExpression(node.initial_value.get(), "Initializer", true);
        }

        DecreaseIndent();
    }

    // ===== 条件编译 =====

    void DebugPrinter::VisitCompilerDirective(CompilerDirective& node)
    {
        PrintIndent();
        PrintColored("CompilerDirective: ", Color::BrightCyan);
        PrintColored("\"" + node.name + "\"", Color::Green);

        if (node.switch_value)
        {
            os_ << " " << GetColor(Color::Magenta) << *node.switch_value << GetColor(Color::Reset);
        }

        if (options_.show_location)
        {
            os_ << " ";
            PrintLocation(node.location);
        }
        os_ << "\n";
    }

    void DebugPrinter::VisitConditionalBlock(ConditionalBlock& node)
    {
        PrintIndent();
        PrintColored("ConditionalBlock: ", Color::BrightCyan);
        PrintConditionalCompilationType(node.type);
        os_ << " " << GetColor(Color::Green) << node.name << GetColor(Color::Reset);

        if (options_.show_location)
        {
            os_ << " ";
            PrintLocation(node.location);
        }
        os_ << "\n";

        IncreaseIndent();

        if (!node.consequence.empty())
        {
            PrintIndent();
            PrintColored("Consequence:", Color::Yellow);
            os_ << "\n";
            IncreaseIndent();
            PrintStatements(node.consequence);
            DecreaseIndent();
        }

        if (!node.alternative.empty())
        {
            PrintIndent();
            PrintColored("Alternative:", Color::Yellow);
            os_ << "\n";
            IncreaseIndent();
            PrintStatements(node.alternative);
            DecreaseIndent();
        }

        DecreaseIndent();
    }

    void DebugPrinter::VisitConditionalDirective(ConditionalDirective& node)
    {
        PrintIndent();
        PrintColored("ConditionalDirective: ", Color::BrightCyan);
        PrintConditionalCompilationType(node.type);
        os_ << " " << GetColor(Color::Green) << node.name << GetColor(Color::Reset);

        if (options_.show_location)
        {
            os_ << " ";
            PrintLocation(node.location);
        }
        os_ << "\n";
    }

    void DebugPrinter::VisitTSLXBlock(TSLXBlock& node)
    {
        PrintIndent();
        PrintColored("TSLXBlock", Color::BrightCyan);

        if (options_.show_location)
        {
            os_ << " ";
            PrintLocation(node.span);
        }
        os_ << "\n";

        // TSLXBlock 的具体内容未定义，暂时只打印节点名称
    }

    // ===== 便捷函数实现 =====

    std::string DebugString(const ASTNode* node, const PrintOptions& opts)
    {
        std::ostringstream oss;
        DebugPrinter printer(oss, opts);
        printer.Print(node);
        return oss.str();
    }

    std::string DebugString(const ParseResult& result, const PrintOptions& opts)
    {
        std::ostringstream oss;
        DebugPrinter printer(oss, opts);
        printer.PrintParseResult(result);
        return oss.str();
    }

    void DebugPrint(const ASTNode* node, const PrintOptions& opts)
    {
        DebugPrinter printer(std::cout, opts);
        printer.Print(node);
    }

    void DebugPrint(const ParseResult& result, const PrintOptions& opts)
    {
        DebugPrinter printer(std::cout, opts);
        printer.PrintParseResult(result);
    }

    void DebugPrint(const ASTNode* node, const std::string& source, const PrintOptions& opts)
    {
        DebugPrinter printer(std::cout, opts);
        printer.SetSourceCode(&source);
        printer.Print(node);
    }

    void DebugPrint(const ParseResult& result, const std::string& source, const PrintOptions& opts)
    {
        DebugPrinter printer(std::cout, opts);
        printer.SetSourceCode(&source);
        printer.PrintParseResult(result);
    }
}