con importUtil = import("util")
con importPath = import('path')
con importConfig = import('config')
con isJson = importConfig.config.isJson
con wirteLogFile = importUtil.wirteLogFile
con axeCaskFromDb = function(type, name) {
    return importUtil.guaSearchFromDb(type, name)
}
con redirectedUrl = function(url) {
    var header = 'User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/83.0.4103.97 Safari/537.36'
    var c = 'curl -I -i -H "{}" "{}"'.format(header, url)
    var r = importUtil.call(c)
    var lines = r.split('\n')
    var firstLine = lines[0]
    var httpCode = firstLine.split(' ')[1]
    var strLocation = 'location'
    var lenLocation = strLocation.length()
    if (httpCode == '200') {
        return url
    } else if (importUtil.guaStringIn(httpCode, "301") or importUtil.guaStringIn(httpCode, "302")){
        var i = 0
        var l = lines.length()
        while (i < l) {
            var line = lines[i]
            line = line.strip('\r')
            var locationInLine = line.cut(0, lenLocation).lower()
            if (locationInLine == strLocation) {
                var redirect = line.cut(lenLocation+1)
                redirect = redirect.strip()
                return redirect
            }
            i += 1
        }
    }
}
con urlFromCask = function(caskItem) {
    var rawUrl = caskItem['url']
    var u = redirectedUrl(rawUrl)
    if (u == null) {
        if (isJson) {
            con m = "download failed, url: {}".format(rawUrl)
            wirteLogFile(m)
        } else {
            log("download failed, url: {}".format(rawUrl))
        }
    }
    return u
}
con suffixOfFile = function(url) {
    var r = url
    var index = importUtil.guaStringFindReverse(r, '.')
    var s = r.cut(index)
    var i = 1
    var len = s.length()
    while (i < len) {
        var c = s[i]
        if (not importUtil.guaCharIsAlpha(c)) {
            return s.cut(0, i)
        }
        i += 1
    }
    return s
}
con prepare = function() {
    importUtil.guaFileMkdir(importPath.pathHome())
    importUtil.guaFileMkdir(importPath.pathCaskDownload())
    importUtil.guaFileMkdir(importPath.pathCaskDecompressed())
}
con randomDirName = function(xml) {
    var lines = xml.split('\n')
    var i = 0
    var len = lines.length()
    while (i < len) {
        var line = lines[i]
        if (line.find('<key>mount-point</key>') != -1) {
            var l = lines[i+1]
            var keyBegin = '<string>'
            var keyEnd = '</'
            var begin = l.find(keyBegin) + keyBegin.length()
            var end = l.find(keyEnd)
            var path = l.cut(begin, end)
            return path
        }
        i += 1
    }
}
con download = function(name, url) {
    url = url.strip('\r')
    var f = importPath.pathCaskFileDownload(name)
    var c = ''
    url.writeToFile('/tmp/store_url1.log')
    if (url.has('sourceforge.net')) {
        c = 'curl --location "{}" > "{}" --progress-bar'.format(url, f)
    } else {
        var header = 'User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/83.0.4103.97 Safari/537.36'
        c = 'curl --location -H "{}" "{}" > "{}" --progress-bar'.format(header, url, f)
    }
    importUtil.callWithoutOutput(c)
}
con unzip = function(name) {
    var d = importPath.pathCaskDecompressed()
    var path = '{}/{}'.format(d, name)
    con clear = 'rm -rf {}'.format(path)
    importUtil.call(clear)
    var f = importPath.pathCaskFileDownload(name)
    var c = 'unzip -qq "{}" -d "{}"'.format(f, path)
    importUtil.call(c)
    return path
}
con filesFound = function(path, file_format) {
    var files = importUtil.guaFilesInDirectory(path)
    var filesWanted = []
    var i = 0
    var l = files.length()
    while (i < l) {
        var file = files[i]
        if (importUtil.guaStringEndwith(file, file_format)) {
            filesWanted.add(file)
        }
        i += 1
    }
    return filesWanted
}
con tar = function(name) {
    var d = importPath.pathCaskDecompressed()
    var path = '{}/{}'.format(d, name)
    var f = importPath.pathCaskFileDownload(name)
    con clear = 'rm -rf {}'.format(path)
    importUtil.call(clear)
    importUtil.guaFileMkdir(path)
    var c = 'tar xof "{}" -C "{}"'.format(f, path)
    var result = importUtil.call(c)
    var files = importUtil.guaFilesInDirectory(path)
    var len = files.length()
    if (len == 1) {
        var firstFile = files[0]
        if (importUtil.guaStringEndwith(firstFile, '.app')) {
            return path
        } else {
            return firstFile
        }
    } else {
        var i = 0
        while (i < len) {
            var file = files[i]
            if (importUtil.guaStringEndwith(file, '.app')) {
                return path
            }
            i += 1
        }
    }
}
con _convertedDmg = function(name, pathFile) {
    var m = importPath.pathCaskMount()
    var nameCdr = '{}.cdr'.format(name)
    var pathCdr = '{}/{}'.format(m, nameCdr)
    var c = 'hdiutil convert -quiet -format UDTO -o {} {}'.format(pathCdr, pathFile)
    importUtil.call(c)
    return pathCdr
}
con mount = function(name) {
    var fileDownload = importPath.pathCaskFileDownload(name)
    var m = importPath.pathCaskMount()
    var t = 'echo Y | hdiutil attach -plist -nobrowse -readonly -noidme -mountrandom "{}" "{}"'
    var c = t.format(m, fileDownload)
    var result = importUtil.call(c)
    return randomDirName(result)
}
con copyToApp = function(path) {
    var dirs = importUtil.guaFilesInDirectory(path, true, false)
    var i = 0
    var l = dirs.length()
    while (i < l) {
        var dir = dirs[i]
        if (importUtil.guaStringEndwith(dir, '.app')) {
            var appName = importUtil.guaListGetReverse(dir, -1)
            var pathApp = '/Applications/{}'.format(appName)
            if (importUtil.guaFileIsDirectory(pathApp)) {
                continue
            } else {
                var dest = '/Applications'
                importUtil.guaFileCp(dir, dest)
            }
        }
        i += 1
    }
}
con unmount = function(path) {
    var c = 'diskutil unmount force {}'.format(path)
    var result = importUtil.call(c)
}
con installDmg = function(name, url) {
    download(name, url)
    var path = mount(name)
    var filesApp = filesFound(path, 'app')
    var filesPkg = filesFound(path, 'pkg')
    var lenApp = filesApp.length()
    var lenPkg = filesPkg.length()
    if (lenApp > 0) {
        copyToApp(path)
    } else if (lenPkg > 0) {
        var filePkg = filesPkg[0]
        _installPkg(filePkg)
    }
    unmount(path)
}
con installZip = function(name, url) {
    download(name, url)
    var path = unzip(name)
    var filesPkg = filesFound(path, 'pkg')
    if (filesPkg.length() > 0) {
        var filePkg = filesPkg[0]
        _installPkg(filePkg)
    } else {
        copyToApp(path)
    }
}
con installTar = function(name, url) {
    download(name, url)
    var path = tar(name)
    copyToApp(path)
}
con installPkg = function(name, url) {
    download(name, url)
    var fileAxestore = importPath.pathCaskFileDownload(name)
    var index = importUtil.guaStringFindReverse(fileAxestore, '.')
    var filePkg = fileAxestore.cut(0, index) + '.pkg'
    importUtil.guaFileMv(fileAxestore, filePkg)
    _installPkg(filePkg)
}
con _installPkg = function(pkgPath) {
    var c = "sudo installer -pkg '{}' -target /".format(pkgPath)
    importUtil.call(c)
}
con caskFromToken = function(token) {
    var s = importUtil.guaItemFromDb('cask', token)
    if (s.length() > 0) {
        var line = s.split('|')
        var item = line[3]
        return json.loads(item)
    } else {
        return null
    }
}
con versionFromCask = function(s) {
    s = s.replace(',', '.')
    s = s.replace('-', '.')
    var numbers = s.split('.')
    numbers = numbers.cut(0, 3)
    con version = numbers.join('.')
    return version
}
con tokenExist = function(token) {
    con t = caskFromToken(token)
    return t != null
}
con search = function(name) {
    con type = 'cask'
    var s = axeCaskFromDb(type, name)
    var lines = s.split('\n')
    var searchNames = []
    for (i, e in lines) {
        if (e == '') {
            continue
        }
        var line = e.split('|')
        var itemName = line[0]
        var token = line[1]
        var artifacts = line[2]
        var item = json.loads(line.cut(3).join('|'))
        con version = versionFromCask(item['version'])
        con _item = {
            'name': itemName,
            'version': version,
            'installed': hasInstalled(artifacts),
            'token': token,
        }
        searchNames.add(_item)
    }
    return searchNames
}
con getApp = function(token) {
    con item = caskFromToken(token)
    var name = token
    var url = urlFromCask(item)
    if (url == null) {
        if (isJson) {
            con m = '{} download url is null'.format(name)
            wirteLogFile(m)
        }
        return false
    }
    remove(token, false)
    var s = suffixOfFile(url)
    if (s == '.zip') {
        installZip(name, url)
    } else if (s == '.dmg') {
        installDmg(name, url)
    } else if (s == '.pkg') {
        installPkg(name, url)
    } else if (s == '.tar') {
        installTar(name, url)
    } else {
        if (isJson) {
            con m = '{} not support file'.format(url)
            wirteLogFile(m)
        } else {
            log('not support file {}'.format(url))
        }
        return false
    }
    addCmd(item)
    importUtil.addInstalled(token)
    return true
}
con addCmd = function(cask) {
    con artifacts = cask['artifacts']
    var cmds = []
    for (var i = 0; i < artifacts.length(); i += 1) {
        con item = artifacts[i]
        if (type(item) == type([])) {
            cmds.add(item)
        }
    }
    for (var i = 0; i < cmds.length(); i += 1) {
        con cmd = cmds[i]
        var pathCmd = null
        var target = null
        if (cmd.length() == 1) {
            var c = cmd[0]
            if (c.startswith('/Applications')) {
                pathCmd = c
                target = c.split('/')[-1]
            }
        } else if (cmd.length() > 1) {
            var c = cmd[0]
            var t = cmd[1]
            if (c.startswith('/Applications')) {
                pathCmd = c
                if (t.has('target')) {
                    target = t.get('target')
                } else {
                    target = c.split('/')[-1]
                }
            }
        }
        if (pathCmd != null and target != null) {
            var source = pathCmd
            var binPrefix = importPath.pathBottleBin()
            var dest = '{}/{}'.format(binPrefix, target)
            importUtil.guaFileSymbolicLink(source, dest)
        }
    }
}
con remove = function(token, needLog=true) {
    con cask = caskFromToken(token)
    con artifacts = cask['artifacts']
    var appInstalled = []
    for (var i = 0; i < artifacts.length(); i += 1) {
        con item = artifacts[i]
        if (type(item) == type([])) {
            appInstalled = item
            break 
        }
    }
    for (var i = 0; i < appInstalled.length(); i += 1) {
        con app = appInstalled[i]
        con p = '/Applications/{}'.format(app)
        con e = importUtil.guaFileExist(p, true)
        if (e) {
            if (needLog) {
                log('rm', p)
            }
            importUtil.guaFileRm(p)
        } else {
            if (needLog) {
                log('file<{}> not exist'.format(p))
            }
            return false
        }
    }
    return true
}
con hasInstalled = function(artifacts) {
    if (artifacts == '') {
        return false
    }
    con pathSuffix = importPath.pathApplications()
    var p = '{}/{}'.format(pathSuffix, artifacts)
    if (importUtil.guaFileExist(p, true)) {
        return true
    }
    return false
}
con __main = function() {
}