#!/usr/local/axe/meta/gualang
con importAxe = import("axe")
con importCask = import("cask")
con importBottle = import("bottle")
con importUtil = import("util")
con importPath = import("path")
con importUpdate = import("update")
con importSetup = import("_setup")
con importConfig = import('config')
con emojiAxe = '🍏'
con emojiBottle = '🍉'
con emojiCask = '🍏'
con emojiMelon = '🍉'
var isJson = importConfig.config.isJson
var wirteLogFile = importUtil.wirteLogFile
con colorfulOk = function(word) {
    con okGreen = '\033[92m'
    con endc = '\033[0m'
    con f = '{}{}{}'.format(okGreen, word, endc)
    return f
}
con colorfulError = function(word) {
    con errorRed = '\033[91m'
    con endc = '\033[0m'
    con f = '{}{}{}'.format(errorRed, word, endc)
    return f
}
con beautifierBottleGet = function(token) {
    con r = importBottle.getApp(token)
    if (not r) {
        log(colorfulError('install aborted'))
    } else {
        con num = 3
        con emoji = importUtil.guaStringMultiply(emojiBottle, num)
        log('{} [cli] {} install successfully'.format(emoji, colorfulOk(token)))
        log('{} store.axe bin path: {} '.format(emoji, colorfulOk(importPath.pathBottleBin())))
        log('{} store.axe lib path: {} '.format(emoji, colorfulOk(importPath.pathLib())))
    }
}
con jsonBottleGet = function(token) {
    con action = 'get'
    con r = importBottle.getApp(token)
    if (not r) {
        var o = importUtil.outputForJson(action, 'error', [], 'can not install {}'.format(token))
        log(o)
        os.exit()
    }
    con data = [{
        type: 'bottle',
        token: token,
    }]
    var o = importUtil.outputForJson(action, 'ok', data)
    log(o)
}
con beautifierCaskGet = function(token) {
    con r = importCask.getApp(token)
    if (not r) {
        beautifierCaskGetFailed(token)
    } else {
        con num = 3
        con emoji = importUtil.guaStringMultiply(emojiCask, num)
        log('{} [app] {} install successfully'.format(emoji, colorfulOk(token)))
    }
}
con jsonCaskGet = function(token) {
    con action = 'get'
    con r = importCask.getApp(token)
    if (not r) {
        var o = importUtil.outputForJson(action, 'error', [], 'can not install {}'.format(token))
        return
    }
    con data = [{
        type: 'cask',
        token: token,
    }]
    var o = importUtil.outputForJson(action, 'ok', data)
    log(o)
}
con beautifierCaskGetFailed = function(token) {
    con num = 3
    con emoji = importUtil.guaStringMultiply("!", num)
    log('{} [app] {} install failed.check your network, or maybe this software can not download in China.'.format(emoji, colorfulError(token)))
}
con beautifierSearchOutput = function(items) {
    con hintAxe = ' [axe] '
    con hintBottle = ' [cli] '
    con hintCask = ' [app] '
    con showConfigMap = {
        'axe': [emojiCask, hintCask],
        'bottle': [emojiBottle, hintBottle],
        'cask': [emojiCask, hintCask],
    }
    var emoji = emojiBottle
    var outputs = []
    for (var i = 0; i < items.length(); i += 1) {
        con item = items[i]
        con token = item['token']
        con num = i + 1
        con name = item['name']
        con version = item['version']
        con type = item['type']
        con showConfig = showConfigMap[type]
        con emoji = showConfig[0]
        con hint = showConfig[1]
        con template = emoji + hint + '[{}] {}  {}@{}'
        con s = template.format(colorfulOk(num), token, name, version)
        outputs.add(s)
    }
    con ss = outputs.join('\n')
    log(ss)
}
con jsonSearchOutput = function(token, items, type) {
    con action = 'sou'
    var o = importUtil.outputForJson(action, 'ok', [])
    var list = []
    for (var i = 0; i < items.length(); i += 1) {
        con item = items[i]
        if (type != '') {
            if (item.type == type) {
                list.add({
                    type: item.type,
                    token: item.token,
                    name: item.name,
                    version: item.version,
                    installed: item.installed,
                    install_type: item.install_type,
                })
            }
        } else {
            list.add({
                type: item.type,
                token: item.token,
                name: item.name,
                version: item.version,
                installed: item.installed,
                install_type: item.install_type,
            })
        }
    }
    o.data = list
    log(o)
}
con newVersionHint = function() {
    con version = async_result_check_version()
    if (version != null) {
        con hintVersion = 'new version of store found, please update(store.axe update)'
        con colorfulVersion = colorfulOk(hintVersion)
        log('')
        log(colorfulVersion)
    }
}
con selectNumFromInput = function(maxNum) {
    con hintMsg = 'type number to install, Enter to exit:'
    log(hintMsg)
    var strNum =  importUtil.input()
    strNum = strNum.strip(' ')
    if (strNum == '') {
        return -1
    }
    con num = importUtil.guaStringToInt(strNum)
    con errMsg = colorfulError("please select correct number")
    if (num == null) {
        log(errMsg)
        return null
    } else if (num > 0 and num <= maxNum) {
        return num
    } else {
        log(errMsg)
        return null
    }
}
con promptSearch = function(funcSearch, token, type='') {
    con out = funcSearch(token, type)
    con funcMap = {
        'axe': beautifierAxeGet,
        'bottle': beautifierBottleGet,
        'cask': beautifierCaskGet,
    }
    con maxNum = out.length()
    if (isJson) {
        jsonSearchOutput(token, out, type)
    } else {
        if (maxNum == 0) {
            con error = colorfulError("can not find any items.")
            log(error)
            return
        }
        log("find items:")
        beautifierSearchOutput(out)
        newVersionHint()
        while (true) {
            con selected = selectNumFromInput(maxNum)
            if (selected == -1) {
                break
            } else if (selected == null) {
                continue
            } else {
                con item = out[selected - 1]
                con type = item['install_type']
                con token = item['token']
                con func = funcMap[type]
                return func(token)
            }
        }
    }
}
con comboSearch = function(name, type='') {
    var combo = []
    if (type == 'axe' or type == '') {
        con a = importAxe.search(name)
        for (var i = 0; i < a.length(); i += 1) {
            var item = a[i]
            if (item['type'] == 'bottle') {
                item['install_type'] = 'axe'
                combo.add(item)
            }
        }
        for (var i = 0; i < a.length(); i += 1) {
            var item = a[i]
            if (item['type'] == 'cask') {
                item['install_type'] = 'axe'
                combo.add(item)
            }
        }
    }
    if (type == 'bottle' or type == '') {
        con b = importBottle.search(name)
        for (var i = 0; i < b.length(); i += 1) {
            var item = b[i]
            item['install_type'] = 'bottle'
            item['type'] = 'bottle'
            combo.add(item)
        }
    }
    if (type == 'cask' or type == '') {
        con c = importCask.search(name)
        for (var i = 0; i < c.length(); i += 1) {
            var item = c[i]
            item['install_type'] = 'cask'
            item['type'] = 'cask'
            combo.add(item)
        }
    }
    return combo
}
con beautifierAxeGet = function(token) {
    con r = importAxe.getApp(token)
    if (not r) {
        log(colorfulError('install failed'))
    } else {
        con num = 3
        var software = importAxe.axeSoftFromName(token)
        var emoji = null
        if (software['type'] == 'bottle') {
            emoji = importUtil.guaStringMultiply(emojiBottle, num)
        } else {
            emoji = importUtil.guaStringMultiply(emojiCask, num)
        }
        log('{} [axe] {} install successfully'.format(emoji, colorfulOk(token)))
    }
}
con jsonAxeGet = function(token) {
    con action = 'get'
    con r = importAxe.getApp(token)
    if (not r) {
        var o = importUtil.outputForJson(action, 'error', [], 'can not install {}'.format(token))
        return
    }
    con data = [{
        type: 'axe',
        token: token,
    }]
    var o = importUtil.outputForJson(action, 'ok', data)
    log(o)
}
con promptGet = function(token, type) {
    con ae = importAxe.tokenExist(token)
    con be = importBottle.tokenExist(token)
    con ce = importCask.tokenExist(token)
    if (isJson) {
        con result = {
            'axe': [ae, jsonAxeGet],
            'bottle': [be, jsonBottleGet],
            'cask': [ce, jsonCaskGet],
        }
        con v = result[type]
        con found = v[0]
        con func = v[1]
        if (found) {
            func(token)
        } else {
            con o = importUtil.outputForJson('get', 'error', [], '{} not found'.format(token))
            log(o)
        }
    } else {
        con result = {
            'axe': [ae, beautifierAxeGet],
            'bottle': [be, beautifierBottleGet],
            'cask': [ce, beautifierCaskGet],
        }
        var foundNum = 0
        var foundType = null
        con keys = result.keys()
        for (var i = 0; i < keys.length(); i += 1) {
            con key = keys[i]
            con v = result[key]
            con found = v[0]
            if (found) {
                foundNum += 1
                foundType = key
            }
        }
        if (foundNum == 0) {
            log(colorfulError('token not exist'))
        } else if (foundNum == 1) {
            con software = result[foundType]
            con func = software[1]
            func(token)
        } else {
            promptSearch(comboSearch, token)
        }
    }
}
con promptHelp = function() {
    log('{} usage: {}'.format(emojiMelon, colorfulOk('store.axe get/sou qq')))
    log('{} update store: {}'.format(emojiMelon, colorfulOk('store.axe update')))
    log('{} remove app: {}'.format(emojiMelon, colorfulOk('store.axe rm qqmusic')))
    log('{} store.axe bin path: {}'.format(emojiMelon, colorfulOk(importPath.pathBottleBin())))
    log('{} store.axe lib path: {}'.format(emojiMelon, colorfulOk(importPath.pathLib())))
    log('{} store.axe opt path: {}'.format(emojiMelon, colorfulOk(importPath.pathOpt())))
    log('{} store.axe config path: {}'.format(emojiMelon, colorfulOk(importPath.pathConfigFile())))
}
con promptUpdate = function(result) {
    if (isJson) {
        con o = importUtil.outputForJson('update', 'ok', [], 'latest version')
        log(o)
    } else {
        con num = 3
        con emoji = importUtil.guaStringMultiply(emojiMelon, num)
        log('{} your store is up-to-date'.format(emoji))
    }
}
con promptRm = function(token) {
    con action = 'rm'
    if (isJson) {
        con r = importCask.remove(token, false)
        var status = 'ok'
        if (not r) {
            status = 'error'
        }
        con o = importUtil.outputForJson(action, status, [{
            type: 'cask',
            token: token,
        }])
        log(o)
    } else {
        con e = importCask.tokenExist(token)
        if (not e) {
            log(colorfulError('token not exist'))
            return
        }
        con r = importCask.remove(token)
        if (r) {
            con hint = 'rm {} successfully'.format(colorfulOk(token))
            log(hint)
        } else {
            log(colorfulError('rm failed')) 
        }
    }
}
con promptList = function() {
    con action = 'list'
    var list = importUtil.loadInstalled()
    if (isJson) {
        var o = importUtil.outputForJson(action, 'ok', list)
        log(o)
    } else {
        var tokens = list.keys()
        var s = tokens.join('\n')
        log(s)
    }
}
con macValid = function() {
    con name = importBottle.macosName()
    return name != null
}
con prepare = function() {
    importBottle.prepare()
    importCask.prepare()
}
con async_call_check_version = function() {
    con pathMetaBin = importPath.pathMetaBin()
    con gua = '{}/async_check.gua'.format(pathMetaBin)
    con c = '(/usr/local/axe/meta/gualang {} > /dev/null 2>&1 &)'.format(gua)
    importUtil.callWithoutOutput(c)
}
con async_result_check_version = function() {
    con pathOutput = importPath.pathAsyncOutput()
    con e = importUtil.guaFileExist(pathOutput)
    if (not e) {
        return null
    }
    con s = stringFromFile(pathOutput)
    if (s == '') {
        return null
    } else {
        return s
    }
}
con promptVersion = function() {
    con p = importPath.pathMetaBin()
    con v = '{}/{}'.format(p, 'version')
    con s = stringFromFile(v)
    con list = []
    for (var i = 0; i < s.length(); i += 1) {
        con c = s[i]
        list.add(c)
    }
    con version = list.join('.')
    if (isJson) {
        con data = [version]
        con o = importUtil.outputForJson('version', 'ok', data)
        log(o)
    } else {
        log('axe.store version: {} by gl2.0+'.format(version))
    }
}
con showVersion = function() {
    con p = importPath.pathMetaBin()
    con v = '{}/{}'.format(p, 'version')
    con s = stringFromFile(v)
    con list = []
    for (var i = 0; i < s.length(); i += 1) {
        con c = s[i]
        list.add(c)
    }
    con version = list.join('.')
    if (not isJson) {
        log('axe.store version: {} by gl2.0+'.format(version))
    }
}
con patchExec = function() {
    con cuser = 'whoami'
    var user = importUtil.call(cuser)
    user = user.cut(0, user.length() - 1)
    con r = importSetup.addToShells(user)
    return r
}
con __main = function() {
    con args = os.args.cut(1)
    if (args[-1] == '--json') {
        args.pop()
    }
    con types = ['--axe', '--cask', '--bottle']
    var type = ''
    if (importUtil.guaArrayHas(types, args[-1])) {
        type = args[-1].cut(2)
        args.pop()
    }
    showVersion()
    con pathResult = patchExec()
    importUtil.cleanTmpFiles()
    if (not macValid()) {
        log(colorfulError("store.axe do not provide support for your MacOS version. We provice support for MacOS 10.14 and 10.15."))
        return
    }
    prepare()
    con l = args.length()
    if (l < 2) {
        return promptHelp()
    }
    con inst = args[1]
    if (inst == 'sou') {
        async_call_check_version()
        if (l < 3) {
            return promptHelp()
        }
        con token = args[2]
        promptSearch(comboSearch, token, type)
    } else if (inst == 'get') {
        if (l < 3) {
            return promptHelp()
        }
        con token = args[2]
        promptGet(token, type)
    } else if (inst == 'update') {
        con r = importUpdate.updateStore()
        promptUpdate(r)
    } else if (inst == 'rm') {
        con token = args[2]
        promptRm(token)
    } else if (inst == 'version') {
        promptVersion()
    }
     else {
        promptHelp()
    }
    if (pathResult) {
        con c = 'exec $SHELL'
        importUtil.callWithoutOutput(c)
    }
}