// Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.

library heap_profile_element;

import 'dart:async';
import 'dart:html';
import 'observatory_element.dart';
import 'package:charted/charted.dart';
import 'package:observatory/app.dart';
import 'package:observatory/service.dart';
import 'package:observatory/elements.dart';
import 'package:polymer/polymer.dart';

class ClassSortedTable extends SortedTable {

  ClassSortedTable(columns) : super(columns);

  @override
  dynamic getSortKeyFor(int row, int col) {
    if (col == 0) {
      // Use class name as sort key.
      return rows[row].values[col].name;
    }
    return super.getSortKeyFor(row, col);
  }
}

@CustomTag('heap-profile')
class HeapProfileElement extends ObservatoryElement {
  @observable String lastServiceGC = '---';
  @observable String lastAccumulatorReset = '---';

  // Pie chart of new space usage.
  var _newPieChart;
  final _newPieChartRows = [];
  // Pie chart of old space usage.
  var _oldPieChart;
  final _oldPieChartRows = [];

  @observable ClassSortedTable classTable;
  var _classTableBody;

  @published bool autoRefresh = false;
  var _subscriptionFuture;

  @published Isolate isolate;
  @observable ServiceMap profile;

  final _pieChartColumns = [
      new ChartColumnSpec(label: 'Type', type: ChartColumnSpec.TYPE_STRING),
      new ChartColumnSpec(label: 'Size', formatter: (v) => v.toString())
  ];

  HeapProfileElement.created() : super.created() {
    _initPieChartData(_newPieChartRows);
    _initPieChartData(_oldPieChartRows);

    // Create class table model.
    var columns = [
      new SortedTableColumn('Class'),
      new SortedTableColumn(''),  // Spacer column.
      new SortedTableColumn.withFormatter('Accumulated Size (New)',
                                          Utils.formatSize),
      new SortedTableColumn.withFormatter('Accumulated Instances',
                                          Utils.formatCommaSeparated),
      new SortedTableColumn.withFormatter('Current Size',
                                          Utils.formatSize),
      new SortedTableColumn.withFormatter('Current Instances',
                                          Utils.formatCommaSeparated),
      new SortedTableColumn(''),  // Spacer column.
      new SortedTableColumn.withFormatter('Accumulator Size (Old)',
                                          Utils.formatSize),
      new SortedTableColumn.withFormatter('Accumulator Instances',
                                          Utils.formatCommaSeparated),
      new SortedTableColumn.withFormatter('Current Size',
                                          Utils.formatSize),
      new SortedTableColumn.withFormatter('Current Instances',
                                          Utils.formatCommaSeparated)
    ];
    classTable = new ClassSortedTable(columns);
    // By default, start with accumulated new space bytes.
    classTable.sortColumnIndex = 2;
  }

  LayoutArea _makePieChart(String id, List rows) {
    var wrapper = shadowRoot.querySelector(id);
    var areaHost = wrapper.querySelector('.chart-host');
    assert(areaHost != null);
    var legendHost = wrapper.querySelector('.chart-legend-host');
    assert(legendHost != null);
    var series = new ChartSeries(id, [1], new PieChartRenderer(
      sortDataByValue: false
    ));
    var config = new ChartConfig([series], [0]);
    config.minimumSize = new Rect(300, 300);
    config.legend = new ChartLegend(legendHost, showValues: true);
    var data = new ChartData(_pieChartColumns, rows);
    var area = new LayoutArea(areaHost,
                              data,
                              config,
                              state: new ChartState(),
                              autoUpdate: false);
    area.addChartBehavior(new Hovercard());
    area.addChartBehavior(new AxisLabelTooltip());
    return area;
  }

  @override
  void attached() {
    super.attached();
    _newPieChart = _makePieChart('#new-pie-chart', _newPieChartRows);
    _oldPieChart = _makePieChart('#old-pie-chart', _oldPieChartRows);
    _classTableBody = shadowRoot.querySelector('#classTableBody');
    _subscriptionFuture =
        app.vm.listenEventStream(VM.kGCStream, _onEvent);
  }

  @override
  void detached() {
    cancelFutureSubscription(_subscriptionFuture);
    _subscriptionFuture = null;
    super.detached();
  }

  // Keep at most one outstanding auto-refresh RPC.
  bool refreshAutoPending = false;
  bool refreshAutoQueued = false;

