function! asyncomplete#log(...) abort
    if !empty(g:asyncomplete_log_file)
        call writefile([json_encode(a:000)], g:asyncomplete_log_file, 'a')
    endif
endfunction

" do nothing, place it here only to avoid the message
augroup asyncomplete_silence_messages
    au!
    autocmd User asyncomplete_setup silent
augroup END

if !has('timers')
    echohl ErrorMsg
    echomsg 'Vim/Neovim compiled with timers required for asyncomplete.vim.'
    echohl NONE
    if has('nvim')
        call asyncomplete#log('neovim compiled with timers required.')
    else
        call asyncomplete#log('vim compiled with timers required.')
    endif
    " Clear augroup so this message is only displayed once.
    au! asyncomplete_enable *
    finish
endif

let s:already_setup = 0
let s:sources = {}
let s:matches = {} " { server_name: { incomplete: 1, startcol: 0, items: [], refresh: 0, status: 'idle|pending|success|failure', ctx: ctx } }
let s:has_complete_info = exists('*complete_info')
let s:has_matchfuzzypos = exists('*matchfuzzypos')

function! s:setup_if_required() abort
    if !s:already_setup
        " register asyncomplete change manager
        for l:change_manager in g:asyncomplete_change_manager
            call asyncomplete#log('core', 'initializing asyncomplete change manager', l:change_manager)
            if type(l:change_manager) == type('')
                execute 'let s:on_change_manager = function("'. l:change_manager  .'")()'
            else
                let s:on_change_manager = l:change_manager()
            endif
            if has_key(s:on_change_manager, 'error')
                call asyncomplete#log('core', 'initializing asyncomplete change manager failed', s:on_change_manager['name'], s:on_change_manager['error'])
            else
                call s:on_change_manager.register(function('s:on_change'))
                call asyncomplete#log('core', 'initializing asyncomplete change manager complete', s:on_change_manager['name'])
                break
            endif
        endfor

        augroup asyncomplete
            autocmd!
            autocmd InsertEnter * call s:on_insert_enter()
            autocmd InsertLeave * call s:on_insert_leave()
        augroup END

        doautocmd <nomodeline> User asyncomplete_setup
        let s:already_setup = 1
    endif
endfunction

function! asyncomplete#enable_for_buffer() abort
    call s:setup_if_required()
    let b:asyncomplete_enable = 1
endfunction

function! asyncomplete#disable_for_buffer() abort
    let b:asyncomplete_enable = 0
endfunction

function! asyncomplete#get_source_names() abort
    return keys(s:sources)
endfunction

function! asyncomplete#get_source_info(source_name) abort
    return s:sources[a:source_name]
endfunction

function! asyncomplete#register_source(info) abort
    if has_key(s:sources, a:info['name'])
        call asyncomplete#log('core', 'duplicate asyncomplete#register_source', a:info['name'])
        return -1
    else
        let s:sources[a:info['name']] = a:info
        if has_key(a:info, 'events') && has_key(a:info, 'on_event')
            execute 'augroup asyncomplete_source_event_' . a:info['name']
            for l:event in a:info['events']
                let l:exec =  'if get(b:,"asyncomplete_enable",0) | call s:notify_event_to_source("' . a:info['name'] . '", "'.l:event.'",asyncomplete#context()) | endif'
                if type(l:event) == type('')
                    execute 'au ' . l:event . ' * ' . l:exec
                elseif type(l:event) == type([])
                    execute 'au ' . join(l:event,' ') .' ' .  l:exec
                endif
            endfor
            execute 'augroup end'
        endif

        if exists('b:asyncomplete_active_sources')
          unlet b:asyncomplete_active_sources
          call s:get_active_sources_for_buffer()
        endif

        if exists('b:asyncomplete_triggers')
          unlet b:asyncomplete_triggers
          call s:update_trigger_characters()
        endif

        return 1
    endif
endfunction

