/*
 * Copyright (C) 2019 Apple Inc. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#pragma once

#include <wtf/Platform.h>
#if ENABLE(ACCESSIBILITY_ISOLATED_TREE)

#include <WebCore/AXCoreObject.h>
#include <WebCore/AXLoggerBase.h>
#include <WebCore/AXObjectCache.h>
#include <WebCore/AXTextMarker.h>
#include <WebCore/AXTextRun.h>
#include <WebCore/AXTreeStore.h>
#include <WebCore/AccessibilityObject.h>
#include <WebCore/ColorHash.h>
#include <WebCore/FrameIdentifier.h>
#include <WebCore/RenderStyleConstants.h>
#include <WebCore/StyleSpeakAs.h>
#include <wtf/HashMap.h>
#include <wtf/Lock.h>
#include <wtf/RefPtr.h>
#include <wtf/RetainPtr.h>
#include <wtf/RuntimeApplicationChecks.h>
#include <wtf/ThreadSafeRefCounted.h>
#include <wtf/ThreadSafeWeakPtr.h>

namespace WTF {
class TextStream;
}

namespace WebCore {

class AXIsolatedObject;
class AXGeometryManager;
class AXObjectCache;
class AccessibilityObject;
enum class AXStreamOptions : uint16_t;

static constexpr uint16_t lastPropertyFlagIndex = 30;
// The most common boolean properties are stored in a bitfield rather than in a HashMap.
// If you edit these, make sure the corresponding AXProperty is ordered correctly in that
// enum, and update lastPropertyFlagIndex above.
enum class AXPropertyFlag : uint32_t {
    CanSetFocusAttribute                          = 1 << 0,
    CanSetSelectedAttribute                       = 1 << 1,
    CanSetValueAttribute                          = 1 << 2,
    HasBoldFont                                   = 1 << 3,
    HasClickHandler                               = 1 << 4,
    HasCursorPointer                              = 1 << 5,
    HasItalicFont                                 = 1 << 6,
    HasPlainText                                  = 1 << 7,
    HasPointerEventsNone                          = 1 << 8,
    IsARIAHidden                                  = 1 << 9,
    IsBlockFlow                                   = 1 << 10,
    IsEnabled                                     = 1 << 11,
    IsExposedTableCell                            = 1 << 12,
    IsExposedTableRow                             = 1 << 13,
    IsGrabbed                                     = 1 << 14,
    IsHiddenUntilFoundContainer                   = 1 << 15,
    IsIgnored                                     = 1 << 16,
    IsInlineText                                  = 1 << 17,
    IsKeyboardFocusable                           = 1 << 18,
    IsNonLayerSVGObject                           = 1 << 19,
    // These IsTextEmissionBehavior flags are the variants of enum TextEmissionBehavior.
    IsTextEmissionBehaviorTab                     = 1 << 20,
    IsTextEmissionBehaviorNewline                 = 1 << 21,
    IsTextEmissionBehaviorDoubleNewline           = 1 << 22,
    IsVisited                                     = 1 << 23,
    ShowsCursorOnHover                            = 1 << 24,
    SupportsCheckedState                          = 1 << 25,
    SupportsDragging                              = 1 << 26,
    SupportsExpanded                              = 1 << 27,
    SupportsPath                                  = 1 << 28,
    SupportsPosInSet                              = 1 << 29,
    SupportsSetSize                               = 1 << lastPropertyFlagIndex
};

enum class AXProperty : uint16_t {
    CanSetFocusAttribute = 0,
    CanSetSelectedAttribute = 1,
    CanSetValueAttribute = 2,
    HasBoldFont = 3,
    HasClickHandler = 4,
    HasCursorPointer = 5,
    HasItalicFont = 6,
    HasPlainText = 7,
    HasPointerEventsNone = 8,
    IsARIAHidden = 9,
    IsBlockFlow = 10,
    IsEnabled = 11,
    IsExposedTableCell = 12,
    IsExposedTableRow = 13,
    IsGrabbed = 14,
    IsHiddenUntilFoundContainer = 15,
    IsIgnored = 16,
    IsInlineText = 17,
    IsKeyboardFocusable = 18,
    IsNonLayerSVGObject = 19,
    IsTextEmissionBehaviorTab = 20,
    IsTextEmissionBehaviorNewline = 21,
    IsTextEmissionBehaviorDoubleNewline = 22,
    IsVisited = 23,
    ShowsCursorOnHover = 24,
    SupportsCheckedState = 25,
    SupportsDragging = 26,
    SupportsExpanded = 27,
    SupportsPath = 28,
    SupportsPosInSet = 29,
    SupportsSetSize = lastPropertyFlagIndex,
    // End bool attributes that are matched in order by AXPropertyFlag.

    Abbreviation,
    ARIALevel,
    ARIARoleDescription,
    AXColumnCount,
    AXColumnIndex,
    AXColumnIndexText,
    AXRowCount,
    AXRowIndex,
    AXRowIndexText,
    AccessKey,
    AccessibilityText,
    ActionVerb,
    BackgroundColor,
    BrailleLabel,
    BrailleRoleDescription,
    ButtonState,
    CanBeMultilineTextField,
#if PLATFORM(MAC)
    CaretBrowsingEnabled,
#endif
    Cells,
    CellScope,
    CellSlots,
    ColorValue,
    Columns,
    ColumnIndex,
    ColumnIndexRange,
    IsFocusedWebArea,
    CrossFrameChildFrameID,
    CrossFrameParentFrameID,
    CrossFrameParentAXID,
    CurrentState,
    DateTimeComponentsType,
    DateTimeValue,
    DatetimeAttributeValue,
    DecrementButton,
    Description,
    DisclosedByRow,
    DisclosedRows,
    DocumentEncoding,
    DocumentLinks,
    DocumentURI,
    ElementName,
    EmbeddedImageDescription,
    ExplicitAutoCompleteValue,
    ExplicitInvalidStatus,
    ExplicitLiveRegionRelevant,
    ExplicitLiveRegionStatus,
    ExplicitOrientation,
    ExtendedDescription,
#if PLATFORM(COCOA)
    Font,
    FontOrientation,
#endif
    TextColor,
    HasApplePDFAnnotationAttribute,
    HasExplicitGroupRole,
    HasLinethrough,
    HasRemoteFrameChild,
    HeadingLevel,
    InputType,
    IsEditableWebArea,
    IsSubscript,
    IsSuperscript,
    HasTextShadow,
    HorizontalScrollBar,
    IdentifierAttribute,
    IncrementButton,
    InitialLocalRect,
    InnerHTML,
    InternalLinkElement,
    IsARIAGridRow,
    IsARIATreeGridRow,
    IsAnonymousMathOperator,
    IsAttachment,
    IsBusy,
    IsChecked,
    IsColumnHeader,
    IsExpanded,
    IsExposableTable,
    IsFieldset,
    IsIndeterminate,
    IsMathElement,
    IsMathFraction,
    IsMathFenced,
    IsMathSubscriptSuperscript,
    IsMathRow,
    IsMathUnderOver,
    IsMathRoot,
    IsMathSquareRoot,
    IsMathTable,
    IsMathTableRow,
    IsMathTableCell,
    IsMathMultiscript,
    IsMathToken,
    IsMultiSelectable,
    IsPlugin,
    IsPressed,
    IsRequired,
    IsRowHeader,
    IsSecureField,
    IsSelected,
    IsSelectedOptionActive,
    IsTable,
    IsTree,
    IsTreeItem,
    IsValueAutofillAvailable,
    IsVisible,
    IsWidget,
    KeyShortcuts,
    Language,
    LinethroughColor,
    ListMarkerLineID,
    ListMarkerText,
    LiveRegionAtomic,
    LocalizedActionVerb,
    MathFencedOpenString,
    MathFencedCloseString,
    MathLineThickness,
    MathPrescripts,
    MathPostscripts,
    MathRadicand,
    MathRootIndexObject,
    MathUnderObject,
    MathOverObject,
    MathNumeratorObject,
    MathDenominatorObject,
    MathBaseObject,
    MathSubscriptObject,
    MathSuperscriptObject,
    MaxValueForRange,
    MinValueForRange,
    NameAttribute,
    OuterHTML,
    PlaceholderValue,
#if PLATFORM(COCOA)
    PlatformWidget,
#endif
    PopupValue,
    PosInSet,
    PreventKeyboardDOMEventDispatch,
    RadioButtonGroupMembers,
    RelativeFrame,
    RemoteFrameOffset,
    RemoteFramePlatformElement,
#if PLATFORM(COCOA)
    RemoteFrameID,
    RemoteFrameProcessIdentifier,
    RemoteParent,
#endif
    RevealableText,
    RolePlatformString,
    Rows,
    RowHeaders,
    RowIndex,
    RowIndexRange,
    ScreenRelativePosition,
    SelectedTextRange,
    SetSize,
    SortDirection,
    SpeakAs,
    StitchGroups,
    StringValue,
    SubrolePlatformString,
    SupportsDropping,
    SupportsARIAOwns,
    SupportsCurrent,
    SupportsKeyShortcuts,
    TextContentPrefixFromListMarker,
    TextInputMarkedTextMarkerRange,
    TextRuns,
    TitleAttribute,
    URL,
    UnderlineColor,
    ValueAutofillButtonType,
    ValueDescription,
    ValueForRange,
    VerticalScrollBar,
    VisibleChildren,
    VisibleRows,
    WebAreaTitle
};
WTF::TextStream& operator<<(WTF::TextStream&, AXProperty);

using AXPropertySet = HashSet<AXProperty, IntHash<AXProperty>, WTF::StrongEnumHashTraits<AXProperty>>;

struct AXIDAndCharacterRange {
    WTF_MAKE_TZONE_ALLOCATED(AXIDAndCharacterRange);
public:
    Markable<AXID> first;
    CharacterRange second;

    AXIDAndCharacterRange() = default;
    AXIDAndCharacterRange(Markable<AXID> axID, CharacterRange range)
        : first(axID), second(range) { }
};

// If this type is modified, the switchOn statment in AXIsolatedObject::setProperty must be updated as well.
using AXPropertyValueVariant = Variant<std::nullptr_t, Markable<AXID>, String, bool, int, unsigned, double, float, uint64_t, WallTime, DateComponentsType, AccessibilityButtonState, Color, std::unique_ptr<URL>, LayoutRect, FloatPoint, FloatRect, InputType::Type, IntPoint, IntRect, std::pair<unsigned, unsigned>, Vector<AccessibilityText>, Vector<AXID>, Vector<std::pair<Markable<AXID>, Markable<AXID>>>, Vector<String>, Vector<AXStitchGroup>, OptionSet<AXAncestorFlag>, Vector<Vector<Markable<AXID>>>, CharacterRange, std::unique_ptr<AXIDAndCharacterRange>, ElementName, AccessibilityOrientation
#if PLATFORM(COCOA)
    , RetainPtr<NSAttributedString>
    , RetainPtr<NSView>
    , RetainPtr<id>
    , Style::SpeakAs
#endif // PLATFORM(COCOA)
    , RetainPtr<CTFontRef>
    , FontOrientation
    , std::unique_ptr<AXTextRuns>
    , AXTextRunLineID
    , FrameIdentifier
>;
using AXPropertyVector = Vector<std::pair<AXProperty, AXPropertyValueVariant>>;
WTF::TextStream& operator<<(WTF::TextStream&, const AXPropertyVector&);

static_assert(sizeof(AXPropertyValueVariant) == 24, "The AX property value variant should not be larger than 24.");

struct AXPropertyChange {
    AXID axID; // ID of the object whose properties changed.
    AXPropertyVector properties; // Changed properties.
};

struct NodeUpdateOptions {
    AXPropertySet properties;
    bool shouldUpdateNode { false };
    bool shouldUpdateChildren { false };

    NodeUpdateOptions(const AXPropertySet& propertyNames, bool shouldUpdateNode, bool shouldUpdateChildren)
        : properties(propertyNames)
        , shouldUpdateNode(shouldUpdateNode)
        , shouldUpdateChildren(shouldUpdateChildren)
    { }

    NodeUpdateOptions(const AXPropertySet& propertyNames)
        : properties(propertyNames)
    { }

    NodeUpdateOptions(AXProperty propertyName)
        : properties({ propertyName })
    { }

    static NodeUpdateOptions nodeUpdate()
    {
        return { { }, true, false };
    }

    static NodeUpdateOptions childrenUpdate()
    {
        return { { }, false, true };
    }
};

void setPropertyIn(AXProperty, AXPropertyValueVariant&&, AXPropertyVector&, OptionSet<AXPropertyFlag>&);

struct NodeAndParentID {
    AXID nodeID;
    Markable<AXID> parentID;
};

struct IsolatedObjectData {
    Vector<AXID> childrenIDs;
    AXPropertyVector properties;
    Ref<AXIsolatedTree> tree;
    Markable<AXID> parentID;
    AXID axID;
    AccessibilityRole role;
    OptionSet<AXPropertyFlag> propertyFlags;
    bool getsGeometryFromChildren;

    IsolatedObjectData(Vector<AXID> childrenIDs, AXPropertyVector properties, Ref<AXIsolatedTree> tree, Markable<AXID> parentID, AXID axID, AccessibilityRole role, OptionSet<AXPropertyFlag> propertyFlags, bool getsGeometryFromChildren)
        : childrenIDs(WTF::move(childrenIDs))
        , properties(WTF::move(properties))
        , tree(WTF::move(tree))
        , parentID(parentID)
        , axID(axID)
        , role(role)
        , propertyFlags(propertyFlags)
        , getsGeometryFromChildren(getsGeometryFromChildren)
    { }

    IsolatedObjectData(const IsolatedObjectData&) = delete;
    IsolatedObjectData(IsolatedObjectData&&) = default;

    void setProperty(AXProperty property, AXPropertyValueVariant&& value)
    {
        properties.removeFirstMatching([&property] (const auto& propertyAndValue) {
            return propertyAndValue.first == property;
        });
        setPropertyIn(property, WTF::move(value), properties, propertyFlags);
    }
};

enum class DidTearDown : bool { No, Yes };

DECLARE_ALLOCATOR_WITH_HEAP_IDENTIFIER(AXIsolatedTree);
class AXIsolatedTree : public ThreadSafeRefCountedAndCanMakeThreadSafeWeakPtr<AXIsolatedTree>
    , public AXTreeStore<AXIsolatedTree> {
    WTF_MAKE_NONCOPYABLE(AXIsolatedTree);
    WTF_MAKE_TZONE_ALLOCATED(AXIsolatedTree);
    friend WTF::TextStream& operator<<(WTF::TextStream&, AXIsolatedTree&);
    friend void streamIsolatedSubtreeOnMainThread(TextStream&, const AXIsolatedTree&, AXID, const OptionSet<AXStreamOptions>&);
public:
    static RefPtr<AXIsolatedTree> create(AXObjectCache&);
    // Creates a tree consisting of only the Scrollview and the WebArea objects. This tree is used as a temporary placeholder while the whole tree is being built.
    static Ref<AXIsolatedTree> createEmpty(AXObjectCache&);
    constexpr bool isEmptyContentTree() const { return m_isEmptyContentTree; }
    unsigned nodeMapSize() const { return m_nodeMap.size(); }
    virtual ~AXIsolatedTree();

    static void removeTreeForFrameID(FrameIdentifier);

    // Retrieve the tree for the frame ID of any LocalFrame
    WEBCORE_EXPORT static RefPtr<AXIsolatedTree> treeForFrameID(FrameIdentifier);
    AXObjectCache* axObjectCache() const;
    constexpr AXGeometryManager* geometryManager() const { return m_geometryManager.get(); }

#if ENABLE(ACCESSIBILITY_LOCAL_FRAME)
    AXFrameGeometry frameGeometry() const { return m_frameGeometry; }
    IntPoint frameViewOriginScrollPosition() const { return m_frameViewOriginScrollPosition; }
    bool isFrameGeometryInitialized() const { return m_hasReceivedFrameGeometry; }
    void setFrameGeometry(AXFrameGeometry&&, IntPoint viewOriginScrollPosition);
    void updateFrameGeometryAndScrollPositionIfNeeded(AXObjectCache&);
#endif

    AXIsolatedObject* rootNode() { AX_ASSERT(!isMainThread()); return objectForID(m_rootNodeID); }
    std::optional<AXID> pendingRootNodeID();
    RefPtr<AXIsolatedObject> rootWebArea();
    std::optional<AXID> focusedNodeID();
    WEBCORE_EXPORT RefPtr<AXIsolatedObject> focusedNode();

    bool unsafeHasObjectForID(AXID axID) const;
    // Not threadsafe, only for debug snapshot use.
    std::optional<AXID> unsafeFocusedNodeID() const { return m_focusedNodeID; }
    std::optional<AXID> unsafeRootNodeID() const { return m_rootNodeID; }

    inline AXIsolatedObject* objectForID(AXID axID) const
    {
        AX_ASSERT(!isMainThread());

        auto iterator = m_readerThreadNodeMap.find(axID);
        if (iterator != m_readerThreadNodeMap.end())
            return iterator->value.ptr();
        return nullptr;
    }
    inline AXIsolatedObject* objectForID(std::optional<AXID> axID) const
    {
        return axID ? objectForID(*axID) : nullptr;
    }
    template<typename U> Vector<Ref<AXCoreObject>> objectsForIDs(const U&);

    struct CachedUnignoredChildren {
        Vector<Ref<AXCoreObject>> children;
        bool hasPotentialStitchable { false };
        // true if any child hosts a cross-frame subtree (i.e. a LocalFrame).
        bool hasCrossFrameChild { false };
    };
    HashMap<AXID, CachedUnignoredChildren>& cachedUnignoredChildrenMap() { AX_ASSERT(!isMainThread()); return m_cachedUnignoredChildren; }

    void generateSubtree(AccessibilityObject&);
    bool shouldCreateNodeChange(AccessibilityObject&);
    enum class ResolveNodeChanges : bool { No, Yes };
    void updateChildrenForObjects(const ListHashSet<Ref<AccessibilityObject>>&);
    void updateDependentProperties(AccessibilityObject&);
    void updatePropertiesForSelfAndDescendants(AccessibilityObject&, const AXPropertySet&);
    void updateFrame(AXID, IntRect&&);
    void updateRootScreenRelativePosition();
    void overrideNodeProperties(AXID, AXPropertyVector&&);

    double NODELETE loadingProgress();
    void NODELETE updateLoadingProgress(double);

    void addUnconnectedNode(Ref<AccessibilityObject>);
    bool isUnconnectedNode(std::optional<AXID> axID) const { return axID && m_unconnectedNodes.contains(*axID); }
    // Removes the corresponding isolated object and all descendants from the m_nodeMap and queues their removal from the tree.
    void removeNode(AXID, std::optional<AXID> /* parentID */);
    // Removes the given node and all its descendants from m_nodeMap.
    void removeSubtreeFromNodeMap(std::optional<AXID>, std::optional<AXID> /* parentID */);

    void objectBecameIgnored(const AccessibilityObject& object)
    {
        objectChangedIgnoredState(object);
        queueNodeUpdate(object.objectID(), { { AXProperty::IsIgnored, AXProperty::RevealableText } });
    }
    void objectBecameUnignored(const AccessibilityObject& object)
    {
        // We only cache minimal properties for ignored objects, so do a full node update to ensure all properties are cached.
        queueNodeUpdate(object.objectID(), NodeUpdateOptions::nodeUpdate());
        objectChangedIgnoredState(object);
    }

    // Both setPendingRootNodeLocked and setFocusedNodeID are called during the generation
    // of the IsolatedTree.
    // Focused node updates in AXObjectCache use setFocusNodeID.
    void setPendingRootNodeID(AXID);
    void NODELETE setPendingRootNodeIDLocked(AXID) WTF_REQUIRES_LOCK(m_changeLogLock);
    void setFocusedNodeID(std::optional<AXID>);

    // Relationships between objects.
    std::optional<ListHashSet<AXID>> relatedObjectIDsFor(const AXIsolatedObject&, AXRelation);
    void markRelationsDirty() { m_relationsNeedUpdate = true; }
    void updateRelations(HashMap<AXID, AXRelations>&&);

    AXCoreObject::AccessibilityChildrenVector sortedLiveRegions();
    AXCoreObject::AccessibilityChildrenVector sortedNonRootWebAreas();

    void markMostRecentlyPaintedTextDirty() { m_mostRecentlyPaintedTextIsDirty = true; }
    const HashMap<AXID, LineRange>& mostRecentlyPaintedText() const LIFETIME_BOUND { return m_mostRecentlyPaintedText; }

    // Called on AX thread from WebAccessibilityObjectWrapper methods.
    WEBCORE_EXPORT void applyPendingChanges();
    void applyPendingChangesUnlessQueuedForDestruction();

