import { Neovim } from '@chemzqm/neovim'
import { Disposable } from '@chemzqm/neovim/lib/api/Buffer'
import fs from 'fs'
import { Position, Range, TextDocumentEdit, TextEdit, WorkspaceEdit } from 'vscode-languageserver-types'
import { URI } from 'vscode-uri'
import RefactorBuffer, { FileItemDef, fixChangeParams } from '../../handler/refactor/buffer'
import Changes from '../../handler/refactor/changes'
import Refactor from '../../handler/refactor/index'
import languages from '../../languages'
import { DidChangeTextDocumentParams } from '../../types'
import workspace from '../../workspace'
import helper, { createTmpFile } from '../helper'

let nvim: Neovim
let refactor: Refactor

beforeAll(async () => {
  await helper.setup()
  nvim = helper.nvim
  refactor = helper.plugin.getHandler().refactor
})

afterAll(async () => {
  await helper.shutdown()
})

afterEach(async () => {
  refactor.reset()
  await helper.reset()
})

function createEdit(uri: string): WorkspaceEdit {
  let edit = TextEdit.insert(Position.create(0, 0), 'a')
  let doc = { uri, version: null }
  return { documentChanges: [TextDocumentEdit.create(doc, [edit])] }
}

// assert ranges is expected.
async function assertSynchronized(buf: RefactorBuffer) {
  let buffer = nvim.createBuffer(buf.bufnr)
  let lines = await buffer.lines
  let items: { lnum: number, lines: string[] }[] = []
  for (let i = 0; i < lines.length; i++) {
    let line = lines[i]
    if (line.includes('\u3000') && line.length > 1) {
      items.push({ lnum: i + 1, lines: [] })
    }
  }
  let curr: { lnum: number, lines: string[] }[] = []
  buf.fileItems.forEach(item => {
    item.ranges.forEach(r => {
      curr.push({ lnum: r.lnum, lines: [] })
    })
  })
  curr.sort((a, b) => a.lnum - b.lnum)
  expect(items).toEqual(curr)
}

describe('fixChangeParams', () => {
  function createChangeParams(range: Range, text: string, original: string, originalLines: ReadonlyArray<string>): DidChangeTextDocumentParams {
    return {
      textDocument: {
        uri: 'untitled:/1',
        version: 1,
      },
      originalLines,
      original,
      bufnr: 1,
      contentChanges: [{ range, text }]
    }
  }

  it('should fix delete change params', async () => {
    let e = createChangeParams(Range.create(0, 4, 2, 4), '', 'x\nfoo\n\u3000bar', [
      '\u3000barx',
      'foo',
      '\u3000bara'
    ])
    e = fixChangeParams(e)
    expect(e.original).toBe('\u3000barx\nfoo\n')
    expect(e.contentChanges[0].range).toEqual(Range.create(0, 0, 2, 0))
  })

  it('should fix insert change params', async () => {
    let e = createChangeParams(Range.create(0, 4, 0, 4), 'x\nfoo\n\u3000bar', '', [
      '\u3000bara'
    ])
    e = fixChangeParams(e)
    expect(e.original).toBe('')
    let change = e.contentChanges[0]
    expect(change.range).toEqual(Range.create(0, 0, 0, 0))
    expect(change.text).toBe('\u3000barx\nfoo\n')
  })
})

