"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.createPostData = exports.getMac = exports.md5 = exports.checkLocalCache = exports.checkUpdate = void 0;
const fs_extra_1 = __importDefault(require("fs-extra"));
const os_1 = __importDefault(require("os"));
const path_1 = __importDefault(require("path"));
const debug_1 = __importDefault(require("debug"));
const crypto_1 = __importDefault(require("crypto"));
const https_1 = require("https");
const compare_versions_1 = __importDefault(require("compare-versions"));
const shared_1 = require("@vue/shared");
const json_1 = require("./json");
const hbx_1 = require("./hbx");
const debugCheckUpdate = (0, debug_1.default)('uni:check-update');
const INTERVAL = 1000 * 60 * 60 * 24;
async function checkUpdate(options) {
    if (process.env.CI) {
        debugCheckUpdate('isInCI');
        return;
    }
    if ((0, hbx_1.isInHBuilderX)()) {
        debugCheckUpdate('isInHBuilderX');
        return;
    }
    const { inputDir, compilerVersion } = options;
    const updateCache = readCheckUpdateCache(inputDir);
    debugCheckUpdate('read.cache', updateCache);
    const res = checkLocalCache(updateCache, compilerVersion);
    if (res) {
        if ((0, shared_1.isString)(res)) {
            console.log();
            console.log(res);
        }
    }
    else {
        await checkVersion(options, normalizeUpdateCache(updateCache, (0, json_1.parseManifestJsonOnce)(inputDir)));
    }
    writeCheckUpdateCache(inputDir, statUpdateCache(normalizeUpdateCache(updateCache)));
}
exports.checkUpdate = checkUpdate;
function normalizeUpdateCache(updateCache, manifestJson) {
    const platform = process.env.UNI_PLATFORM;
    if (!updateCache[platform]) {
        updateCache[platform] = {
            appid: '',
            dev: 0,
            build: 0,
        };
    }
    if (manifestJson) {
        const platformOptions = manifestJson[platform === 'app' ? 'app-plus' : platform];
        updateCache[platform].appid = platformOptions
            ? platformOptions.appid || platformOptions.package || ''
            : '';
    }
    return updateCache;
}
function statUpdateCache(updateCache) {
    debugCheckUpdate('stat.before', updateCache);
    const platform = process.env.UNI_PLATFORM;
    const type = process.env.NODE_ENV === 'production' ? 'build' : 'dev';
    const platformOptions = updateCache[platform];
    platformOptions[type] = (platformOptions[type] || 0) + 1;
    debugCheckUpdate('stat.after', updateCache);
    return updateCache;
}
function getFilepath(inputDir, filename) {
    return path_1.default.resolve(os_1.default.tmpdir(), 'uni-app-cli', md5(inputDir), filename);
}
function getCheckUpdateFilepath(inputDir) {
    return getFilepath(inputDir, 'check-update.json');
}
function generateVid() {
    let result = '';
    for (let i = 0; i < 4; i++) {
        result += ((65536 * (1 + Math.random())) | 0).toString(16).substring(1);
    }
    return 'UNI_' + result.toUpperCase();
}
function createCheckUpdateCache(vid = generateVid()) {
    return {
        vid: generateVid(),
        lastCheck: 0,
    };
}
function readCheckUpdateCache(inputDir) {
    const updateFilepath = getCheckUpdateFilepath(inputDir);
    debugCheckUpdate('read:', updateFilepath);
    if (fs_extra_1.default.existsSync(updateFilepath)) {
        try {
            return require(updateFilepath);
        }
        catch (e) {
            debugCheckUpdate('read.error', e);
        }
    }
    return createCheckUpdateCache();
}
/**
 * 检查本地缓存，返回 false 表示需要执行云端检查，返回 true 表示，无需云端检查，返回 string 表示，无需云端检测，且有更新
 * @param inputDir
 * @param compilerVersion
 * @param interval
 * @returns
 */
