" cache.vim
" @Author:      Tom Link (micathom AT gmail com?subject=[vim])
" @Website:     http://www.vim.org/account/profile.php?user_id=4037
" @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
" @Created:     2007-06-30.
" @Last Change: 2019-01-02.
" @Revision:    125.1.243


" The cache directory. If empty, use |tlib#dir#MyRuntime|.'/cache'.
" You might want to delete old files from this directory from time to 
" time with a command like: >
"   find ~/vimfiles/cache/ -atime +31 -type f -print -delete
TLet g:tlib_cache = ''

" |tlib#cache#Purge()|: Remove cache files older than N days.
TLet g:tlib#cache#purge_days = 31

" Purge the cache every N days. Disable automatic purging by setting 
" this value to a negative value.
TLet g:tlib#cache#purge_every_days = 31

" The encoding used for the purge-cache script.
" Default: 'enc'
TLet g:tlib#cache#script_encoding = &enc

" Whether to run the directory removal script:
"    0 ... No
"    1 ... Query user
"    2 ... Yes
TLet g:tlib#cache#run_script = 1

" Verbosity level:
"     0 ... Be quiet
"     1 ... Display informative message
"     2 ... Display detailed messages
TLet g:tlib#cache#verbosity = 1

" A list of regexps that are matched against partial filenames of the 
" cached files. If a regexp matches, the file won't be removed by 
" |tlib#cache#Purge()|.
TLet g:tlib#cache#dont_purge = ['[\/]\.last_purge$']

" If the cache filename is longer than N characters, use 
" |pathshorten()|.
TLet g:tlib#cache#max_filename = 200

TLet g:tlib#cache#use_json = 0

TLet g:tlib#cache#use_encoding = ''


let s:cache = {}


" :display: tlib#cache#Dir(?mode = 'bg', ?ensure_dir = true)
" The default cache directory.
function! tlib#cache#Dir(...) "{{{3
    TVarArg ['mode', 'bg'], ['ensure_dir', 1]
    let dir = tlib#var#Get('tlib_cache', mode)
    if empty(dir)
        let dir = tlib#file#Join([tlib#dir#MyRuntime(), 'cache'])
    endif
    if ensure_dir
        call tlib#dir#Ensure(dir)
    endif
    return dir
endf


" :display: tlib#cache#EncodedFilename(type, file, ?mkdir=0, ?dir='')
" Encode `file` and call |tlib#cache#Filename()|.
function! tlib#cache#EncodedFilename(type, file, ...) "{{{3
    let file = tlib#url#Encode(a:file)
    return call(function('tlib#cache#Filename'), [a:type, file] + a:000)
endf


" :def: function! tlib#cache#Filename(type, ?file=%, ?mkdir=0, ?dir='')
function! tlib#cache#Filename(type, ...) "{{{3
    " TLogDBG 'bufname='. bufname('.')
    let dir0 = a:0 >= 3 && !empty(a:3) ? a:3 : tlib#cache#Dir()
    let dir = dir0
    if a:0 >= 1 && !empty(a:1)
        let file  = a:1
    else
        if empty(expand('%:t'))
            return ''
        endif
        let file  = expand('%:p')
        let file  = tlib#file#Relative(file, tlib#file#Join([dir, '..']))
    endif
    " TLogVAR file, dir
    let mkdir = a:0 >= 2 ? a:2 : 0
    let file  = substitute(file, '\.\.\|[:&<>]\|//\+\|\\\\\+', '_', 'g')
    let dirs  = [dir, a:type]
    let dirf  = fnamemodify(file, ':h')
    if dirf != '.'
        call add(dirs, dirf)
    endif
    let dir   = tlib#file#Join(dirs)
    " TLogVAR dir
    let dir   = tlib#dir#PlainName(dir)
    " TLogVAR dir
    let file  = fnamemodify(file, ':t')
    " TLogVAR file, dir, mkdir
    let cache_file = tlib#file#Join([dir, file])
    if len(cache_file) > g:tlib#cache#max_filename
        " echom "DBG long filename" cache_file
        " echom "DBG long filename" dir
        if v:version >= 704
            let shortfilename = sha256(file)
        else
            let shortfilename = tlib#hash#Adler32(file)
        endif
        " let cache_file = tlib#cache#Filename(a:type, shortfilename, mkdir, dir0)
        let cache_file = tlib#file#Join([dir, shortfilename])
    else
        if mkdir && !isdirectory(dir)
            try
                call mkdir(dir, 'p')
            catch /^Vim\%((\a\+)\)\=:E739:/
                if filereadable(dir) && !isdirectory(dir)
                    echoerr 'TLib: Cannot create directory for cache file because a file with the same name exists (please delete it):' dir
                    " call delete(dir)
                    " call mkdir(dir, 'p')
                endif
            endtry
        endif
    endif
    " TLogVAR cache_file
    return cache_file
