/* -*- Mode: js; js-indent-level: 2; -*- */
/*
 * Copyright 2011 Mozilla Foundation and contributors
 * Licensed under the New BSD license. See LICENSE or:
 * http://opensource.org/licenses/BSD-3-Clause
 */

const SourceMapGenerator = require('./source-map-generator').SourceMapGenerator
const util = require('./util')

// Matches a Windows-style `\r\n` newline or a `\n` newline used by all other
// operating systems these days (capturing the result).
const REGEX_NEWLINE = /(\r?\n)/

// Newline character code for charCodeAt() comparisons
const NEWLINE_CODE = 10

// Private symbol for identifying `SourceNode`s when multiple versions of
// the source-map library are loaded. This MUST NOT CHANGE across
// versions!
const isSourceNode = '$$$isSourceNode$$$'

/**
 * SourceNodes provide a way to abstract over interpolating/concatenating
 * snippets of generated JavaScript source code while maintaining the line and
 * column information associated with the original source code.
 *
 * @param aLine The original line number.
 * @param aColumn The original column number.
 * @param aSource The original source's filename.
 * @param aChunks Optional. An array of strings which are snippets of
 *        generated JS, or other SourceNodes.
 * @param aName The original identifier.
 */
class SourceNode {
  constructor(aLine, aColumn, aSource, aChunks, aName) {
    this.children = []
    this.sourceContents = {}
    this.line = aLine == null ? null : aLine
    this.column = aColumn == null ? null : aColumn
    this.source = aSource == null ? null : aSource
    this.name = aName == null ? null : aName
    this[isSourceNode] = true
    if (aChunks != null) this.add(aChunks)
  }

  /**
   * Creates a SourceNode from generated code and a SourceMapConsumer.
   *
   * @param aGeneratedCode The generated code
   * @param aSourceMapConsumer The SourceMap for the generated code
   * @param aRelativePath Optional. The path that relative sources in the
   *        SourceMapConsumer should be relative to.
   */
  static fromStringWithSourceMap(
    aGeneratedCode,
    aSourceMapConsumer,
    aRelativePath
  ) {
    // The SourceNode we want to fill with the generated code
    // and the SourceMap
    const node = new SourceNode()

    // All even indices of this array are one line of the generated code,
    // while all odd indices are the newlines between two adjacent lines
    // (since `REGEX_NEWLINE` captures its match).
    // Processed fragments are accessed by calling `shiftNextLine`.
    const remainingLines = aGeneratedCode.split(REGEX_NEWLINE)
    let remainingLinesIndex = 0
    const shiftNextLine = function () {
      const lineContents = getNextLine()
      // The last line of a file might not have a newline.
      const newLine = getNextLine() || ''
      return lineContents + newLine

      function getNextLine() {
        return remainingLinesIndex < remainingLines.length
          ? remainingLines[remainingLinesIndex++]
          : undefined
      }
    }

    // We need to remember the position of "remainingLines"
    let lastGeneratedLine = 1,
      lastGeneratedColumn = 0

    // The generate SourceNodes we need a code range.
    // To extract it current and last mapping is used.
    // Here we store the last mapping.
    let lastMapping = null
    let nextLine

    aSourceMapConsumer.eachMapping(function (mapping) {
      if (lastMapping !== null) {
        // We add the code from "lastMapping" to "mapping":
        // First check if there is a new line in between.
        if (lastGeneratedLine < mapping.generatedLine) {
          // Associate first line with "lastMapping"
          addMappingWithCode(lastMapping, shiftNextLine())
          lastGeneratedLine++
          lastGeneratedColumn = 0
          // The remaining code is added without mapping
        } else {
          // There is no new line in between.
          // Associate the code between "lastGeneratedColumn" and
          // "mapping.generatedColumn" with "lastMapping"
          nextLine = remainingLines[remainingLinesIndex] || ''
          const code = nextLine.substr(
            0,
            mapping.generatedColumn - lastGeneratedColumn
          )
          remainingLines[remainingLinesIndex] = nextLine.substr(
            mapping.generatedColumn - lastGeneratedColumn
          )
          lastGeneratedColumn = mapping.generatedColumn
          addMappingWithCode(lastMapping, code)
          // No more remaining code, continue
          lastMapping = mapping
          return
        }
      }
      // We add the generated code until the first mapping
      // to the SourceNode without any mapping.
      // Each line is added as separate string.
      while (lastGeneratedLine < mapping.generatedLine) {
        node.add(shiftNextLine())
        lastGeneratedLine++
      }
      if (lastGeneratedColumn < mapping.generatedColumn) {
        nextLine = remainingLines[remainingLinesIndex] || ''
        node.add(nextLine.substr(0, mapping.generatedColumn))
        remainingLines[remainingLinesIndex] = nextLine.substr(
          mapping.generatedColumn
        )
        lastGeneratedColumn = mapping.generatedColumn
      }
      lastMapping = mapping
    }, this)
    // We have processed all mappings.
    if (remainingLinesIndex < remainingLines.length) {
      if (lastMapping) {
        // Associate the remaining code in the current line with "lastMapping"
        addMappingWithCode(lastMapping, shiftNextLine())
      }
      // and add the remaining lines without any mapping
      node.add(remainingLines.splice(remainingLinesIndex).join(''))
    }

    // Copy sourcesContent into SourceNode
    aSourceMapConsumer.sources.forEach(function (sourceFile) {
      const content = aSourceMapConsumer.sourceContentFor(sourceFile)
      if (content != null) {
        if (aRelativePath != null) {
          sourceFile = util.join(aRelativePath, sourceFile)
        }
        node.setSourceContent(sourceFile, content)
      }
    })

    return node

    function addMappingWithCode(mapping, code) {
      if (mapping === null || mapping.source === undefined) {
        node.add(code)
      } else {
        const source = aRelativePath
          ? util.join(aRelativePath, mapping.source)
          : mapping.source
        node.add(
          new SourceNode(
            mapping.originalLine,
            mapping.originalColumn,
            source,
            code,
            mapping.name
          )
        )
      }
    }
  }

