'use strict'
import { Neovim } from '@chemzqm/neovim'
import fs from 'fs-extra'
import glob from 'glob'
import minimatch from 'minimatch'
import os from 'os'
import path from 'path'
import { promisify } from 'util'
import { v4 as uuid } from 'uuid'
import { CancellationToken, CancellationTokenSource, CreateFile, CreateFileOptions, DeleteFile, DeleteFileOptions, Emitter, Event, Position, RenameFile, RenameFileOptions, TextDocumentEdit, WorkspaceEdit } from 'vscode-languageserver-protocol'
import { URI } from 'vscode-uri'
import Configurations from '../configuration'
import events from '../events'
import Document from '../model/document'
import EditInspect, { EditState, RecoverFunc } from '../model/editInspect'
import RelativePattern from '../model/relativePattern'
import { DocumentChange, Env, FileCreateEvent, FileDeleteEvent, FileRenameEvent, FileWillCreateEvent, FileWillDeleteEvent, FileWillRenameEvent, LinesChange } from '../types'
import * as errors from '../util/errors'
import { fixDriver, isFile, isParentFolder, statAsync } from '../util/fs'
import { byteLength } from '../util/string'
import { getAnnotationKey, getConfirmAnnotations, toDocumentChanges } from '../util/textedit'
import type { Window } from '../window'
import Documents from './documents'
import type Keymaps from './keymaps'
import * as ui from './ui'
import WorkspaceFolderController from './workspaceFolder'

export type GlobPattern = string | RelativePattern

interface WaitUntilEvent {
  waitUntil(thenable: Thenable<WorkspaceEdit | any>): void
}

const logger = require('../util/logger')('core-files')

export default class Files {
  private nvim: Neovim
  private env: Env
  private window: Window
  private editState: EditState | undefined
  private operationTimeout = 500
  private _onDidCreateFiles = new Emitter<FileCreateEvent>()
  private _onDidRenameFiles = new Emitter<FileRenameEvent>()
  private _onDidDeleteFiles = new Emitter<FileDeleteEvent>()
  private _onWillCreateFiles = new Emitter<FileWillCreateEvent>()
  private _onWillRenameFiles = new Emitter<FileWillRenameEvent>()
  private _onWillDeleteFiles = new Emitter<FileWillDeleteEvent>()

  public readonly onDidCreateFiles: Event<FileCreateEvent> = this._onDidCreateFiles.event
  public readonly onDidRenameFiles: Event<FileRenameEvent> = this._onDidRenameFiles.event
  public readonly onDidDeleteFiles: Event<FileDeleteEvent> = this._onDidDeleteFiles.event
  public readonly onWillCreateFiles: Event<FileWillCreateEvent> = this._onWillCreateFiles.event
  public readonly onWillRenameFiles: Event<FileWillRenameEvent> = this._onWillRenameFiles.event
  public readonly onWillDeleteFiles: Event<FileWillDeleteEvent> = this._onWillDeleteFiles.event
  constructor(
    private documents: Documents,
    private configurations: Configurations,
    private workspaceFolderControl: WorkspaceFolderController,
    private keymaps: Keymaps
  ) {
  }

  public attach(nvim: Neovim, env: Env, window: Window): void {
    this.nvim = nvim
    this.env = env
    this.window = window
  }

  public async openTextDocument(uri: URI | string): Promise<Document> {
    uri = typeof uri === 'string' ? URI.file(uri) : uri
    let doc = this.documents.getDocument(uri.toString())
    if (doc) {
      await this.jumpTo(uri.toString(), null, 'drop')
      return doc
    }
    const scheme = uri.scheme
    if (scheme == 'file') {
      if (!fs.existsSync(uri.fsPath)) throw errors.fileNotExists(uri.fsPath)
      fs.accessSync(uri.fsPath, fs.constants.R_OK)
    }
    if (scheme == 'untitled') {
      await this.nvim.call('coc#util#open_file', ['tab drop', uri.path])
      return await this.documents.document
    }
    return await this.loadResource(uri.toString())
  }

