#pragma once

#include "./table.hpp"

namespace lsp::language::symbol
{
    class Builder : public ast::ASTVisitor
    {
    public:
        explicit Builder(SymbolTable& table);

        void Build(ast::ASTNode& root);

        // Visit statements and declarations
        void VisitProgram(ast::Program& node) override;
        void VisitUnitDefinition(ast::UnitDefinition& node) override;
        void VisitClassDefinition(ast::ClassDefinition& node) override;
        void VisitFunctionDefinition(ast::FunctionDefinition& node) override;
        void VisitFunctionDeclaration(ast::FunctionDeclaration& node) override;
        void VisitMethodDeclaration(ast::MethodDeclaration& node) override;
        void VisitPropertyDeclaration(ast::PropertyDeclaration& node) override;
        void VisitExternalMethodDefinition(ast::ExternalMethodDefinition& node) override;
        void VisitClassMember(ast::ClassMember& node) override;

        // Declarations
        void VisitVarDeclaration(ast::VarDeclaration& node) override;
        void VisitStaticDeclaration(ast::StaticDeclaration& node) override;
        void VisitGlobalDeclaration(ast::GlobalDeclaration& node) override;
        void VisitConstDeclaration(ast::ConstDeclaration& node) override;
        void VisitFieldDeclaration(ast::FieldDeclaration& node) override;

        void VisitBlockStatement(ast::BlockStatement& node) override;
        void VisitIfStatement(ast::IfStatement& node) override;
        void VisitForInStatement(ast::ForInStatement& node) override;
        void VisitForToStatement(ast::ForToStatement& node) override;
        void VisitWhileStatement(ast::WhileStatement& node) override;
        void VisitRepeatStatement(ast::RepeatStatement& node) override;
        void VisitCaseStatement(ast::CaseStatement& node) override;
        void VisitTryStatement(ast::TryStatement& node) override;

        // Uses statement handling
        void VisitUsesStatement(ast::UsesStatement& node) override;

        // Visit expressions (只遍历，不收集引用)
        void VisitIdentifier(ast::Identifier& node) override {}
        void VisitCallExpression(ast::CallExpression& node) override;
        void VisitAttributeExpression(ast::AttributeExpression& node) override;
        void VisitAssignmentExpression(ast::AssignmentExpression& node) override;

        // Other node visits
        void VisitLiteral(ast::Literal& node) override;
        void VisitBinaryExpression(ast::BinaryExpression& node) override;
        void VisitTernaryExpression(ast::TernaryExpression& node) override;
        void VisitSubscriptExpression(ast::SubscriptExpression& node) override;
        void VisitArrayExpression(ast::ArrayExpression& node) override;
        void VisitAnonymousFunctionExpression(ast::AnonymousFunctionExpression& node) override;

        // Unary expressions
        void VisitUnaryPlusExpression(ast::UnaryPlusExpression& node) override;
        void VisitUnaryMinusExpression(ast::UnaryMinusExpression& node) override;
        void VisitPrefixIncrementExpression(ast::PrefixIncrementExpression& node) override;
        void VisitPrefixDecrementExpression(ast::PrefixDecrementExpression& node) override;
        void VisitPostfixIncrementExpression(ast::PostfixIncrementExpression& node) override;
        void VisitPostfixDecrementExpression(ast::PostfixDecrementExpression& node) override;
        void VisitLogicalNotExpression(ast::LogicalNotExpression& node) override;
        void VisitBitwiseNotExpression(ast::BitwiseNotExpression& node) override;
        void VisitDerivativeExpression(ast::DerivativeExpression& node) override;
        void VisitMatrixTransposeExpression(ast::MatrixTransposeExpression& node) override;
        void VisitExprOperatorExpression(ast::ExprOperatorExpression& node) override;

        void VisitFunctionPointerExpression(ast::FunctionPointerExpression& node) override;

        // Other expressions
        void VisitNewExpression(ast::NewExpression& node) override;
        void VisitEchoExpression(ast::EchoExpression& node) override;
        void VisitRaiseExpression(ast::RaiseExpression& node) override;
        void VisitInheritedExpression(ast::InheritedExpression& node) override;
        void VisitParenthesizedExpression(ast::ParenthesizedExpression& node) override;

        void VisitExpressionStatement(ast::ExpressionStatement& node) override;
        void VisitBreakStatement(ast::BreakStatement& node) override;
        void VisitContinueStatement(ast::ContinueStatement& node) override;
        void VisitReturnStatement(ast::ReturnStatement& node) override;
        void VisitTSSQLExpression(ast::TSSQLExpression& node) override;
        void VisitColumnReference(ast::ColumnReference& node) override;
        void VisitUnpackPattern(ast::UnpackPattern& node) override;
        void VisitMatrixIterationStatement(ast::MatrixIterationStatement& node) override;

        // Compiler directives
        void VisitCompilerDirective(ast::CompilerDirective& node) override;
        void VisitConditionalDirective(ast::ConditionalDirective& node) override;
        void VisitConditionalBlock(ast::ConditionalBlock& node) override;
        void VisitTSLXBlock(ast::TSLXBlock& node) override;

        void VisitParameter(ast::Parameter& node) override;

    private:
        SymbolId CreateFunctionSymbol(
            const std::string& name,
            const ast::Location& location,
            const std::vector<std::unique_ptr<ast::Parameter>>& parameters,
            const std::optional<ast::TypeAnnotation>& return_type);

        SymbolId CreateMethodSymbol(
            const std::string& name,
            const ast::Location& location,
            const std::vector<std::unique_ptr<ast::Parameter>>& parameters,
            const std::optional<ast::TypeAnnotation>& return_type);

        SymbolId CreateSymbol(
            const std::string& name,
            protocol::SymbolKind kind,
            const ast::Location& location,
            const std::optional<std::string>& type_hint = std::nullopt);

        SymbolId CreateSymbol(
            const std::string& name,
            protocol::SymbolKind kind,
            const ast::ASTNode& node,
            const std::optional<std::string>& type_hint = std::nullopt);

        // Scope management
        ScopeId EnterScopeWithSymbol(ScopeKind kind, SymbolId symbol_id, const ast::Location& range);
        ScopeId EnterScope(ScopeKind kind, const ast::Location& range);
        void ExitScope();

        // Traversal helpers
        void VisitStatements(const std::vector<ast::StatementPtr>& statements);
        void VisitExpression(ast::Expression& expr);

        // Type and parameter extraction
        std::optional<std::string> ExtractTypeName(const std::optional<ast::TypeAnnotation>& type) const;

        std::vector<language::symbol::Parameter> BuildParameters(const std::vector<std::unique_ptr<ast::Parameter>>& parameters) const;
        void ProcessLValue(const ast::LValue& lvalue, bool is_write);

    private:
        SymbolTable& table_;

        ScopeId current_scope_id_;
        std::optional<SymbolId> current_parent_symbol_id_;
        std::optional<SymbolId> current_function_id_;

        bool in_interface_section_;
    };

} // namespace lsp::language::symbol