describe('refactor', () => {
  describe('checkInsert()', () => {
    it('should check inserted ranges', async () => {
      let c = new Changes()
      expect(c.checkInsert([1])).toBeUndefined()
      c.add([{ filepath: __filename, start: 1, lnum: 1, lines: [''] }])
      expect(c.checkInsert([2])).toBeUndefined()
    })
  })

  describe('getFileRange()', () => {
    it('should throw when range does not exist', async () => {
      let uri = URI.file(__filename).toString()
      let locations = [{ uri, range: Range.create(0, 0, 0, 6) }]
      let buf = await refactor.fromLocations(locations)
      let fn = () => {
        buf.getFileRange(1)
      }
      expect(fn).toThrow(Error)
    })

    it('should find file range', async () => {
      let uri = URI.file(__filename).toString()
      let locations = [{ uri, range: Range.create(0, 0, 0, 6) }]
      let buf = await refactor.fromLocations(locations)
      let res = buf.getFileRange(4)
      expect(res).toBeDefined()
    })
  })

  describe('getRange()', () => {
    it('should get delete range', async () => {
      let filename = await createTmpFile('foo\n\nbar\n')
      let fileItem: FileItemDef = {
        filepath: filename,
        ranges: [{ start: 0, end: 1 }, { start: 2, end: 3 }]
      }
      let buf = await refactor.createRefactorBuffer()
      await buf.addFileItems([fileItem])
      let res = buf.getFileRange(4)
      let r = buf.getDeleteRange(res)
      expect(r).toEqual(Range.create(3, 0, 6, 0))
      res = buf.getFileRange(7)
      r = buf.getDeleteRange(res)
      expect(r).toEqual(Range.create(6, 0, 8, 0))
    })

    it('should get replace range', async () => {
      let filename = await createTmpFile('foo\n\nbar\n')
      let fileItem: FileItemDef = {
        filepath: filename,
        ranges: [{ start: 0, end: 1 }, { start: 2, end: 3 }]
      }
      let buf = await refactor.createRefactorBuffer()
      await buf.addFileItems([fileItem])
      let res = buf.getFileRange(4)
      let r = buf.getReplaceRange(res)
      expect(r).toEqual(Range.create(4, 0, 4, 3))
      res = buf.getFileRange(7)
      r = buf.getReplaceRange(res)
      expect(r).toEqual(Range.create(7, 0, 7, 3))
    })
  })

  describe('fromWorkspaceEdit()', () => {
    it('should not create from invalid workspaceEdit', async () => {
      let res = await refactor.fromWorkspaceEdit(undefined)
      expect(res).toBeUndefined()
      res = await refactor.fromWorkspaceEdit({ documentChanges: [] })
      expect(res).toBeUndefined()
    })

    it('should create from document changes', async () => {
      let edit = createEdit(URI.file(__filename).toString())
      let buf = await refactor.fromWorkspaceEdit(edit)
      let shown = await buf.valid
      expect(shown).toBe(true)
      let items = buf.fileItems
      expect(items.length).toBe(1)
      await nvim.command(`bd! ${buf.bufnr}`)
      await helper.wait(30)
      let has = refactor.has(buf.bufnr)
      expect(has).toBe(false)
    })

    it('should create from workspaceEdit', async () => {
      let changes = {
        [URI.file(__filename).toString()]: [{
          range: Range.create(0, 0, 0, 6),
          newText: ''
        }, {
          range: Range.create(1, 0, 1, 6),
          newText: ''
        }, {
          range: Range.create(50, 0, 50, 1),
          newText: ' '
        }, {
          range: Range.create(60, 0, 60, 1),
          newText: ' '
        }]
      }
      let edit: WorkspaceEdit = { changes }
      let buf = await refactor.fromWorkspaceEdit(edit)
      let shown = await buf.valid
      expect(shown).toBe(true)
      let items = buf.fileItems
      expect(items.length).toBe(1)
    })
  })

  describe('fromLocations()', () => {
    it('should create from locations', async () => {
      let uri = URI.file(__filename).toString()
      let locations = [{
        uri,
        range: Range.create(0, 0, 0, 6),
      }, {
        uri,
        range: Range.create(1, 0, 1, 6),
      }]
      let buf = await refactor.fromLocations(locations)
      let shown = await buf.valid
      expect(shown).toBe(true)
      let items = buf.fileItems
      expect(items.length).toBe(1)
    })

    it('should not create from empty locations', async () => {
      let buf = await refactor.fromLocations([])
      expect(buf).toBeUndefined()
    })
  })

  describe('onChange()', () => {
    async function setup(): Promise<RefactorBuffer> {
      let uri = URI.file(__filename).toString()
      let locations = [{
        uri,
        range: Range.create(0, 0, 0, 6),
      }, {
        uri,
        range: Range.create(1, 0, 1, 6),
      }, {
        uri,
        range: Range.create(10, 0, 10, 6),
      }]
      return await refactor.fromLocations(locations)
    }

    it('should refresh on empty text change', async () => {
      let buf = await setup()
      let line = await nvim.call('getline', [4])
      let doc = workspace.getDocument(buf.bufnr)
      await nvim.call('setline', [4, line])
      doc._forceSync()
      let srcId = await nvim.createNamespace('coc-refactor')
      let markers = await helper.getMarkers(doc.bufnr, srcId)
      expect(markers.length).toBe(2)
    })

    it('should detect range delete and undo', async () => {
      let buf = await setup()
      let doc = workspace.getDocument(buf.bufnr)
      let r = buf.getFileRange(4)
      let end = r.lnum + r.lines.length
      await nvim.command(`${r.lnum},${end + 1}d`)
      await doc.synchronize()
      await assertSynchronized(buf)
      await nvim.command('undo')
      await doc.synchronize()
      await assertSynchronized(buf)
    })

    it('should detect normal delete', async () => {
      let buf = await setup()
      let doc = workspace.getDocument(buf.bufnr)
      let r = buf.getFileRange(4)
      await nvim.command(`${r.lnum + 1},${r.lnum + 1}d`)
      await doc.synchronize()
      await assertSynchronized(buf)
    })

    it('should detect insert', async () => {
      let buf = await setup()
      let doc = workspace.getDocument(buf.bufnr)
      let buffer = nvim.createBuffer(buf.bufnr)
      await buffer.append(['foo'])
      await doc.synchronize()
      await assertSynchronized(buf)
      await buffer.append(['foo', '\u3000'])
      await doc.synchronize()
      await assertSynchronized(buf)
    })
  })

  describe('onDocumentChange()', () => {
    it('should ignore when change after range', async () => {
      let doc = await helper.createDocument()
      await doc.buffer.append(['foo', 'bar'])
      await doc.synchronize()
      let buf = await refactor.fromLocations([{ uri: doc.uri, range: Range.create(0, 0, 0, 3) }])
      let lines = await nvim.call('getline', [1, '$'])
      await doc.buffer.append(['def'])
      await doc.synchronize()
      let newLines = await nvim.call('getline', [1, '$'])
      expect(lines).toEqual(newLines)
      await assertSynchronized(buf)
    })

    it('should adjust when change before range', async () => {
      let doc = await helper.createDocument()
      await doc.buffer.append(['', '', '', '', 'foo', 'bar'])
      await doc.synchronize()
      let buf = await refactor.fromLocations([{ uri: doc.uri, range: Range.create(4, 0, 4, 3) }])
      await doc.buffer.setLines(['def'], { start: 0, end: 0, strictIndexing: false })
      await doc.synchronize()
      let fileRange = buf.getFileRange(4)
      expect(fileRange.start).toBe(2)
      expect(fileRange.lines.length).toBe(6)
      await assertSynchronized(buf)
    })

    it('should remove ranges when lines empty', async () => {
      let doc = await helper.createDocument()
      await doc.buffer.append(['', '', '', '', 'foo', 'bar'])
      await doc.synchronize()
      let buf = await refactor.fromLocations([{ uri: doc.uri, range: Range.create(4, 0, 4, 3) }])
      await doc.buffer.setLines([], { start: 0, end: -1, strictIndexing: false })
      await doc.synchronize()
      let lines = await nvim.call('getline', [1, '$'])
      expect(lines.length).toBe(3)
      let items = buf.fileItems
      expect(items.length).toBe(0)
      await assertSynchronized(buf)
    })

    it('should change when liens changed', async () => {
      let doc = await helper.createDocument()
      await doc.buffer.append(['', '', '', '', 'foo', 'bar'])
      await doc.synchronize()
      let buf = await refactor.fromLocations([{ uri: doc.uri, range: Range.create(4, 0, 4, 3) }])
      await doc.buffer.setLines(['def', 'def'], { start: 5, end: 6, strictIndexing: false })
      await doc.synchronize()
      let lines = await nvim.call('getline', [1, '$'])
      expect(lines[lines.length - 2]).toBe('def')
      await assertSynchronized(buf)
    })
  })

  describe('getFileChanges()', () => {
    it('should get changes #1', async () => {
      await helper.createDocument()
      let lines = `
Save current buffer to make changes
\u3000
\u3000
\u3000/a.ts
    })
  } `
      let buf = await refactor.fromLines(lines.split('\n'))
      let changes = await buf.getFileChanges()
      expect(changes).toEqual([{ lnum: 5, filepath: '/a.ts', lines: ['    })', '  } '] }])
    })

    it('should get changes #2', async () => {
      let lines = `
\u3000/a.ts
    })
  } `
      let buf = await refactor.fromLines(lines.split('\n'))
      let changes = await buf.getFileChanges()
      expect(changes).toEqual([{ lnum: 2, filepath: '/a.ts', lines: ['    })', '  } '] }])
    })

    it('should get changes #3', async () => {
      let lines = `
\u3000/a.ts
    })
  }
\u3000`
      let buf = await refactor.fromLines(lines.split('\n'))
      let changes = await buf.getFileChanges()
      expect(changes).toEqual([{ lnum: 2, filepath: '/a.ts', lines: ['    })', '  }'] }])
    })

    it('should get changes #4', async () => {
      let lines = `
\u3000/a.ts
foo
\u3000/b.ts
bar
\u3000`
      let buf = await refactor.fromLines(lines.split('\n'))
      let changes = await buf.getFileChanges()
      expect(changes).toEqual([
        { filepath: '/a.ts', lnum: 2, lines: ['foo'] },
        { filepath: '/b.ts', lnum: 4, lines: ['bar'] }
      ])
    })
  })

  describe('createRefactorBuffer()', () => {
    it('should create refactor buffer', async () => {
      let winid = await nvim.call('win_getid')
      let buf = await refactor.createRefactorBuffer()
      let curr = await nvim.call('win_getid')
      expect(curr).toBeGreaterThan(winid)
      let valid = await buf.valid
      expect(valid).toBe(true)
      buf = await refactor.createRefactorBuffer('vim')
      valid = await buf.valid
      expect(valid).toBe(true)
    })

    it('should use conceal for line numbers', async () => {
      let buf = await refactor.createRefactorBuffer(undefined, true)
      let fileItem: FileItemDef = {
        filepath: __filename,
        ranges: [{ start: 10, end: 11 }, { start: 15, end: 20 }]
      }
      await buf.addFileItems([fileItem])
      let arr = await nvim.call('getmatches') as any[]
      arr = arr.filter(o => o.group == 'Conceal')
      expect(arr.length).toBeGreaterThan(0)
      await buf.addFileItems([{
        filepath: __filename,
        ranges: [{ start: 1, end: 3 }]
      }])
      await nvim.command('normal! ggdG')
      let doc = workspace.getDocument(buf.bufnr)
      await doc.synchronize()
      let b = nvim.createBuffer(buf.bufnr)
      let res = await b.getVar('line_infos')
      expect(res).toEqual({})
    })
  })

  describe('splitOpen()', () => {
    async function setup(): Promise<RefactorBuffer> {
      let buf = await refactor.createRefactorBuffer()
      let fileItem: FileItemDef = {
        filepath: __filename,
        ranges: [{ start: 10, end: 11 }, { start: 15, end: 20 }]
      }
      await buf.addFileItems([fileItem])
      await nvim.call('cursor', [5, 1])
      return buf
    }

    it('should jump to position by <CR>', async () => {
      let buf = await setup()
      await buf.splitOpen()
      let line = await nvim.eval('line(".")')
      let bufname = await nvim.eval('bufname("%")')
      expect(bufname).toMatch('refactor.test.ts')
      expect(line).toBe(11)
    })

    it('should jump split window when original window not valid', async () => {
      let win = await nvim.window
      let buf = await setup()
      await nvim.call('nvim_win_close', [win.id, true])
      await buf.splitOpen()
      let line = await nvim.eval('line(".")')
      let bufname = await nvim.eval('bufname("%")')
      expect(bufname).toMatch('refactor.test.ts')
      expect(line).toBe(11)
    })
  })

  describe('showMenu()', () => {
    async function setup(): Promise<RefactorBuffer> {
      let buf = await refactor.createRefactorBuffer()
      let fileItem: FileItemDef = {
        filepath: __filename,
        ranges: [{ start: 10, end: 11 }, { start: 15, end: 20 }]
      }
      await buf.addFileItems([fileItem])
      await nvim.call('cursor', [5, 1])
      return buf
    }

    it('should do nothing when cancelled or range not found', async () => {
      let buf = await setup()
      let p = buf.showMenu()
      await helper.wait(50)
      await nvim.input('<esc>')
      await p
      let bufnr = await nvim.call('bufnr', ['%'])
      expect(bufnr).toBe(buf.bufnr)
      await nvim.call('cursor', [1, 1])
      p = buf.showMenu()
      await helper.wait(50)
      await nvim.input('1')
      await p
      bufnr = await nvim.call('bufnr', ['%'])
      expect(bufnr).toBe(buf.bufnr)
    })

    it('should open file in new tab', async () => {
      let buf = await setup()
      await nvim.call('cursor', [4, 1])
      let p = buf.showMenu()
      await helper.wait(30)
      await nvim.input('1')
      await p
      let nr = await nvim.call('tabpagenr')
      expect(nr).toBe(2)
      let lnum = await nvim.call('line', ['.'])
      expect(lnum).toBe(11)
    })

    it('should remove current block', async () => {
      let buf = await setup()
      await nvim.call('cursor', [4, 1])
      let p = buf.showMenu()
      await helper.wait(30)
      await nvim.input('2')
      await p
      let items = buf.fileItems
      expect(items[0].ranges.length).toBe(1)
      await assertSynchronized(buf)
    })
  })

  describe('saveRefactor()', () => {
    it('should adjust line ranges after change', async () => {
      let filename = await createTmpFile('foo\n\nbar\n')
      let fileItem: FileItemDef = {
        filepath: filename,
        ranges: [{ start: 0, end: 1 }, { start: 2, end: 3 }]
      }
      let buf = await refactor.createRefactorBuffer()
      const getRanges = () => {
        let items = buf.fileItems
        let item = items.find(o => o.filepath == filename)
        return item.ranges.map(o => {
          return [o.start, o.start + o.lines.length]
        })
      }
      await buf.addFileItems([fileItem, {
        filepath: __filename,
        ranges: [{ start: 1, end: 5 }]
      }])
      expect(getRanges()).toEqual([[0, 1], [2, 3]])
      nvim.pauseNotification()
      nvim.call('setline', [5, ['xyoo']], true)
      nvim.command('undojoin', true)
      nvim.call('append', [5, ['de']], true)
      nvim.command('undojoin', true)
      nvim.call('setline', [9, ['b']], true)
      await nvim.resumeNotification()
      let doc = workspace.getDocument(buf.bufnr)
      await doc.synchronize()
      let res = await refactor.save(buf.buffer.id)
      expect(res).toBe(true)
      expect(getRanges()).toEqual([[0, 2], [3, 4]])
      let content = fs.readFileSync(filename, 'utf8')
      expect(content).toBe('xyoo\nde\n\nb\n')
    })

    it('should not save when no change made', async () => {
      let buf = await refactor.createRefactorBuffer()
      let fileItem: FileItemDef = {
        filepath: __filename,
        ranges: [{ start: 10, end: 11 }, { start: 15, end: 20 }]
      }
      await buf.addFileItems([fileItem])
      let res = await buf.save()
      expect(res).toBe(false)
    })

    it('should sync buffer change to file', async () => {
      let doc = await helper.createDocument()
      await doc.buffer.replace(['foo', 'bar', 'line'], 0)
      await helper.wait(30)
      let filename = URI.parse(doc.uri).fsPath
      let fileItem: FileItemDef = {
        filepath: filename,
        ranges: [{ start: 0, end: 2 }]
      }
      let buf = await refactor.createRefactorBuffer()
      await buf.addFileItems([fileItem])
      await nvim.call('setline', [5, 'changed'])
      let res = await buf.save()
      expect(res).toBe(true)
      expect(fs.existsSync(filename)).toBe(true)
      let content = fs.readFileSync(filename, 'utf8')
      let lines = content.split('\n')
      expect(lines).toEqual(['changed', 'bar', 'line', ''])
      fs.unlinkSync(filename)
    })
  })

  describe('doRefactor', () => {
    let disposable: Disposable

    afterEach(() => {
      if (disposable) disposable.dispose()
      disposable = null
    })

    it('should throw when rename provider not found', async () => {
      await helper.createDocument()
      let err
      try {
        await refactor.doRefactor()
      } catch (e) {
        err = e
      }
      expect(err).toBeDefined()
    })

    it('should show message when prepare failed', async () => {
      await helper.createDocument()
      disposable = languages.registerRenameProvider(['*'], {
        prepareRename: () => {
          return undefined
        },
        provideRenameEdits: () => {
          return null
        }
      })
      await refactor.doRefactor()
      let res = await helper.getCmdline()
      expect(res).toMatch(/unable to rename/)
    })

    it('should show message when returned edits is null', async () => {
      await helper.createDocument()
      disposable = languages.registerRenameProvider(['*'], {
        provideRenameEdits: () => {
          return null
        }
      })
      await refactor.doRefactor()
      let res = await helper.getCmdline()
      expect(res).toMatch(/returns null/)
    })

    it('should open refactor window when edits is valid', async () => {
      let filepath = __filename
      disposable = languages.registerRenameProvider(['*'], {
        provideRenameEdits: () => {
          let changes = {
            [URI.file(filepath).toString()]: [{
              range: Range.create(0, 0, 0, 6),
              newText: ''
            }, {
              range: Range.create(1, 0, 1, 6),
              newText: ''
            }]
          }
          let edit: WorkspaceEdit = { changes }
          return edit
        }
      })
      await helper.createDocument(filepath)
      let winid = await nvim.call('win_getid')
      await refactor.doRefactor()
      let currWin = await nvim.call('win_getid')
      expect(currWin - winid).toBeGreaterThan(0)
      let bufnr = await nvim.call('bufnr', ['%'])
      let b = refactor.getBuffer(bufnr)
      expect(b).toBeDefined()
    })
  })

  describe('search', () => {
    it('should open refactor buffer from search result', async () => {
      let escaped = await nvim.call('fnameescape', [__dirname])
      await nvim.command(`cd ${escaped}`)
      await helper.createDocument()
      await refactor.search(['registerRenameProvider'])
      let buf = await nvim.buffer
      let name = await buf.name
      expect(name).toMatch(/__coc_refactor__/)
      let lines = await buf.lines
      expect(lines[0]).toMatch(/Save current buffer/)
    })
  })
})