function checkLocalCache(updateCache, compilerVersion, interval = INTERVAL) {
    if (!updateCache.lastCheck) {
        debugCheckUpdate('cache: lastCheck not found');
        return false;
    }
    if (Date.now() - updateCache.lastCheck > interval) {
        debugCheckUpdate('cache: lastCheck > interval');
        return false;
    }
    if (updateCache.newVersion &&
        (0, compare_versions_1.default)(updateCache.newVersion, compilerVersion) > 0) {
        debugCheckUpdate('cache: find new version');
        return updateCache.note;
    }
    return true;
}
exports.checkLocalCache = checkLocalCache;
function writeCheckUpdateCache(inputDir, updateCache) {
    const filepath = getCheckUpdateFilepath(inputDir);
    debugCheckUpdate('write:', filepath, updateCache);
    try {
        fs_extra_1.default.outputFileSync(filepath, JSON.stringify(updateCache));
    }
    catch (e) {
        debugCheckUpdate('write.error', e);
    }
}
function md5(str) {
    return crypto_1.default.createHash('md5').update(str).digest('hex');
}
exports.md5 = md5;
function getMac() {
    let mac = '';
    const network = os_1.default.networkInterfaces();
    for (const key in network) {
        const array = network[key];
        for (let i = 0; i < array.length; i++) {
            const item = array[i];
            if (!item.family || (item.mac && item.mac === '00:00:00:00:00:00')) {
                continue;
            }
            if (
            // Node < v18
            (0, shared_1.isString)(item.family) &&
                (item.family === 'IPv4' || item.family === 'IPv6')) {
                mac = item.mac;
                break;
            }
            else if (
            // Node >= v18
            typeof item.family === 'number' &&
                (item.family === 4 || item.family === 6)) {
                mac = item.mac;
                break;
            }
        }
    }
    return mac;
}
exports.getMac = getMac;
function createPostData({ versionType, compilerVersion }, manifestJson, updateCache) {
    const data = {
        vv: 3,
        device: md5(getMac()),
        vtype: versionType,
        vcode: compilerVersion,
    };
    if (manifestJson.appid) {
        data.appid = manifestJson.appid;
    }
    else {
        data.vid = updateCache.vid;
    }
    Object.keys(updateCache).forEach((name) => {
        const value = updateCache[name];
        if ((0, shared_1.isPlainObject)(value) &&
            ((0, shared_1.hasOwn)(value, 'dev') || (0, shared_1.hasOwn)(value, 'build'))) {
            data[name] = value;
        }
    });
    return JSON.stringify(data);
}
exports.createPostData = createPostData;
function handleCheckVersion({ code, isUpdate, newVersion, note }, updateCache) {
    if (code !== 0) {
        return;
    }
    // clear
    Object.keys(updateCache).forEach((key) => {
        if (key !== 'vid')
            delete updateCache[key];
    });
    updateCache.lastCheck = Date.now();
    if (isUpdate) {
        updateCache.note = note;
        updateCache.newVersion = newVersion;
    }
    else {
        delete updateCache.note;
        delete updateCache.newVersion;
    }
}
const HOSTNAME = 'uniapp.dcloud.net.cn';
const PATH = '/update/cli';
function checkVersion(options, updateCache) {
    return new Promise((resolve) => {
        const postData = JSON.stringify({
            id: createPostData(options, (0, json_1.parseManifestJsonOnce)(options.inputDir), updateCache),
        });
        let responseData = '';
        const req = (0, https_1.request)({
            hostname: HOSTNAME,
            path: PATH,
            port: 443,
            method: 'POST',
            headers: {
                'Content-Type': 'application/json',
                'Content-Length': postData.length,
            },
        }, (res) => {
            res.setEncoding('utf8');
            res.on('data', (chunk) => {
                responseData += chunk;
            });
            res.on('end', () => {
                debugCheckUpdate('response: ', responseData);
                try {
                    handleCheckVersion(JSON.parse(responseData), updateCache);
                }
                catch (e) { }
                resolve(true);
            });
            res.on('error', (e) => {
                debugCheckUpdate('response.error:', e);
                resolve(false);
            });
        }).on('error', (e) => {
            debugCheckUpdate('request.error:', e);
            resolve(false);
        });
        debugCheckUpdate('request: ', postData);
        req.write(postData);
        req.end();
    });
}