function! asyncomplete#unregister_source(info_or_server_name) abort
    if type(a:info_or_server_name) == type({})
        let l:server_name = a:info_or_server_name['name']
    else
        let l:server_name = a:info_or_server_name
    endif
    if has_key(s:sources, l:server_name)
        let l:server = s:sources[l:server_name]
        if has_key(l:server, 'unregister')
            call l:server.unregister()
        endif
        unlet s:sources[l:server_name]
        return 1
    else
        return -1
    endif
endfunction

function! asyncomplete#context() abort
    let l:ret = {'bufnr':bufnr('%'), 'curpos':getcurpos(), 'changedtick':b:changedtick}
    let l:ret['lnum'] = l:ret['curpos'][1]
    let l:ret['col'] = l:ret['curpos'][2]
    let l:ret['filetype'] = &filetype
    let l:ret['filepath'] = expand('%:p')
    let l:ret['typed'] = strpart(getline(l:ret['lnum']),0,l:ret['col']-1)
    return l:ret
endfunction

function! s:on_insert_enter() abort
    call s:get_active_sources_for_buffer() " call to cache
    call s:update_trigger_characters()
endfunction

function! s:on_insert_leave() abort
    let s:matches = {}
    if exists('s:update_pum_timer')
        call timer_stop(s:update_pum_timer)
        unlet s:update_pum_timer
    endif
endfunction

function! s:get_active_sources_for_buffer() abort
    if exists('b:asyncomplete_active_sources')
        " active sources were cached for buffer
        return b:asyncomplete_active_sources
    endif

    call asyncomplete#log('core', 'computing active sources for buffer', bufnr('%'))
    let b:asyncomplete_active_sources = []
    for [l:name, l:info] in items(s:sources)
        let l:blocked = 0

        if has_key(l:info, 'blocklist')
            let l:blocklistkey = 'blocklist'
        else
            let l:blocklistkey = 'blacklist'
        endif
        if has_key(l:info, l:blocklistkey)
            for l:filetype in l:info[l:blocklistkey]
                if l:filetype == &filetype || l:filetype is# '*'
                    let l:blocked = 1
                    break
                endif
            endfor
        endif

        if l:blocked
            continue
        endif

        if has_key(l:info, 'allowlist')
            let l:allowlistkey = 'allowlist'
        else
            let l:allowlistkey = 'whitelist'
        endif
        if has_key(l:info, l:allowlistkey)
            for l:filetype in l:info[l:allowlistkey]
                if l:filetype == &filetype || l:filetype is# '*'
                    let b:asyncomplete_active_sources += [l:name]
                    break
                endif
            endfor
        endif
    endfor

    call asyncomplete#log('core', 'active source for buffer', bufnr('%'), b:asyncomplete_active_sources)

    return b:asyncomplete_active_sources
endfunction

function! s:update_trigger_characters() abort
    if exists('b:asyncomplete_triggers')
        " triggers were cached for buffer
        return b:asyncomplete_triggers
    endif
    let b:asyncomplete_triggers = {} " { char: { 'sourcea': 1, 'sourceb': 2 } }

    for l:source_name in s:get_active_sources_for_buffer()
        let l:source_info = s:sources[l:source_name]
        if has_key(l:source_info, 'triggers') && has_key(l:source_info['triggers'], &filetype)
            let l:triggers = l:source_info['triggers'][&filetype]
        elseif has_key(l:source_info, 'triggers') && has_key(l:source_info['triggers'], '*')
            let l:triggers = l:source_info['triggers']['*']
        elseif has_key(g:asyncomplete_triggers, &filetype)
            let l:triggers = g:asyncomplete_triggers[&filetype]
        elseif has_key(g:asyncomplete_triggers, '*')
            let l:triggers = g:asyncomplete_triggers['*']
        else
            let l:triggers = []
        endif

        for l:trigger in l:triggers
            let l:last_char = l:trigger[len(l:trigger) -1]
            if !has_key(b:asyncomplete_triggers, l:last_char)
                let b:asyncomplete_triggers[l:last_char] = {}
            endif
            if !has_key(b:asyncomplete_triggers[l:last_char], l:source_name)
                let b:asyncomplete_triggers[l:last_char][l:source_name] = []
            endif
            call add(b:asyncomplete_triggers[l:last_char][l:source_name], l:trigger)
        endfor
    endfor
    call asyncomplete#log('core', 'trigger characters for buffer', bufnr('%'), b:asyncomplete_triggers)
