module;

#include <cstdint>

export module lsp.provider.text_document.completion;
import spdlog;

import std;

import lsp.protocol;
import lsp.codec.facade;
import lsp.provider.base.interface;
import lsp.language.ast;
import lsp.language.symbol;
import lsp.language.semantic;
import lsp.language.keyword;
import lsp.utils.string;
import lsp.utils.text_coordinates;

namespace transform = lsp::codec;

export namespace lsp::provider::text_document
{
    class Completion : public AutoRegisterProvider<Completion, IRequestProvider>
    {
    public:
        static constexpr std::string_view kMethod = "textDocument/completion";
        static constexpr std::string_view kProviderName = "TextDocumentCompletion";
        std::string ProvideResponse(const protocol::RequestMessage& request, ExecutionContext& execution_context) override;
    };
}

namespace lsp::provider::text_document
{
    namespace
    {
        enum class CompletionSource
        {
            kEditing,
            kWorkspace,
            kSystem,
            kKeyword
        };

        struct CompletionContext
        {
            std::string uri;
            protocol::Position position{};
            std::string line_content;
            std::string prefix;
            std::string class_name;
            bool is_new_context = false;
            bool is_createobject_context = false;
            bool is_unit_context = false;
            bool is_class_context = false;
            bool is_class_method_context = false;
            bool is_unit_member_context = false;
            bool is_object_member_context = false;
            bool is_unit_scoped_new = false;
            std::string unit_name;
            std::string member_prefix;
            std::string object_name;
            bool createobject_has_open_quote = false;
            char createobject_quote = '"';
        };

        struct SourcedCompletionItem
        {
            protocol::CompletionItem item;
            CompletionSource source;
        };

        std::string SourceTag(CompletionSource source)
        {
            switch (source)
            {
            case CompletionSource::kEditing:
                return "[E]";
            case CompletionSource::kWorkspace:
                return "[W]";
            case CompletionSource::kSystem:
                return "[S]";
            case CompletionSource::kKeyword:
            default:
                return "[K]";
            }
        }

        protocol::CompletionItemKind ToCompletionItemKind(protocol::SymbolKind kind)
        {
            switch (kind)
            {
            case protocol::SymbolKind::Function:
                return protocol::CompletionItemKind::Function;
            case protocol::SymbolKind::Method:
                return protocol::CompletionItemKind::Method;
            case protocol::SymbolKind::Constructor:
                return protocol::CompletionItemKind::Constructor;
            case protocol::SymbolKind::Class:
                return protocol::CompletionItemKind::Class;
            case protocol::SymbolKind::Property:
                return protocol::CompletionItemKind::Property;
            case protocol::SymbolKind::Field:
                return protocol::CompletionItemKind::Field;
            case protocol::SymbolKind::Variable:
            case protocol::SymbolKind::TypeParameter:
                return protocol::CompletionItemKind::Variable;
            case protocol::SymbolKind::Constant:
                return protocol::CompletionItemKind::Constant;
            case protocol::SymbolKind::Module:
                return protocol::CompletionItemKind::Module;
            default:
                return protocol::CompletionItemKind::Text;
            }
        }

        std::string BuildSignature(const std::vector<language::symbol::Parameter>& params, const std::optional<std::string>& return_type)
        {
            std::string detail = "(";
            for (std::size_t i = 0; i < params.size(); ++i)
            {
                if (i > 0)
                    detail += ", ";
                detail += params[i].name;
                if (params[i].type && !params[i].type->empty())
                    detail += ": " + *params[i].type;
            }
            detail += ")";
            if (return_type && !return_type->empty())
                detail += ": " + *return_type;
            return detail;
        }

        bool IsNewContext(const std::string& line)
        {
            std::string line_lower = utils::ToLower(line);
            std::size_t new_pos = line_lower.rfind("new ");
            if (new_pos == std::string::npos)
                return false;

            std::string after_new = utils::Trim(line.substr(new_pos + 4));
            return after_new.find('(') == std::string::npos;
        }

        struct CreateObjectContextInfo
        {
            std::string prefix;
            bool has_open_quote = false;
            char quote = '"';
        };

        bool IsCreateObjectContext(const std::string& line, CreateObjectContextInfo& out)
        {
            std::string line_lower = utils::ToLower(line);
            std::size_t pos = line_lower.rfind("createobject(");
            if (pos == std::string::npos)
            {
                return false;
            }

            std::string after = line.substr(pos + std::string("createobject(").size());
            std::size_t i = 0;
            while (i < after.size() && std::isspace(static_cast<unsigned char>(after[i])))
            {
                ++i;
            }
            after = after.substr(i);

            if (after.empty())
            {
                out = CreateObjectContextInfo{};
                return true;
            }

            if (after.find(',') != std::string::npos)
            {
                return false;
            }

            char first = after.front();
            if (first == '"' || first == '\'')
            {
                out.has_open_quote = true;
                out.quote = first;
                out.prefix = after.substr(1);
                if (out.prefix.find(first) != std::string::npos)
                {
                    return false;
                }
                return true;
            }

            out.prefix = after;
            out.has_open_quote = false;
            out.quote = '"';
            return true;
        }

        bool IsClassMethodContext(const std::string& line, std::string& out_class_name, std::string& out_prefix)
        {
            std::string line_lower = utils::ToLower(line);
            std::size_t class_pos = line_lower.rfind("class(");
            if (class_pos == std::string::npos)
                return false;

            std::string after_class = line.substr(class_pos + 6);
            std::size_t close_paren = after_class.find(')');
            if (close_paren == std::string::npos)
                return false;

            std::size_t dot_pos = after_class.find('.', close_paren);
            if (dot_pos == std::string::npos)
                return false;

            out_class_name = utils::Trim(after_class.substr(0, close_paren));
            if (out_class_name.empty())
                return false;

            out_prefix = utils::Trim(after_class.substr(dot_pos + 1));
            return true;
        }

        bool IsUnitContext(const std::string& line)
        {
            std::string line_lower = utils::ToLower(line);
            std::size_t unit_pos = line_lower.rfind("unit(");
            if (unit_pos == std::string::npos)
                return false;

            std::string after = line.substr(unit_pos + 5);
            return after.find(')') == std::string::npos;
        }

