" Author: Mykola Golubyev ( Nickolay Golubev )
" Email: golubev.nikolay@gmail.com
" Site: www.railmoon.com
" Plugin: oscan
" Purpose: quick move through current document or through any entities that can be tagged


if ! exists('g:ctags_exe')
    if exists('Tlist_Ctags_Cmd')
        let g:ctags_exe = Tlist_Ctags_Cmd
    else
        let g:ctags_exe = "ctags"
    endif
endif

let s:previous_records_to_print_count = 1
let s:previous_suggestions_count = 1
let s:records_to_print = []
let s:suggestions = []
" - 
" [ internal usage ]
" Purpose: find tag position inside line. 
"          tag can be with spaces. delimiter is comma.
"          return list with begin and end ( start from 0 ).
" [ parameters ]
"   line        string
"   column      column that starts from 1
" -
function! s:tag_in_line_position(line, column)
    let column = a:column - 1

    while a:line[column] == ',' && column > 0
        let column -= 1
    endwhile

    let begin = column 
    let end = column
    let length = len(a:line)

    while begin > 0 && a:line[begin - 1] != ','
        let begin -= 1
    endwhile

    while end < length && a:line[end + 1] != ','
        let end += 1
    endwhile

    return [begin, end]
endfunction

" - 
" [ internal usage ]
" Purpose: find tag inside line. 
"          details in function above
" [ parameters ]
"   line        string
"   column      column that starts from 1
" -
function! s:tag_in_line(line, column)
    let position = s:tag_in_line_position(a:line, a:column)

    let result = a:line[position[0] : position[1]]
    if result == ','
        return ''
    endif

    return result
endfunction

" -
" call backs for widgets
" -
let s:plugin_window_goes_close = 0
let s:common_widget_callback = {}

function! s:common_widget_callback.on_close()
    call railmoon#trace#push('common_widget_callback.on_close')
    try

        let s:plugin_window_goes_close = 1

        call s:turnon_unexpected_plugins()

        call railmoon#trace#debug('tabclose')
        tabclose

        call railmoon#widget#window#load_selected(s:plugin_invoker_position)

    finally
        call railmoon#trace#debug('...')
        call railmoon#trace#pop()
    endtry
endfunction

function! s:common_widget_callback.on_tab_leave()
    call railmoon#trace#push('common_widget_callback.on_tab_leave')
    try

        call railmoon#trace#debug('leaving tab')
        if ! s:plugin_window_goes_close
            let s:plugin_window_goes_close = 1
            call s:turnon_unexpected_plugins()
            tabclose " TODO make sure we close right tabpage
        endif

    finally
        call railmoon#trace#debug('...')
        call railmoon#trace#pop()
    endtry
endfunction

function! s:common_widget_callback.on_close_with_tab_page()
    call railmoon#trace#push('common_widget_callback.on_close_with_tab_page')
    try
    finally
        call railmoon#trace#debug('...')
        call railmoon#trace#pop()
    endtry
endfunction

let s:suggestion_window_callback = copy(s:common_widget_callback)
function! s:suggestion_window_callback.on_select(line)
endfunction

let s:result_window_callback = copy(s:common_widget_callback)
function! s:result_window_callback.on_select(line)
    call s:result_select()
endfunction

let s:tag_enter_window_callback = copy(s:common_widget_callback)
let s:tag_enter_window_callback.edit_column = -1

let s:suggestion_window_model = {}
function! s:suggestion_window_model.get_item(i)
    let item = { 'data':[], 'header':'' }
    if len(s:suggestions) > 0
        call add(item.data, s:suggestions[a:i] )
    endif

    return item
endfunction

function! s:suggestion_window_model.get_item_count()
    return len(s:suggestions)
endfunction

let s:result_window_model = {}
function! s:result_window_model.get_item(i)
    if len(s:records_to_print) == 0
        return {'data':[], 'header':''}
    endif 

    let record = s:records_to_print[a:i]
    let item = { 'data':[], 'header':record.additional_info }
    call extend( item.data, record.header )
    return item
endfunction

function! s:result_window_model.get_item_count()
    return len(s:records_to_print)