  public async jumpTo(uri: string, position?: Position | null, openCommand?: string): Promise<void> {
    const preferences = this.configurations.getConfiguration('coc.preferences')
    let jumpCommand = openCommand || preferences.get<string>('jumpCommand', 'edit')
    let { nvim } = this
    let doc = this.documents.getDocument(uri)
    let bufnr = doc ? doc.bufnr : -1
    if (bufnr != -1 && jumpCommand == 'edit') {
      // use buffer command since edit command would reload the buffer
      nvim.pauseNotification()
      nvim.command(`silent! normal! m'`, true)
      nvim.command(`buffer ${bufnr}`, true)
      nvim.command(`if &filetype ==# '' | filetype detect | endif`, true)
      if (position) {
        let line = doc.getline(position.line)
        let col = byteLength(line.slice(0, position.character)) + 1
        nvim.call('cursor', [position.line + 1, col], true)
      }
      await nvim.resumeNotification(true)
    } else {
      let { fsPath, scheme } = URI.parse(uri)
      let pos = position == null ? null : [position.line, position.character]
      if (scheme == 'file') {
        let bufname = fixDriver(path.normalize(fsPath))
        await this.nvim.call('coc#util#jump', [jumpCommand, bufname, pos])
      } else {
        await this.nvim.call('coc#util#jump', [jumpCommand, uri, pos])
      }
    }
  }

  /**
   * Open resource by uri
   */
  public async openResource(uri: string): Promise<void> {
    let { nvim } = this
    let u = URI.parse(uri)
    if (/^https?/.test(u.scheme)) {
      await nvim.call('coc#ui#open_url', uri)
      return
    }
    let wildignore = await nvim.getOption('wildignore')
    await nvim.setOption('wildignore', '')
    await this.jumpTo(uri)
    await nvim.setOption('wildignore', wildignore)
  }

  /**
   * Load uri as document.
   */
  public async loadResource(uri: string): Promise<Document> {
    let doc = this.documents.getDocument(uri)
    if (doc) return doc
    const preferences = this.configurations.getConfiguration('workspace')
    let cmd = preferences.get<string>('openResourceCommand', 'tab drop')
    let u = URI.parse(uri)
    let bufname = u.scheme === 'file' ? u.fsPath : uri
    let bufnr: number
    if (cmd) {
      let winid = await this.nvim.call('win_getid')
      bufnr = await this.nvim.call('coc#util#open_file', [cmd, bufname])
      await this.nvim.call('win_gotoid', [winid])
    } else {
      let arr = await this.nvim.call('coc#ui#open_files', [[bufname]])
      bufnr = arr[0]
    }
    return await this.documents.createDocument(bufnr)
  }

  /**
   * Load the files that not loaded
   */
  public async loadResources(uris: string[]): Promise<(Document | undefined)[]> {
    let { documents } = this
    let files = uris.map(uri => {
      let u = URI.parse(uri)
      return u.scheme == 'file' ? u.fsPath : uri
    })
    let bufnrs = await this.nvim.call('coc#ui#open_files', [files]) as number[]
    return await Promise.all(bufnrs.map(bufnr => {
      return documents.createDocument(bufnr)
    }))
  }

  /**
   * Create a file in vim and disk
   */
  public async createFile(filepath: string, opts: CreateFileOptions = {}, recovers?: RecoverFunc[]): Promise<void> {
    let { nvim } = this
    let exists = fs.existsSync(filepath)
    if (exists && !opts.overwrite && !opts.ignoreIfExists) {
      throw errors.fileExists(filepath)
    }
    if (!exists || opts.overwrite) {
      let tokenSource = new CancellationTokenSource()
      await this.fireWaitUntilEvent(this._onWillCreateFiles, {
        files: [URI.file(filepath)],
        token: tokenSource.token
      }, recovers)
      tokenSource.cancel()
      let dir = path.dirname(filepath)
      if (!fs.existsSync(dir)) {
        let folder: string
        let curr = dir
        while (!['.', '/', path.parse(dir).root].includes(curr)) {
          if (fs.existsSync(path.dirname(curr))) {
            folder = curr
            break
          }
          curr = path.dirname(curr)
        }
        await fs.mkdirp(dir)
        recovers && recovers.push(async () => {
          if (fs.existsSync(folder)) {
            await fs.remove(folder)
          }
        })
      }
      fs.writeFileSync(filepath, '', 'utf8')
      recovers && recovers.push(async () => {
        if (fs.existsSync(filepath)) {
          await fs.unlink(filepath)
        }
      })
      let doc = await this.loadResource(filepath)
      let bufnr = doc.bufnr
      recovers && recovers.push(() => {
        void events.fire('BufUnload', [bufnr])
        return nvim.command(`silent! bd! ${bufnr}`)
      })
      this._onDidCreateFiles.fire({ files: [URI.file(filepath)] })
    }
  }