        bool IsClassContext(const std::string& line)
        {
            std::string line_lower = utils::ToLower(line);
            std::size_t class_pos = line_lower.rfind("class(");
            if (class_pos == std::string::npos)
                return false;

            std::string after = line.substr(class_pos + 6);
            return after.find(')') == std::string::npos;
        }

        std::string ExtractPrefixByScan(std::size_t cursor_pos, std::size_t line_start, const std::string& content)
        {
            std::size_t prefix_start = cursor_pos;
            while (prefix_start > line_start)
            {
                char ch = content[prefix_start - 1];
                if (!std::isalnum(static_cast<unsigned char>(ch)) && ch != '_')
                    break;
                --prefix_start;
            }
            return content.substr(prefix_start, cursor_pos - prefix_start);
        }

        CompletionContext AnalyzeContext(const protocol::CompletionParams& params, const std::optional<std::string>& document_content)
        {
            CompletionContext result;
            result.uri = params.textDocument.uri;
            result.position = params.position;

            if (!document_content)
                return result;

            const std::string& content = *document_content;
            std::size_t line_start = 0;
            std::size_t current_line = 0;
            for (std::size_t i = 0; i < content.length(); ++i)
            {
                if (current_line == result.position.line)
                {
                    line_start = i;
                    break;
                }
                if (content[i] == '\n')
                    ++current_line;
            }

            std::size_t cursor_pos = std::min(line_start + result.position.character, content.length());
            result.line_content = content.substr(line_start, cursor_pos - line_start);

            std::string class_name;
            std::string method_prefix;
            result.is_class_method_context = IsClassMethodContext(result.line_content, class_name, method_prefix);
            if (result.is_class_method_context)
            {
                result.class_name = class_name;
                result.prefix = method_prefix;
            }
            else
            {
                CreateObjectContextInfo create_info;
                result.is_createobject_context = IsCreateObjectContext(result.line_content, create_info);
                if (result.is_createobject_context)
                {
                    result.prefix = utils::Trim(create_info.prefix);
                    result.createobject_has_open_quote = create_info.has_open_quote;
                    result.createobject_quote = create_info.quote;
                }
                else
                {
                    result.is_new_context = IsNewContext(result.line_content);
                    result.is_unit_context = IsUnitContext(result.line_content);
                    result.is_class_context = IsClassContext(result.line_content);

                    if (result.is_new_context)
                        result.prefix = utils::Trim(result.line_content.substr(result.line_content.rfind("new ") + 4));
                    else if (result.is_unit_context)
                        result.prefix = utils::Trim(result.line_content.substr(result.line_content.rfind("unit(") + 5));
                    else if (result.is_class_context)
                        result.prefix = utils::Trim(result.line_content.substr(result.line_content.rfind("class(") + 6));
                    else
                        result.prefix = ExtractPrefixByScan(cursor_pos, line_start, content);
                }
            }
            return result;
        }

        std::string GetModuleName(const language::symbol::SymbolTable& table)
        {
            for (const auto& wrapper : table.all_definitions())
            {
                const auto& symbol = wrapper.get();
                if (symbol.kind() == protocol::SymbolKind::Module)
                    return symbol.name();
            }
            return "";
        }

        std::vector<std::string> CollectVisibleUnits(const language::symbol::SymbolTable* table, const protocol::Position& position, const std::optional<std::string>& content_opt)
        {
            if (!table)
                return {};

            std::unordered_set<std::string, utils::IHasher, utils::IEqualTo> units;

            auto add_imports = [&units](const auto& imports) {
                for (const auto& imp : imports)
                    units.insert(utils::ToLower(imp.unit_name));
            };

            // Always include current module name
            std::string module_name = GetModuleName(*table);
            if (!module_name.empty())
                units.insert(utils::ToLower(module_name));

            // Gather imports from current symbol scope
            if (content_opt)
            {
                std::uint32_t offset = utils::text_coordinates::ToOffset(position, *content_opt);
                language::ast::Location loc{};
                loc.start_line = loc.end_line = position.line;
                loc.start_column = loc.end_column = position.character;
                loc.start_offset = loc.end_offset = offset;

                if (auto id_opt = table->FindSymbolAt(loc))
                {
                    if (const auto* sym = table->definition(*id_opt))
                    {
                        if (const auto* func = sym->As<language::symbol::Function>())
                            add_imports(func->imports);
                        else if (const auto* method = sym->As<language::symbol::Method>())
                            add_imports(method->imports);
                        else if (const auto* cls = sym->As<language::symbol::Class>())
                            add_imports(cls->imports);
                        else if (const auto* unit = sym->As<language::symbol::Unit>())
                        {
                            add_imports(unit->interface_imports);
                            add_imports(unit->implementation_imports);
                        }
                    }
                }
            }

            // Unit level imports
            for (const auto& wrapper : table->all_definitions())
            {
                const auto& sym = wrapper.get();
                if (sym.kind() == protocol::SymbolKind::Module)
                {
                    const auto* unit = sym.As<language::symbol::Unit>();
                    if (unit)
                    {
                        add_imports(unit->interface_imports);
                        add_imports(unit->implementation_imports);
                    }
                }
            }

            std::vector<std::string> result;
            result.reserve(units.size());
            for (const auto& name : units)
                result.push_back(name);
            return result;
        }

        bool IsUnitVisible(const std::unordered_set<std::string, utils::IHasher, utils::IEqualTo>& visible_units, const std::string& unit_name)
        {
            return visible_units.find(utils::ToLower(unit_name)) != visible_units.end();
        }

        void AppendKeywordItems(const std::string& prefix, std::vector<SourcedCompletionItem>& out)
        {
            auto keywords = language::keyword::Repo::Instance().FindByPrefix(utils::ToLower(prefix));
            for (const auto& keyword : keywords)
            {
                protocol::CompletionItem item;
                item.label = keyword.keyword;
                item.kind = protocol::CompletionItemKind::Keyword;
                item.labelDetails = protocol::CompletionItemLabelDetails{ .detail = "", .description = SourceTag(CompletionSource::kKeyword) };
                out.push_back({ std::move(item), CompletionSource::kKeyword });
            }
        }