endfunction

function! s:should_skip() abort
    if mode() isnot# 'i' || !get(b:, 'asyncomplete_enable', 0)
        return 1
    else
        return 0
    endif
endfunction

function! asyncomplete#close_popup() abort
  return pumvisible() ? "\<C-y>" : ''
endfunction

function! asyncomplete#cancel_popup() abort
  return pumvisible() ? "\<C-e>" : ''
endfunction

function! s:get_min_chars(source_name) abort
  if exists('b:asyncomplete_min_chars')
    return b:asyncomplete_min_chars
  elseif has_key(s:sources, a:source_name)
    return get(s:sources[a:source_name], 'min_chars', g:asyncomplete_min_chars)
  endif
  return g:asyncomplete_min_chars
endfunction

function! s:on_change() abort
    if s:should_skip() | return | endif

    if !g:asyncomplete_auto_popup
        return
    endif

    let l:ctx = asyncomplete#context()
    let l:last_char = l:ctx['typed'][l:ctx['col'] - 2] " col is 1-indexed, but str 0-indexed
    if exists('b:asyncomplete_triggers')
        let l:triggered_sources = get(b:asyncomplete_triggers, l:last_char, {})
    else
        let l:triggered_sources = {}
    endif
    let l:refresh_pattern = get(b:, 'asyncomplete_refresh_pattern', '\(\k\+$\)')
    let [l:_, l:startidx, l:endidx] = asyncomplete#utils#matchstrpos(l:ctx['typed'], l:refresh_pattern)

    for l:source_name in get(b:, 'asyncomplete_active_sources', [])
        " match sources based on the last character if it is a trigger character
        " TODO: also check for multiple chars instead of just last chars for
        " languages such as cpp which uses -> and ::
        if has_key(l:triggered_sources, l:source_name)
            let l:startcol = l:ctx['col']
        elseif l:startidx > -1
            let l:startcol = l:startidx + 1 " col is 1-indexed, but str 0-indexed
        endif
        " here we use the existence of `l:startcol` to determine whether to
        " use this completion source. If `l:startcol` exists, we use the
        " source. If it does not exist, it means that we cannot get a
        " meaningful starting point for the current source, and this implies
        " that we cannot use this source for completion. Therefore, we remove
        " the matches from the source.
        if exists('l:startcol') && l:endidx - l:startidx >= s:get_min_chars(l:source_name)
            if !has_key(s:matches, l:source_name) || s:matches[l:source_name]['ctx']['lnum'] !=# l:ctx['lnum'] || s:matches[l:source_name]['startcol'] !=# l:startcol
                let s:matches[l:source_name] = { 'startcol': l:startcol, 'status': 'idle', 'items': [], 'refresh': 0, 'ctx': l:ctx }
            endif
        else
            if has_key(s:matches, l:source_name)
                unlet s:matches[l:source_name]
            endif
        endif
    endfor

    call s:trigger(l:ctx)
    call s:update_pum()
endfunction

function! s:trigger(ctx) abort
    " send cancellation request if supported
    for [l:source_name, l:matches] in items(s:matches)
        call asyncomplete#log('core', 's:trigger', l:matches)
        if l:matches['refresh'] || l:matches['status'] ==# 'idle' || l:matches['status'] ==# 'failure'
            let l:matches['status'] = 'pending'
            try
                " TODO: check for min chars
                call asyncomplete#log('core', 's:trigger.completor()', l:source_name, s:matches[l:source_name], a:ctx)
                call s:sources[l:source_name].completor(s:sources[l:source_name], a:ctx)
            catch
                let l:matches['status'] = 'failure'
                call asyncomplete#log('core', 's:trigger', 'error', v:exception)
                continue
            endtry
        endif
    endfor
endfunction

