bility;
export function parseString(field) { return field };
export const parseVarArgs = 'parse-var-args';

/**
 * Base class for processing log files.
 *
 * @param {boolean} timedRange Ignore ticks outside timed range.
 * @param {boolean} pairwiseTimedRange Ignore ticks outside pairs of timer
 *     markers.
 * @constructor
 */
export class LogReader {
  constructor(timedRange=false, pairwiseTimedRange=false) {
    this.dispatchTable_ = new Map();
    this.timedRange_ = timedRange;
    this.pairwiseTimedRange_ = pairwiseTimedRange;
    if (pairwiseTimedRange) this.timedRange_ = true;
    this.lineNum_ = 0;
    this.csvParser_ = new CsvParser();
    // Variables for tracking of 'current-time' log entries:
    this.hasSeenTimerMarker_ = false;
    this.logLinesSinceLastTimerMarker_ = [];
  }

/**
 * @param {Object} table A table used for parsing and processing
 *     log records.
 *     exampleDispatchTable = {
 *       "log-entry-XXX": {
 *          parser: [parseString, parseInt, ..., parseVarArgs],
 *          processor: this.processXXX.bind(this)
 *        },
 *        ...
 *      }
 */
  setDispatchTable(table) {
    if (Object.getPrototypeOf(table) !== null) {
      throw new Error("Dispatch expected table.__proto__=null for speedup");
    }
    for (let name in table) {
      const parser = table[name];
      if (parser === undefined) continue;
      if (!parser.isAsync) parser.isAsync = false;
      if (!Array.isArray(parser.parsers)) {
        throw new Error(`Invalid parsers: dispatchTable['${
            name}'].parsers should be an Array.`);
      }
      let type = typeof parser.processor;
      if (type !== 'function') {
       throw new Error(`Invalid processor: typeof dispatchTable['${
          name}'].processor is '${type}' instead of 'function'`);
      }
      if (!parser.processor.name.startsWith('bound ')) {
        parser.processor = parser.processor.bind(this);
      }
      this.dispatchTable_.set(name, parser);
    }
  }


  /**
   * A thin wrapper around shell's 'read' function showing a file name on error.
   */
  readFile(fileName) {
    try {
      return read(fileName);
    } catch (e) {
      printErr(`file="${fileName}": ${e.message || e}`);
      throw e;
    }
  }

  /**
   * Used for printing error messages.
   *
   * @param {string} str Error message.
   */
  printError(str) {
    // Do nothing.
  }

  /**
   * Processes a portion of V8 profiler event log.
   *
   * @param {string} chunk A portion of log.
   */
  async processLogChunk(chunk) {
    let end = chunk.length;
    let current = 0;
    // Kept for debugging in case of parsing errors.
    let lineNumber = 0;
    while (current < end) {
      const next = chunk.indexOf("\n", current);
      if (next === -1) break;
      lineNumber++;
      const line = chunk.substring(current, next);
      current = next + 1;
      await this.processLogLine(line);
    }
  }

  /**
   * Processes a line of V8 profiler event log.
   *
   * @param {string} line A line of log.
   */
  async processLogLine(line) {
    if (!this.timedRange_) {
      await this.processLogLine_(line);
      return;
    }
    if (line.startsWith("current-time")) {
      if (this.hasSeenTimerMarker_) {
        await this.processLog_(this.logLinesSinceLastTimerMarker_);
        this.logLinesSinceLastTimerMarker_ = [];
        // In pairwise mode, a "current-time" line ends the timed range.
        if (this.pairwiseTimedRange_) {
          this.hasSeenTimerMarker_ = false;
        }
      } else {
        this.hasSeenTimerMarker_ = true;
      }
    } else {
      if (this.hasSeenTimerMarker_) {
        this.logLinesSinceLastTimerMarker_.push(line);
      } else if (!line.startsWith("tick")) {
        await this.processLogLine_(line);
      }
    }
  }

  /**
   * Processes stack record.
   *
   * @param {number} pc Program counter.
   * @param {number} func JS Function.
   * @param {Array.<string>} stack String representation of a stack.
   * @return {Array.<number>} Processed stack.
   */
  processStack(pc, func, stack) {
    const fullStack = func ? [pc, func] : [pc];
    let prevFrame = pc;
    const length = stack.length;
    for (let i = 0, n = length; i < n; ++i) {
      const frame = stack[i];
      const firstChar = frame[0];
      if (firstChar === '+' || firstChar === '-') {
        // An offset from the previous frame.
        prevFrame += parseInt(frame, 16);
        fullStack.push(prevFrame);
      // Filter out possible 'overflow' string.
      } else if (firstChar !== 'o') {
        fullStack.push(parseInt(frame, 16));
      } else {
        console.error(`Dropping unknown tick frame: ${frame}`);
      }
    }
    return fullStack;
  }

  /**
   * Does a dispatch of a log record.
   *
   * @param {Array.<string>} fields Log record.
   * @private
   */
  async dispatchLogRow_(fields) {
    // Obtain the dispatch.
    const command = fields[0];
    const dispatch = this.dispatchTable_.get(command);
    if (dispatch === undefined) return;
    const parsers = dispatch.parsers;
    const length = parsers.length;
    // Parse fields.
    const parsedFields = new Array(length);
    for (let i = 0; i < length; ++i) {
      const parser = parsers[i];
      if (parser === parseVarArgs) {
        parsedFields[i] = fields.slice(1 + i);
        break;
      } else {
        parsedFields[i] = parser(fields[1 + i]);
      }
    }
    // Run the processor.
    await dispatch.processor(...parsedFields);
  }

  /**
   * Processes log lines.
   *
   * @param {Array.<string>} lines Log lines.
   * @private
   */
  async processLog_(lines) {
    for (let i = 0, n = lines.length; i < n; ++i) {
      await this.processLogLine_(lines[i]);
    }
  }

  /**
   * Processes a single log line.
   *
   * @param {String} a log line
   * @private
   */
  async processLogLine_(line) {
    if (line.length > 0) {
      try {
        const fields = this.csvParser_.parseLine(line);
        await this.dispatchLogRow_(fields);
      } catch (e) {
        this.printError(`line ${this.lineNum_ + 1}: ${e.message || e}\n${e.stack}`);
      }
    }
    this.lineNum_++;
  }
}