  /**
   * Delete a file or folder from vim and disk.
   */
  public async deleteFile(filepath: string, opts: DeleteFileOptions = {}, recovers?: RecoverFunc[]): Promise<void> {
    let { ignoreIfNotExists, recursive } = opts
    let stat = await statAsync(filepath)
    let isDir = stat && stat.isDirectory()
    if (!stat && !ignoreIfNotExists) {
      throw errors.fileNotExists(filepath)
    }
    if (stat == null) return
    let uri = URI.file(filepath)
    await this.fireWaitUntilEvent(this._onWillDeleteFiles, { files: [uri] }, recovers)
    if (!isDir) {
      let bufnr = await this.nvim.call('bufnr', [filepath])
      if (bufnr) {
        void events.fire('BufUnload', [bufnr])
        await this.nvim.command(`silent! bwipeout ${bufnr}`)
        recovers && recovers.push(() => {
          return this.loadResource(uri.toString())
        })
      }
    }
    if (isDir && recursive) {
      // copy files for recover
      let folder = path.join(os.tmpdir(), 'coc-' + uuid())
      await fs.mkdir(folder)
      await fs.copy(filepath, folder, { recursive: true })
      await fs.remove(filepath)
      recovers && recovers.push(async () => {
        await fs.mkdir(filepath)
        await fs.copy(folder, filepath, { recursive: true })
        await fs.remove(folder)
      })
    } else if (isDir) {
      await fs.rmdir(filepath)
      recovers && recovers.push(() => {
        return fs.mkdir(filepath)
      })
    } else {
      let dest = path.join(os.tmpdir(), 'coc-' + uuid())
      await fs.copyFile(filepath, dest)
      await fs.unlink(filepath)
      recovers && recovers.push(() => {
        return fs.move(dest, filepath, { overwrite: true })
      })
    }
    this._onDidDeleteFiles.fire({ files: [uri] })
  }

  /**
   * Rename a file or folder on vim and disk
   */
  public async renameFile(oldPath: string, newPath: string, opts: RenameFileOptions & { skipEvent?: boolean } = {}, recovers?: RecoverFunc[]): Promise<void> {
    let { nvim } = this
    let { overwrite, ignoreIfExists } = opts
    if (newPath === oldPath) return
    let exists = fs.existsSync(newPath)
    if (exists && ignoreIfExists && !overwrite) return
    if (exists && !overwrite) throw errors.fileExists(newPath)
    let oldStat = await statAsync(oldPath)
    let loaded = (oldStat && oldStat.isDirectory()) ? 0 : await nvim.call('bufloaded', [oldPath])
    if (!loaded && !oldStat) throw errors.fileNotExists(oldPath)
    let file = { newUri: URI.parse(newPath), oldUri: URI.parse(oldPath) }
    if (!opts.skipEvent) await this.fireWaitUntilEvent(this._onWillRenameFiles, { files: [file] }, recovers)
    if (loaded) {
      let bufnr = await nvim.call('coc#ui#rename_file', [oldPath, newPath, oldStat != null])
      await this.documents.onBufCreate(bufnr)
    } else {
      if (oldStat?.isDirectory()) {
        for (let doc of this.documents.documents) {
          let u = URI.parse(doc.uri)
          if (u.scheme === 'file' && isParentFolder(oldPath, u.fsPath, false)) {
            let filepath = u.fsPath.replace(oldPath, newPath)
            let bufnr = await nvim.call('coc#ui#rename_file', [u.fsPath, filepath, false])
            await this.documents.onBufCreate(bufnr)
          }
        }
      }
      fs.renameSync(oldPath, newPath)
    }
    recovers && recovers.push(() => {
      return this.renameFile(newPath, oldPath, { skipEvent: true })
    })
    if (!opts.skipEvent) this._onDidRenameFiles.fire({ files: [file] })
  }