endf


let s:timestamps = {}


function! s:SetTimestamp(cfile, type) "{{{3
    if !has_key(s:timestamps, a:cfile)
        let s:timestamps[a:cfile] = {}
    endif
    let s:timestamps[a:cfile].atime = getftime(a:cfile)
    let s:timestamps[a:cfile][a:type] = s:timestamps[a:cfile].atime
endf


function! s:PutValue(cfile, value) abort "{{{3
    let s:cache[a:cfile] = {'mtime': localtime(), 'data': a:value}
endf


function! s:GetValue(cfile, default) abort "{{{3
    return get(get(s:cache, a:cfile, {}), 'data', a:default)
endf


function! s:GetCacheTime(cfile) abort "{{{3
    let not_found = !has_key(s:cache, a:cfile)
    let cftime = not_found ? -1 : s:cache[a:cfile].mtime
    return cftime
endf


function! tlib#cache#Save(cfile, value, ...) "{{{3
    TVarArg ['options', {}]
    let in_memory = get(options, 'in_memory', 0)
    if in_memory
        " TLogVAR in_memory, a:cfile, localtime()
        call s:PutValue(a:cfile, a:value)
    elseif !empty(a:cfile)
        " TLogVAR a:value
        let cfile = a:cfile
        if g:tlib#cache#use_json && exists('*json_encode')
            try
                let value = json_encode(a:value)
                let cfile .= '.json'
            catch
                echoerr v:exception
                let value = string(a:value)
            endtry
        else
            let value = string(a:value)
        endif
        Tlibtrace 'tlib', cfile, value
        call writefile([value], cfile, 'b')
        call s:SetTimestamp(a:cfile, 'write')
    endif
endf


function! tlib#cache#MTime(cfile) "{{{3
    let mtime = {'mtime': getftime(a:cfile)}
    let mtime = extend(mtime, get(s:timestamps, a:cfile, {}))
    return mtime
endf


function! tlib#cache#Get(cfile, ...) "{{{3
    TVarArg ['default', {}], ['options', {}]
    let in_memory = get(options, 'in_memory', 0)
    if in_memory
        " TLogVAR in_memory, a:cfile
        return s:GetValue(a:cfile, default)
    else
        call tlib#cache#MaybePurge()
        if !empty(a:cfile)
            let jsonfile = a:cfile .'.json'
            let use_json = g:tlib#cache#use_json && exists('*json_decode') && exists('v:none') && filereadable(jsonfile)
            if use_json
                let use_json = 1
                let cfile = jsonfile
            else
                let cfile = a:cfile
            endif
            let mt = s:GetCacheTime(cfile)
            let ft = getftime(cfile)
            if mt != -1 && mt >= ft
                return s:GetValue(cfile, default)
            elseif ft != -1
                call s:SetTimestamp(cfile, 'read')
                let val = join(readfile(cfile, 'b'), '\n')
                try
                    if use_json
                        " NOTE: Copy result of json_decode() in order to 
                        " avoid "E741: value is locked" error in vim8.
                        let value = json_decode(val)
                        if value is v:none
                            let value = default
                        else
                            let value = copy(value)
                        endif
                    else
                        let value = eval(val)
                    endif
                    call s:PutValue(cfile, value)
                    return value
                catch
                    echohl ErrorMsg
                    echom v:exception
                    echom 'tlib#cache#Get: Invalid value in:' cfile
                    echom 'Value:' string(val)
                    echom 'Please review the file and delete it if necessary'
                    echom 'Will use default value:' string(default)
                    echohl NONE
                    if g:tlib#debug
                        let @* = string(val)
                    endif
                    " call s:PutValue(cfile, default)
                    return default
                endtry
            endif
        endif
        return default
    endif