  /**
   * Add a chunk of generated JS to this source node.
   *
   * @param aChunk A string snippet of generated JS code, another instance of
   *        SourceNode, or an array where each member is one of those things.
   */
  add(aChunk) {
    if (Array.isArray(aChunk)) {
      aChunk.forEach(function (chunk) {
        this.add(chunk)
      }, this)
    } else if (aChunk[isSourceNode] || typeof aChunk === 'string') {
      if (aChunk) {
        this.children.push(aChunk)
      }
    } else {
      throw new TypeError(
        'Expected a SourceNode, string, or an array of SourceNodes and strings. Got ' +
          aChunk
      )
    }
    return this
  }

  /**
   * Add a chunk of generated JS to the beginning of this source node.
   *
   * @param aChunk A string snippet of generated JS code, another instance of
   *        SourceNode, or an array where each member is one of those things.
   */
  prepend(aChunk) {
    if (Array.isArray(aChunk)) {
      for (let i = aChunk.length - 1; i >= 0; i--) {
        this.prepend(aChunk[i])
      }
    } else if (aChunk[isSourceNode] || typeof aChunk === 'string') {
      this.children.unshift(aChunk)
    } else {
      throw new TypeError(
        'Expected a SourceNode, string, or an array of SourceNodes and strings. Got ' +
          aChunk
      )
    }
    return this
  }

  /**
   * Walk over the tree of JS snippets in this node and its children. The
   * walking function is called once for each snippet of JS and is passed that
   * snippet and the its original associated source's line/column location.
   *
   * @param aFn The traversal function.
   */
  walk(aFn) {
    let chunk
    for (let i = 0, len = this.children.length; i < len; i++) {
      chunk = this.children[i]
      if (chunk[isSourceNode]) {
        chunk.walk(aFn)
      } else if (chunk !== '') {
        aFn(chunk, {
          source: this.source,
          line: this.line,
          column: this.column,
          name: this.name,
        })
      }
    }
  }

  /**
   * Like `String.prototype.join` except for SourceNodes. Inserts `aStr` between
   * each of `this.children`.
   *
   * @param aSep The separator.
   */
  join(aSep) {
    let newChildren
    let i
    const len = this.children.length
    if (len > 0) {
      newChildren = []
      for (i = 0; i < len - 1; i++) {
        newChildren.push(this.children[i])
        newChildren.push(aSep)
      }
      newChildren.push(this.children[i])
      this.children = newChildren
    }
    return this
  }