endfunction

function! s:tag_enter_window_callback.on_type(character, is_alpha_numeric)
    let line = getline('.')
    let column = col('.')

    " magic with ','
    " change entered part to tag from suggestion list
    " TODO clean algorithm
    " TODO extract method and test it
    if ! a:is_alpha_numeric
        if a:character == ',' && self.available_tags_window.model.get_item_count() > 0
            let selected_tag = self.available_tags_window.selected_item()

            let position = s:tag_in_line_position(line, column)
            let begin = position[0]
            let end = position[1]
    
                
            if begin != 0
                let new_line = line[ : begin - 1] 
            else
                let new_line = ''
            endif

            let selected_tag_text = selected_tag.data[0]

            if line[end + 1] == ','
                let new_line .= selected_tag_text . line[ end + 1: ]
            else
                let new_line .= selected_tag_text . ',' . line[ end + 1 : ]
            endif

            call self.edit_line_window.set_line(new_line)
            call self.edit_line_window.go_to_position(begin + len(selected_tag_text) + 2)
        endif
        return ''
    endif

    " character isn't at line yet
    " so imagine it'is here
    let line_with_character = line[ : column] . a:character . line[column + 1 : ]
    let current_tag = s:tag_in_line(line_with_character, column)
    
    let suggestions = self.refresh_suggestion_list(current_tag, line_with_character)

    let self.edit_column = col('.') + 1
    if empty(suggestions)
        return ''
    endif

    return a:character
endfunction

function! s:suggestions_sort(lhs, rhs)
    if a:lhs == a:rhs
        return 0
    endif

    let as_current_tag_start_pattern = '^'.s:current_tag
    let number_pattern = '\d\+'

    let left_is_number = a:lhs =~ number_pattern
    let right_is_number = a:rhs =~ number_pattern

    if a:lhs =~ as_current_tag_start_pattern && a:rhs !~ as_current_tag_start_pattern
        return -1
    endif

    if left_is_number && right_is_number
        return a:lhs > a:rhs ? 1 : -1
    endif

    if left_is_number && ! right_is_number
        return 1
    endif

    if right_is_number && ! left_is_number
        return -1
    endif 

    if a:lhs !~ as_current_tag_start_pattern && a:rhs =~ as_current_tag_start_pattern
        return 1
    endif

    return a:lhs > a:rhs ? 1 : -1
endfunction

function! s:tag_enter_window_callback.refresh_suggestion_list(current_tag, line)
    let entered_tags = split(a:line, ',')

    let current_tag = a:current_tag
    if current_tag == '.'
        let current_tag = '\.'
    endif

    if current_tag =~ '"'
        call filter(entered_tags, "v:val != '". current_tag. "'")
    else
        call filter(entered_tags, 'v:val != "'.current_tag.'"')
    endif
    call add(entered_tags, '~'.current_tag)

    let available_records = s:record_browser.get_matched_records( entered_tags )
    let available_tags = s:record_browser.get_available_tags_for_records( available_records, entered_tags )

    let s:suggestions = []
    for w in available_tags
        if w =~ current_tag
            call add(s:suggestions, w)
        endif
    endfor

    let s:current_tag = current_tag
    call sort(s:suggestions, 's:suggestions_sort')

    let s:records_to_print = available_records
    let records_to_print_count = len(s:records_to_print)
    let suggestions_count = len(s:suggestions)

    if records_to_print_count != s:previous_records_to_print_count
        let self.result_window.selected_item_number = 1
    endif

    if suggestions_count != s:previous_suggestions_count
        let self.available_tags_window.selected_item_number = 1
    endif

    let s:previous_records_to_print_count = records_to_print_count
    let s:previous_suggestions_count = suggestions_count

    call self.result_window.draw()

    call self.available_tags_window.draw()

    return s:suggestions
endfunction

function! s:tag_enter_window_callback.on_enter()
endfunction

function! s:tag_enter_window_callback.on_insert_move()
    let line = getline('.')
    let column = col('.')

    if self.edit_column == column
        return
    endif

    let current_tag = s:tag_in_line(line, column)
    call self.refresh_suggestion_list(current_tag, line)