#if ENABLE(ACCESSIBILITY_THREAD_DISPATCHING)
    enum class AXThreadDispatchResult : bool { Succeeded, Failed };
    static AXThreadDispatchResult callOnAXThread(Function<void()>&&);
#endif

    // Returns DidTearDown::Yes if this tree was queued for destruction and tree teardown was performed.
    // "Tear down" is very intentionally chosen wording, as it means we've cleared all internal
    // member variables that could hold a strong-ref to the tree, but we can't actually force
    // tree destruction until its ref-count falls to zero (which may or may not happen from the
    // teardown depending on the outstanding ref-count elsewhere).
    //
    // Callers are responsible for removing the tree from isolatedTreeMap() when true is returned
    // (hence the [[nodiscard]]).
    [[nodiscard]] DidTearDown applyPendingChangesOrTearDown();

    // Returns true if any tree has been queued for destruction but not yet cleaned up.
    static bool anyTreeNeedsTearDown() { return s_anyTreeNeedsTearDown.load(std::memory_order_relaxed); }
    static void clearAnyTreeNeedsTearDown() { s_anyTreeNeedsTearDown.store(false, std::memory_order_relaxed); }

    static bool shouldCacheIdentifierAttribute()
    {
#if !LOG_DISABLED
        // Always cache the ID when logging is enabled to avoid
        // main-thread hits when logging objects.
        return true;
#else
        return AXObjectCache::clientIsInTestMode();
#endif
    }

    constexpr AXTreeID treeID() const { return m_id; }
    constexpr ProcessID processID() const { return m_processID; }
    constexpr bool isMainFrame() const { return m_isMainFrame; }
    constexpr bool siteIsolationEnabled() const { return m_siteIsolationEnabled; }
    void setPageActivityState(OptionSet<ActivityState>);
    WEBCORE_EXPORT OptionSet<ActivityState> pageActivityState() const;

    AXTextMarkerRange selectedTextMarkerRange() { return m_selectedTextMarkerRange; }
    void setSelectedTextMarkerRange(AXTextMarkerRange&&);

    void sortedLiveRegionsDidChange(Vector<AXID>);
    void sortedNonRootWebAreasDidChange(Vector<AXID>);

    void setInitialSortedLiveRegions(Vector<AXID>);
    void setInitialSortedNonRootWebAreas(Vector<AXID>);

    void queueNodeUpdate(AXID, const NodeUpdateOptions&);
    void queueNodeRemoval(const AccessibilityObject&);
    void processQueuedNodeUpdates();

    AXTextMarker firstMarker();
    AXTextMarker lastMarker();

    RefPtr<AXIsolatedTree> replacingTreeForLogging() const { return m_replacingTree; }