        void AppendFunctions(const language::symbol::SymbolTable& table, const std::string& prefix, CompletionSource source, std::vector<SourcedCompletionItem>& out)
        {
            for (const auto& wrapper : table.all_definitions())
            {
                const auto& symbol = wrapper.get();
                if (symbol.kind() != protocol::SymbolKind::Function)
                    continue;
                if (!prefix.empty() && !utils::IStartsWith(symbol.name(), prefix))
                    continue;

                const auto* func = symbol.As<language::symbol::Function>();
                protocol::CompletionItem item;
                item.label = symbol.name();
                item.kind = ToCompletionItemKind(symbol.kind());
                if (func)
                {
                    auto detail = BuildSignature(func->parameters, func->return_type);
                    item.labelDetails = protocol::CompletionItemLabelDetails{ .detail = detail, .description = SourceTag(source) };
                }
                out.push_back({ std::move(item), source });
            }
        }

        void AppendUnitMembers(const language::symbol::SymbolTable& table,
                               const std::string& unit_name,
                               const std::string& member_prefix,
                               CompletionSource source,
                               std::vector<SourcedCompletionItem>& out)
        {
            auto module_name = GetModuleName(table);
            if (module_name.empty() || !utils::IEquals(module_name, unit_name))
                return;

            for (const auto& wrapper : table.all_definitions())
            {
                const auto& symbol = wrapper.get();
                if (symbol.kind() != protocol::SymbolKind::Function &&
                    symbol.kind() != protocol::SymbolKind::Variable &&
                    symbol.kind() != protocol::SymbolKind::Constant &&
                    symbol.kind() != protocol::SymbolKind::Class)
                {
                    continue;
                }

                if (!member_prefix.empty() && !utils::IStartsWith(symbol.name(), member_prefix))
                    continue;

                protocol::CompletionItem item;
                item.label = symbol.name();
                item.kind = ToCompletionItemKind(symbol.kind());

                if (const auto* func = symbol.As<language::symbol::Function>())
                {
                    auto detail = BuildSignature(func->parameters, func->return_type);
                    item.labelDetails = protocol::CompletionItemLabelDetails{ .detail = detail, .description = SourceTag(source) };
                }
                else
                {
                    item.labelDetails = protocol::CompletionItemLabelDetails{ .detail = "", .description = SourceTag(source) };
                }

                out.push_back({ std::move(item), source });
            }
        }

        bool HasStaticMethod(const language::symbol::Class& cls, const language::symbol::SymbolTable& table)
        {
            const auto& scopes = table.scopes().all_scopes();
            for (const auto& [_, scope] : scopes)
            {
                if (scope.kind != language::symbol::ScopeKind::kClass || !scope.owner || *scope.owner != cls.id)
                {
                    continue;
                }

                for (const auto& [_, ids] : scope.symbols)
                {
                    for (auto id : ids)
                    {
                        const auto* member = table.definition(id);
                        if (!member || member->kind() != protocol::SymbolKind::Method)
                            continue;
                        const auto* method = member->As<language::symbol::Method>();
                        if (method && method->is_static)
                            return true;
                    }
                }
            }
            return false;
        }

        std::optional<language::symbol::ScopeId> FindScopeOwnedBy(
            const language::symbol::SymbolTable& table,
            language::symbol::ScopeKind kind,
            language::symbol::SymbolId owner_id)
        {
            for (const auto& [scope_id, scope] : table.scopes().all_scopes())
            {
                if (scope.kind == kind && scope.owner && *scope.owner == owner_id)
                {
                    return scope_id;
                }
            }
            return std::nullopt;
        }

        void AppendClasses(const language::symbol::SymbolTable& table,
                           const std::string& prefix,
                           CompletionSource source,
                           std::vector<SourcedCompletionItem>& out,
                           bool mark_new_context,
                           const std::string& unit_filter = "")
        {
            auto module_name = GetModuleName(table);
            if (!unit_filter.empty())
            {
                if (module_name.empty() || !utils::IEquals(module_name, unit_filter))
                    return;
            }

            for (const auto& wrapper : table.all_definitions())
            {
                const auto& symbol = wrapper.get();
                if (symbol.kind() != protocol::SymbolKind::Class)
                    continue;
                if (!prefix.empty() && !utils::IStartsWith(symbol.name(), prefix))
                    continue;

                const auto* cls = symbol.As<language::symbol::Class>();
                if (!cls)
                    continue;

                if (!mark_new_context && !HasStaticMethod(*cls, table))
                    continue;

                protocol::CompletionItem item;
                item.label = symbol.name();
                item.kind = mark_new_context ? protocol::CompletionItemKind::Constructor : ToCompletionItemKind(symbol.kind());
                item.labelDetails = protocol::CompletionItemLabelDetails{ .detail = "", .description = SourceTag(source) };

                protocol::LSPObject data;
                data["ctx"] = mark_new_context ? "new" : "class";
                data["class"] = symbol.name();
                data["unit"] = module_name;
                item.data = std::move(data);

                out.push_back({ std::move(item), source });
            }
        }

        void AppendUnits(const language::symbol::SymbolTable& table,
                         const std::string& prefix,
                         CompletionSource source,
                         std::vector<SourcedCompletionItem>& out,
                         const std::unordered_set<std::string, utils::IHasher, utils::IEqualTo>* allowed_units = nullptr)
        {
            auto module_name = GetModuleName(table);
            if (!module_name.empty() && allowed_units && !IsUnitVisible(*allowed_units, module_name))
                return;

            for (const auto& wrapper : table.all_definitions())
            {
                const auto& symbol = wrapper.get();
                if (symbol.kind() != protocol::SymbolKind::Module)
                    continue;
                if (!prefix.empty() && !utils::IStartsWith(symbol.name(), prefix))
                    continue;

                protocol::CompletionItem item;
                item.label = symbol.name();
                item.kind = ToCompletionItemKind(symbol.kind());
                item.labelDetails = protocol::CompletionItemLabelDetails{ .detail = "", .description = SourceTag(source) };
                item.data = protocol::LSPAny("unit_context");
                out.push_back({ std::move(item), source });
            }
        }

