<!DOCTYPE html>
<!--
Copyright (c) 2015 The Chromium Authors. All rights reserved.
Use of this source code is governed by a BSD-style license that can be
found in the LICENSE file.
-->

<link rel="import" href="/core/analysis/analysis_link.html">
<link rel="import" href="/core/analysis/flow_classifier.html">
<link rel="import" href="/core/selection.html">
<link rel="import" href="/base/ui/table.html">
<link rel="import" href="/base/ui/dom_helpers.html">

<polymer-element name="tr-c-a-related-events">
  <template>
    <style>
    :host {
      display: flex;
      flex-direction: column;
    }
    #table {
      flex: 1 1 auto;
      align-self: stretch;
    }
    </style>
    <tr-b-ui-table id="table"></tr-b-ui-table>
  </template>

  <script>
  'use strict';

  Polymer({
    ready: function() {
      this.eventGroups_ = [];

      this.$.table.tableColumns = [
        {
          title: 'Event(s)',
          value: function(row) { return row.type; },
          width: '150px'
        },
        {
          title: 'Link',
          width: '100%',
          value: function(row) {
            var linkEl = document.createElement('tr-c-a-analysis-link');
            if (row.name)
              linkEl.setSelectionAndContent(row.selection, row.name);
            else
              linkEl.selection = row.selection;
            return linkEl;
          }
        }
      ];
    },

    hasRelatedEvents: function() {
      return (this.eventGroups_ && this.eventGroups_.length > 0);
    },

    addRelatedEvents: function(selection) {
      this.addConnectedFlows_(selection);
      this.addConnectedEvents_(selection);
      this.updateContents_();
    },

    addConnectedFlows_: function(selection) {
      var classifier = new tr.c.analysis.FlowClassifier();
      selection.forEach(function(slice) {
        if (slice.inFlowEvents) {
          slice.inFlowEvents.forEach(function(flow) {
            classifier.addInFlow(flow);
          });
        }
        if (slice.outFlowEvents) {
          slice.outFlowEvents.forEach(function(flow) {
            classifier.addOutFlow(flow);
          });
        }
      });
      if (!classifier.hasEvents())
        return;

      var addToEventGroups = function(type, flowEvent) {
        this.eventGroups_.push({
          type: type,
          selection: new tr.c.Selection(flowEvent),
          name: flowEvent.title
        });
      };

      classifier.inFlowEvents.forEach(
          addToEventGroups.bind(this, 'Incoming flow'));
      classifier.outFlowEvents.forEach(
          addToEventGroups.bind(this, 'Outgoing flow'));
      classifier.internalFlowEvents.forEach(
          addToEventGroups.bind(this, 'Internal flow'));
    },

    addConnectedEvents_: function(selection) {
      // Preceding and following events are only well-defined for single
      // selections.
      if (selection.length === 1)
        this.addConnectedEventsForSlice_(selection[0]);
      else
        this.addConnectedEventsForSelection_(selection);
    },

    addConnectedEventsForSlice_: function(slice) {
      var precedingEventsSelection = undefined;
      var followingEventsSelection = undefined;
      if (slice.inFlowEvents && slice.inFlowEvents.length !== 0) {
        precedingEventsSelection = new tr.c.Selection();
        this.recursivelyAddConnectedEvents_(precedingEventsSelection, {}, slice,
            function(event) { return event.inFlowEvents; });
        this.eventGroups_.push({
          type: 'Preceding events',
          selection: precedingEventsSelection
        });
      }
      if (slice.outFlowEvents && slice.outFlowEvents.length !== 0) {
        followingEventsSelection = new tr.c.Selection();
        this.recursivelyAddConnectedEvents_(followingEventsSelection, {}, slice,
            function(event) { return event.outFlowEvents; });
        this.eventGroups_.push({
          type: 'Following events',
          selection: followingEventsSelection
        });
      }
      if (precedingEventsSelection && followingEventsSelection) {
        var allEventsSelection = new tr.c.Selection();
        for (var i = 0; i < precedingEventsSelection.length; ++i)
          allEventsSelection.push(precedingEventsSelection[i]);
        // Do not add the first event of followingEventsSelection since it's
        // the slice too.
        for (var i = 1; i < followingEventsSelection.length; ++i)
          allEventsSelection.push(followingEventsSelection[i]);
        this.eventGroups_.push({
          type: 'All connected events',
          selection: allEventsSelection
        });
      }
    },

    addConnectedEventsForSelection_: function(selection) {
      var eventIds = {};
      var allEventsSelection = new tr.c.Selection();
      selection.forEach(function(slice) {
        this.recursivelyAddConnectedEvents_(allEventsSelection, eventIds, slice,
            function(event) {
              var flows = [];
              if (event.inFlowEvents)
                flows = flows.concat(event.inFlowEvents);
              if (event.outFlowEvents)
                flows = flows.concat(event.outFlowEvents);
              return flows;
            });
      }.bind(this));
      // Add related events if it contains more than the original selection.
      if (allEventsSelection.length > selection.length) {
        this.eventGroups_.push({
          type: 'All connected events',
          selection: allEventsSelection
        });
      }
    },

    updateContents_: function() {
      var table = this.$.table;
      if (this.eventGroups_ === undefined)
        table.tableRows = [];
      else
        table.tableRows = this.eventGroups_.slice();
      table.rebuild();
    },

    recursivelyAddConnectedEvents_: function(selection, eventIds, event,
                                             getFlows) {
      if (!event || eventIds[event.guid])
        return;
      eventIds[event.guid] = true;
      selection.push(event);
      var flowEvents = getFlows(event);
      if (!flowEvents)
        return;
      for (var i = 0; i < flowEvents.length; ++i) {
        selection.push(flowEvents[i]);
        this.recursivelyAddConnectedEvents_(selection, eventIds,
            flowEvents[i].startSlice, getFlows);
        this.recursivelyAddConnectedEvents_(selection, eventIds,
            flowEvents[i].endSlice, getFlows);
      }
    }
  });
  </script>
</polymer-element>