endf


" :display: tlib#cache#Value(cfile, generator, ftime, ?generator_args=[], ?options={})
" Get a cached value from cfile. If it is outdated (compared to ftime) 
" or does not exist, create it calling a generator function.
function! tlib#cache#Value(cfile, generator, ftime, ...) "{{{3
    TVarArg ['args', []], ['options', {}]
    let in_memory = get(options, 'in_memory', 0)
    if in_memory
        let cftime = s:GetCacheTime(a:cfile)
    else
        let cftime = getftime(a:cfile)
    endif
    let ftime = a:ftime
    " TLogVAR in_memory, cftime
    if cftime == -1 || ftime == -1 || (ftime != 0 && cftime < ftime)
        " TLogVAR a:generator, args
        let val = call(a:generator, args)
        " TLogVAR val
        let cval = {'val': val}
        " TLogVAR cval
        call tlib#cache#Save(a:cfile, cval, options)
        return val
    else
        let val = tlib#cache#Get(a:cfile, {}, options)
        if !has_key(val, 'val')
            throw 'tlib#cache#Value: Internal error: '. a:cfile
        else
            return val.val
        endif
    endif
endf


function! tlib#cache#ValueFromName(type, name, ...) abort "{{{3
    let cfile = tlib#cache#Filename(a:type, tlib#url#Encode(a:name), 1)
    return call(function('tlib#cache#Value'), [cfile] + a:000)
endf


" Call |tlib#cache#Purge()| if the last purge was done before 
" |g:tlib#cache#purge_every_days|.
function! tlib#cache#MaybePurge() "{{{3
    if g:tlib#cache#purge_every_days < 0
        return
    endif
    let dir = tlib#cache#Dir('g')
    let last_purge = tlib#file#Join([dir, '.last_purge'])
    let last_purge_exists = filereadable(last_purge)
    if last_purge_exists
        let threshold = localtime() - g:tlib#cache#purge_every_days * g:tlib#date#dayshift
        let should_purge = getftime(last_purge) < threshold
    else
        let should_purge = 0 " should ignore empty dirs, like the tmru one: !empty(glob(tlib#file#Join([dir, '**'])))
    endif
    if should_purge
        if last_purge_exists
            let yn = 'y'
        else
            let txt = "TLib: The cache directory '". dir ."' should be purged of old files.\nDelete files older than ". g:tlib#cache#purge_days ." days now?"
            let yn = tlib#input#Dialog(txt, ['yes', 'no'], 'no')
        endif
        if yn =~ '^y\%[es]$'
            call tlib#cache#Purge()
        else
            let g:tlib#cache#purge_every_days = -1
            if !last_purge_exists
                call s:PurgeTimestamp(dir)
            endif
            echohl WarningMsg
            echom "TLib: Please run :call tlib#cache#Purge() to clean up ". dir
            echohl NONE
        endif
    elseif !last_purge_exists
        call s:PurgeTimestamp(dir)
    endif
endf


