/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
"use strict";

const {
  flatten,
} = require("resource://devtools/shared/ThreadSafeDevToolsUtils.js");

/*** Visitor ****************************************************************/

/**
 * A Visitor visits each node and edge of a census report tree as the census
 * report is being traversed by `walk`.
 */
class Visitor {
  /**
   * The `enter` method is called when a new sub-report is entered in traversal.
   *
   * @param {object} breakdown
   *        The breakdown for the sub-report that is being entered by traversal.
   *
   * @param {object} report
   *        The report generated by the given breakdown.
   *
   * @param {any} edge
   *        The edge leading to this sub-report. The edge is null if (but not iff!
   *        eg, null allocation stack edges) we are entering the root report.
   */
  enter() {}
  /**
   * The `exit` method is called when traversal of a sub-report has finished.
   *
   * @param {object} breakdown
   *        The breakdown for the sub-report whose traversal has finished.
   *
   * @param {object} report
   *        The report generated by the given breakdown.
   *
   * @param {any} edge
   *        The edge leading to this sub-report. The edge is null if (but not iff!
   *        eg, null allocation stack edges) we are entering the root report.
   */
  exit() {}
  /**
   * The `count` method is called when leaf nodes (reports whose breakdown is
   * by: "count") in the report tree are encountered.
   *
   * @param {object} breakdown
   *        The count breakdown for this report.
   *
   * @param {object} report
   *        The report generated by a breakdown by "count".
   *
   * @param {any|null} edge
   *        The edge leading to this count report. The edge is null if we are
   *        entering the root report.
   */
  count() {}
}
exports.Visitor = Visitor;

/*** getReportEdges *********************************************************/

const EDGES = Object.create(null);

EDGES.count = function () {
  return [];
};

EDGES.bucket = function () {
  return [];
};

EDGES.internalType = function (breakdown, report) {
  return Object.keys(report).map(key => ({
    edge: key,
    referent: report[key],
    breakdown: breakdown.then,
  }));
};

EDGES.descriptiveType = function (breakdown, report) {
  return Object.keys(report).map(key => ({
    edge: key,
    referent: report[key],
    breakdown: breakdown.then,
  }));
};

EDGES.objectClass = function (breakdown, report) {
  return Object.keys(report).map(key => ({
    edge: key,
    referent: report[key],
    breakdown: key === "other" ? breakdown.other : breakdown.then,
  }));
};

EDGES.coarseType = function (breakdown, report) {
  return [
    { edge: "objects", referent: report.objects, breakdown: breakdown.objects },
    { edge: "scripts", referent: report.scripts, breakdown: breakdown.scripts },
    { edge: "strings", referent: report.strings, breakdown: breakdown.strings },
    { edge: "other", referent: report.other, breakdown: breakdown.other },
    { edge: "domNode", referent: report.domNode, breakdown: breakdown.domNode },
  ];
};

EDGES.allocationStack = function (breakdown, report) {
  const edges = [];
  report.forEach((value, key) => {
    edges.push({
      edge: key,
      referent: value,
      breakdown: key === "noStack" ? breakdown.noStack : breakdown.then,
    });
  });
  return edges;
};

EDGES.filename = function (breakdown, report) {
  return Object.keys(report).map(key => ({
    edge: key,
    referent: report[key],
    breakdown: key === "noFilename" ? breakdown.noFilename : breakdown.then,
  }));
};

/**
 * Get the set of outgoing edges from `report` as specified by the given
 * breakdown.
 *
 * @param {object} breakdown
 *        The census breakdown.
 *
 * @param {object} report
 *        The census report.
 */
function getReportEdges(breakdown, report) {
  return EDGES[breakdown.by](breakdown, report);
}
exports.getReportEdges = getReportEdges;

/*** walk *******************************************************************/

function recursiveWalk(breakdown, edge, report, visitor) {
  if (breakdown.by === "count") {
    visitor.enter(breakdown, report, edge);
    visitor.count(breakdown, report, edge);
    visitor.exit(breakdown, report, edge);
  } else {
    visitor.enter(breakdown, report, edge);
    for (const {
      edge: ed,
      referent,
      breakdown: subBreakdown,
    } of getReportEdges(breakdown, report)) {
      recursiveWalk(subBreakdown, ed, referent, visitor);
    }
    visitor.exit(breakdown, report, edge);
  }
}

