// Copyright 2016 Google Inc. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#include "cobalt/browser/web_module_stat_tracker.h"

#if defined(ENABLE_WEBDRIVER)
#include <sstream>
#endif  // ENABLE_WEBDRIVER

#include "base/stringprintf.h"
#include "cobalt/base/tokens.h"
#include "cobalt/dom/event.h"
#if defined(ENABLE_WEBDRIVER)
#include "cobalt/dom/global_stats.h"
#endif  // ENABLE_WEBDRIVER

namespace cobalt {
namespace browser {

WebModuleStatTracker::WebModuleStatTracker(const std::string& name,
                                           bool should_track_event_stats)
    : name_(name),
      should_track_event_stats_(should_track_event_stats),
      dom_stat_tracker_(new dom::DomStatTracker(name)),
      layout_stat_tracker_(new layout::LayoutStatTracker(name)),
      event_is_processing_(StringPrintf("Event.%s.IsProcessing", name.c_str()),
                           false, "Nonzero when an event is being processed."),
      current_event_type_(kEventTypeInvalid),
      current_event_dispatched_event_(nullptr) {
  if (should_track_event_stats_) {
    event_stats_list_.reserve(kNumEventTypes);
    for (int i = 0; i < kNumEventTypes; ++i) {
      EventType event_type = static_cast<EventType>(i);
      event_stats_list_.push_back(new EventStats(StringPrintf(
          "%s.%s", name.c_str(), GetEventTypeName(event_type).c_str())));
    }
  }

  stop_watches_.reserve(kNumStopWatchTypes);
  for (int i = 0; i < kNumStopWatchTypes; ++i) {
    stop_watches_.push_back(
        base::StopWatch(i, base::StopWatch::kAutoStartOff, this));
  }
  stop_watch_durations_.resize(kNumStopWatchTypes, base::TimeDelta());
}

void WebModuleStatTracker::OnStartDispatchEvent(
    const scoped_refptr<dom::Event>& event) {
  if (!should_track_event_stats_) {
    return;
  }

  // If an event is already being tracked, then don't track this event. It needs
  // to be allowed to finish.
  if (current_event_type_ != kEventTypeInvalid) {
    return;
  }

  // Determine the event type.
  if (event->type() == base::Tokens::keydown()) {
    current_event_type_ = kEventTypeKeyDown;
  } else if (event->type() == base::Tokens::keyup()) {
    current_event_type_ = kEventTypeKeyUp;
  } else if (event->type() == base::Tokens::pointerdown()) {
    current_event_type_ = kEventTypePointerDown;
  } else if (event->type() == base::Tokens::pointerup()) {
    current_event_type_ = kEventTypePointerUp;
  } else {
    current_event_type_ = kEventTypeInvalid;
  }

  // If this is a valid event type, then start tracking it.
  if (current_event_type_ != kEventTypeInvalid) {
    DCHECK(!event_is_processing_);

    event_is_processing_ = true;
    current_event_dispatched_event_ = event;
    current_event_start_time_ = base::TimeTicks::Now();
    current_event_render_tree_produced_time_ = base::TimeTicks();

    dom_stat_tracker_->StartTrackingEvent();
    layout_stat_tracker_->StartTrackingEvent();

    stop_watch_durations_[kStopWatchTypeDispatchEvent] = base::TimeDelta();
    stop_watches_[kStopWatchTypeDispatchEvent].Start();
  }
}

void WebModuleStatTracker::OnStopDispatchEvent(
    const scoped_refptr<dom::Event>& event,
    bool are_animation_frame_callbacks_pending,
    bool is_new_render_tree_pending) {
  // Verify that this dispatched event is the one currently being tracked.
  if (event != current_event_dispatched_event_) {
    return;
  }

  current_event_dispatched_event_ = nullptr;
  stop_watches_[kStopWatchTypeDispatchEvent].Stop();

  if (!are_animation_frame_callbacks_pending && !is_new_render_tree_pending &&
      current_event_render_tree_produced_time_.is_null()) {
    EndCurrentEvent(base::TimeTicks::Now());
  }
}

void WebModuleStatTracker::OnRanAnimationFrameCallbacks(
    bool is_new_render_tree_pending) {
  if (current_event_type_ == kEventTypeInvalid) {
    return;
  }

  if (!is_new_render_tree_pending &&
      current_event_render_tree_produced_time_.is_null()) {
    EndCurrentEvent(base::TimeTicks::Now());
  }
}

void WebModuleStatTracker::OnRenderTreeProduced(
    const base::TimeTicks& produced_time) {
  // Flush the periodic tracking regardless of whether or not there is a current
  // event. Periodic tracking is not tied to events.
  dom_stat_tracker_->FlushPeriodicTracking();
  layout_stat_tracker_->FlushPeriodicTracking();

  if (current_event_type_ == kEventTypeInvalid) {
    return;
  }

  // Event tracking stops when the first render tree being produced. At that
  // point, processing switches to the rasterizer thread and any subsequent
  // dom/layout work that occurs will not be associated with the event's first
  // render tree.
  if (current_event_render_tree_produced_time_.is_null()) {
    current_event_render_tree_produced_time_ = produced_time;
    dom_stat_tracker_->StopTrackingEvent();
    layout_stat_tracker_->StopTrackingEvent();
  }
}

void WebModuleStatTracker::OnRenderTreeRasterized(
    const base::TimeTicks& produced_time,
    const base::TimeTicks& rasterized_time) {
  if (current_event_type_ == kEventTypeInvalid) {
    return;
  }

  // End the event if the event's render tree has already been produced and
  // the rasterized render tree is not older than the event's render tree.
  if (!current_event_render_tree_produced_time_.is_null() &&
      produced_time >= current_event_render_tree_produced_time_) {
    EndCurrentEvent(rasterized_time);
  }
}

WebModuleStatTracker::EventStats::EventStats(const std::string& name)
    : start_time(StringPrintf("Event.Time.%s.Start", name.c_str()), 0,
          "The time that the event started."),
      produced_render_tree(
          StringPrintf("Event.%s.ProducedRenderTree", name.c_str()), false,
          "Nonzero when the event produced a render tree."),
      count_dom_html_element(
          StringPrintf("Event.Count.%s.DOM.HtmlElement", name.c_str()), 0,
          "Total number of HTML elements."),
      count_dom_html_element_created(
          StringPrintf("Event.Count.%s.DOM.HtmlElement.Created", name.c_str()),
          0, "Total number of HTML elements created."),
      count_dom_html_element_destroyed(
          StringPrintf("Event.Count.%s.DOM.HtmlElement.Destroyed",
                       name.c_str()),
          0, "Total number of HTML elements destroyed."),
      count_dom_html_element_document(
          StringPrintf("Event.Count.%s.DOM.HtmlElement.Document", name.c_str()),
          0, "Number of HTML elements in document."),
      count_dom_html_element_document_added(
          StringPrintf("Event.Count.%s.DOM.HtmlElement.Document.Added",
                       name.c_str()),
          0, "Number of HTML elements added to document."),
      count_dom_html_element_document_removed(
          StringPrintf("Event.Count.%s.DOM.HtmlElement.Document.Removed",
                       name.c_str()),
          0, "Number of HTML elements removed from document."),
      count_dom_update_matching_rules(
          StringPrintf("Event.Count.%s.DOM.HtmlElement.UpdateMatchingRules",
                       name.c_str()),
          0, "Number of HTML elements that had their matching rules updated."),
      count_dom_update_computed_style(
          StringPrintf("Event.Count.%s.DOM.HtmlElement.UpdateComputedStyle",
                       name.c_str()),
          0, "Number of HTML elements that had their computed style updated."),
      count_dom_generate_html_element_computed_style(
          StringPrintf(
              "Event.Count.%s.DOM.HtmlElement.GenerateHtmlElementComputedStyle",
              name.c_str()),
          0,
          "Number of HTML elements that had their computed style generated."),
      count_dom_generate_pseudo_element_computed_style(
          StringPrintf("Event.Count.%s.DOM.HtmlElement."
                       "GeneratePseudoElementComputedStyle",
                       name.c_str()),
          0,
          "Number of pseudo elements that had their computed style generated."),
      count_layout_box(StringPrintf("Event.Count.%s.Layout.Box", name.c_str()),
                       0, "Number of layout boxes."),
      count_layout_box_created(
          StringPrintf("Event.Count.%s.Layout.Box.Created", name.c_str()), 0,
          "Number of layout boxes created."),
      count_layout_box_destroyed(
          StringPrintf("Event.Count.%s.Layout.Box.Destroyed", name.c_str()), 0,
          "Number of layout boxes destroyed."),
      count_layout_update_size(
          StringPrintf("Event.Count.%s.Layout.Box.UpdateSize", name.c_str()), 0,
          "Number of layout boxes that had their size updated."),
      count_layout_render_and_animate(
          StringPrintf("Event.Count.%s.Layout.Box.RenderAndAnimate",
                       name.c_str()),
          0, "Number of layout boxes that had their render tree node updated."),
      count_layout_update_cross_references(
          StringPrintf("Event.Count.%s.Layout.Box.UpdateCrossReferences",
                       name.c_str()),
          0, "Number of layout boxes that had their cross references updated."),
      duration_total(StringPrintf("Event.Duration.%s", name.c_str()),
                     base::TimeDelta(),
                     "Total duration of the event (in microseconds). This is "
                     "the time elapsed from the event dispatch until the "
                     "render tree is produced."),
      duration_dom_dispatch_event(
          StringPrintf("Event.Duration.%s.DOM.DispatchEvent", name.c_str()),
          base::TimeDelta(),
          "Dispatch duration, which includes JS, for event (in "
          "microseconds). This does not include subsequent DOM and Layout "
          "processing."),
      duration_dom_run_animation_frame_callbacks(
          StringPrintf("Event.Duration.%s.DOM.RunAnimationFrameCallbacks",
                       name.c_str()),
          base::TimeDelta(),
          "Run animation frame callbacks duration for event (in "
          "microseconds)."),
      duration_dom_update_computed_style(
          StringPrintf("Event.Duration.%s.DOM.UpdateComputedStyle",
                       name.c_str()),
          base::TimeDelta(),
          "UpdateComputedStyle duration for event (in microseconds)."),
      duration_layout_box_tree(
          StringPrintf("Event.Duration.%s.Layout.BoxTree", name.c_str()),
          base::TimeDelta(),
          "Layout box tree duration for event (in microseconds)."),
      duration_layout_box_generation(
          StringPrintf("Event.Duration.%s.Layout.BoxTree.BoxGeneration",
                       name.c_str()),
          base::TimeDelta(),
          "BoxGeneration duration for event (in microseconds)."),
      duration_layout_update_used_sizes(
          StringPrintf("Event.Duration.%s.Layout.BoxTree.UpdateUsedSizes",
                       name.c_str()),
          base::TimeDelta(),
          "UpdateUsedSizes duration for event (in microseconds)."),
      duration_layout_render_and_animate(
          StringPrintf("Event.Duration.%s.Layout.RenderAndAnimate",
                       name.c_str()),
          base::TimeDelta(),
          "RenderAndAnimate duration for event (in microseconds)."),
      duration_renderer_rasterize(
          StringPrintf("Event.Duration.%s.Renderer.Rasterize", name.c_str()),
          base::TimeDelta(), "Rasterize duration for event (in microseconds).")
#if defined(ENABLE_WEBDRIVER)
      ,
      value_dictionary(
          StringPrintf("Event.%s.ValueDictionary", name.c_str()), "{}",
          "All event values represented as a dictionary in a string.")
#endif  // ENABLE_WEBDRIVER
{
}

bool WebModuleStatTracker::IsStopWatchEnabled(int /*id*/) const { return true; }

void WebModuleStatTracker::OnStopWatchStopped(int id,
                                              base::TimeDelta time_elapsed) {
  stop_watch_durations_[static_cast<size_t>(id)] += time_elapsed;
}

void WebModuleStatTracker::EndCurrentEvent(base::TimeTicks event_end_time) {
  if (current_event_type_ == kEventTypeInvalid) {
    return;
  }

  DCHECK(event_is_processing_);
  DCHECK(!current_event_start_time_.is_null());

  // If no render tree was produced by this event, then tracking stops at the
  // end of the event; otherwise, it already stopped when the render tree was
  // produced.
  if (current_event_render_tree_produced_time_.is_null()) {
    dom_stat_tracker_->StopTrackingEvent();
    layout_stat_tracker_->StopTrackingEvent();
  }

  // If a render tree was produced by this event, then the event is ending with
  // the render tree's rasterization; otherwise, there was no rasterization.
  base::TimeDelta renderer_rasterize_duration =
      !current_event_render_tree_produced_time_.is_null()
          ? event_end_time - current_event_render_tree_produced_time_
          : base::TimeDelta();

  EventStats* event_stats = event_stats_list_[current_event_type_];
  event_stats->start_time = current_event_start_time_.ToInternalValue();
  event_stats->produced_render_tree =
      !current_event_render_tree_produced_time_.is_null();

  // Update event counts
  event_stats->count_dom_html_element =
      dom_stat_tracker_->EventCountHtmlElement();
  event_stats->count_dom_html_element_created =
      dom_stat_tracker_->event_count_html_element_created();
  event_stats->count_dom_html_element_destroyed =
      dom_stat_tracker_->event_count_html_element_destroyed();
  event_stats->count_dom_html_element_document =
      dom_stat_tracker_->EventCountHtmlElementDocument();
  event_stats->count_dom_html_element_document_added =
      dom_stat_tracker_->event_count_html_element_document_added();
  event_stats->count_dom_html_element_document_removed =
      dom_stat_tracker_->event_count_html_element_document_removed();
  event_stats->count_dom_update_matching_rules =
      dom_stat_tracker_->event_count_update_matching_rules();
  event_stats->count_dom_update_computed_style =
      dom_stat_tracker_->event_count_update_computed_style();
  event_stats->count_dom_generate_html_element_computed_style =
      dom_stat_tracker_->event_count_generate_html_element_computed_style();
  event_stats->count_dom_generate_pseudo_element_computed_style =
      dom_stat_tracker_->event_count_generate_pseudo_element_computed_style();
  event_stats->count_layout_box = layout_stat_tracker_->EventCountBox();
  event_stats->count_layout_box_created =
      layout_stat_tracker_->event_count_box_created();
  event_stats->count_layout_box_destroyed =
      layout_stat_tracker_->event_count_box_destroyed();
  event_stats->count_layout_update_size =
      layout_stat_tracker_->event_count_update_size();
  event_stats->count_layout_render_and_animate =
      layout_stat_tracker_->event_count_render_and_animate();
  event_stats->count_layout_update_cross_references =
      layout_stat_tracker_->event_count_update_cross_references();

  // Update event durations
  event_stats->duration_total = event_end_time - current_event_start_time_;
  event_stats->duration_dom_dispatch_event =
      stop_watch_durations_[kStopWatchTypeDispatchEvent];
  event_stats->duration_dom_run_animation_frame_callbacks =
      dom_stat_tracker_->GetStopWatchTypeDuration(
          dom::DomStatTracker::kStopWatchTypeRunAnimationFrameCallbacks);
  event_stats->duration_dom_update_computed_style =
      dom_stat_tracker_->GetStopWatchTypeDuration(
          dom::DomStatTracker::kStopWatchTypeUpdateComputedStyle);
  event_stats->duration_layout_box_tree =
      layout_stat_tracker_->GetStopWatchTypeDuration(
          layout::LayoutStatTracker::kStopWatchTypeLayoutBoxTree);
  event_stats->duration_layout_box_generation =
      layout_stat_tracker_->GetStopWatchTypeDuration(
          layout::LayoutStatTracker::kStopWatchTypeBoxGeneration);
  event_stats->duration_layout_update_used_sizes =
      layout_stat_tracker_->GetStopWatchTypeDuration(
          layout::LayoutStatTracker::kStopWatchTypeUpdateUsedSizes);
  event_stats->duration_layout_render_and_animate =
      layout_stat_tracker_->GetStopWatchTypeDuration(
          layout::LayoutStatTracker::kStopWatchTypeRenderAndAnimate);
  event_stats->duration_renderer_rasterize = renderer_rasterize_duration;

#if defined(ENABLE_WEBDRIVER)
  // When the Webdriver is enabled, all of the event's values are stored
  // within a single string representing a dictionary of key-value pairs.
  // This allows the Webdriver to query a single CVal to retrieve all of the
  // event's values.
  std::ostringstream oss;
  oss << "{"
      << "\"StartTime\":" << current_event_start_time_.ToInternalValue() << ", "
      << "\"ProducedRenderTree\":"
      << !current_event_render_tree_produced_time_.is_null() << ", "
      << "\"CntDomEventListeners\":"
      << dom::GlobalStats::GetInstance()->GetNumEventListeners() << ", "
      << "\"CntDomNodes\":" << dom::GlobalStats::GetInstance()->GetNumNodes()
      << ", "
      << "\"CntDomHtmlElements\":" << dom_stat_tracker_->EventCountHtmlElement()
      << ", "
      << "\"CntDomDocumentHtmlElements\":"
      << dom_stat_tracker_->EventCountHtmlElementDocument() << ", "
      << "\"CntDomHtmlElementsCreated\":"
      << dom_stat_tracker_->event_count_html_element_created() << ", "
      << "\"CntDomUpdateMatchingRules\":"
      << dom_stat_tracker_->event_count_update_matching_rules() << ", "
      << "\"CntDomUpdateComputedStyle\":"
      << dom_stat_tracker_->event_count_update_computed_style() << ", "
      << "\"CntDomGenerateHtmlComputedStyle\":"
      << dom_stat_tracker_->event_count_generate_html_element_computed_style()
      << ", "
      << "\"CntDomGeneratePseudoComputedStyle\":"
      << dom_stat_tracker_->event_count_generate_pseudo_element_computed_style()
      << ", "
      << "\"CntLayoutBoxes\":" << layout_stat_tracker_->EventCountBox() << ", "
      << "\"CntLayoutBoxesCreated\":"
      << layout_stat_tracker_->event_count_box_created() << ", "
      << "\"CntLayoutUpdateSize\":"
      << layout_stat_tracker_->event_count_update_size() << ", "
      << "\"CntLayoutRenderAndAnimate\":"
      << layout_stat_tracker_->event_count_render_and_animate() << ", "
      << "\"CntLayoutUpdateCrossReferences\":"
      << layout_stat_tracker_->event_count_update_cross_references() << ", "
      << "\"DurTotalUs\":"
      << (event_end_time - current_event_start_time_).InMicroseconds() << ", "
      << "\"DurDomInjectEventUs\":"
      << stop_watch_durations_[kStopWatchTypeDispatchEvent].InMicroseconds()
      << ", "
      << "\"DurDomRunAnimationFrameCallbacksUs\":"
      << dom_stat_tracker_
             ->GetStopWatchTypeDuration(
                 dom::DomStatTracker::kStopWatchTypeRunAnimationFrameCallbacks)
             .InMicroseconds()
      << ", "
      << "\"DurDomUpdateComputedStyleUs\":"
      << dom_stat_tracker_
             ->GetStopWatchTypeDuration(
                 dom::DomStatTracker::kStopWatchTypeUpdateComputedStyle)
             .InMicroseconds()
      << ", "
      << "\"DurLayoutBoxTreeUs\":"
      << layout_stat_tracker_
             ->GetStopWatchTypeDuration(
                 layout::LayoutStatTracker::kStopWatchTypeLayoutBoxTree)
             .InMicroseconds()
      << ", "
      << "\"DurLayoutBoxTreeBoxGenerationUs\":"
      << layout_stat_tracker_
             ->GetStopWatchTypeDuration(
                 layout::LayoutStatTracker::kStopWatchTypeBoxGeneration)
             .InMicroseconds()
      << ", "
      << "\"DurLayoutBoxTreeUpdateUsedSizesUs\":"
      << layout_stat_tracker_
             ->GetStopWatchTypeDuration(
                 layout::LayoutStatTracker::kStopWatchTypeUpdateUsedSizes)
             .InMicroseconds()
      << ", "
      << "\"DurLayoutRenderAndAnimateUs\":"
      << layout_stat_tracker_
             ->GetStopWatchTypeDuration(
                 layout::LayoutStatTracker::kStopWatchTypeRenderAndAnimate)
             .InMicroseconds()
      << ", "
      << "\"DurRendererRasterizeUs\":"
      << renderer_rasterize_duration.InMicroseconds() << "}";
  event_stats->value_dictionary = oss.str();
#endif  // ENABLE_WEBDRIVER

  event_is_processing_ = false;
  current_event_type_ = kEventTypeInvalid;
}

std::string WebModuleStatTracker::GetEventTypeName(
    WebModuleStatTracker::EventType event_type) {
  switch (event_type) {
    case WebModuleStatTracker::kEventTypeKeyDown:
      return "KeyDown";
    case WebModuleStatTracker::kEventTypeKeyUp:
      return "KeyUp";
    case WebModuleStatTracker::kEventTypePointerDown:
      return "PointerDown";
    case WebModuleStatTracker::kEventTypePointerUp:
      return "PointerUp";
    case WebModuleStatTracker::kEventTypeInvalid:
    case WebModuleStatTracker::kNumEventTypes:
      break;
  }
  NOTREACHED();
  return "Invalid";
}

}  // namespace browser
}  // namespace cobalt