  public async renameCurrent(): Promise<void> {
    let { nvim } = this
    let oldPath = await nvim.call('expand', ['%:p'])
    // await nvim.callAsync()
    let newPath = await nvim.callAsync('coc#util#with_callback', ['input', ['New path: ', oldPath, 'file']])
    newPath = newPath ? newPath.trim() : null
    if (newPath === oldPath || !newPath) return
    if (oldPath.toLowerCase() != newPath.toLowerCase() && fs.existsSync(newPath)) {
      let overwrite = await ui.showPrompt(this.nvim, `${newPath} exists, overwrite?`)
      if (!overwrite) return
    }
    await this.renameFile(oldPath, newPath, { overwrite: true })
  }

  private get currentUri(): string {
    let document = this.documents.getDocument(this.documents.bufnr)
    return document ? document.uri : null
  }

  /**
   * Apply WorkspaceEdit.
   */
  public async applyEdit(edit: WorkspaceEdit, nested?: boolean): Promise<boolean> {
    let documentChanges = toDocumentChanges(edit)
    let recovers: RecoverFunc[] = []
    let currentOnly = false
    try {
      let { changeAnnotations } = edit
      let { currentUri } = this
      let toConfirm = changeAnnotations ? getConfirmAnnotations(documentChanges, changeAnnotations) : []
      let changes: { [uri: string]: LinesChange } = {}
      let denied: string[] = []
      for (let key of toConfirm) {
        let annotation = changeAnnotations[key]
        annotation.needsConfirmation = false
        let res = await this.window.showMenuPicker(['Yes', 'No'], {
          position: 'center',
          title: 'Confirm edits',
          content: annotation.label + (annotation.description ? ' ' + annotation.description : '')
        })
        if (res !== 0) denied.push(key)
      }
      documentChanges = documentChanges.filter(c => !denied.includes(getAnnotationKey(c)))
      if (!documentChanges.length) return true
      currentOnly = documentChanges.every(o => TextDocumentEdit.is(o) && o.textDocument.uri === currentUri)
      this.validateChanges(documentChanges)
      for (const change of documentChanges) {
        if (TextDocumentEdit.is(change)) {
          let { textDocument, edits } = change
          let { uri } = textDocument
          let doc = await this.loadResource(uri)
          let revertEdit = await doc.applyEdits(edits, false, uri === currentUri)
          if (revertEdit) {
            let version = doc.version
            let { newText, range } = revertEdit
            changes[uri] = {
              uri,
              lnum: range.start.line + 1,
              newLines: doc.getLines(range.start.line, range.end.line),
              oldLines: newText.endsWith('\n') ? newText.slice(0, -1).split('\n') : newText.split('\n')
            }
            recovers.push(async () => {
              let doc = this.documents.getDocument(uri)
              if (!doc || !doc.attached || doc.version !== version) return
              await doc.applyEdits([revertEdit])
              textDocument.version = doc.version
            })
          }
        } else if (CreateFile.is(change)) {
          await this.createFile(fsPath(change.uri), change.options, recovers)
        } else if (DeleteFile.is(change)) {
          await this.deleteFile(fsPath(change.uri), change.options, recovers)
        } else if (RenameFile.is(change)) {
          await this.renameFile(fsPath(change.oldUri), fsPath(change.newUri), change.options, recovers)
        }
      }
      // nothing changed
      if (recovers.length === 0) return true
      if (!nested) this.editState = { edit: { documentChanges, changeAnnotations: edit.changeAnnotations }, changes, recovers, applied: true }
      this.nvim.redrawVim()
    } catch (e) {
      logger.error('Error on applyEdits:', edit, e)
      await this.undoChanges(recovers)
      if (!nested) void this.window.showErrorMessage(`Error on applyEdits: ${e}`)
      return false
    }
    // avoid message when change current file only.
    if (nested || currentOnly) return true
    void this.window.showInformationMessage(`Use ':wa' to save changes or ':CocCommand workspace.inspectEdit' to inspect.`)
    return true
  }

  private async undoChanges(recovers: RecoverFunc[]): Promise<void> {
    while (recovers.length > 0) {
      let fn = recovers.pop()
      await fn()
    }
  }