        std::optional<const language::symbol::Symbol*> FindClassSymbol(const language::symbol::SymbolTable& table, const std::string& class_name)
        {
            auto ids = table.FindSymbolsByName(class_name);
            for (auto id : ids)
            {
                const auto* symbol = table.definition(id);
                if (symbol && symbol->kind() == protocol::SymbolKind::Class)
                    return symbol;
            }
            return std::nullopt;
        }

        struct DotAccessContext
        {
            bool is_unit_call = false;
            std::string base_name;
            std::string member_prefix;
        };

        struct QualifiedPrefix
        {
            std::string unit_name;
            std::string member_prefix;
        };

        std::optional<QualifiedPrefix> ParseUnitQualifiedPrefix(const std::string& text)
        {
            std::string trimmed = utils::Trim(text);
            if (trimmed.empty())
            {
                return std::nullopt;
            }

            std::string lower = utils::ToLower(trimmed);

            // unit(UnitA).Prefix
            if (lower.starts_with("unit("))
            {
                std::string after_unit = trimmed.substr(5);
                std::size_t close_paren = after_unit.find(')');
                if (close_paren == std::string::npos)
                {
                    return std::nullopt;
                }

                std::string unit_name = utils::Trim(after_unit.substr(0, close_paren));
                std::size_t dot_pos = after_unit.find('.', close_paren);
                std::string member_prefix;
                if (dot_pos != std::string::npos && dot_pos + 1 <= after_unit.size())
                {
                    member_prefix = utils::Trim(after_unit.substr(dot_pos + 1));
                }

                if (unit_name.empty())
                {
                    return std::nullopt;
                }

                return QualifiedPrefix{
                    .unit_name = std::move(unit_name),
                    .member_prefix = std::move(member_prefix),
                };
            }

            // UnitA.Prefix
            std::size_t dot_pos = trimmed.find_last_of('.');
            if (dot_pos != std::string::npos)
            {
                std::string unit_name = utils::Trim(trimmed.substr(0, dot_pos));
                std::string member_prefix;
                if (dot_pos + 1 <= trimmed.size())
                {
                    member_prefix = utils::Trim(trimmed.substr(dot_pos + 1));
                }

                if (unit_name.empty())
                {
                    return std::nullopt;
                }

                return QualifiedPrefix{
                    .unit_name = std::move(unit_name),
                    .member_prefix = std::move(member_prefix),
                };
            }

            return std::nullopt;
        }

        std::optional<DotAccessContext> DetectDotAccessContext(const std::string& line)
        {
            // unit(xxx).prefix
            {
                std::string line_lower = utils::ToLower(line);
                std::size_t unit_pos = line_lower.rfind("unit(");
                if (unit_pos != std::string::npos)
                {
                    std::string after_unit = line.substr(unit_pos + 5);
                    std::size_t close_paren = after_unit.find(')');
                    if (close_paren == std::string::npos)
                    {
                        return std::nullopt;
                    }
                    std::size_t dot_pos = after_unit.find('.', close_paren);
                    if (dot_pos != std::string::npos && dot_pos > close_paren)
                    {
                        DotAccessContext ctx;
                        ctx.is_unit_call = true;
                        ctx.base_name = utils::Trim(after_unit.substr(0, close_paren));
                        ctx.member_prefix = utils::Trim(after_unit.substr(dot_pos + 1));
                        if (!ctx.base_name.empty())
                        {
                            return ctx;
                        }
                    }
                }
            }

            // ident.prefix
            std::size_t dot_pos = line.rfind('.');
            if (dot_pos == std::string::npos)
            {
                return std::nullopt;
            }

            std::size_t start = dot_pos;
            while (start > 0)
            {
                char ch = line[start - 1];
                if (!std::isalnum(static_cast<unsigned char>(ch)) && ch != '_')
                    break;
                --start;
            }

            std::string base = utils::Trim(line.substr(start, dot_pos - start));
            if (base.empty())
            {
                return std::nullopt;
            }

            DotAccessContext ctx;
            ctx.base_name = std::move(base);
            ctx.member_prefix = utils::Trim(line.substr(dot_pos + 1));
            return ctx;
        }

        std::vector<std::string> CollectUnitSearchOrder(const language::symbol::SymbolTable& table,
                                                        const protocol::Position& position,
                                                        const std::string& content)
        {
            std::vector<std::string> imports;

            std::uint32_t offset = utils::text_coordinates::ToOffset(position, content);
            language::ast::Location loc{};
            loc.start_line = loc.end_line = position.line;
            loc.start_column = loc.end_column = position.character;
            loc.start_offset = loc.end_offset = offset;

            auto add_imports = [&imports](const auto& vec) {
                imports.reserve(imports.size() + vec.size());
                for (const auto& imp : vec)
                {
                    imports.push_back(imp.unit_name);
                }
            };

            if (auto id_opt = table.FindSymbolAt(loc))
            {
                if (const auto* sym = table.definition(*id_opt))
                {
                    if (const auto* func = sym->As<language::symbol::Function>())
                        add_imports(func->imports);
                    else if (const auto* method = sym->As<language::symbol::Method>())
                        add_imports(method->imports);
                    else if (const auto* cls = sym->As<language::symbol::Class>())
                        add_imports(cls->imports);
                    else if (const auto* unit = sym->As<language::symbol::Unit>())
                    {
                        add_imports(unit->interface_imports);
                        add_imports(unit->implementation_imports);
                    }
                }
            }

            if (imports.empty())
            {
                for (const auto& wrapper : table.all_definitions())
                {
                    const auto& sym = wrapper.get();
                    if (sym.kind() == protocol::SymbolKind::Module)
                    {
                        if (const auto* unit = sym.As<language::symbol::Unit>())
                        {
                            add_imports(unit->interface_imports);
                            add_imports(unit->implementation_imports);
                        }
                        break;
                    }
                }
            }

            std::vector<std::string> order;
            std::unordered_set<std::string, utils::IHasher, utils::IEqualTo> seen;

            std::string module_name = GetModuleName(table);
            if (!module_name.empty())
            {
                order.push_back(module_name);
                seen.insert(module_name);
            }

            for (auto it = imports.rbegin(); it != imports.rend(); ++it)
            {
                if (it->empty())
                {
                    continue;
                }
                if (seen.find(*it) != seen.end())
                {
                    continue;
                }
                order.push_back(*it);
                seen.insert(*it);
            }

            return order;
        }