/**
 * Walk the given `report` that was generated by taking a census with the
 * specified `breakdown`.
 *
 * @param {object} breakdown
 *        The census breakdown.
 *
 * @param {object} report
 *        The census report.
 *
 * @param {Visitor} visitor
 *        The Visitor instance to call into while traversing.
 */
function walk(breakdown, report, visitor) {
  recursiveWalk(breakdown, null, report, visitor);
}
exports.walk = walk;

/*** diff *******************************************************************/

/**
 * Return true if the object is a Map, false otherwise. Works with Map objects
 * from other globals, unlike `instanceof`.
 *
 * @returns {boolean}
 */
function isMap(obj) {
  return Object.prototype.toString.call(obj) === "[object Map]";
}

const basisTotalBytes = (exports.basisTotalBytes = Symbol("basisTotalBytes"));
const basisTotalCount = (exports.basisTotalCount = Symbol("basisTotalCount"));

/**
 * A Visitor for computing the difference between the census report being
 * traversed and the given other census.
 */
class DiffVisitor extends Visitor {
  /**
   * @param {object} otherCensus
   *        The other census report.
   */
  constructor(otherCensus) {
    super();

    // The other census we are comparing against.
    this._otherCensus = otherCensus;

    // The total bytes and count of the basis census we are traversing.
    this._totalBytes = 0;
    this._totalCount = 0;

    // Stack maintaining the current corresponding sub-report for the other
    // census we are comparing against.
    this._otherCensusStack = [];

    // Stack maintaining the set of edges visited at each sub-report.
    this._edgesVisited = [new Set()];

    // The final delta census. Valid only after traversal.
    this._results = null;

    // Stack maintaining the results corresponding to each sub-report we are
    // currently traversing.
    this._resultsStack = [];
  }
  /**
   * Given a report and an outgoing edge, get the edge's referent.
   */
  _get(report, edge) {
    if (!report) {
      return undefined;
    }
    return isMap(report) ? report.get(edge) : report[edge];
  }
  /**
   * Given a report, an outgoing edge, and a value, set the edge's referent to
   * the given value.
   */
  _set(report, edge, val) {
    if (isMap(report)) {
      report.set(edge, val);
    } else {
      report[edge] = val;
    }
  }
  /**
   * @override
   */
  enter(breakdown, report, edge) {
    const newResults = breakdown.by === "allocationStack" ? new Map() : {};
    let newOther;

    if (!this._results) {
      // This is the first time we have entered a sub-report.
      this._results = newResults;
      newOther = this._otherCensus;
    } else {
      const topResults = this._resultsStack[this._resultsStack.length - 1];
      this._set(topResults, edge, newResults);

      const topOther =
        this._otherCensusStack[this._otherCensusStack.length - 1];
      newOther = this._get(topOther, edge);
    }

    this._resultsStack.push(newResults);
    this._otherCensusStack.push(newOther);

    const visited = this._edgesVisited[this._edgesVisited.length - 1];
    visited.add(edge);
    this._edgesVisited.push(new Set());
  }
  /**
   * @override
   */
  exit(breakdown) {
    // Find all the edges in the other census report that were not traversed and
    // add them to the results directly.
    const other = this._otherCensusStack[this._otherCensusStack.length - 1];
    if (other) {
      const visited = this._edgesVisited[this._edgesVisited.length - 1];
      const unvisited = getReportEdges(breakdown, other)
        .map(e => e.edge)
        .filter(e => !visited.has(e));
      const results = this._resultsStack[this._resultsStack.length - 1];
      for (const edg of unvisited) {
        this._set(results, edg, this._get(other, edg));
      }
    }

    this._otherCensusStack.pop();
    this._resultsStack.pop();
    this._edgesVisited.pop();
  }
  /**
   * @override
   */
  count(breakdown, report) {
    const other = this._otherCensusStack[this._otherCensusStack.length - 1];
    const results = this._resultsStack[this._resultsStack.length - 1];

    if (breakdown.count) {
      this._totalCount += report.count;
    }
    if (breakdown.bytes) {
      this._totalBytes += report.bytes;
    }

    if (other) {
      if (breakdown.count) {
        results.count = other.count - report.count;
      }
      if (breakdown.bytes) {
        results.bytes = other.bytes - report.bytes;
      }
    } else {
      if (breakdown.count) {
        results.count = -report.count;
      }
      if (breakdown.bytes) {
        results.bytes = -report.bytes;
      }
    }
  }

