const { CompositeDisposable } = require('atom')
const { repositoryForPath } = require('./helpers')

const MAX_BUFFER_LENGTH_TO_DIFF = 2 * 1024 * 1024

module.exports = class GitDiffView {
  constructor (editor) {
    this.updateDiffs = this.updateDiffs.bind(this)
    this.editor = editor
    this.subscriptions = new CompositeDisposable()
    this.decorations = {}
    this.markers = []
  }

  start () {
    const editorElement = this.editor.getElement()

    this.subscribeToRepository()

    this.subscriptions.add(
      this.editor.onDidStopChanging(this.updateDiffs),
      this.editor.onDidChangePath(this.updateDiffs),
      atom.project.onDidChangePaths(() => this.subscribeToRepository()),
      atom.commands.add(editorElement, 'git-diff:move-to-next-diff', () =>
        this.moveToNextDiff()
      ),
      atom.commands.add(editorElement, 'git-diff:move-to-previous-diff', () =>
        this.moveToPreviousDiff()
      ),
      atom.config.onDidChange('git-diff.showIconsInEditorGutter', () =>
        this.updateIconDecoration()
      ),
      atom.config.onDidChange('editor.showLineNumbers', () =>
        this.updateIconDecoration()
      ),
      editorElement.onDidAttach(() => this.updateIconDecoration()),
      this.editor.onDidDestroy(() => {
        this.cancelUpdate()
        this.removeDecorations()
        this.subscriptions.dispose()
      })
    )

    this.updateIconDecoration()
    this.scheduleUpdate()
  }

  moveToNextDiff () {
    const cursorLineNumber = this.editor.getCursorBufferPosition().row + 1
    let nextDiffLineNumber = null
    let firstDiffLineNumber = null
    if (this.diffs) {
      for (const { newStart } of this.diffs) {
        if (newStart > cursorLineNumber) {
          if (nextDiffLineNumber == null) nextDiffLineNumber = newStart - 1
          nextDiffLineNumber = Math.min(newStart - 1, nextDiffLineNumber)
        }

        if (firstDiffLineNumber == null) firstDiffLineNumber = newStart - 1
        firstDiffLineNumber = Math.min(newStart - 1, firstDiffLineNumber)
      }
    }

    // Wrap around to the first diff in the file
    if (
      atom.config.get('git-diff.wrapAroundOnMoveToDiff') &&
      nextDiffLineNumber == null
    ) {
      nextDiffLineNumber = firstDiffLineNumber
    }

    this.moveToLineNumber(nextDiffLineNumber)
  }

  updateIconDecoration () {
    const gutter = this.editor.getElement().querySelector('.gutter')
    if (gutter) {
      if (
        atom.config.get('editor.showLineNumbers') &&
        atom.config.get('git-diff.showIconsInEditorGutter')
      ) {
        gutter.classList.add('git-diff-icon')
      } else {
        gutter.classList.remove('git-diff-icon')
      }
    }
  }

  moveToPreviousDiff () {
    const cursorLineNumber = this.editor.getCursorBufferPosition().row + 1
    let previousDiffLineNumber = -1
    let lastDiffLineNumber = -1
    if (this.diffs) {
      for (const { newStart } of this.diffs) {
        if (newStart < cursorLineNumber) {
          previousDiffLineNumber = Math.max(
            newStart - 1,
            previousDiffLineNumber
          )
        }
        lastDiffLineNumber = Math.max(newStart - 1, lastDiffLineNumber)
      }
    }

    // Wrap around to the last diff in the file
    if (
      atom.config.get('git-diff.wrapAroundOnMoveToDiff') &&
      previousDiffLineNumber === -1
    ) {
      previousDiffLineNumber = lastDiffLineNumber
    }

    this.moveToLineNumber(previousDiffLineNumber)
  }

  moveToLineNumber (lineNumber) {
    if (lineNumber != null && lineNumber >= 0) {
      this.editor.setCursorBufferPosition([lineNumber, 0])
      this.editor.moveToFirstCharacterOfLine()
    }
  }

  subscribeToRepository () {
    this.repository = repositoryForPath(this.editor.getPath())
    if (this.repository) {
      this.subscriptions.add(
        this.repository.onDidChangeStatuses(() => {
          this.scheduleUpdate()
        })
      )
      this.subscriptions.add(
        this.repository.onDidChangeStatus(changedPath => {
          if (changedPath === this.editor.getPath()) this.scheduleUpdate()
        })
      )
    }
  }

  cancelUpdate () {
    clearImmediate(this.immediateId)
  }

  scheduleUpdate () {
    this.cancelUpdate()
    this.immediateId = setImmediate(this.updateDiffs)
  }

  updateDiffs () {
    if (this.editor.isDestroyed()) return
    this.removeDecorations()
    const path = this.editor && this.editor.getPath()
    if (
      path &&
      this.editor.getBuffer().getLength() < MAX_BUFFER_LENGTH_TO_DIFF
    ) {
      this.diffs =
        this.repository &&
        this.repository.getLineDiffs(path, this.editor.getText())
      if (this.diffs) this.addDecorations(this.diffs)
    }
  }

  addDecorations (diffs) {
    for (const { newStart, oldLines, newLines } of diffs) {
      const startRow = newStart - 1
      const endRow = newStart + newLines - 1
      if (oldLines === 0 && newLines > 0) {
        this.markRange(startRow, endRow, 'git-line-added')
      } else if (newLines === 0 && oldLines > 0) {
        if (startRow < 0) {
          this.markRange(0, 0, 'git-previous-line-removed')
        } else {
          this.markRange(startRow, startRow, 'git-line-removed')
        }
      } else {
        this.markRange(startRow, endRow, 'git-line-modified')
      }
    }
  }

  removeDecorations () {
    for (let marker of this.markers) marker.destroy()
    this.markers = []
  }

  markRange (startRow, endRow, klass) {
    const marker = this.editor.markBufferRange([[startRow, 0], [endRow, 0]], {
      invalidate: 'never'
    })
    this.editor.decorateMarker(marker, { type: 'line-number', class: klass })
    this.markers.push(marker)
  }
}