<!DOCTYPE html>
<!--
Copyright 2016 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="/tracing/model/event_set.html">
<link rel="import" href="/tracing/value/diagnostics/diagnostic.html">
<link rel="import" href="/tracing/value/diagnostics/event_ref.html">

<script>
'use strict';

tr.exportTo('tr.v.d', function() {
  /**
   * @typedef {!(tr.v.d.EventRef|tr.model.Event)} EventLike
   */

  /**
   * A RelatedEventSet diagnostic contains references to Events
   */
  class RelatedEventSet extends tr.v.d.Diagnostic {
    /**
     * @param {!(tr.model.EventSet|Array.<EventLike>|EventLike)=} opt_events
     */
    constructor(opt_events) {
      super();
      this.eventsByStableId_ = new Map();
      if (opt_events) {
        if (opt_events instanceof tr.model.EventSet ||
            opt_events instanceof Array) {
          for (var event of opt_events)
            this.add(event);
        } else {
          this.add(opt_events);
        }
      }
    }

    /**
     * @param {!(tr.v.d.EventRef|tr.model.Event)} event
     */
    add(event) {
      this.eventsByStableId_.set(event.stableId, event);
    }

    /**
     * @param {!(tr.v.d.EventRef|tr.model.Event)} event
     * @return {boolean}
     */
    has(event) {
      return this.eventsByStableId_.has(event.stableId);
    }

    get length() {
      return this.eventsByStableId_.size;
    }

    *[Symbol.iterator]() {
      for (var [stableId, event] of this.eventsByStableId_)
        yield event;
    }

    /**
     * Resolve all EventRefs into Events by finding their stableIds in |model|.
     * If a stableId cannot be found and |opt_required| is true, then throw an
     * Error.
     * If a stableId cannot be found and |opt_required| is false, then the
     * EventRef will remain an EventRef.
     *
     * @param {!tr.model.Model} model
     * @param {boolean=} opt_required
     */
    resolve(model, opt_required) {
      for (var [stableId, event] of this.eventsByStableId_) {
        if (!(event instanceof tr.v.d.EventRef))
          continue;

        event = model.getEventByStableId(stableId);
        if (event instanceof tr.model.Event)
          this.eventsByStableId_.set(stableId, event);
        else if (opt_required)
          throw new Error('Unable to find Event ' + stableId);
      }
    }

    asDictInto_(d) {
      d.events = [];
      for (var event of this) {
        d.events.push({
          stableId: event.stableId,
          title: event.title,
          start: event.start,
          duration: event.duration
        });
      }
    }

    static fromDict(d) {
      return new RelatedEventSet(d.events.map(
          event => new tr.v.d.EventRef(event)));
    }
  }

  tr.v.d.Diagnostic.register(RelatedEventSet, {
    elementName: 'tr-v-ui-related-event-set-span'
  });

  return {
    RelatedEventSet: RelatedEventSet
  };
});
</script>