endfunction

function! s:tag_selection_up()
    call s:available_tags_window.selection_up(1)
endfunction

function! s:tag_selection_down()
    call s:available_tags_window.selection_down(1)
endfunction

function! s:result_selection_up()
    call s:result_window.selection_up(1)
endfunction

function! s:result_selection_down()
    call s:result_window.selection_down(1)
endfunction

function! s:result_select()
    call railmoon#trace#push('s:result_select')
    try

    if empty(s:records_to_print)
        return
    endif

    let selected_item_number = s:result_window.selected_item_number
    let record = s:records_to_print[selected_item_number - 1]

    let s:last_entred_tags_line = s:tag_enter_window_callback.edit_line_window.get_line()
    let s:last_selected_result_item_number = selected_item_number

    tabclose
    call railmoon#widget#window#load_selected(s:plugin_invoker_position)

    call s:record_browser.record_extractor.process(record)

    finally
        call railmoon#trace#debug('...')
        call railmoon#trace#pop()
    endtry
endfunction

function! s:close_all()
    call railmoon#trace#debug('close_all')
    call s:result_window.close()
endfunction

function! s:map_result_moving_keys()
    let result_down_keys = [ '<down>', '<C-n>', '<C-j>' ]
    let result_up_keys = [ '<up>', '<C-p>', '<C-k>' ]

    for key in result_down_keys
        let command = 'inoremap <silent> <buffer> '.key.' <C-R>=<SID>result_selection_down()?"":""<CR>'
        exec command
        let command = 'noremap <silent> <buffer> '.key.' :call <SID>result_selection_down()<CR>'
        exec command
    endfor

    for key in result_up_keys
        let command = 'inoremap <silent> <buffer> '.key.' <C-R>=<SID>result_selection_up()?"":""<CR>'
        exec command
        let command = 'noremap <silent> <buffer> '.key.' :call <SID>result_selection_up()<CR>'
        exec command
    endfor

    inoremap <silent> <buffer> <C-p> <C-R>=<SID>result_selection_up()?'':''<CR>
    inoremap <silent> <buffer> <cr> <C-R>=<SID>result_select()?' ':' '<CR>
endfunction

function! s:map_suggestion_moving_keys()
    inoremap <silent> <buffer> <Tab> <C-R>=<SID>tag_selection_down()?'':''<CR>
    inoremap <silent> <buffer> <C-Tab> <C-R>=<SID>tag_selection_up()?'':''<CR>
    noremap <silent> <buffer> <Tab> :call <SID>tag_selection_down()<CR>
    noremap <silent> <buffer> <C-Tab> :call <SID>tag_selection_up()<CR>
endfunction

function! s:map_common_keys()
    nnoremap <silent> <buffer> <esc> :call <SID>close_all()<CR>
endfunction

" information to help 0scan repeat
let s:last_extractor = {}
let s:last_record_browser = {}
let s:last_entred_tags_line = ''
let s:last_selected_result_item_number = 0


function! s:turnoff_unexpected_plugins()
    if exists('g:loaded_minibufexplorer')
        CMiniBufExplorer
    endif

    if exists('g:loaded_autocomplpop')
        call railmoon#trace#debug('Turn off autocomplpop.vim')
        AutoComplPopLock
    endif
endfunction

function! s:turnon_unexpected_plugins()
    if exists('g:loaded_autocomplpop')
        call railmoon#trace#debug('Turn on autocomplpop.vim')
        AutoComplPopUnlock
    endif
endfunction

function! s:process_last_extractor_new_selection( record_number )
    let record = s:records_to_print[ a:record_number - 1 ]
    call s:last_extractor.process(record)
endfunction

function! s:print_error( message )
    echohl Error | echo '[ 0scan ] '.a:message | echohl None
endfunction

function! s:process_last_extractor_select_next( shift )
    let records_count = len( s:records_to_print )
    let new_record_number = s:last_selected_result_item_number + a:shift

    if new_record_number < 1
        call s:print_error( 'first record reached' )
        return
    endif

    if new_record_number > records_count
        call s:print_error( "last record reached" )
        return
    endif

    let s:last_selected_result_item_number = new_record_number
    call s:process_last_extractor_new_selection( new_record_number )