  void _onEvent(ServiceEvent event) {
    assert(event.kind == 'GC');
    if (autoRefresh) {
      if (!refreshAutoPending) {
        refreshAuto();
      } else {
        // Remember to refresh once more, to ensure latest profile.
        refreshAutoQueued = true;
      }
    }
  }

  void refreshAuto() {
    refreshAutoPending = true;
    refreshAutoQueued = false;
    refresh().then((_) {
      refreshAutoPending = false;
      // Keep refreshing if at least one GC event was received while waiting.
      if (refreshAutoQueued) {
        refreshAuto();
      }
    }).catchError(app.handleException);
  }

  static const _USED_INDEX = 0;
  static const _FREE_INDEX = 1;
  static const _EXTERNAL_INDEX = 2;

  static const _LABEL_INDEX = 0;
  static const _VALUE_INDEX = 1;

  void _initPieChartData(List rows) {
    rows.add(['Used', 0]);
    rows.add(['Free', 0]);
    rows.add(['External', 0]);
  }

  void _updatePieChartData(List rows, HeapSpace space) {
    rows[_USED_INDEX][_VALUE_INDEX] = space.used;
    rows[_FREE_INDEX][_VALUE_INDEX] = space.capacity - space.used;
    rows[_EXTERNAL_INDEX][_VALUE_INDEX] = space.external;
  }

  void _updatePieCharts() {
    assert(profile != null);
    _updatePieChartData(_newPieChartRows, isolate.newSpace);
    _updatePieChartData(_oldPieChartRows, isolate.oldSpace);
  }

  void _updateClasses() {
    for (ServiceMap clsAllocations in profile['members']) {
      Class cls = clsAllocations['class'];
      if (cls == null) {
        continue;
      }
      cls.newSpace.update(clsAllocations['new']);
      cls.oldSpace.update(clsAllocations['old']);
    }
  }

  void _updateClassTable() {
    classTable.clearRows();
    for (ServiceMap clsAllocations in profile['members']) {
      Class cls = clsAllocations['class'];
      if (cls == null) {
        continue;
      }
      if (cls.hasNoAllocations) {
        // If a class has no allocations, don't display it.
        continue;
      }
      var row = [cls,
                 '',  // Spacer column.
                 cls.newSpace.accumulated.bytes,
                 cls.newSpace.accumulated.instances,
                 cls.newSpace.current.bytes,
                 cls.newSpace.current.instances,
                 '', // Spacer column.
                 cls.oldSpace.accumulated.bytes,
                 cls.oldSpace.accumulated.instances,
                 cls.oldSpace.current.bytes,
                 cls.oldSpace.current.instances];
      classTable.addRow(new SortedTableRow(row));
    }
    classTable.sort();
  }

  void _addClassTableDomRow() {
    assert(_classTableBody != null);
    var tr = new TableRowElement();

    // Add class ref.
    var cell = tr.insertCell(-1);
    ClassRefElement classRef = new Element.tag('class-ref');
    cell.children.add(classRef);

    // Add spacer.
    cell = tr.insertCell(-1);
    cell.classes.add('left-border-spacer');

    // Add new space.
    cell = tr.insertCell(-1);
    cell = tr.insertCell(-1);
    cell = tr.insertCell(-1);
    cell = tr.insertCell(-1);

    // Add spacer.
    cell = tr.insertCell(-1);
    cell.classes.add('left-border-spacer');

    // Add old space.
    cell = tr.insertCell(-1);
    cell = tr.insertCell(-1);
    cell = tr.insertCell(-1);
    cell = tr.insertCell(-1);

    // Add row to table.
    _classTableBody.children.add(tr);
  }

  void _fillClassTableDomRow(TableRowElement tr, int rowIndex) {
    const SPACER_COLUMNS = const [1, 6];

    var row = classTable.rows[rowIndex];
    // Add class ref.
    ClassRefElement classRef = tr.children[0].children[0];
    classRef.ref = row.values[0];

    for (var i = 1; i < row.values.length; i++) {
      if (SPACER_COLUMNS.contains(i)) {
        // Skip spacer columns.
        continue;
      }
      var cell = tr.children[i];
      cell.title = row.values[i].toString();
      cell.text = classTable.getFormattedValue(rowIndex, i);
      if (i > 1) {  // Numbers.
        cell.style.textAlign = 'right';
        cell.style.paddingLeft = '1em';
      }
    }
  }