        void AppendClassMethods(const language::symbol::SymbolTable& table, const language::symbol::Class& cls, const std::string& prefix, CompletionSource source, std::vector<SourcedCompletionItem>& out)
        {
            auto scope_id = FindScopeOwnedBy(table, language::symbol::ScopeKind::kClass, cls.id);
            if (!scope_id)
            {
                return;
            }

            const auto* scope = table.scopes().scope(*scope_id);
            if (!scope)
            {
                return;
            }

            for (const auto& [_, ids] : scope->symbols)
            {
                for (auto id : ids)
                {
                    const auto* member_symbol = table.definition(id);
                    if (!member_symbol || member_symbol->kind() != protocol::SymbolKind::Method)
                        continue;

                    const auto* method = member_symbol->As<language::symbol::Method>();
                    if (!method)
                        continue;

                    // 仅补全类方法（静态）
                    if (!method->is_static)
                        continue;

                    if (!prefix.empty() && !utils::IStartsWith(method->name, prefix))
                        continue;

                    protocol::CompletionItem item;
                    item.label = method->name;
                    item.kind = protocol::CompletionItemKind::Method;
                    item.labelDetails = protocol::CompletionItemLabelDetails{
                        .detail = BuildSignature(method->parameters, method->return_type),
                        .description = SourceTag(source)
                    };
                    out.push_back({ std::move(item), source });
                }
            }
        }

        std::optional<std::string> ResolveTypeNameInScope(
            const language::symbol::SymbolTable& table,
            const language::semantic::SemanticModel* semantic,
            const protocol::Position& position,
            const std::string& content,
            const std::string& name)
        {
            if (name.empty())
            {
                return std::nullopt;
            }

            std::uint32_t offset = utils::text_coordinates::ToOffset(position, content);
            language::ast::Location loc{};
            loc.start_line = loc.end_line = position.line;
            loc.start_column = loc.end_column = position.character;
            loc.start_offset = loc.end_offset = offset;

            auto scope_id = table.scopes().FindScopeAt(loc);
            if (!scope_id)
            {
                return std::nullopt;
            }

            auto symbol_id = table.scopes().FindSymbolInScopeChain(*scope_id, name);
            if (!symbol_id)
            {
                return std::nullopt;
            }

            const auto* sym = table.definition(*symbol_id);
            if (!sym)
            {
                return std::nullopt;
            }

            if (semantic)
            {
                auto type = semantic->type_system().GetSymbolType(*symbol_id);
                if (type && type->kind() == language::semantic::TypeKind::kClass)
                {
                    if (const auto* class_type = type->As<language::semantic::ClassType>())
                    {
                        if (const auto* class_symbol = table.definition(class_type->class_id()))
                        {
                            return class_symbol->name();
                        }
                    }
                }
            }

            if (const auto* var = sym->As<language::symbol::Variable>())
            {
                return var->type;
            }

            if (const auto* field = sym->As<language::symbol::Field>())
            {
                return field->type;
            }

            return std::nullopt;
        }

        void AppendInstanceMembers(const language::symbol::SymbolTable& table,
                                   language::symbol::SymbolId class_id,
                                   const std::string& prefix,
                                   CompletionSource source,
                                   std::vector<SourcedCompletionItem>& out)
        {
            auto scope_id = FindScopeOwnedBy(table, language::symbol::ScopeKind::kClass, class_id);
            if (!scope_id)
            {
                return;
            }

            const auto* scope = table.scopes().scope(*scope_id);
            if (!scope)
            {
                return;
            }

            for (const auto& [_, ids] : scope->symbols)
            {
                for (auto id : ids)
                {
                    const auto* member = table.definition(id);
                    if (!member)
                    {
                        continue;
                    }

                    if (!prefix.empty() && !utils::IStartsWith(member->name(), prefix))
                    {
                        continue;
                    }

                    if (member->kind() == protocol::SymbolKind::Method)
                    {
                        const auto* method = member->As<language::symbol::Method>();
                        if (!method || method->is_static)
                        {
                            continue;
                        }
                        if (method->method_kind == language::ast::MethodKind::kConstructor ||
                            method->method_kind == language::ast::MethodKind::kDestructor)
                        {
                            continue;
                        }

                        protocol::CompletionItem item;
                        item.label = method->name;
                        item.kind = protocol::CompletionItemKind::Method;
                        item.labelDetails = protocol::CompletionItemLabelDetails{
                            .detail = BuildSignature(method->parameters, method->return_type),
                            .description = SourceTag(source)
                        };
                        out.push_back({ std::move(item), source });
                        continue;
                    }

                    if (member->kind() == protocol::SymbolKind::Property)
                    {
                        protocol::CompletionItem item;
                        item.label = member->name();
                        item.kind = protocol::CompletionItemKind::Property;
                        item.labelDetails = protocol::CompletionItemLabelDetails{ .detail = "", .description = SourceTag(source) };
                        out.push_back({ std::move(item), source });
                        continue;
                    }

                    if (member->kind() == protocol::SymbolKind::Field)
                    {
                        const auto* field = member->As<language::symbol::Field>();
                        if (!field || field->is_static)
                        {
                            continue;
                        }

                        protocol::CompletionItem item;
                        item.label = field->name;
                        item.kind = protocol::CompletionItemKind::Field;
                        item.labelDetails = protocol::CompletionItemLabelDetails{ .detail = "", .description = SourceTag(source) };
                        out.push_back({ std::move(item), source });
                        continue;
                    }
                }
            }
        }