  /**
   * Call String.prototype.replace on the very right-most source snippet. Useful
   * for trimming whitespace from the end of a source node, etc.
   *
   * @param aPattern The pattern to replace.
   * @param aReplacement The thing to replace the pattern with.
   */
  replaceRight(aPattern, aReplacement) {
    const lastChild = this.children[this.children.length - 1]
    if (lastChild[isSourceNode]) {
      lastChild.replaceRight(aPattern, aReplacement)
    } else if (typeof lastChild === 'string') {
      this.children[this.children.length - 1] = lastChild.replace(
        aPattern,
        aReplacement
      )
    } else {
      this.children.push(''.replace(aPattern, aReplacement))
    }
    return this
  }

  /**
   * Set the source content for a source file. This will be added to the SourceMapGenerator
   * in the sourcesContent field.
   *
   * @param aSourceFile The filename of the source file
   * @param aSourceContent The content of the source file
   */
  setSourceContent(aSourceFile, aSourceContent) {
    this.sourceContents[util.toSetString(aSourceFile)] = aSourceContent
  }

  /**
   * Walk over the tree of SourceNodes. The walking function is called for each
   * source file content and is passed the filename and source content.
   *
   * @param aFn The traversal function.
   */
  walkSourceContents(aFn) {
    for (let i = 0, len = this.children.length; i < len; i++) {
      if (this.children[i][isSourceNode]) {
        this.children[i].walkSourceContents(aFn)
      }
    }

    const sources = Object.keys(this.sourceContents)
    for (let i = 0, len = sources.length; i < len; i++) {
      aFn(util.fromSetString(sources[i]), this.sourceContents[sources[i]])
    }
  }

  /**
   * Return the string representation of this source node. Walks over the tree
   * and concatenates all the various snippets together to one string.
   */
  toString() {
    let str = ''
    this.walk(function (chunk) {
      str += chunk
    })
    return str
  }

  /**
   * Returns the string representation of this source node along with a source
   * map.
   */
  toStringWithSourceMap(aArgs) {
    const generated = {
      code: '',
      line: 1,
      column: 0,
    }
    const map = new SourceMapGenerator(aArgs)
    let sourceMappingActive = false
    let lastOriginalSource = null
    let lastOriginalLine = null
    let lastOriginalColumn = null
    let lastOriginalName = null
    this.walk(function (chunk, original) {
      generated.code += chunk
      if (
        original.source !== null &&
        original.line !== null &&
        original.column !== null
      ) {
        if (
          lastOriginalSource !== original.source ||
          lastOriginalLine !== original.line ||
          lastOriginalColumn !== original.column ||
          lastOriginalName !== original.name
        ) {
          map.addMapping({
            source: original.source,
            original: {
              line: original.line,
              column: original.column,
            },
            generated: {
              line: generated.line,
              column: generated.column,
            },
            name: original.name,
          })
        }
        lastOriginalSource = original.source
        lastOriginalLine = original.line
        lastOriginalColumn = original.column
        lastOriginalName = original.name
        sourceMappingActive = true
      } else if (sourceMappingActive) {
        map.addMapping({
          generated: {
            line: generated.line,
            column: generated.column,
          },
        })
        lastOriginalSource = null
        sourceMappingActive = false
      }
      for (let idx = 0, length = chunk.length; idx < length; idx++) {
        if (chunk.charCodeAt(idx) === NEWLINE_CODE) {
          generated.line++
          generated.column = 0
          // Mappings end at eol
          if (idx + 1 === length) {
            lastOriginalSource = null
            sourceMappingActive = false
          } else if (sourceMappingActive) {
            map.addMapping({
              source: original.source,
              original: {
                line: original.line,
                column: original.column,
              },
              generated: {
                line: generated.line,
                column: generated.column,
              },
              name: original.name,
            })
          }
        } else {
          generated.column++
        }
      }
    })
    this.walkSourceContents(function (sourceFile, sourceContent) {
      map.setSourceContent(sourceFile, sourceContent)
    })

    return { code: generated.code, map }
  }
}

exports.SourceNode = SourceNode