function! asyncomplete#complete(name, ctx, startcol, items, ...) abort
    let l:refresh = a:0 > 0 ? a:1 : 0
    let l:ctx = asyncomplete#context()
    if !has_key(s:matches, a:name) || l:ctx['lnum'] != a:ctx['lnum'] " TODO: handle more context changes
        call asyncomplete#log('core', 'asyncomplete#log', 'ignoring due to context chnages', a:name, a:ctx, a:startcol, l:refresh, a:items)
        call s:update_pum()
        return
    endif

    call asyncomplete#log('asyncomplete#complete', a:name, a:ctx, a:startcol, l:refresh, a:items)

    let l:matches = s:matches[a:name]
    let l:matches['items'] = s:normalize_items(a:items)
    let l:matches['refresh'] = l:refresh
    let l:matches['startcol'] = a:startcol
    let l:matches['status'] = 'success'

    call s:update_pum()
endfunction

function! s:normalize_items(items) abort
    if len(a:items) > 0 && type(a:items[0]) ==# type('')
        let l:items = []
        for l:item in a:items
            let l:items += [{'word': l:item }]
        endfor
        return l:items
    else
        return a:items
    endif
endfunction

function! asyncomplete#force_refresh() abort
    return asyncomplete#menu_selected() ? "\<c-y>\<c-r>=asyncomplete#_force_refresh()\<CR>" : "\<c-r>=asyncomplete#_force_refresh()\<CR>"
endfunction

function! asyncomplete#_force_refresh() abort
    if s:should_skip() | return | endif

    let l:ctx = asyncomplete#context()
    let l:startcol = l:ctx['col']
    let l:last_char = l:ctx['typed'][l:startcol - 2]

    " loop left and find the start of the word or trigger chars and set it as the startcol for the source instead of refresh_pattern
    let l:refresh_pattern = get(b:, 'asyncomplete_refresh_pattern', '\(\k\+$\)')
    let [l:_, l:startidx, l:endidx] = asyncomplete#utils#matchstrpos(l:ctx['typed'], l:refresh_pattern)
    " When no word here, startcol is current col
    let l:startcol = l:startidx == -1 ? col('.') : l:startidx + 1

    let s:matches = {}

    for l:source_name in get(b:, 'asyncomplete_active_sources', [])
        let s:matches[l:source_name] = { 'startcol': l:startcol, 'status': 'idle', 'items': [], 'refresh': 0, 'ctx': l:ctx }
    endfor

    call s:trigger(l:ctx)
    call s:update_pum()
    return ''
endfunction

function! s:update_pum() abort
    if exists('s:update_pum_timer')
        call timer_stop(s:update_pum_timer)
        unlet s:update_pum_timer
    endif
    call asyncomplete#log('core', 's:update_pum')
    let s:update_pum_timer = timer_start(g:asyncomplete_popup_delay, function('s:recompute_pum'))
endfunction

function! s:recompute_pum(...) abort
    if s:should_skip() | return | endif

    " TODO: add support for remote recomputation of complete items,
    " Ex: heavy computation such as fuzzy search can happen in a python thread

    call asyncomplete#log('core', 's:recompute_pum')

    if asyncomplete#menu_selected()
        call asyncomplete#log('core', 's:recomputed_pum', 'ignorning refresh pum due to menu selection')
        return
    endif

    let l:ctx = asyncomplete#context()

    let l:startcols = []
    let l:matches_to_filter = {}

    for [l:source_name, l:match] in items(s:matches)
        " ignore sources that have been unregistered
        if !has_key(s:sources, l:source_name) | continue | endif
        let l:startcol = l:match['startcol']
        let l:startcols += [l:startcol]
        let l:curitems = l:match['items']

        if l:startcol > l:ctx['col']
            call asyncomplete#log('core', 's:recompute_pum', 'ignoring due to wrong start col', l:startcol, l:ctx['col'])
            continue
        else
            let l:matches_to_filter[l:source_name] = l:match
        endif
    endfor

    let l:startcol = min(l:startcols)
    let l:base = l:ctx['typed'][l:startcol - 1:] " col is 1-indexed, but str 0-indexed

    let l:filter_ctx = extend({
        \ 'base': l:base,
        \ 'startcol': l:startcol,
        \ }, l:ctx)

    let l:mode = s:has_complete_info ? complete_info(['mode'])['mode'] : 'unknown'
    if l:mode ==# '' || l:mode ==# 'eval' || l:mode ==# 'unknown'
        let l:Preprocessor = empty(g:asyncomplete_preprocessor) ? function('s:default_preprocessor') : g:asyncomplete_preprocessor[0]
        call l:Preprocessor(l:filter_ctx, l:matches_to_filter)
    endif