        void AppendCreateObjectClasses(const language::symbol::SymbolTable& table,
                                       const std::string& prefix,
                                       CompletionSource source,
                                       std::vector<SourcedCompletionItem>& out,
                                       bool has_open_quote,
                                       char quote_char,
                                       const std::string& unit_filter = "")
        {
            auto module_name = GetModuleName(table);
            if (!unit_filter.empty())
            {
                if (module_name.empty() || !utils::IEquals(module_name, unit_filter))
                    return;
            }

            for (const auto& wrapper : table.all_definitions())
            {
                const auto& symbol = wrapper.get();
                if (symbol.kind() != protocol::SymbolKind::Class)
                    continue;
                if (!prefix.empty() && !utils::IStartsWith(symbol.name(), prefix))
                    continue;

                protocol::CompletionItem item;
                item.label = symbol.name();
                item.kind = protocol::CompletionItemKind::Constructor;
                item.labelDetails = protocol::CompletionItemLabelDetails{ .detail = "", .description = SourceTag(source) };

                protocol::LSPObject data;
                data["ctx"] = "createobject";
                data["class"] = symbol.name();
                data["unit"] = module_name;
                data["has_open_quote"] = has_open_quote;
                data["quote"] = std::string(1, quote_char);
                item.data = std::move(data);

                out.push_back({ std::move(item), source });
            }
        }

        std::vector<SourcedCompletionItem> FilterAndSort(const std::vector<SourcedCompletionItem>& items, const std::string& prefix)
        {
            std::vector<const SourcedCompletionItem*> unique_items;
            std::set<std::string> seen_labels;

            for (const auto& item : items)
            {
                if (seen_labels.count(item.item.label) > 0)
                    continue;
                seen_labels.insert(item.item.label);

                if (!prefix.empty() && !utils::IStartsWith(item.item.label, prefix))
                    continue;

                unique_items.push_back(&item);
            }

            std::sort(
                unique_items.begin(),
                unique_items.end(),
                [&prefix](const SourcedCompletionItem* a, const SourcedCompletionItem* b) {
                    std::string a_lower = utils::ToLower(a->item.label);
                    std::string b_lower = utils::ToLower(b->item.label);
                    std::string prefix_lower = utils::ToLower(prefix);

                    bool a_exact = (a_lower == prefix_lower);
                    bool b_exact = (b_lower == prefix_lower);
                    if (a_exact != b_exact)
                        return a_exact;

                    if (!prefix.empty())
                    {
                        int a_score = static_cast<int>(prefix.length()) * 100 / static_cast<int>(a->item.label.length());
                        int b_score = static_cast<int>(prefix.length()) * 100 / static_cast<int>(b->item.label.length());
                        if (a_score != b_score)
                            return a_score > b_score;
                    }

                    if (a->source != b->source)
                    {
                        auto priority = [](CompletionSource src) -> int {
                            switch (src)
                            {
                            case CompletionSource::kEditing:
                                return 0;
                            case CompletionSource::kWorkspace:
                                return 1;
                            case CompletionSource::kSystem:
                                return 2;
                            case CompletionSource::kKeyword:
                            default:
                                return 3;
                            }
                        };
                        return priority(a->source) < priority(b->source);
                    }

                    return a_lower < b_lower;
                });

            std::vector<SourcedCompletionItem> result;
            result.reserve(unique_items.size());
            for (const auto* item : unique_items)
                result.push_back(*item);
            return result;
        }

        protocol::CompletionList BuildCompletionList(const protocol::CompletionParams& params, ExecutionContext& execution_context)
        {
            protocol::CompletionList list;
            list.isIncomplete = false;

            auto& manager_hub = execution_context.GetManagerHub();
            const auto content = manager_hub.documents().GetContent(params.textDocument.uri);
            auto context = AnalyzeContext(params, content);

            std::vector<SourcedCompletionItem> collected;

            // 当前文档符号表
            const auto* editing_table = manager_hub.symbols().GetSymbolTable(params.textDocument.uri);
            const auto* editing_semantic = manager_hub.symbols().GetSemanticModel(params.textDocument.uri);
            // 工作区/系统符号表
            auto workspace_tables = manager_hub.symbols().GetWorkspaceSymbolTables();
            auto system_tables = manager_hub.symbols().GetSystemSymbolTables();

            std::unordered_set<std::string, utils::IHasher, utils::IEqualTo> visible_units_set;
            if (editing_table)
            {
                auto visible_units = CollectVisibleUnits(editing_table, params.position, content);
                for (auto& u : visible_units)
                    visible_units_set.insert(u);
            }

            // Member access context (unit/obj)
            if (!context.is_class_method_context &&
                !context.is_new_context &&
                !context.is_unit_context &&
                !context.is_class_context &&
                !context.is_createobject_context)
            {
                if (auto dot_ctx = DetectDotAccessContext(context.line_content))
                {
                    context.prefix = dot_ctx->member_prefix;
                    context.member_prefix = dot_ctx->member_prefix;

                    if (dot_ctx->is_unit_call)
                    {
                        if (IsUnitVisible(visible_units_set, dot_ctx->base_name))
                        {
                            context.is_unit_member_context = true;
                            context.unit_name = dot_ctx->base_name;
                        }
                    }
                    else
                    {
                        if (IsUnitVisible(visible_units_set, dot_ctx->base_name))
                        {
                            context.is_unit_member_context = true;
                            context.unit_name = dot_ctx->base_name;
                        }
                        else
                        {
                            context.is_object_member_context = true;
                            context.object_name = dot_ctx->base_name;
                        }
                    }
                }
            }

            // 处理 new unit(...) 或 alias.class
            if (context.is_new_context && !context.prefix.empty())
            {
                std::string lower_prefix = utils::ToLower(context.prefix);
                if (lower_prefix.starts_with("unit("))
                {
                    auto after = context.prefix.substr(5);
                    auto close = after.find(')');
                    auto dot = after.find('.');
                    std::size_t name_end = std::min(
                        close == std::string::npos ? after.size() : close,
                        dot == std::string::npos ? after.size() : dot);
                    context.unit_name = utils::Trim(after.substr(0, name_end));
                    if (!context.unit_name.empty())
                    {
                        context.is_unit_scoped_new = true;
                        if (dot != std::string::npos && dot + 1 < after.size())
                            context.prefix = utils::Trim(after.substr(dot + 1));
                        else
                            context.prefix = "";
                    }
                }
                else
                {
                    auto dot = context.prefix.find_last_of('.');
                    if (dot != std::string::npos)
                    {
                        auto alias = utils::Trim(context.prefix.substr(0, dot));
                        if (!alias.empty())
                        {
                            context.is_unit_scoped_new = true;
                            context.unit_name = alias;
                            context.prefix = utils::Trim(context.prefix.substr(dot + 1));
                        }
                    }
                }
            }