  /**
   * Get the resulting report of the difference between the traversed census
   * report and the other census report.
   *
   * @returns {object}
   *          The delta census report.
   */
  results() {
    if (!this._results) {
      throw new Error("Attempt to get results before computing diff!");
    }

    if (this._resultsStack.length) {
      throw new Error("Attempt to get results while still computing diff!");
    }

    this._results[basisTotalBytes] = this._totalBytes;
    this._results[basisTotalCount] = this._totalCount;

    return this._results;
  }
}

/**
 * Take the difference between two censuses. The resulting delta report
 * contains the number/size of things that are in the `endCensus` that are not
 * in the `startCensus`.
 *
 * @param {object} breakdown
 *        The breakdown used to generate both census reports.
 *
 * @param {object} startCensus
 *        The first census report.
 *
 * @param {object} endCensus
 *        The second census report.
 *
 * @returns {object}
 *          A delta report mirroring the structure of the two census reports (as
 *          specified by the given breakdown). Has two additional properties:
 *            - {Number} basisTotalBytes: the total number of bytes in the start
 *                                        census.
 *            - {Number} basisTotalCount: the total count in the start census.
 */
function diff(breakdown, startCensus, endCensus) {
  const visitor = new DiffVisitor(endCensus);
  walk(breakdown, startCensus, visitor);
  return visitor.results();
}
exports.diff = diff;

/**
 * Creates a hash map mapping node IDs to its parent node.
 *
 * @param {CensusTreeNode} node
 * @param {{[key: number]: TreeNode}} aggregator
 *
 * @return {{[key: number]: TreeNode}}
 */
const createParentMap = function (node, getId = n => n.id, aggregator = {}) {
  if (node.children) {
    for (let i = 0, length = node.children.length; i < length; i++) {
      const child = node.children[i];
      aggregator[getId(child)] = node;
      createParentMap(child, getId, aggregator);
    }
  }
  return aggregator;
};
exports.createParentMap = createParentMap;

const BUCKET = Object.freeze({ by: "bucket" });

/**
 * Convert a breakdown whose leaves are { by: "count" } to an identical
 * breakdown, except with { by: "bucket" } leaves.
 *
 * @param {object} breakdown
 * @returns {object}
 */
exports.countToBucketBreakdown = function (breakdown) {
  if (typeof breakdown !== "object" || !breakdown) {
    return breakdown;
  }

  if (breakdown.by === "count") {
    return BUCKET;
  }

  const keys = Object.keys(breakdown);
  const vals = keys.reduce((vs, k) => {
    vs.push(exports.countToBucketBreakdown(breakdown[k]));
    return vs;
  }, []);

  const result = {};
  for (let i = 0, length = keys.length; i < length; i++) {
    result[keys[i]] = vals[i];
  }

  return Object.freeze(result);
};

/**
 * A Visitor for finding report leaves by their DFS index.
 */
class GetLeavesVisitor extends Visitor {
  constructor(targetIndices) {
    super();

    this._index = -1;
    this._targetIndices = targetIndices;
    this._leaves = [];
  }
  /**
   * @override
   */
  enter(breakdown, report) {
    this._index++;
    if (this._targetIndices.has(this._index)) {
      this._leaves.push(report);
    }
  }
  /**
   * Get the accumulated report leaves after traversal.
   */
  leaves() {
    if (this._index === -1) {
      throw new Error("Attempt to call `leaves` before traversing report!");
    }
    return this._leaves;
  }
}

/**
 * Given a set of indices of leaves in a pre-order depth-first traversal of the
 * given census report, return the leaves.
 *
 * @param {Set<number>} indices
 * @param {object} breakdown
 * @param {object} report
 *
 * @returns {Array<object>}
 */
exports.getReportLeaves = function (indices, breakdown, report) {
  const visitor = new GetLeavesVisitor(indices);
  walk(breakdown, report, visitor);
  return visitor.leaves();
};

/**
 * Get a list of the individual node IDs that belong to the census report leaves
 * of the given indices.
 *
 * @param {Set<number>} indices
 * @param {object} breakdown
 * @param {HeapSnapshot} snapshot
 *
 * @returns {Array<NodeId>}
 */
exports.getCensusIndividuals = function (indices, countBreakdown, snapshot) {
  const bucketBreakdown = exports.countToBucketBreakdown(countBreakdown);
  const bucketReport = snapshot.takeCensus({ breakdown: bucketBreakdown });
  const buckets = exports.getReportLeaves(
    indices,
    bucketBreakdown,
    bucketReport
  );
  return flatten(buckets);
};