endfunction

function! s:process_last_extractor_quick_selection( command )
    if a:command == 'lastup'
        call s:process_last_extractor_select_next( -1 )
    elseif a:command == 'lastdown'
        call s:process_last_extractor_select_next( 1 )
    endif
endfunction

function! s:create_extractor( name )
        let extractor = eval('railmoon#oscan#extractor#'.a:name.'#create()')
        return extractor
endfunction

" returns files from dir
"
function! s:get_filenames_from_dir( dir )
    let files_list = split( glob( a:dir."/*" ), "\n" )
    let result = []

    for item in files_list
        if filereadable( item )
            call add( result, item )
        endif
    endfor

    return result
endfunction

" returns list of [ extractor_name, extractor_description, not_implemented_flag ]
"
function! s:get_available_extractors()
    let extractor_files = []

    let vimfiles_folders = split( &runtimepath, ',' )
    for folder in vimfiles_folders
        if folder =~ 'after$'
            continue
        endif

        let extractor_folder = folder.'/autoload/railmoon/oscan/extractor'
        call extend( extractor_files, s:get_filenames_from_dir( extractor_folder ) )
    endfor

    let extractors = []

    for extractor_file in extractor_files
        "echo extractor_file
        let extractor_name = fnamemodify( extractor_file, ":t:r" )

        try
            let extractor = s:create_extractor( extractor_name )
        catch /.*/
            continue
        endtry

        let extractor_description = extractor.description
        let extractor_not_implemented = has_key( extractor, 'not_implemented' ) ? extractor.not_implemented : 0
        call add( extractors, [ extractor_name, extractor_description, extractor_not_implemented ] )
    endfor

    return extractors
endfunction

function! s:show_available_extractors()
    let extractors = s:get_available_extractors()

    let max_extractor_name_len = 0
    for extractor_description in extractors
        let len = len( extractor_description[0] )
        if len > max_extractor_name_len
            let max_extractor_name_len = len
        endif
    endfor

    echohl Comment
    echo "Please specify scan you would like you use"
    echo ":OScan scan_name [tag1] [tag2]<CR>"
    echohl None
    for extractor_description in extractors
        echohl Keyword | echo printf( "%".max_extractor_name_len."s\t", extractor_description[0] ) 

        if extractor_description[2]
            echohl Error | echon "[ Not implemented ]" | echohl None | echon " "
        endif

        echohl String | echon extractor_description[1] | echohl None
    endfor
endfunction

" completition function for :OScan command
"
function! railmoon#oscan#complete( argLead, cmdLine, cursorPos )
    let result = ''

    let extractors = s:get_available_extractors()

    for extractor_description in extractors
        if extractor_description[2]
            continue
        endif

        if ! empty( result )
            let result .= "\n"
        endif

        let result .= extractor_description[0]
    endfor

    return result
endfunction