            if (context.is_class_method_context)
            {
                bool found = false;
                if (editing_table)
                {
                    if (auto cls_opt = FindClassSymbol(*editing_table, context.class_name))
                    {
                        const auto* cls = cls_opt.value()->As<language::symbol::Class>();
                        if (cls)
                        {
                            AppendClassMethods(*editing_table, *cls, context.prefix, CompletionSource::kEditing, collected);
                            found = true;
                        }
                    }
                }

                if (!found)
                {
                    for (const auto* table : workspace_tables)
                    {
                        if (auto cls_opt = FindClassSymbol(*table, context.class_name))
                        {
                            const auto* cls = cls_opt.value()->As<language::symbol::Class>();
                            if (cls)
                                AppendClassMethods(*table, *cls, context.prefix, CompletionSource::kWorkspace, collected);
                            found = true;
                            break;
                        }
                    }
                }

                if (!found)
                {
                    for (const auto* table : system_tables)
                    {
                        if (auto cls_opt = FindClassSymbol(*table, context.class_name))
                        {
                            const auto* cls = cls_opt.value()->As<language::symbol::Class>();
                            if (cls)
                                AppendClassMethods(*table, *cls, context.prefix, CompletionSource::kSystem, collected);
                            break;
                        }
                    }
                }
            }
            else if (context.is_unit_member_context)
            {
                if (context.unit_name.empty() || !IsUnitVisible(visible_units_set, context.unit_name))
                {
                    // not visible -> no unit member suggestions
                }
                else
                {
                    if (editing_table)
                        AppendUnitMembers(*editing_table, context.unit_name, context.member_prefix, CompletionSource::kEditing, collected);
                    for (const auto* table : workspace_tables)
                        AppendUnitMembers(*table, context.unit_name, context.member_prefix, CompletionSource::kWorkspace, collected);
                    for (const auto* table : system_tables)
                        AppendUnitMembers(*table, context.unit_name, context.member_prefix, CompletionSource::kSystem, collected);
                }
            }
            else if (context.is_object_member_context)
            {
                if (editing_table && content)
                {
                    if (auto type_name = ResolveTypeNameInScope(*editing_table, editing_semantic, params.position, *content, context.object_name))
                    {
                        std::string type_text = utils::Trim(*type_name);
                        std::string class_name = type_text;
                        std::vector<std::string> unit_candidates;

                        if (auto qualified = ParseUnitQualifiedPrefix(type_text))
                        {
                            if (!qualified->unit_name.empty() && !qualified->member_prefix.empty())
                            {
                                unit_candidates.push_back(qualified->unit_name);
                                class_name = qualified->member_prefix;
                            }
                        }

                        if (!class_name.empty())
                        {
                            if (unit_candidates.empty())
                            {
                                unit_candidates = CollectUnitSearchOrder(*editing_table, params.position, *content);
                            }

                            bool found_class = false;
                            for (const auto& unit_name : unit_candidates)
                            {
                                if (found_class)
                                    break;

                                auto try_table = [&](const language::symbol::SymbolTable& table, CompletionSource source) {
                                    if (!utils::IEquals(GetModuleName(table), unit_name))
                                    {
                                        return;
                                    }

                                    auto cls_opt = FindClassSymbol(table, class_name);
                                    if (!cls_opt)
                                    {
                                        return;
                                    }

                                    AppendInstanceMembers(table, (*cls_opt)->id(), context.member_prefix, source, collected);
                                    found_class = true;
                                };

                                try_table(*editing_table, CompletionSource::kEditing);
                                for (const auto* table : workspace_tables)
                                    try_table(*table, CompletionSource::kWorkspace);
                                for (const auto* table : system_tables)
                                    try_table(*table, CompletionSource::kSystem);
                            }

                            (void)found_class;
                        }
                    }
                }
            }
            else if (context.is_new_context)
            {
                if (context.is_unit_scoped_new && !context.unit_name.empty())
                {
                    if (editing_table)
                        AppendClasses(*editing_table, context.prefix, CompletionSource::kEditing, collected, true, context.unit_name);
                    for (const auto* table : workspace_tables)
                        AppendClasses(*table, context.prefix, CompletionSource::kWorkspace, collected, true, context.unit_name);
                    for (const auto* table : system_tables)
                        AppendClasses(*table, context.prefix, CompletionSource::kSystem, collected, true, context.unit_name);
                }
                else
                {
                    if (editing_table && content)
                    {
                        auto unit_order = CollectUnitSearchOrder(*editing_table, params.position, *content);
                        if (!unit_order.empty())
                        {
                            for (const auto& unit_name : unit_order)
                            {
                                AppendClasses(*editing_table, context.prefix, CompletionSource::kEditing, collected, true, unit_name);
                                for (const auto* table : workspace_tables)
                                    AppendClasses(*table, context.prefix, CompletionSource::kWorkspace, collected, true, unit_name);
                                for (const auto* table : system_tables)
                                    AppendClasses(*table, context.prefix, CompletionSource::kSystem, collected, true, unit_name);
                            }
                        }
                        else
                        {
                            AppendClasses(*editing_table, context.prefix, CompletionSource::kEditing, collected, true);
                            for (const auto* table : workspace_tables)
                                AppendClasses(*table, context.prefix, CompletionSource::kWorkspace, collected, true);
                            for (const auto* table : system_tables)
                                AppendClasses(*table, context.prefix, CompletionSource::kSystem, collected, true);
                        }
                    }
                    else
                    {
                        if (editing_table)
                            AppendClasses(*editing_table, context.prefix, CompletionSource::kEditing, collected, true);
                        for (const auto* table : workspace_tables)
                            AppendClasses(*table, context.prefix, CompletionSource::kWorkspace, collected, true);
                        for (const auto* table : system_tables)
                            AppendClasses(*table, context.prefix, CompletionSource::kSystem, collected, true);
                    }
                }
            }
            else if (context.is_createobject_context)
            {
                if (auto qualified = ParseUnitQualifiedPrefix(context.prefix))
                {
                    if (editing_table)
                        AppendCreateObjectClasses(*editing_table, qualified->member_prefix, CompletionSource::kEditing, collected, context.createobject_has_open_quote, context.createobject_quote, qualified->unit_name);
                    for (const auto* table : workspace_tables)
                        AppendCreateObjectClasses(*table, qualified->member_prefix, CompletionSource::kWorkspace, collected, context.createobject_has_open_quote, context.createobject_quote, qualified->unit_name);
                    for (const auto* table : system_tables)
                        AppendCreateObjectClasses(*table, qualified->member_prefix, CompletionSource::kSystem, collected, context.createobject_has_open_quote, context.createobject_quote, qualified->unit_name);
                }
                else if (editing_table && content)
                {
                    auto unit_order = CollectUnitSearchOrder(*editing_table, params.position, *content);
                    if (!unit_order.empty())
                    {
                        for (const auto& unit_name : unit_order)
                        {
                            AppendCreateObjectClasses(*editing_table, context.prefix, CompletionSource::kEditing, collected, context.createobject_has_open_quote, context.createobject_quote, unit_name);
                            for (const auto* table : workspace_tables)
                                AppendCreateObjectClasses(*table, context.prefix, CompletionSource::kWorkspace, collected, context.createobject_has_open_quote, context.createobject_quote, unit_name);
                            for (const auto* table : system_tables)
                                AppendCreateObjectClasses(*table, context.prefix, CompletionSource::kSystem, collected, context.createobject_has_open_quote, context.createobject_quote, unit_name);
                        }
                    }
                    else
                    {
                        AppendCreateObjectClasses(*editing_table, context.prefix, CompletionSource::kEditing, collected, context.createobject_has_open_quote, context.createobject_quote);
                        for (const auto* table : workspace_tables)
                            AppendCreateObjectClasses(*table, context.prefix, CompletionSource::kWorkspace, collected, context.createobject_has_open_quote, context.createobject_quote);
                        for (const auto* table : system_tables)
                            AppendCreateObjectClasses(*table, context.prefix, CompletionSource::kSystem, collected, context.createobject_has_open_quote, context.createobject_quote);
                    }
                }
                else
                {
                    if (editing_table)
                        AppendCreateObjectClasses(*editing_table, context.prefix, CompletionSource::kEditing, collected, context.createobject_has_open_quote, context.createobject_quote);
                    for (const auto* table : workspace_tables)
                        AppendCreateObjectClasses(*table, context.prefix, CompletionSource::kWorkspace, collected, context.createobject_has_open_quote, context.createobject_quote);
                    for (const auto* table : system_tables)
                        AppendCreateObjectClasses(*table, context.prefix, CompletionSource::kSystem, collected, context.createobject_has_open_quote, context.createobject_quote);
                }
            }
            else if (context.is_unit_context)
            {
                if (!visible_units_set.empty())
                {
                    if (editing_table)
                        AppendUnits(*editing_table, context.prefix, CompletionSource::kEditing, collected, &visible_units_set);
                    for (const auto* table : workspace_tables)
                        AppendUnits(*table, context.prefix, CompletionSource::kWorkspace, collected, &visible_units_set);
                    for (const auto* table : system_tables)
                        AppendUnits(*table, context.prefix, CompletionSource::kSystem, collected, &visible_units_set);
                }
            }
            else if (context.is_class_context)
            {
                if (editing_table)
                    AppendClasses(*editing_table, context.prefix, CompletionSource::kEditing, collected, false);
                for (const auto* table : workspace_tables)
                    AppendClasses(*table, context.prefix, CompletionSource::kWorkspace, collected, false);
                for (const auto* table : system_tables)
                    AppendClasses(*table, context.prefix, CompletionSource::kSystem, collected, false);
            }
            else
            {
                AppendKeywordItems(context.prefix, collected);

                if (editing_table)
                    AppendFunctions(*editing_table, context.prefix, CompletionSource::kEditing, collected);
                for (const auto* table : workspace_tables)
                    AppendFunctions(*table, context.prefix, CompletionSource::kWorkspace, collected);
                for (const auto* table : system_tables)
                    AppendFunctions(*table, context.prefix, CompletionSource::kSystem, collected);
            }