  void _updateClassTableInDom() {
    assert(_classTableBody != null);
    // Resize DOM table.
    if (_classTableBody.children.length > classTable.sortedRows.length) {
      // Shrink the table.
      var deadRows =
          _classTableBody.children.length - classTable.sortedRows.length;
      for (var i = 0; i < deadRows; i++) {
        _classTableBody.children.removeLast();
      }
    } else if (_classTableBody.children.length < classTable.sortedRows.length) {
      // Grow table.
      var newRows =
          classTable.sortedRows.length - _classTableBody.children.length;
      for (var i = 0; i < newRows; i++) {
        _addClassTableDomRow();
      }
    }
    assert(_classTableBody.children.length == classTable.sortedRows.length);
    // Fill table.
    for (var i = 0; i < classTable.sortedRows.length; i++) {
      var rowIndex = classTable.sortedRows[i];
      var tr = _classTableBody.children[i];
      _fillClassTableDomRow(tr, rowIndex);
    }
  }

  void _drawCharts() {
    _newPieChart.draw();
    _oldPieChart.draw();
  }

  @observable void changeSort(Event e, var detail, Element target) {
    if (target is TableCellElement) {
      if (classTable.sortColumnIndex != target.cellIndex) {
        classTable.sortColumnIndex = target.cellIndex;
        classTable.sortDescending = true;
      } else {
        classTable.sortDescending = !classTable.sortDescending;
      }
      classTable.sort();
      _updateClassTableInDom();
    }
  }

  void isolateChanged(oldValue) {
    if (isolate == null) {
      profile = null;
      return;
    }
    isolate.invokeRpc('_getAllocationProfile', {})
      .then(_update)
      .catchError(app.handleException);
  }

  Future refresh() {
    if (isolate == null) {
      return new Future.value(null);
    }
    return isolate.invokeRpc('_getAllocationProfile', {})
        .then(_update);
  }

  Future refreshGC() {
    if (isolate == null) {
      return new Future.value(null);
    }
    return isolate.invokeRpc('_getAllocationProfile', { 'gc': 'full' })
        .then(_update);
  }

  Future resetAccumulator() {
    if (isolate == null) {
      return new Future.value(null);
    }
    return isolate.invokeRpc('_getAllocationProfile', { 'reset': 'true' })
        .then(_update);
  }

  void _update(ServiceMap newProfile) {
    profile = newProfile;
  }

  void profileChanged(oldValue) {
    if (profile == null) {
      return;
    }
    isolate.updateHeapsFromMap(profile['heaps']);
    var millis = int.parse(profile['dateLastAccumulatorReset']);
    if (millis != 0) {
      lastAccumulatorReset =
              new DateTime.fromMillisecondsSinceEpoch(millis).toString();
    }
    millis = int.parse(profile['dateLastServiceGC']);
    if (millis != 0) {
      lastServiceGC =
              new DateTime.fromMillisecondsSinceEpoch(millis).toString();
    }
    _updatePieCharts();
    _updateClasses();
    _updateClassTable();
    _updateClassTableInDom();
    _drawCharts();
    notifyPropertyChange(#formattedAverage, 0, 1);
    notifyPropertyChange(#formattedTotalCollectionTime, 0, 1);
    notifyPropertyChange(#formattedCollections, 0, 1);
  }

  @observable String formattedAverage(bool newSpace) {
    if (profile == null) {
      return '';
    }
    var heap = newSpace ? isolate.newSpace : isolate.oldSpace;
    var avg = ((heap.totalCollectionTimeInSeconds * 1000.0) / heap.collections);
    return '${avg.toStringAsFixed(2)} ms';
  }

  @observable String formattedCollections(bool newSpace) {
    if (profile == null) {
      return '';
    }
    var heap = newSpace ? isolate.newSpace : isolate.oldSpace;
    return heap.collections.toString();
  }

  @observable String formattedTotalCollectionTime(bool newSpace) {
    if (profile == null) {
      return '';
    }
    var heap = newSpace ? isolate.newSpace : isolate.oldSpace;
    return '${Utils.formatSeconds(heap.totalCollectionTimeInSeconds)} secs';
  }
}