function! railmoon#oscan#open(...)
    "call railmoon#trace#start_debug('oscan.debug')

    if empty( a:000 )
        call s:show_available_extractors()
        return
    endif

    let extractor_name = a:000[0]

    " not real extractor, but convinient way to quick run through last
    " results
    "
    if ( extractor_name == 'lastup' || extractor_name == 'lastdown' ) && !empty( s:last_extractor )
        call s:process_last_extractor_quick_selection( extractor_name )
        return
    endif

    call railmoon#trace#debug('save invoker position')

    let s:plugin_invoker_position = railmoon#widget#window#save_selected()

    call railmoon#trace#debug('create tag browser:'.extractor_name)

    let extractor = {}
    let extractor_description = ''

    let is_repeat_last_extractor = extractor_name == 'last' && ! empty(s:last_extractor)

    if is_repeat_last_extractor
        let extractor = s:last_extractor
        let extractor_description = extractor.description

        let s:record_browser = s:last_record_browser
    elseif extractor_name == 'last'
        call s:print_error( 'Nothing to repeat' )
        return
    else 
        let extractor = {}
        try
            let extractor = s:create_extractor( extractor_name )
        catch /.*/
            call s:print_error( "Can't create \"".extractor_name."\" scan" )
            return
        endtry

        let extractor_description = extractor.description

        let s:record_browser = railmoon#oscan#record_browser#create(extractor)
    endif

    if s:record_browser.is_empty()
        call s:print_error( 'no records with tags found' )
        return
    endif

    let s:last_record_browser = deepcopy(s:record_browser)
    let s:last_extractor = deepcopy(extractor)

    call railmoon#trace#debug('create new tab page')

    try
        "set lazyredraw
        silent tab help

        let width = winwidth('%')

        let s:plugin_window_goes_close = 0

        call railmoon#widget#stop_handle_autocommands()
        call s:turnoff_unexpected_plugins()

        call railmoon#trace#debug('create available_tags_window')
        let tags_window_width = width/5
        exec tags_window_width.' vsplit'

        let s:available_tags_window = railmoon#widget#selection_window#create(
            \ 'Available tags window',
            \ extractor_description,
            \ 'TODO',
            \ s:suggestion_window_model,
            \ s:suggestion_window_callback)

        call s:map_common_keys()

        call s:available_tags_window.draw()


        call railmoon#trace#debug('create result_window')
        wincmd w
        let s:result_window = railmoon#widget#selection_window#create(
            \ 'Result window',
            \ extractor_description,
            \ 'DiffAdd',
            \ s:result_window_model,
            \ s:result_window_callback)

        call s:map_common_keys()

        call extractor.colorize()

        if is_repeat_last_extractor
            call s:result_window.select_item(s:last_selected_result_item_number)
        endif

        call railmoon#trace#debug('create tag_enter_window')
        split
        resize 1
        let edit_line_window = railmoon#widget#edit_line_window#create(
            \'Tag enter window',
            \ extractor_description,
            \ s:tag_enter_window_callback)

        call s:map_common_keys()
        call s:map_result_moving_keys()
        call s:map_suggestion_moving_keys()


        if ! is_repeat_last_extractor
            let tag_line = join(a:000[ 1: ], ',')
            if len(tag_line) > 0
                let tag_line .= ','
            endif

            call edit_line_window.set_line(tag_line)
        else
            call edit_line_window.set_line(s:last_entred_tags_line)
        endif

        call railmoon#widget#window#select(edit_line_window.id)
        startinsert!
    catch /.*/
        call s:print_error( v:exception )
    finally
        call railmoon#widget#start_handle_autocommands()
        "set nolazyredraw
        "redraw
    endtry

    let s:tag_enter_window_callback.edit_line_window = edit_line_window
    let s:tag_enter_window_callback.available_tags_window = s:available_tags_window
    let s:tag_enter_window_callback.result_window = s:result_window
endfunction

" -
" [ testing ]
" -
let s:unit_test = railmoon#unit_test#create('oscan')

function! s:unit_test.test_tag_in_line()
    call self.assert_equal(s:tag_in_line('January,', 7), 'January')
    call self.assert_equal(s:tag_in_line('January,', 8), 'January')
    call self.assert_equal(s:tag_in_line('January,', 9), '')
    call self.assert_equal(s:tag_in_line('January,February', 8), 'January')
    call self.assert_equal(s:tag_in_line(',word,', 2), 'word')
    call self.assert_equal(s:tag_in_line(',word,', 3), 'word')
    call self.assert_equal(s:tag_in_line(',word,', 4), 'word')
    call self.assert_equal(s:tag_in_line(',word,', 5), 'word')
    call self.assert_equal(s:tag_in_line(',word,', 6), 'word')
    call self.assert_equal(s:tag_in_line('word,', 4), 'word')
    call self.assert_equal(s:tag_in_line('word,', 5), 'word')
    call self.assert_equal(s:tag_in_line('word,', 6), '')
    call self.assert_equal(s:tag_in_line('word,,', 6), 'word')
    call self.assert_equal(s:tag_in_line('', 1), '')
    call self.assert_equal(s:tag_in_line(',', 1), '')
endfunction

call s:unit_test.run()