            for (auto& entry : collected)
            {
                if (!entry.item.data)
                {
                    continue;
                }

                if (!entry.item.data->Is<protocol::LSPObject>())
                {
                    continue;
                }

                auto& obj = entry.item.data->Get<protocol::LSPObject>();
                auto ctx_it = obj.find("ctx");
                if (ctx_it == obj.end())
                {
                    continue;
                }

                if (!ctx_it->second.Is<protocol::string>())
                {
                    continue;
                }

                obj["uri"] = params.textDocument.uri;
            }

            std::string filter_prefix = context.prefix;
            if (context.is_createobject_context)
            {
                if (auto qualified = ParseUnitQualifiedPrefix(context.prefix))
                {
                    filter_prefix = qualified->member_prefix;
                }
            }

            auto filtered = FilterAndSort(collected, filter_prefix);
            list.items.reserve(filtered.size());
            for (auto& item : filtered)
                list.items.push_back(std::move(item.item));
            return list;
        }
    }

    

    

    std::string Completion::ProvideResponse(const protocol::RequestMessage& request, ExecutionContext& execution_context)
    {
        spdlog::debug("{}: Processing completion request", GetProviderName());

        if (!request.params.has_value())
        {
            spdlog::warn("{}: Missing params in request", GetProviderName());
            return BuildErrorResponseMessage(request, protocol::ErrorCodes::InvalidParams, "Missing params");
        }

        const auto params = transform::FromLSPAny.template operator()<protocol::CompletionParams>(request.params.value());
        auto completion_list = BuildCompletionList(params, execution_context);

        protocol::ResponseMessage response;
        response.id = request.id;
        response.result = transform::ToLSPAny(completion_list);

        auto json = transform::Serialize(response);
        if (!json)
            return BuildErrorResponseMessage(request, protocol::ErrorCodes::InternalError, "Failed to serialize response");

        return *json;
    }
}