private:
    AXIsolatedTree(AXObjectCache&);
    static void storeTree(AXObjectCache&, const Ref<AXIsolatedTree>&);
    void reportLoadingProgress(double);

    // Queue this isolated tree up to destroy itself on the secondary thread.
    // We can't destroy the tree on the main-thread (by removing all `Ref`s to it)
    // because it could be being used by the secondary thread to service an AX request.
    void queueForDestruction();

    void deleteSubtree(Ref<AXCoreObject>&&, const HashSet<AXID>& protectedFromDeletionIDs);
    void clearTreeContentsLocked() WTF_REQUIRES_LOCK(m_changeLogLock);
    bool hasPendingChanges() const { return m_hasPendingChanges.load(); }

#if ENABLE(ACCESSIBILITY_THREAD_DISPATCHING)
    static AXThreadDispatchResult platformCallOnAXThread(Function<void()>&&);
#endif

    static std::atomic<bool> s_anyTreeNeedsTearDown;

    // rdar://161259641 (Figure out a way to enforce WTF_REQUIRES_LOCK when we might need to access it while already holding the lock)
    static HashMap<FrameIdentifier, Ref<AXIsolatedTree>>& NODELETE treeFrameCache(); // WTF_REQUIRES_LOCK(s_storeLock);

    void createEmptyContent(AccessibilityObject&);
    constexpr bool isUpdatingSubtree() const { return m_rootOfSubtreeBeingUpdated; }
    constexpr void updatingSubtree(AccessibilityObject* axObject) { m_rootOfSubtreeBeingUpdated = axObject; }

    struct NodeChange {
        IsolatedObjectData data;
#if PLATFORM(COCOA)
        RetainPtr<AccessibilityObjectWrapper> wrapper;
#elif USE(ATSPI)
        RefPtr<AccessibilityObjectWrapper> wrapper;
#endif
        explicit NodeChange(IsolatedObjectData&& isolatedData, RetainPtr<AccessibilityObjectWrapper> wrapper)
            : data(WTF::move(isolatedData))
            , wrapper(WTF::move(wrapper))
        { }

        NodeChange(const NodeChange&) = delete;
        NodeChange(NodeChange&&) = default;
    };

    struct PendingChanges {
        Markable<AXID> focusedNodeID;
        Markable<AXID> rootNodeID;
        Vector<NodeChange> appends;
        Vector<AXPropertyChange> propertyChanges;
        Vector<NodeAndParentID> subtreeRemovals;
        Vector<std::pair<AXID, Vector<AXID>>> childrenUpdates;
        HashSet<AXID> protectedFromDeletionIDs;
        HashMap<AXID, AXID> parentUpdates;
        std::optional<Vector<AXID>> sortedLiveRegionIDs;
        std::optional<Vector<AXID>> sortedNonRootWebAreaIDs;
        std::optional<HashMap<AXID, LineRange>> mostRecentlyPaintedText;
        std::optional<HashMap<AXID, AXRelations>> relations;
        std::optional<AXTextMarkerRange> selectedTextMarkerRange;
#if ENABLE(ACCESSIBILITY_LOCAL_FRAME)
        std::optional<AXFrameGeometry> frameGeometry;
        std::optional<IntPoint> frameViewOriginScrollPosition;
#endif
    };

    class PendingChangesAccessor {
        WTF_MAKE_NONCOPYABLE(PendingChangesAccessor);
    public:
        PendingChangesAccessor(PendingChanges& data, std::atomic<bool>& flagToSetOnCompletion)
            : m_data(data), m_flagToSetOnCompletion(flagToSetOnCompletion) { }
        ~PendingChangesAccessor()
        {
            // Don't create a PendingChangesAccessor without using it — the destructor
            // unconditionally sets m_hasPendingChanges, so unused accessors cause
            // false-positive dirty flags.
            AX_ASSERT(m_wasAccessed);
            m_flagToSetOnCompletion.store(true);
        }
        PendingChanges* operator->()
        {
#if ASSERT_ENABLED
            m_wasAccessed = true;
#endif
            return &m_data;
        }
    private:
        PendingChanges& m_data;
        std::atomic<bool>& m_flagToSetOnCompletion;
#if ASSERT_ENABLED
        bool m_wasAccessed { false };
#endif
    };

    PendingChangesAccessor mutablePendingChanges() WTF_REQUIRES_LOCK(m_changeLogLock)
    {
        return { m_pendingChanges, m_hasPendingChanges };
    }

    PendingChanges takePendingChangesLocked() WTF_REQUIRES_LOCK(m_changeLogLock);
    void applyPendingChangesFromSnapshot(PendingChanges&&);
    void removeStaleAppends(const Vector<NodeAndParentID>&, Vector<NodeChange>&);

    void updateChildren(AccessibilityObject&, ResolveNodeChanges = ResolveNodeChanges::Yes);
    void updateNode(AccessibilityObject&);
    void updateNodeProperties(AccessibilityObject&, const AXPropertySet&);

    std::optional<NodeChange> nodeChangeForObject(Ref<AccessibilityObject>);
    void collectNodeChangesForSubtree(AccessibilityObject&);
    bool isCollectingNodeChanges() const { return m_isCollectingNodeChanges; }
    void queueChange(NodeChange&&) WTF_REQUIRES_LOCK(m_changeLogLock);
    void queueRemovals(Vector<NodeAndParentID>&&);
    void queueRemovalsLocked(Vector<NodeAndParentID>&&) WTF_REQUIRES_LOCK(m_changeLogLock);
    void queueRemovalsAndUnresolvedChanges();
    Vector<NodeChange> resolveAppends();
    void queueAppendsAndRemovals(Vector<NodeChange>&&, Vector<NodeAndParentID>&&);

    void objectChangedIgnoredState(const AccessibilityObject&);

    const WeakPtr<AXObjectCache> m_axObjectCache;
    RefPtr<AXGeometryManager> m_geometryManager;
    // Reference to a temporary, empty content tree that this tree will replace. Used for updating the empty content tree while this is built.
    RefPtr<AXIsolatedTree> m_replacingTree;
    RefPtr<AccessibilityObject> m_rootOfSubtreeBeingUpdated;

    // Stores the parent ID and children IDs for a given IsolatedObject.
    struct ParentChildrenIDs {
        Markable<AXID> parentID;
        Vector<AXID> childrenIDs;
    };
    // Only accessed on the main thread.
    // A representation of the tree's parent-child relationships. Each
    // IsolatedObject must have one and only one entry in this map, that maps
    // its ObjectID to its ParentChildrenIDs struct.
    HashMap<AXID, ParentChildrenIDs> m_nodeMap;

    // Only accessed on the main thread.
    // Stores all nodes that are added via addUnconnectedNode, which do not get stored in m_nodeMap.
    HashSet<AXID> m_unconnectedNodes;

    // Only accessed on the main thread.
    // The key is the ID of the object that will be resolved into an m_pendingAppends NodeChange.
    HashSet<AXID> m_unresolvedPendingAppends;
    // Only accessed on the main thread.
    // While performing tree updates, we append nodes to this list that are no longer connected
    // in the tree and should be removed. This list turns into m_pendingSubtreeRemovals when
    // handed off to the secondary thread.
    Vector<NodeAndParentID> m_subtreesToRemove;
    // Only accessed on the main thread.
    // This is used when updating the isolated tree in response to dynamic children changes.
    // It is required to protect objects from being incorrectly deleted when they are re-parented,
    // as the original parent will want to queue it for removal, but we need to keep the object around
    // for the new parent.
    HashSet<AXID> m_protectedFromDeletionIDs;
    // Only accessed on the main thread.
    // Objects whose parent has changed, and said change needs to be synced to the secondary thread.
    HashSet<AXID> m_needsParentUpdate;

    // Only accessed on AX thread.
    HashMap<AXID, Ref<AXIsolatedObject>> m_readerThreadNodeMap;
    Markable<AXID> m_rootNodeID;

    // Written to by main thread under lock, accessed and applied by AX thread.
    PendingChanges m_pendingChanges WTF_GUARDED_BY_LOCK(m_changeLogLock);

    // These are placed here to fit in padding that would otherwise be between m_pendingSortedLiveRegionIDs and m_pendingSortedNonRootWebAreaIDs.
    OptionSet<ActivityState> m_pageActivityState;
    bool m_isEmptyContentTree { false };
    bool m_queuedForDestruction WTF_GUARDED_BY_LOCK(m_changeLogLock) { false };
    bool m_isMainFrame { false };
    bool m_siteIsolationEnabled { false };

    Markable<AXID> m_focusedNodeID;
    std::atomic<double> m_loadingProgress { 0 };
    std::atomic<double> m_processingProgress { 1 };
    std::atomic<bool> m_hasPendingChanges { false };