" Delete old files.
function! tlib#cache#Purge() "{{{3
    let threshold = localtime() - g:tlib#cache#purge_days * g:tlib#date#dayshift
    let dir = tlib#cache#Dir('g')
    if g:tlib#cache#verbosity >= 1
        echohl WarningMsg
        echom "TLib: Delete files older than ". g:tlib#cache#purge_days ." days from ". dir
        echohl NONE
    endif
    let files = tlib#cache#ListFilesInCache()
    let deldir = []
    let newer = []
    let msg = []
    let more = &more
    set nomore
    try
        for file in files
            if isdirectory(file)
                if empty(filter(copy(newer), 'tlib#string#Strcharpart(v:val, 0, len(file)) ==# file'))
                    call add(deldir, file)
                endif
            else
                if getftime(file) < threshold
                    call s:Delete(msg, file, '')
                else
                    call add(newer, file)
                endif
            endif
        endfor
    finally
        let &more = more
    endtry
    if !empty(msg) && g:tlib#cache#verbosity >= 1
        echo join(msg, "\n")
    endif
    if !empty(deldir)
        let deldir = filter(reverse(sort(deldir)), 's:Delete(msg, v:val, "d")')
        if !empty(deldir)
            if &shell =~ 'sh\(\.exe\)\?$'
                let scriptfile = 'deldir.sh'
                let rmdir = 'rm -rf %s'
            else
                let scriptfile = 'deldir.bat'
                let rmdir = 'rmdir /S /Q %s'
            endif
            let enc = g:tlib#cache#script_encoding
            if has('multi_byte') && enc != &enc
                call map(deldir, 'iconv(v:val, &enc, enc)')
            endif
            let scriptfile = tlib#file#Join([dir, scriptfile])
            if filereadable(scriptfile)
                let script = readfile(scriptfile)
            else
                let script = []
            endif
            let script += map(copy(deldir), 'printf(rmdir, shellescape(v:val, 1))')
            let script = tlib#list#Uniq(script)
            call writefile(script, scriptfile)
            call inputsave()
            if g:tlib#cache#run_script == 0
                if g:tlib#cache#verbosity >= 1
                    echohl WarningMsg
                    if g:tlib#cache#verbosity >= 2
                        echom "TLib: Purged cache. Need to run script to delete directories"
                    endif
                    echom "TLib: Please review and execute: ". scriptfile
                    echohl NONE
                endif
            else
                try
                    let yn = g:tlib#cache#run_script == 2 ? 'y' : tlib#input#Dialog("TLib: About to delete directories by means of a shell script.\nDirectory removal script: ". scriptfile ."\nRun script to delete directories now?", ['yes', 'no', 'edit'], 'no')
                    if yn =~ '^y\%[es]$'
                        exec 'silent cd '. fnameescape(dir)
                        exec '! ' &shell shellescape(scriptfile, 1)
                        exec 'silent cd -'
                        call delete(scriptfile)
                    elseif yn =~ '^e\%[dit]$'
                        exec 'edit '. fnameescape(scriptfile)
                    endif
                finally
                    call inputrestore()
                endtry
            endif
        endif
    endif
    call s:PurgeTimestamp(dir)
endf


function! s:Delete(msg, file, flags) abort "{{{3
    let rv = delete(a:file, a:flags)
    if !rv && g:tlib#cache#verbosity >= 2
        call add(a:msg, "TLib#cache: Delete ". file)
    endif
    return rv
endf


function! s:PurgeTimestamp(dir) "{{{3
    let last_purge = tlib#file#Join([a:dir, '.last_purge'])
    " TLogVAR last_purge
    call writefile([" "], last_purge)
endf

function! tlib#cache#ListFilesInCache(...) "{{{3
    let dir = a:0 >= 1 ? a:1 : tlib#cache#Dir('g')
    if v:version > 702 || (v:version == 702 && has('patch51'))
        let filess = glob(tlib#file#Join([dir, '**']), 1)
    else
        let filess = glob(tlib#file#Join([dir, '**']))
    endif
    let files = reverse(split(filess, '\n'))
    let pos0 = len(tlib#dir#CanonicName(dir))
    call filter(files, 's:ShouldPurge(tlib#string#Strcharpart(v:val, pos0))')
    return files
endf


function! s:ShouldPurge(partial_filename) "{{{3
    " TLogVAR a:partial_filename
    for rx in g:tlib#cache#dont_purge
        if a:partial_filename =~ rx
            " TLogVAR a:partial_filename, rx
            return 0
        endif
    endfor
    return 1
endf