// runtime/runtime.h：公开的关联对象 API
objc_setAssociatedObject(id object, const void *key, id value,
                         objc_AssociationPolicy policy);

objc_getAssociatedObject(id object, const void *key);

objc_removeAssociatedObjects(id object);

// runtime/objc-references.mm：扩展后的 policy 位
OBJC_ASSOCIATION_SETTER_ASSIGN      = 0,
OBJC_ASSOCIATION_SETTER_RETAIN      = 1,
OBJC_ASSOCIATION_SETTER_COPY        = 3,
OBJC_ASSOCIATION_GETTER_RETAIN      = (1 << 8),
OBJC_ASSOCIATION_GETTER_AUTORELEASE = (2 << 8),
OBJC_ASSOCIATION_SYSTEM_OBJECT      = _OBJC_ASSOCIATION_SYSTEM_OBJECT;

// runtime/objc-references.mm：单个关联值的封装
class ObjcAssociation {
    uintptr_t _policy;  // 保存 retain/copy/assign、getter retain/autorelease、system object 等位
    id _value;          // 实际关联值

public:
    void acquireValue();           // set 前按 policy retain 或 copy 新值
    void releaseHeldValue();       // 替换、删除、销毁时释放旧值
    void retainReturnedValue();    // atomic getter 在锁内 retain
    id autoreleaseReturnedValue(); // atomic getter 出锁后 autorelease
};

// runtime/objc-references.mm：两层哈希表
typedef DenseMap<const void *, ObjcAssociation> ObjectAssociationMap;
typedef DenseMap<DisguisedPtr<objc_object>, ObjectAssociationMap> AssociationsHashMap;

class AssociationsManager {
    static ExplicitInitDenseMap<DisguisedPtr<objc_object>, ObjectAssociationMap> _mapStorage;

public:
    AssociationsManager()  { AssociationsManagerLock.lock(); }   // RAII 加锁
    ~AssociationsManager() { AssociationsManagerLock.unlock(); } // 离开作用域解锁
    AssociationsHashMap &get() { return _mapStorage.get(); }
};

// 带注释的精简版 _object_set_associative_reference
void set_association(id object, const void *key, id value, uintptr_t policy) {
    if (!object && !value) return;       // 兼容旧行为：nil + nil 不崩溃

    Class cls = object->getIsa();
    cls->realizeIfNeeded();
    if (cls->forbidsAssociatedObjects()) {
        fatal("class does not allow associated objects");
    }

    ObjcAssociation association{policy, value};
    association.acquireValue();          // retain/copy 新值；不在锁内执行

    bool isFirstAssociation = false;
    {
        AssociationsManager manager;     // 加全局关联表锁
        if (value) {
            // 第一层：按 object 找到或创建 ObjectAssociationMap
            auto refs = associations.try_emplace(object, ObjectAssociationMap{});
            isFirstAssociation = refs.second;

            // 第二层：按 key 插入；若已存在，swap 出旧 association
            auto result = refs.first->second.try_emplace(key, std::move(association));
            if (!result.second) association.swap(result.first->second);
        } else {
            // value == nil 表示清掉这个 key
            auto old = refs.find(key);
            if (old != refs.end()) {
                association.swap(old->second); // 旧值带出锁外释放
                refs.erase(old);
            }
        }
    }

    if (isFirstAssociation) object->setHasAssociatedObjects();
    association.releaseHeldValue();      // 释放被替换或删除的旧值
}

// 带注释的精简版 _object_get_associative_reference
id get_association(id object, const void *key) {
    ObjcAssociation association{};
    {
        AssociationsManager manager;      // 查表期间持锁
        auto i = associations.find(object);
        if (i != associations.end()) {
            auto j = i->second.find(key);
            if (j != i->second.end()) {
                association = j->second; // 复制 policy/value
                association.retainReturnedValue();
            }
        }
    }
    return association.autoreleaseReturnedValue();
}

// runtime/objc-runtime-new.mm：实例销毁的关键顺序
bool cxx = obj->hasCxxDtor();
bool assoc = obj->hasAssociatedObjects();

if (cxx) object_cxxDestruct(obj);
if (assoc) _object_remove_associations(obj, true);
obj->clearDeallocating();

// 带注释的精简版 _object_remove_associations
void remove_associations(id object, bool deallocating) {
    ObjectAssociationMap refs{};
    {
        AssociationsManager manager;
        auto i = associations.find(object);
        if (i != associations.end()) {
            refs.swap(i->second);          // 把所有关联转移到局部变量

            if (!deallocating) {
                // 普通 objc_removeAssociatedObjects 保留 system object
                for (auto &ref : refs) {
                    if (ref.second.policy() & OBJC_ASSOCIATION_SYSTEM_OBJECT)
                        i->second.insert(ref);
                }
            }
        }
    }

    // 普通关联先释放；system object 在 deallocating 时延后释放
    for (auto &ref : refs) {
        if (ref.second.policy() & OBJC_ASSOCIATION_SYSTEM_OBJECT) later.push_back(&ref.second);
        else ref.second.releaseHeldValue();
    }
    for (auto *ref : later) ref->releaseHeldValue();
}

// runtime/objc-runtime-new.mm：realize 时继承/传播禁止标志
if ((ro->flags & RO_FORBIDS_ASSOCIATED_OBJECTS) ||
    (supercls && supercls->forbidsAssociatedObjects())) {
    rw->flags |= RW_FORBIDS_ASSOCIATED_OBJECTS;
}

// runtime/objc-references.mm：set 时检查
if (objectClass->forbidsAssociatedObjects()) {
    _objc_fatal("objc_setAssociatedObject called on instance ...");
}

// runtime/objc-references.mm：值获取和释放策略
void acquireValue() {
    if (!_value) return;
    switch (_policy & 0xFF) {
    case OBJC_ASSOCIATION_SETTER_RETAIN:
        _value = objc_retain(_value);         // retain policy
        break;
    case OBJC_ASSOCIATION_SETTER_COPY:
        _value = objc_msgSend(_value, @selector(copy)); // copy policy
        break;
    }
}

void releaseHeldValue() {
    if (_value && (_policy & OBJC_ASSOCIATION_SETTER_RETAIN))
        objc_release(_value);                 // retain 和 copy 都会释放
}

// runtime/objc-object.h：non-pointer isa 情况
bool hasAssociatedObjects() const {
    if (isTaggedPointer()) return true;
    if (isa().nonpointer) return isa().has_assoc;
    return true;                  // raw isa 对象无法精确跟踪，保守返回 true
}

void setHasAssociatedObjects() {
    if (isTaggedPointer()) return;
    ...
    newisa.has_assoc = true;       // 首次关联后设置 isa 标志
}