  public async inspectEdit(): Promise<void> {
    if (!this.editState) {
      void this.window.showWarningMessage('No workspace edit to inspect')
      return
    }
    let inspect = new EditInspect(this.nvim, this.keymaps)
    await inspect.show(this.editState)
  }

  public async undoWorkspaceEdit(): Promise<void> {
    let { editState } = this
    if (!editState || !editState.applied) {
      void this.window.showWarningMessage(`No workspace edit to undo`)
      return
    }
    editState.applied = false
    await this.undoChanges(editState.recovers)
  }

  public async redoWorkspaceEdit(): Promise<void> {
    let { editState } = this
    if (!editState || editState.applied) {
      void this.window.showWarningMessage(`No workspace edit to redo`)
      return
    }
    this.editState = undefined
    await this.applyEdit(editState.edit)
  }

  private validateChanges(documentChanges: ReadonlyArray<DocumentChange>): void {
    let { documents } = this
    for (let change of documentChanges) {
      if (TextDocumentEdit.is(change)) {
        let { uri, version } = change.textDocument
        let doc = documents.getDocument(uri)
        if (typeof version === 'number' && version > 0) {
          if (!doc) throw new Error(`File ${uri} not loaded`)
          if (doc.version != version) throw new Error(`${uri} changed before apply edit`)
        } else if (!doc) {
          if (!isFile(uri)) throw errors.badScheme(URI.parse(uri).scheme)
        }
      } else if (CreateFile.is(change) || DeleteFile.is(change)) {
        if (!isFile(change.uri)) throw errors.badScheme(URI.parse(change.uri).scheme)
      } else if (RenameFile.is(change)) {
        if (!isFile(change.oldUri) || !isFile(change.newUri)) {
          throw errors.badScheme(URI.parse(change.oldUri).scheme)
        }
      }
    }
  }

  public async findFiles(include: GlobPattern, exclude?: GlobPattern | null, maxResults?: number, token?: CancellationToken): Promise<URI[]> {
    let folders = this.workspaceFolderControl.workspaceFolders
    if (token?.isCancellationRequested || !folders.length || maxResults === 0) return []
    maxResults = maxResults ?? Infinity
    let roots = folders.map(o => URI.parse(o.uri).fsPath)
    if (typeof include !== 'string') {
      let base = include.baseUri.fsPath
      roots = roots.filter(r => isParentFolder(base, r, true))
    }
    let pattern = typeof include === 'string' ? include : include.pattern
    let res: URI[] = []
    for (let root of roots) {
      if (res.length >= maxResults) break
      let files = await promisify(glob)(pattern, {
        dot: true,
        cwd: root,
        nodir: true,
        absolute: false
      })
      if (token?.isCancellationRequested) return []
      for (let file of files) {
        if (exclude && fileMatch(root, file, exclude)) continue
        res.push(URI.file(path.join(root, file)))
        if (res.length === maxResults) break
      }
    }
    return res
  }

  private async fireWaitUntilEvent<T extends WaitUntilEvent>(emitter: Emitter<T>, properties: Omit<T, 'waitUntil'>, recovers?: RecoverFunc[]): Promise<void> {
    let firing = true
    let promises: Promise<any>[] = []
    emitter.fire({
      ...properties,
      waitUntil: thenable => {
        if (!firing) throw errors.shouldNotAsync('waitUntil')
        let tp = new Promise(resolve => {
          setTimeout(resolve, this.operationTimeout)
        })
        let promise = Promise.race([thenable, tp]).then(edit => {
          if (edit && WorkspaceEdit.is(edit)) {
            return this.applyEdit(edit, true)
          }
        })
        promises.push(promise)
      }
    } as any)
    firing = false
    await Promise.all(promises)
  }
}

function fileMatch(root: string, relpath: string, pattern: GlobPattern): boolean {
  let filepath = path.join(root, relpath)
  if (typeof pattern !== 'string') {
    let base = pattern.baseUri.fsPath
    if (!isParentFolder(base, filepath)) return false
    let rp = path.relative(base, filepath)
    return minimatch(rp, pattern.pattern, { dot: true })
  }
  return minimatch(relpath, pattern, { dot: true })
}

function fsPath(uri: string): string {
  return URI.parse(uri).fsPath
}