" Define a function Input(function) implementing input() with completion.
" Other actions are possible, too.
"
" The completion must be handled by the function given as argument. It will be
" invoked in three different ways:
"
" 1) function("init")
"
" The function can set up command line mode mappings that set the global
" variable 'g:InputHandlerString'. If set to the empty string, Input() will
" terminate. Mappings for <C-C> will be overriden and the special string
" "CtrlC" is reserved.
"
" For all this to work, the mappings should be of the form of eg.
"
"    cnoremap <Tab> <C-R>=KeyHandler("Tab")<CR><CR>
"    fun KeyHandler(key)
"       let g:InputHandlerString = a:key
"       return ''
"   endfun
"
" Note that an empty string is returned. If not, vim will return 0, which is
" inserted at the current cursor position in the input() string.
"
" 2) function("handle", str)
"
" The function is handed the current string used by the input() cycle.
" Depending on the value of the 'g:InputHandlerString' variable, different
" actions can be taken. Whatever is returned by the function is used in the
" next input() cycle.
"
" 3) function("cleanup")
"
" The function should reset mappings defined during initialisation.
"
" ----------------------------------------------------------------------------
"
" A fairly silly example of all this, which does not behave well and just
" overrides a mapping for <Tab>:
"
"   fun! <SID>KeyHandler(key)
"       let g:InputHandlerString = a:key
"       return ''
"   endfun
"
"   fun! InputFoo(action, ...)
"       if a:action == "init"
"           cnoremap <Tab> <C-R>=<SID>KeyHandler("Tab")<CR><CR>
"           return ''
"       elseif a:action == "cleanup"
"           silent! cunmap <Tab>
"           return ''
"       endif
"       " Handle completion.
"       if a:1 == 'foo'
"           return a:1 . 'bar'
"       elseif a:1 == 'foobar'
"           return 'foo'
"       endif
"       return a:1
"   endfun
"
"   :call Input("InputFoo")
"   What: foo<Tab><Tab><Tab><CR>
"
" TODO: recursion of Input() calls.

" ----------------------------------------------------------------------------

" Internal function to detect CTRL-C.
" The "CtrlC" key is reserved for this script to handle abortion.
fun! s:InputCtrlC()
    let g:InputHandlerString = "CtrlC"
    return ''
endfun

" Function to safely map <C-C>.
" TODO: Information on :cnoremap'ed mappings are lost.
" TODO: We cannot fully rely on maparg() (eg. if a key is mapped to <Nop>).
" TODO: If a <buffer> and regular map are identical, only the regular one is
"       restored later on.
" TODO: If more than <buffer> and standard maps are stacked, this approach
"       is not the best. Not sure if they can be.
"       A bit of testing indicates that <script> mappings do not interfer.
" TODO: One idea for all of the above is to use ":redir @z" and
"       ":silent cmap <C-C>" - but then we may loose information on a
"       blockwise register.
fun! s:InputInitCtrlC()
    let s:map_buffer_ctrl_c = ''
    let s:map_ctrl_c = ''
    let mapcc1 = maparg('<C-C>', 'c')
    silent! cunmap <buffer> <C-C>
    if mapcc1 != ''
        let mapcc2 = maparg('<C-C>', 'c')
        if mapcc2 == ''
            let s:map_ctrl_c = mapcc1
        else
            let s:map_buffer_ctrl_c = mapcc1
            let s:map_ctrl_c = mapcc2
        endif
    endif
    silent! cunmap <C-C>
    cnoremap <C-C> <C-R>=s:InputCtrlC()<CR><CR>
endfun

" Function to restore maps set by s:InputMapInitCtrlC().
" It must be called after InputMapInitCtrlC().
" TODO: Take the TODO items for s:InputMapInitCtrlC() into account.
fun! s:InputRestoreCtrlC()
    if s:map_buffer_ctrl_c != ''
        exec 'cmap <C-C> ' . s:map_buffer_ctrl_c
    endif
    if s:map_ctrl_c != ''
        exec 'cmap <C-C> ' . s:map_ctrl_c
    endif
endfun

" input() function with completion of 'foo' to 'foobar'
" May 
fun! Input(function)
    let prompt = 'What: '
    echo 'call ' . a:function . '("init")'
    exec 'call ' . a:function . '("init")'
    call s:InputInitCtrlC()
    let g:InputHandlerString = ''
    let str = input(prompt)
    while g:InputHandlerString != ''
        if g:InputHandlerString ==# 'CtrlC'
            let str = ''
            break
        endif
        exec 'let str = ' . a:function . '("handle", str)'
        let g:InputHandlerString = ''
        let str = input(prompt, str)
    endwhile
    call s:InputRestoreCtrlC()
    exec 'call ' . a:function . '("cleanup")'
    return str
endfun