/*
 * Copyright (C) 2014 Google 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 COMPUTER, 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 COMPUTER, 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.
 *
 */

#ifndef THIRD_PARTY_BLINK_RENDERER_CORE_DOM_EVENTS_TREE_SCOPE_EVENT_CONTEXT_H_
#define THIRD_PARTY_BLINK_RENDERER_CORE_DOM_EVENTS_TREE_SCOPE_EVENT_CONTEXT_H_

#include "third_party/blink/renderer/core/core_export.h"
#include "third_party/blink/renderer/core/dom/events/event_target.h"
#include "third_party/blink/renderer/core/dom/node.h"
#include "third_party/blink/renderer/core/dom/tree_scope.h"
#include "third_party/blink/renderer/platform/wtf/vector.h"

namespace blink {

class ContainerNode;
class EventPath;
class EventTarget;
template <typename NodeType>
class StaticNodeTypeList;
using StaticNodeList = StaticNodeTypeList<Node>;
class TouchEventContext;
class TreeScope;

class CORE_EXPORT TreeScopeEventContext final
    : public GarbageCollected<TreeScopeEventContext> {
 public:
  explicit TreeScopeEventContext(TreeScope&);
  void Trace(Visitor*) const;

  TreeScope& GetTreeScope() const { return *tree_scope_; }
  ContainerNode& RootNode() const { return tree_scope_->RootNode(); }

  EventTarget* Target() const { return target_.Get(); }
  void SetTarget(EventTarget&);

  EventTarget* RelatedTarget() const { return related_target_.Get(); }
  void SetRelatedTarget(EventTarget&);

  TouchEventContext* GetTouchEventContext() const {
    return touch_event_context_.Get();
  }
  TouchEventContext& EnsureTouchEventContext();

  HeapVector<Member<EventTarget>>& EnsureEventPath(EventPath&);

  bool IsInclusiveAncestorOf(const TreeScopeEventContext&) const;
  bool IsDescendantOf(const TreeScopeEventContext&) const;
#if DCHECK_IS_ON()
  bool IsExclusivePartOf(const TreeScopeEventContext&) const;
#endif
  void AddChild(TreeScopeEventContext& child) { children_.push_back(&child); }

  // For ancestor-descendant relationship check in O(1).
  // Preprocessing takes O(N).
  int CalculateTreeOrderAndSetNearestAncestorClosedTree(
      int order_number,
      TreeScopeEventContext* nearest_ancestor_closed_tree_scope_event_context);

  TreeScopeEventContext* ContainingClosedShadowTree() const {
    return containing_closed_shadow_tree_.Get();
  }

 private:
  void CheckReachableNode(EventTarget&);

  bool IsUnclosedTreeOf(const TreeScopeEventContext& other);

  Member<TreeScope> tree_scope_;
  Member<EventTarget> target_;
  Member<EventTarget> related_target_;
  Member<HeapVector<Member<EventTarget>>> event_path_;
  Member<TouchEventContext> touch_event_context_;
  Member<TreeScopeEventContext> containing_closed_shadow_tree_;

  HeapVector<Member<TreeScopeEventContext>> children_;
  int pre_order_;
  int post_order_;
};

#if DCHECK_IS_ON()
inline void TreeScopeEventContext::CheckReachableNode(EventTarget& target) {
  if (!target.ToNode())
    return;
  // FIXME: Checks also for SVG elements.
  if (target.ToNode()->IsSVGElement())
    return;
  DCHECK(target.ToNode()->GetTreeScope().IsInclusiveAncestorTreeScopeOf(
      GetTreeScope()));
}
#else
inline void TreeScopeEventContext::CheckReachableNode(EventTarget&) {}
#endif

inline void TreeScopeEventContext::SetTarget(EventTarget& target) {
  CheckReachableNode(target);
  target_ = target;
}

inline void TreeScopeEventContext::SetRelatedTarget(
    EventTarget& related_target) {
  CheckReachableNode(related_target);
  related_target_ = related_target;
}

inline bool TreeScopeEventContext::IsInclusiveAncestorOf(
    const TreeScopeEventContext& other) const {
  DCHECK_NE(pre_order_, -1);
  DCHECK_NE(post_order_, -1);
  DCHECK_NE(other.pre_order_, -1);
  DCHECK_NE(other.post_order_, -1);
  return pre_order_ <= other.pre_order_ && other.post_order_ <= post_order_;
}

inline bool TreeScopeEventContext::IsDescendantOf(
    const TreeScopeEventContext& other) const {
  DCHECK_NE(pre_order_, -1);
  DCHECK_NE(post_order_, -1);
  DCHECK_NE(other.pre_order_, -1);
  DCHECK_NE(other.post_order_, -1);
  return other.pre_order_ < pre_order_ && post_order_ < other.post_order_;
}

#if DCHECK_IS_ON()
inline bool TreeScopeEventContext::IsExclusivePartOf(
    const TreeScopeEventContext& other) const {
  DCHECK_NE(pre_order_, -1);
  DCHECK_NE(post_order_, -1);
  DCHECK_NE(other.pre_order_, -1);
  DCHECK_NE(other.post_order_, -1);
  return (pre_order_ < other.pre_order_ && post_order_ < other.pre_order_) ||
         (pre_order_ > other.pre_order_ && pre_order_ > other.post_order_);
}
#endif

}  // namespace blink

#endif  // THIRD_PARTY_BLINK_RENDERER_CORE_DOM_EVENTS_TREE_SCOPE_EVENT_CONTEXT_H_