#if ENABLE(ACCESSIBILITY_THREAD_DISPATCHING)
    std::atomic<bool> m_appliedOrApplyingMainThreadSnapshot { true };
#endif

    // Only accessed on the accessibility thread.
    Vector<AXID> m_sortedLiveRegionIDs;
    Vector<AXID> m_sortedNonRootWebAreaIDs;
    HashMap<AXID, LineRange> m_mostRecentlyPaintedText;
    HashMap<AXID, AXRelations> m_relations;
    // Cache of unignoredChildren() results for AXIsolatedObjects. Populated lazily
    // on cache miss; cleared in applyPendingChangesFromSnapshot when the incoming snapshot
    // carries a change that could affect any unignored-children list (tree structure change,
    // or IsIgnored / IsExposableTable / StitchGroups property update).
    HashMap<AXID, CachedUnignoredChildren> m_cachedUnignoredChildren;
#if ENABLE(ACCESSIBILITY_LOCAL_FRAME)
    AXFrameGeometry m_frameGeometry;
    IntPoint m_frameViewOriginScrollPosition;
    bool m_hasReceivedFrameGeometry { false };
#endif

    // Set to true by the AXObjectCache and false by AXIsolatedTree.
    // Both are only to be used on the main-thread.
    bool m_relationsNeedUpdate { true };
    bool m_mostRecentlyPaintedTextIsDirty { true };

    Lock m_changeLogLock;

    // Only accessed on the main thread.
    bool m_isCollectingNodeChanges;

    AXTextMarkerRange m_selectedTextMarkerRange;
    const ProcessID m_processID { legacyPresentingApplicationPID() };

    // Queued node updates used for building a new tree snapshot.
    ListHashSet<AXID> m_needsUpdateChildren;
    ListHashSet<AXID> m_needsUpdateNode;
    HashMap<AXID, AXPropertySet> m_needsPropertyUpdates;
    // The key is the ID of the node being removed. The value is the ID of the parent in the core tree (if it exists).
    HashMap<AXID, std::optional<AXID>> m_needsNodeRemoval;
};

IsolatedObjectData createIsolatedObjectData(const Ref<AccessibilityObject>&, Ref<AXIsolatedTree>);
std::optional<AXPropertyFlag> NODELETE convertToPropertyFlag(AXProperty);

inline AXObjectCache* AXIsolatedTree::axObjectCache() const
{
    AX_ASSERT(isMainThread());
    return m_axObjectCache.get();
}

template<typename U>
inline Vector<Ref<AXCoreObject>> AXIsolatedTree::objectsForIDs(const U& axIDs)
{
    AX_ASSERT(!isMainThread());

    Vector<Ref<AXCoreObject>> result;
    result.reserveInitialCapacity(axIDs.size());
    for (const auto& axID : axIDs) {
        if (RefPtr object = objectForID(axID))
            result.append(object.releaseNonNull());
    }
    result.shrinkToFit();
    return result;
}

} // namespace WebCore

#endif
