/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "EventQueue.h"

#include "DocAccessibleChild.h"
#include "LocalAccessible-inl.h"
#include "mozilla/PerfStats.h"
#include "mozilla/ProfilerMarkers.h"
#include "nsEventShell.h"
#include "nsTextEquivUtils.h"
#ifdef A11Y_LOG
#  include "Logging.h"
#endif
#include "Relation.h"

namespace mozilla {
namespace a11y {

// Defines the number of selection add/remove events in the queue when they
// aren't packed into single selection within event.
const unsigned int kSelChangeCountToPack = 5;

////////////////////////////////////////////////////////////////////////////////
// EventQueue
////////////////////////////////////////////////////////////////////////////////

bool EventQueue::PushEvent(AccEvent* aEvent) {
  NS_ASSERTION((aEvent->mAccessible && aEvent->mAccessible->IsApplication()) ||
                   aEvent->Document() == mDocument,
               "Queued event belongs to another document!");

  if (aEvent->mEventType == nsIAccessibleEvent::EVENT_FOCUS) {
    mFocusEvent = aEvent;
    return true;
  }

  if (aEvent->mEventRule == AccEvent::eRemoveDupes && !mEvents.IsEmpty()) {
    // Check for duplicate events. If aEvent is identical to an older event, do
    // not append aEvent. We do this here rather than in CoalesceEvents because
    // CoalesceEvents never *removes* events; it only sets them to eDoNotEmit.
    // If there are many duplicate events and we appended them, this would
    // result in a massive event queue and coalescing would become increasingly
    // slow with each event queued. Doing it here, we avoid appending a
    // duplicate event in the first place.
    uint32_t last = mEvents.Length() - 1;
    for (uint32_t index = last; index <= last; --index) {
      AccEvent* checkEvent = mEvents[index];
      if (checkEvent->mEventType == aEvent->mEventType &&
          checkEvent->mEventRule == aEvent->mEventRule &&
          checkEvent->mAccessible == aEvent->mAccessible) {
        aEvent->mEventRule = AccEvent::eDoNotEmit;
        return true;
      }
    }
  }

  // XXX(Bug 1631371) Check if this should use a fallible operation as it
  // pretended earlier, or change the return type to void.
  mEvents.AppendElement(aEvent);

  // Filter events.
  CoalesceEvents();

  if (aEvent->mEventType == nsIAccessibleEvent::EVENT_NAME_CHANGE ||
      aEvent->mEventType == nsIAccessibleEvent::EVENT_TEXT_REMOVED ||
      aEvent->mEventType == nsIAccessibleEvent::EVENT_TEXT_INSERTED) {
    MOZ_ASSERT(aEvent->mEventRule != AccEvent::eDoNotEmit);
    PushNameOrDescriptionChange(aEvent);
  }
  return true;
}

bool EventQueue::PushNameOrDescriptionChangeToRelations(
    LocalAccessible* aAccessible, RelationType aType) {
  MOZ_ASSERT(aType == RelationType::LABEL_FOR ||
             aType == RelationType::DESCRIPTION_FOR);

  bool pushed = false;
  uint32_t eventType = aType == RelationType::LABEL_FOR
                           ? nsIAccessibleEvent::EVENT_NAME_CHANGE
                           : nsIAccessibleEvent::EVENT_DESCRIPTION_CHANGE;
  Relation rel = aAccessible->RelationByType(aType);
  while (LocalAccessible* relTarget = rel.LocalNext()) {
    auto nameChangeEvent = MakeRefPtr<AccEvent>(eventType, relTarget);
    pushed |= PushEvent(nameChangeEvent);
  }

  return pushed;
}

bool EventQueue::PushNameOrDescriptionChange(AccEvent* aOrigEvent) {
  // Fire name/description change event on parent or related LocalAccessible
  // being labelled/described given that this event hasn't been coalesced, the
  // dependent's name/description was calculated from this subtree, and the
  // subtree was changed.
  LocalAccessible* target = aOrigEvent->mAccessible;
  // If the text of a text leaf changed without replacing the leaf, the only
  // event we get is text inserted on the container. Or, a reorder event may
  // change the container's name. In this case, we might need to fire a name
  // change event on the target itself.
  const bool maybeTargetNameChanged =
      (aOrigEvent->mEventType == nsIAccessibleEvent::EVENT_TEXT_REMOVED ||
       aOrigEvent->mEventType == nsIAccessibleEvent::EVENT_TEXT_INSERTED ||
       aOrigEvent->mEventType == nsIAccessibleEvent::EVENT_REORDER ||
       aOrigEvent->mEventType == nsIAccessibleEvent::EVENT_INNER_REORDER) &&
      nsTextEquivUtils::HasNameRule(target, eNameFromSubtreeRule);
  const bool doName = target->HasNameDependent() || maybeTargetNameChanged;
  const bool doDesc = target->HasDescriptionDependent();

  if (!doName && !doDesc) {
    return false;
  }
  bool pushed = false;
  bool nameCheckAncestor = true;
  // Only continue traversing up the tree if it's possible that the parent
  // LocalAccessible's name (or a LocalAccessible being labelled by this
  // LocalAccessible or an ancestor) can depend on this LocalAccessible's name.
  LocalAccessible* parent = target;
  do {
    // Test possible name dependent parent.
    if (doName) {
      if (nameCheckAncestor && (maybeTargetNameChanged || parent != target) &&
          nsTextEquivUtils::HasNameRule(parent, eNameFromSubtreeRule)) {
        // HTML file inputs always get part of their name from the subtree, even
        // if the author provided a name.
        bool fireNameChange = parent->IsHTMLFileInput();
        if (!fireNameChange) {
          nsAutoString name;
          ENameValueFlag nameFlag = parent->DirectName(name);
          switch (nameFlag) {
            case eNameOK:
              // Descendants of subtree may have been removed, making the name
              // void.
              fireNameChange = name.IsVoid();
              break;
            case eNameFromSubtree:
              // If name is obtained from subtree, fire name change event.
              fireNameChange = true;
              break;
            case eNameFromTooltip:
              // If the descendants of this accessible were removed, the name
              // may be calculated using the tooltip. We can guess that the name
              // was obtained from the subtree before.
              fireNameChange = true;
              break;
            case eNameFromRelations:
              fireNameChange = true;
              break;
            default:
              MOZ_ASSERT_UNREACHABLE("All name flags not covered!");
          }
        }

        if (fireNameChange) {
          auto nameChangeEvent = MakeRefPtr<AccEvent>(
              nsIAccessibleEvent::EVENT_NAME_CHANGE, parent);
          pushed |= PushEvent(nameChangeEvent);
        }
        nameCheckAncestor = false;
      }

      pushed |= PushNameOrDescriptionChangeToRelations(parent,
                                                       RelationType::LABEL_FOR);
    }

    if (doDesc) {
      pushed |= PushNameOrDescriptionChangeToRelations(
          parent, RelationType::DESCRIPTION_FOR);
    }

    if (parent->IsDoc()) {
      // Never cross document boundaries.
      break;
    }
    parent = parent->LocalParent();
  } while (parent &&
           nsTextEquivUtils::HasNameRule(parent, eNameFromSubtreeIfReqRule));

  return pushed;
}

////////////////////////////////////////////////////////////////////////////////
// EventQueue: private

void EventQueue::CoalesceEvents() {
  AUTO_PROFILER_MARKER_TEXT("EventQueue::CoalesceEvents", A11Y, {}, ""_ns);
  PerfStats::AutoMetricRecording<PerfStats::Metric::A11Y_CoalesceEvents>
      autoRecording;
  // DO NOT ADD CODE ABOVE THIS BLOCK: THIS CODE IS MEASURING TIMINGS.

  NS_ASSERTION(mEvents.Length(), "There should be at least one pending event!");
  uint32_t tail = mEvents.Length() - 1;
  AccEvent* tailEvent = mEvents[tail];

  switch (tailEvent->mEventRule) {
    case AccEvent::eCoalesceReorder: {
      DebugOnly<LocalAccessible*> target = tailEvent->mAccessible.get();
      MOZ_ASSERT(
          target->IsApplication() || target->IsOuterDoc() ||
              target->IsXULTree(),
          "Only app or outerdoc accessible reorder events are in the queue");
      MOZ_ASSERT(tailEvent->GetEventType() == nsIAccessibleEvent::EVENT_REORDER,
                 "only reorder events should be queued");
      break;  // case eCoalesceReorder
    }

    case AccEvent::eCoalesceOfSameType: {
      // Coalesce old events by newer event.
      for (uint32_t index = tail - 1; index < tail; index--) {
        AccEvent* accEvent = mEvents[index];
        if (accEvent->mEventType == tailEvent->mEventType &&
            accEvent->mEventRule == tailEvent->mEventRule) {
          accEvent->mEventRule = AccEvent::eDoNotEmit;
          return;
        }
      }
      break;  // case eCoalesceOfSameType
    }

    case AccEvent::eCoalesceSelectionChange: {
      AccSelChangeEvent* tailSelChangeEvent = downcast_accEvent(tailEvent);
      for (uint32_t index = tail - 1; index < tail; index--) {
        AccEvent* thisEvent = mEvents[index];
        if (thisEvent->mEventRule == tailEvent->mEventRule) {
          AccSelChangeEvent* thisSelChangeEvent = downcast_accEvent(thisEvent);

          // Coalesce selection change events within same control.
          if (tailSelChangeEvent->mWidget == thisSelChangeEvent->mWidget) {
            CoalesceSelChangeEvents(tailSelChangeEvent, thisSelChangeEvent,
                                    index);
            return;
          }
        }
      }
      break;  // eCoalesceSelectionChange
    }

    case AccEvent::eCoalesceStateChange: {
      // If state change event is duped then ignore previous event. If state
      // change event is opposite to previous event then no event is emitted
      // (accessible state wasn't changed).
      for (uint32_t index = tail - 1; index < tail; index--) {
        AccEvent* thisEvent = mEvents[index];
        if (thisEvent->mEventRule != AccEvent::eDoNotEmit &&
            thisEvent->mEventType == tailEvent->mEventType &&
            thisEvent->mAccessible == tailEvent->mAccessible) {
          AccStateChangeEvent* thisSCEvent = downcast_accEvent(thisEvent);
          AccStateChangeEvent* tailSCEvent = downcast_accEvent(tailEvent);
          if (thisSCEvent->mState == tailSCEvent->mState) {
            thisEvent->mEventRule = AccEvent::eDoNotEmit;
            if (thisSCEvent->mIsEnabled != tailSCEvent->mIsEnabled) {
              tailEvent->mEventRule = AccEvent::eDoNotEmit;
            }
          }
        }
      }
      break;  // eCoalesceStateChange
    }

    case AccEvent::eCoalesceTextSelChange: {
      // Coalesce older event by newer event for the same selection or target.
      // Events for same selection may have different targets and vice versa one
      // target may be pointed by different selections (for latter see
      // bug 927159).
      for (uint32_t index = tail - 1; index < tail; index--) {
        AccEvent* thisEvent = mEvents[index];
        if (thisEvent->mEventRule != AccEvent::eDoNotEmit &&
            thisEvent->mEventType == tailEvent->mEventType) {
          AccTextSelChangeEvent* thisTSCEvent = downcast_accEvent(thisEvent);
          AccTextSelChangeEvent* tailTSCEvent = downcast_accEvent(tailEvent);
          if (thisTSCEvent->mSel == tailTSCEvent->mSel ||
              thisEvent->mAccessible == tailEvent->mAccessible) {
            thisEvent->mEventRule = AccEvent::eDoNotEmit;
          }
        }
      }
      break;  // eCoalesceTextSelChange
    }

    default:
      // eRemoveDupes is handled in PushEvent.
      break;  // case eRemoveDupes, eAllowDupes, eDoNotEmit
  }  // switch
}

void EventQueue::CoalesceSelChangeEvents(AccSelChangeEvent* aTailEvent,
                                         AccSelChangeEvent* aThisEvent,
                                         uint32_t aThisIndex) {
  aTailEvent->mPreceedingCount = aThisEvent->mPreceedingCount + 1;

  // Pack all preceding events into single selection within event
  // when we receive too much selection add/remove events.
  if (aTailEvent->mPreceedingCount >= kSelChangeCountToPack) {
    aTailEvent->mEventType = nsIAccessibleEvent::EVENT_SELECTION_WITHIN;
    aTailEvent->mAccessible = aTailEvent->mWidget;
    aThisEvent->mEventRule = AccEvent::eDoNotEmit;

    // Do not emit any preceding selection events for same widget if they
    // weren't coalesced yet.
    if (aThisEvent->mEventType != nsIAccessibleEvent::EVENT_SELECTION_WITHIN) {
      for (uint32_t jdx = aThisIndex - 1; jdx < aThisIndex; jdx--) {
        AccEvent* prevEvent = mEvents[jdx];
        if (prevEvent->mEventRule == aTailEvent->mEventRule) {
          AccSelChangeEvent* prevSelChangeEvent = downcast_accEvent(prevEvent);
          if (prevSelChangeEvent->mWidget == aTailEvent->mWidget) {
            prevSelChangeEvent->mEventRule = AccEvent::eDoNotEmit;
          }
        }
      }
    }
    return;
  }

  // Pack sequential selection remove and selection add events into
  // single selection change event.
  if (aTailEvent->mPreceedingCount == 1 &&
      aTailEvent->mItem != aThisEvent->mItem) {
    if (aTailEvent->mSelChangeType == AccSelChangeEvent::eSelectionAdd &&
        aThisEvent->mSelChangeType == AccSelChangeEvent::eSelectionRemove) {
      aThisEvent->mEventRule = AccEvent::eDoNotEmit;
      aTailEvent->mEventType = nsIAccessibleEvent::EVENT_SELECTION;
      aTailEvent->mPackedEvent = aThisEvent;
      return;
    }

    if (aThisEvent->mSelChangeType == AccSelChangeEvent::eSelectionAdd &&
        aTailEvent->mSelChangeType == AccSelChangeEvent::eSelectionRemove) {
      aTailEvent->mEventRule = AccEvent::eDoNotEmit;
      aThisEvent->mEventType = nsIAccessibleEvent::EVENT_SELECTION;
      aThisEvent->mPackedEvent = aTailEvent;
      return;
    }
  }

  // Unpack the packed selection change event because we've got one
  // more selection add/remove.
  if (aThisEvent->mEventType == nsIAccessibleEvent::EVENT_SELECTION) {
    if (aThisEvent->mPackedEvent) {
      aThisEvent->mPackedEvent->mEventType =
          aThisEvent->mPackedEvent->mSelChangeType ==
                  AccSelChangeEvent::eSelectionAdd
              ? nsIAccessibleEvent::EVENT_SELECTION_ADD
              : nsIAccessibleEvent::EVENT_SELECTION_REMOVE;

      aThisEvent->mPackedEvent->mEventRule = AccEvent::eCoalesceSelectionChange;

      aThisEvent->mPackedEvent = nullptr;
    }

    aThisEvent->mEventType =
        aThisEvent->mSelChangeType == AccSelChangeEvent::eSelectionAdd
            ? nsIAccessibleEvent::EVENT_SELECTION_ADD
            : nsIAccessibleEvent::EVENT_SELECTION_REMOVE;

    return;
  }

  // Convert into selection add since control has single selection but other
  // selection events for this control are queued.
  if (aTailEvent->mEventType == nsIAccessibleEvent::EVENT_SELECTION) {
    aTailEvent->mEventType = nsIAccessibleEvent::EVENT_SELECTION_ADD;
  }
}

////////////////////////////////////////////////////////////////////////////////
// EventQueue: event queue

void EventQueue::ProcessEventQueue() {
  // Process only currently queued events.
  const nsTArray<RefPtr<AccEvent> > events = std::move(mEvents);
  nsTArray<uint64_t> selectedIDs;
  nsTArray<uint64_t> unselectedIDs;

  uint32_t eventCount = events.Length();
#ifdef A11Y_LOG
  if ((eventCount > 0 || mFocusEvent) && logging::IsEnabled(logging::eEvents)) {
    logging::MsgBegin("EVENTS", "events processing");
    logging::Address("document", mDocument);
    logging::MsgEnd();
  }
#endif

  if (mFocusEvent) {
    // Always fire a pending focus event before all other events. We do this for
    // two reasons:
    // 1. It prevents extraneous screen reader speech if the name, states, etc.
    // of the currently focused item change at the same time as another item is
    // focused. If aria-activedescendant is used, even setting
    // aria-activedescendant before changing other properties results in the
    // property change events being queued before the focus event because we
    // process  aria-activedescendant async.
    // 2. It improves perceived performance. Focus changes should be reported as
    // soon as possible, so clients should handle focus events before they spend
    // time on anything else.
    RefPtr<AccEvent> event = std::move(mFocusEvent);
    if (!event->mAccessible->IsDefunct()) {
      FocusMgr()->ProcessFocusEvent(event);
    }
  }

  for (uint32_t idx = 0; idx < eventCount; idx++) {
    AccEvent* event = events[idx];
    uint32_t eventType = event->mEventType;
    LocalAccessible* target = event->GetAccessible();
    if (!target || target->IsDefunct()) {
      continue;
    }

    // Collect select changes
    if (IPCAccessibilityActive()) {
      if ((event->mEventRule == AccEvent::eDoNotEmit &&
           (eventType == nsIAccessibleEvent::EVENT_SELECTION_ADD ||
            eventType == nsIAccessibleEvent::EVENT_SELECTION_REMOVE ||
            eventType == nsIAccessibleEvent::EVENT_SELECTION)) ||
          eventType == nsIAccessibleEvent::EVENT_SELECTION_WITHIN) {
        // The selection even was either dropped or morphed to a
        // selection-within. We need to collect the items from all these events
        // and manually push their new state to the parent process.
        AccSelChangeEvent* selChangeEvent = downcast_accEvent(event);
        LocalAccessible* item = selChangeEvent->mItem;
        if (!item->IsDefunct()) {
          uint64_t itemID =
              item->IsDoc() ? 0 : reinterpret_cast<uint64_t>(item->UniqueID());
          bool selected = selChangeEvent->mSelChangeType ==
                          AccSelChangeEvent::eSelectionAdd;
          if (selected) {
            selectedIDs.AppendElement(itemID);
          } else {
            unselectedIDs.AppendElement(itemID);
          }
        }
      }
    }

    if (event->mEventRule == AccEvent::eDoNotEmit) {
      continue;
    }

    // Dispatch caret moved and text selection change events.
    if (eventType == nsIAccessibleEvent::EVENT_TEXT_SELECTION_CHANGED) {
      SelectionMgr()->ProcessTextSelChangeEvent(event);
      continue;
    }

    // Fire selected state change events in support to selection events.
    if (eventType == nsIAccessibleEvent::EVENT_SELECTION_ADD) {
      nsEventShell::FireEvent(event->mAccessible, states::SELECTED, true,
                              event->mIsFromUserInput);

    } else if (eventType == nsIAccessibleEvent::EVENT_SELECTION_REMOVE) {
      nsEventShell::FireEvent(event->mAccessible, states::SELECTED, false,
                              event->mIsFromUserInput);

    } else if (eventType == nsIAccessibleEvent::EVENT_SELECTION) {
      AccSelChangeEvent* selChangeEvent = downcast_accEvent(event);
      nsEventShell::FireEvent(
          event->mAccessible, states::SELECTED,
          (selChangeEvent->mSelChangeType == AccSelChangeEvent::eSelectionAdd),
          event->mIsFromUserInput);

      if (selChangeEvent->mPackedEvent) {
        nsEventShell::FireEvent(selChangeEvent->mPackedEvent->mAccessible,
                                states::SELECTED,
                                (selChangeEvent->mPackedEvent->mSelChangeType ==
                                 AccSelChangeEvent::eSelectionAdd),
                                selChangeEvent->mPackedEvent->mIsFromUserInput);
      }
    }

    nsEventShell::FireEvent(event);

    if (!mDocument) {
      return;
    }

    // Some mutation events may be queued incidentally by this function. Send
    // them immediately so they stay in order. This can happen due to code in
    // DoInitialUpdate and TextUpdater that calls FireDelayedEvent for mutation
    // events, rather than QueueMutationEvent. DoInitialUpdate can do this with
    // reorder events, and TextUpdater can do this with text inserted/removed
    // events. Process these events now to avoid sending them out-of-order.
    if (eventType == nsIAccessibleEvent::EVENT_REORDER ||
        eventType == nsIAccessibleEvent::EVENT_TEXT_INSERTED ||
        eventType == nsIAccessibleEvent::EVENT_TEXT_REMOVED) {
      if (auto* ipcDoc = mDocument->IPCDoc()) {
        ipcDoc->SendQueuedMutationEvents();
      }
    }
  }

  if (!mDocument) {
    return;
  }
  if (auto* ipcDoc = mDocument->IPCDoc();
      ipcDoc && (!selectedIDs.IsEmpty() || !unselectedIDs.IsEmpty())) {
    ipcDoc->SendSelectedAccessiblesChanged(selectedIDs, unselectedIDs);
  }
}

}  // namespace a11y
}  // namespace mozilla