endfunction

let s:pair = {
\  '"':  '"',
\  '''':  '''',
\}

function! s:default_preprocessor(options, matches) abort
    let l:items = []
    let l:startcols = []
    for [l:source_name, l:matches] in items(a:matches)
        let l:startcol = l:matches['startcol']
        let l:base = a:options['typed'][l:startcol - 1:]
        if has_key(s:sources[l:source_name], 'filter')
            let l:result = s:sources[l:source_name].filter(l:matches, l:startcol, l:base)
            let l:items += l:result[0]
            let l:startcols += l:result[1]
        else
            if empty(l:base)
                for l:item in l:matches['items']
                    call add(l:items, s:strip_pair_characters(l:base, l:item))
                    let l:startcols += [l:startcol]
                endfor
            elseif s:has_matchfuzzypos && g:asyncomplete_matchfuzzy
                for l:item in matchfuzzypos(l:matches['items'], l:base, {'key':'word'})[0]
                    call add(l:items, s:strip_pair_characters(l:base, l:item))
                    let l:startcols += [l:startcol]
                endfor
            else
                for l:item in l:matches['items']
                    if stridx(l:item['word'], l:base) == 0
                        call add(l:items, s:strip_pair_characters(l:base, l:item))
                        let l:startcols += [l:startcol]
                    endif
                endfor
            endif
        endif
    endfor

    let a:options['startcol'] = min(l:startcols)

    call asyncomplete#preprocess_complete(a:options, l:items)
endfunction

function! s:strip_pair_characters(base, item) abort
    " Strip pair characters. If pre-typed text is '"', candidates
    " should have '"' suffix.
    let l:item = a:item
    if has_key(s:pair, a:base[0])
        let [l:lhs, l:rhs, l:str] = [a:base[0], s:pair[a:base[0]], l:item['word']]
        if len(l:str) > 1 && l:str[0] ==# l:lhs && l:str[-1:] ==# l:rhs
            let l:item = extend({}, l:item)
            let l:item['word'] = l:str[:-2]
        endif
    endif
    return l:item
endfunction

function! asyncomplete#preprocess_complete(ctx, items) abort
    " TODO: handle cases where this is called asynchronsouly. Currently not supported
    if s:should_skip() | return | endif

    call asyncomplete#log('core', 'asyncomplete#preprocess_complete')

    if asyncomplete#menu_selected()
        call asyncomplete#log('core', 'asyncomplete#preprocess_complete', 'ignorning pum update due to menu selection')
        return
    endif

    if (g:asyncomplete_auto_completeopt == 1)
        setl completeopt=menuone,noinsert,noselect
    endif

    let l:startcol = a:ctx['startcol']
    call asyncomplete#log('core', 'asyncomplete#preprocess_complete calling complete()', l:startcol, a:items)
    if l:startcol > 0 " Prevent E578: Not allowed to change text here
        call complete(l:startcol, a:items)
    endif
endfunction

function! asyncomplete#menu_selected() abort
    " when the popup menu is visible, v:completed_item will be the
    " current_selected item
    " if v:completed_item is empty, no item is selected
    return pumvisible() && !empty(v:completed_item)
endfunction

function! s:notify_event_to_source(name, event, ctx) abort
    try
        if has_key(s:sources, a:name)
            call s:sources[a:name].on_event(s:sources[a:name], a:ctx, a:event)
        endif
    catch
        call asyncomplete#log('core', 's:notify_event_to_source', 'error', v:exception)
        return
    endtry
endfunction