main.js

/*
 * This file is a part of Telegram X Publisher
 * Copyright © Vyacheslav Krylov (tgx-android@pm.me) 2022-2023
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 */

'use strict';

process.env.NTBA_FIX_319 = 1;
process.env.NTBA_FIX_350 = 1;

const MAX_TEXT_MESSAGE_LENGTH = 4096;
const ELLIPSIS = '…';

const fs = require('fs'),
      os = require('os'),
      crypto = require('crypto'),
      TelegramBot = require('node-telegram-bot-api'),
      path = require('path'),
      https = require('https'),
      http = require('http'),
      iconv = require('iconv-lite'),
      AdmZip = require('adm-zip'),
      FormData = require('form-data'),
      UriTemplate = require('uri-template');
const { spawn, exec, execSync } = require('child_process');
const { google } = require('googleapis');
const { Level } = require('level');

// ERROR

function globalErrorHandler () {
  const stack = new Error('Global error happened here:').stack;
  return (error) => {
    console.log(error.code, stack, error);
  };
}

// ARGV CONSTANTS

function checkPath (path) {
  return path && fs.existsSync(path);
}

const LOCAL = process.env.TGX_PRODUCTION !== '1';
const settings = JSON.parse(fs.readFileSync(path.join(__dirname, 'settings.json'), 'UTF-8'));
if (!settings.app.id || !settings.app.id.match(/^(?!\.)[a-z0-9._]+(?!\.)$/))
  throw Error('app.id is not specified in settings.json or not valid: ' + settings.app.id);

const TESTING_URL = settings.url.testing;
const MARKET_URL = settings.url.market;

const ADMIN_USER_ID = settings.telegram.admin_user_id;
const BETA_CHAT_ID = settings.telegram.target_chat_id.public_builds;
const PR_CHAT_ID = settings.telegram.target_chat_id.pr_builds;
const ALPHA_CHAT_ID = LOCAL ? ADMIN_USER_ID : settings.telegram.target_chat_id.private_builds;
const INTERNAL_CHAT_ID = settings.telegram.target_chat_id.internal_builds;

const TELEGRAM_API_TOKEN_2 = settings.tokens.verifier.production;

const TELEGRAM_APP_ID = process.env.TELEGRAM_APP_ID || settings.telegram.server.api_id;
const TELEGRAM_APP_HASH = process.env.TELEGRAM_APP_HASH || settings.telegram.server.api_hash;

const PACKAGE_NAME = settings.app.id;

['TGX_SOURCE_PATH', 'TGX_KEYSTORE_PATH', 'ANDROID_SDK_ROOT', 'GOOGLE_TOKEN_PATH', 'TDLIB_SYMBOLS_PATH'].forEach((path) => {
  if (!checkPath(process.env[path]) && !(LOCAL && path === 'GOOGLE_TOKEN_PATH')) {
    console.error(path + ' not found! ' + process.env[path]);
    process.exit(1);
    return;
  }
  settings[path] = process.env[path];
});

// TELEGRAM CONSTANTS

const APK_MIME_TYPE = 'application/vnd.android.package-archive';
const ZIP_MIME_TYPE = 'application/octet-stream'; //'application/zip';
const TXT_MIME_TYPE = 'application/octet-stream'; // 'text/plain';

const TELEGRAM_API_TOKEN = process.env.TELEGRAM_API_TOKEN || settings.tokens.builder[LOCAL ? 'debug' : 'production'];
if (!TELEGRAM_API_TOKEN) {
  console.error('Invalid TELEGRAM_API_TOKEN', TELEGRAM_API_TOKEN);
  process.exit(1);
  return;
}

if (!TELEGRAM_APP_ID || !TELEGRAM_APP_HASH) {
  console.error('Invalid Telegram APP_ID / APP_HASH', TELEGRAM_APP_ID, TELEGRAM_APP_HASH);
  process.exit(1);
  return;
}

// GOOGLE PLAY CONSTANTS

const googleAuth = LOCAL ? null : new google.auth.GoogleAuth({
  keyFile: settings.GOOGLE_TOKEN_PATH,
  scopes: ['https://www.googleapis.com/auth/androidpublisher'],
});
if (!LOCAL) {
  google.options({
    // timeout: 1000,
    auth: googleAuth
  });
}
const play = LOCAL ? null : google.androidpublisher({
  version: 'v3',
  params: {
    packageName: PACKAGE_NAME
  }
});

// CONSTANTS

const ALL_PLATFORMS = ['googlePlay', 'huawei', 'github', 'telegram'];
const GITHUB_BUILDS = {
  'latest': ['universal'],
  'marshmallow': ['universal'],
  'lollipop': ['universal'],
  'legacy': ['arm32']
};

// MAIN


const db = new Level('./db');

const cpus = os.cpus();
const cpuCount = cpus.length;
let threadCount;
const cpuNames = [];
cpus.forEach((cpu) => {
  if (!cpuNames.includes(cpu.model)) {
    cpuNames.push(cpu.model);
  }
});
const platform = os.platform();
if (platform === 'linux') {
  const output = execSync('lscpu -p | grep -Evc \'^#\'', {encoding: 'utf8'});
  threadCount = parseInt(output.trim());
} else if (platform === 'darwin') {
  const output = execSync('sysctl -n hw.logicalcpu_max', {encoding: 'utf8'});
  threadCount = parseInt(output.trim());
}
let cpuSignature = cpuNames.join(', ') + ' @ ' + cpuCount + (cpuCount > 1 ? ' cores' : ' core') + (threadCount !== cpuCount ? ' (' + threadCount + ' threads)' : '');

const cur = {
  cache: {},
  build_no: -1,
  pending_build: null,
  uploaded_version: -1,
  killServer: false,
  server: null
};

function runServer (onClose, detached) {
  detached = !!detached;
  const server = spawn('telegram-bot-api',
    [
      '--api-id=' + TELEGRAM_APP_ID,
      '--api-hash=' + TELEGRAM_APP_HASH,
      '--local',
      '--dir=' + process.cwd() + '/server',
      '--log=' + process.cwd() + '/server.log',
      '--verbosity=' + (settings.server_verbosity || 1)
    ],
    {detached}
  );
  server.stdout.on('data', (data) => {
    if (LOCAL) {
      console.log('Server says:', data);
    }
  });
  server.stderr.on('data', (data) => {
    if (LOCAL) {
      console.log('Server cries:', data);
    }
  });
  server.on('close', (code) => {
    console.log(`Server process exited with code ${code}`);
    if (onClose) {
      onClose(server);
    }
  });
  if (detached) {
    server.unref();
  }
  return server;
}

cur.server = runServer((closedServer) => {
  if (cur.server === closedServer) {
    console.error('Server closed, quitting process', cur.exiting);
    cur.server = null;
    if (!cur.exiting) {
      process.kill(process.pid, 'SIGINT');
    }
  } else {
    console.error('Unknown server closed');
  }
});

function isOffline () {
  return cur.server === null;
}

async function stopServer () {
  console.log('Killing server…', isOffline());
  if (!isOffline()) {
    cur.server.kill('SIGTERM');
  }
}

// Wait for the server
Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 1000);

const TELEGRAM_API_URL = 'http://127.0.0.1:8081';

const bots = [
  {
    id: 'private',
    bot: new TelegramBot(TELEGRAM_API_TOKEN, {
      polling: true,
      filepath: false,
      baseApiUrl: TELEGRAM_API_URL
    })
  },
  {
    id: 'public',
    bot: new TelegramBot(TELEGRAM_API_TOKEN_2, {
      polling: true,
      filepath: false,
      baseApiUrl: TELEGRAM_API_URL
    })
  }
];
const botMap = {};
bots.forEach((bot) => {
  botMap[bot.id] = bot.bot;
});

function nextBuildId () {
  let id = cur.build_no ? cur.build_no + 1 : 1;
  cur.build_no = id;
  db.put('build_count', id);
  return id;
}

function areEqual (a, b) {
  if (a === b)
    return true;
  if (!a || !b)
    return false;
  for (let key in a) {
    if (a[key] === b[key] || (typeof a[key] === typeof b[key] && typeof a[key] === 'object' && areEqual(a[key], b[key])))
      continue;
    return false;
  }
  for (let key in b) {
    if (!a.hasOwnProperty(key))
      return false;
  }
  return true;
}

function ucfirst (str) {
  return str && str.length ? str.charAt(0).toUpperCase() + str.substring(1) : str;
}

function escapeRegExp (string) {
  return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
}

function empty (obj) {
  if (typeof obj === 'object') {
    for (const key in obj) {
      if (obj.hasOwnProperty(key)) {
        return false;
      }
    }
  }
  return true;
}

function limitMessageLength (html, maxCodePointCount) {
  const originalLength = messageLength(html);
  if (originalLength <= maxCodePointCount) {
    return html;
  }

  const ellipsis = ELLIPSIS;
  const ellipsisSize = messageLength(ellipsis);
  let trimmedEnd = 0;

  let tag = null;
  let index = 0;
  let codePointCount = 0;
  const openTags = [];

  for (const codePoint of html) {
    if (codePoint === '<' || codePoint === '>') {
      const isTagOpen = (codePoint === '<');
      if (isTagOpen) {
        tag = { name: '', startIndex: index };
      } else if (tag !== null) {
        if (tag.isClose) {
          const openTag = openTags.pop();
          // TODO(?): check if tags match?
          if (openTags.length === 0) {
            if (codePointCount <= maxCodePointCount - ellipsisSize) {
              trimmedEnd = index + codePoint.length;
            } else {
              break; // can't fit close tag.
            }
          }
        } else if (tag.lastSymbol === '/') { /* <br /> */
          if (openTags.length === 0) {
            trimmedEnd = index + codePoint.length;
          }
        } else {
          openTags.push(tag);
        }
        tag = null;
      }
    } else if (tag !== null) { /* inside < ... > */
      if (tag.name.length === 0 && codePoint === '/') {
        tag.isClose = true;
      } else {
        tag.name += codePoint;
        tag.lastSymbol = codePoint;
      }
    } else {
      if (openTags.length === 0) {
        if (codePointCount + 1 <= maxCodePointCount - ellipsisSize) {
          trimmedEnd = index + codePoint.length;
        } else {
          break; // can't fit more code points.
        }
      }
      codePointCount++;
    }
    index += codePoint.length;
  }

  return html.substring(0, trimmedEnd) + ellipsis;
}

function messageLength (html) {
  let codePointCount = 0;
  let inTag = false;
  for (const codePoint of html) {
    if (codePoint === '<' || codePoint === '>') {
      inTag = (codePoint === '<');
    } else if (!inTag) {
      codePointCount++;
    }
  }
  return codePointCount;
}

async function getObject (type, id) {
  if (!cur.cache[type]) {
    cur.cache[type] = {};
  }
  const cached = cur.cache[type][id];
  if (cached !== undefined) {
    return cached;
  }
  try {
    const value = await db.get(type + '_' + id, {valueEncoding: 'json'});
    cur.cache[type][id] = value;
    return value;
  } catch (err) {
    cur.cache[type][id] = null;
    return null;
  }
}

function checksum (path, callback, algorithm) {
  const stream = fs.createReadStream(path);
  const checksum = crypto.createHash(algorithm);
  stream.on('error', function (err) {
    return callback(err, null)
  });
  stream.on('data', function (chunk) {
    try {
      checksum.update(chunk)
    } catch (ex) {
      return callback(ex, null)
    }
  });
  stream.on('end', function () {
    return callback(null, checksum.digest('hex'))
  });
}

async function storeObject (type, obj, id) {
  if (obj === undefined)
    return;
  if (id === undefined)
    id = obj.id;
  if (id === undefined)
    return;
  const existing = await getObject(type, id);
  if (!areEqual(obj, existing)) {
    cur.cache[type][id] = obj;
    await db.put(type + '_' + id, obj, {valueEncoding: 'json'});
  }
}

function getCommitDate (callback) {
  exec('git show -s --format=%ct', {cwd: settings.TGX_SOURCE_PATH}, (error, stdout, stderr) => {
    if (error) {
      throw error;
    }
    const result = parseInt(trimIndent(stdout).trim());
    callback(result);
  });
}

function gitPull (callback) {
  exec('git pull', {cwd: settings.TGX_SOURCE_PATH}, (error, stdout, stderr) => {
    if (error) {
      throw error;
    }
    callback(stdout);
  });
}

function getGitData (callback) {
  exec('echo "$(git rev-parse --short HEAD) $(git rev-parse HEAD) $(git show -s --format=%ct) $(git config --get remote.origin.url) $(git rev-parse --abbrev-ref HEAD) $(git log -1 --pretty=format:\'%an\')"', {cwd: settings.TGX_SOURCE_PATH}, (error, stdout, stderr) => {
    if (error) {
      throw error;
    }
    const result = trimIndent(stdout).trim().split(' ', 6);
    let remoteUrl = sshToHttpUrl(result[3]);
    callback({
      commit: {
        short: result[0],
        long: result[1]
      },
      remoteUrl: remoteUrl,
      branch: result[4],
      author: result[5],
      date: parseInt(result[2])
    });
  });
}

function getLocalChanges (callback) {
  exec('git status --porcelain --untracked-files=no', {cwd: settings.TGX_SOURCE_PATH}, (error, stdout, stderr) => {
    if (error) {
      throw error;
    }
    const changes = trimIndent(stdout).trim();
    callback(changes && changes.length ? changes : null);
  });
}

function postHttp (url, jsonData, needBinary, httpOptions, method) {
  return new Promise((accept, reject) => {
    const parsed = new URL(url);
    const protocol = (parsed.protocol === 'https:' ? https : http);
    try {
      const postData = JSON.stringify(jsonData);
      const options = Object.assign({
        host: parsed.host,
        path: parsed.pathname + parsed.search,
        method: (method || 'POST'),
        headers: {
          'Content-Type': 'application/json',
          'Content-Length': Buffer.byteLength(postData),
        }
      }, httpOptions || {});

      const req = protocol.request(options, (res) => {
        toUtf8(res, (contentType, content) => {
          accept({statusCode: res.statusCode, statusMessage: res.statusMessage, content, contentType});
        }, needBinary);
      }).on('error', reject);
      req.write(postData);
      req.end();
    } catch (e) {
      console.error('Cannot fetch', url, e);
      reject(e);
    }
  });
}

function fetchHttp (url, needBinary, httpOptions) {
  return new Promise((accept, reject) => {
    const parsed = new URL(url);
    const protocol = (parsed.protocol === 'https:' ? https : http);
    try {
      protocol.get(Object.assign({
        host: parsed.host,
        path: parsed.pathname + parsed.search
      }, httpOptions || {}), (res) => {
        toUtf8(res, (contentType, content) => {
          accept({statusCode: res.statusCode, statusMessage: res.statusMessage, content, contentType});
        }, needBinary);
      }).on('error', reject);
    } catch (e) {
      console.error('Cannot fetch', url, e);
      reject(e);
    }
  });
}

function uploadHttpFile (url, filePath, httpHeaders, httpOptions, needBinary) {
  return new Promise((accept, reject) => {
    const parsed = new URL(url);
    const protocol = (parsed.protocol === 'https:' ? https : http);

    const file = fs.createReadStream(filePath);
    const stat = fs.statSync(filePath);

    const options = Object.assign({
      host: parsed.host,
      path: parsed.pathname + parsed.search,
      method: 'POST',
      headers: Object.assign({
        'Content-Type': 'application/octet-stream',
        'Content-Length': stat.size
      }, httpHeaders || {})
    }, httpOptions || {});

    const req = protocol.request(options, (res) => {
      toUtf8(res, (contentType, content) => {
        accept({statusCode: res.statusCode, statusMessage: res.statusMessage, content, contentType});
      }, needBinary);
    });

    req.on('error', reject);
    file.pipe(req);
  });
}

function toUtf8 (res, onDone, needBinary) {
  const contentType = (res.headers['content-type'] || '').split(';');
  let encoding = null;
  for (let i = 0; i < contentType.length; i++) {
    const keyValue = contentType[i].split('=');
    if (keyValue.length === 2 && keyValue[0].toLowerCase() === 'charset') {
      encoding = keyValue[1].toLowerCase();
    }
  }
  let data = [];
  res.setEncoding('binary');
  res.on('data', (chunk) => {
    data.push(Buffer.from(chunk, 'binary'));
  });
  res.on('end', () => {
    const binary = Buffer.concat(data);
    if (needBinary) {
      onDone(contentType, binary);
    } else {
      if (encoding && encoding !== 'utf-8') {
        onDone(contentType, iconv.encode(iconv.decode(binary, encoding), 'utf-8'));
      } else {
        onDone(contentType, binary.toString('utf-8'));
      }
    }
  });
}

function getProperty (data, variableName) {
  variableName = variableName.replace(/\./gi, '\\.');
  const regexp = new RegExp(variableName + '\s*=\s*[^\n]+');
  const lookup = data.match(regexp);
  const result = lookup && lookup.length == 1 ? lookup[0] : null;
  if (result) {
    return result.substring(result.indexOf('=') + 1)
  }
  return null;
}

function monthYears (now, then) {
  let years = now.getUTCFullYear() - then.getUTCFullYear()
  let months = 0;
  if (now.getUTCMonth() < then.getUTCMonth() ||
    (now.getUTCMonth() === then.getUTCMonth() && now.getUTCDate() < then.getUTCDate())) {
    years--
    months = 12 - then.getUTCMonth() + now.getUTCMonth()
  } else {
    months = now.getUTCMonth() - then.getUTCMonth()
  }
  if (now.getUTCDate() < then.getUTCDate()) {
    months--
  }
  return years + '.' + months;
} 

function getAppVersion (callback) {
  fs.readFile(settings.TGX_SOURCE_PATH + '/version.properties', 'utf-8', function (err, data) {
    if (err) {
      callback(null);
    } else {
      const buildVersion = parseInt(getProperty(data, 'version.app'));
      const creationDate = parseInt(getProperty(data, 'version.creation'));
      if (!creationDate) {
        callback('#' + buildVersion);
        return;
      }
      const majorVersion = getProperty(data, 'version.major');
      getCommitDate((commitDate) => {
        const buildDate = new Date(commitDate * 1000);
        const fromDate = new Date(creationDate);
        const minorVersion = monthYears(buildDate, fromDate);
        callback({code: buildVersion, name: majorVersion + '.' + minorVersion + '.' + buildVersion});
      });
    }    
  });
}

function escapeMarkdown (text) {
  if (!text)
    return text;
  return text.replace(/\\/g, '\\\\').replace(/\-/g, '\\-').replace(/\*/g, '\\*').replace(/\./g, '\\.').replace(/\!/g, '\\!');
}

function escapeHtml (text) {
  if (!text)
    return text;
  return text.replace(/</g, '&lt;').replace(/>/g, '&gt;');
}

function trimIndent (text) {
  if (!text)
    return text;
  const lines = text.split('\n');
  let minIndendWidth = -1;
  for (let lineIndex = 0; lineIndex < lines.length; lineIndex++) {
    const line = lines[lineIndex];
    if (line.length) {
      let indentWidth = 0;
      for (let i = 0; i < line.length; i++) {
        if (line[i] === ' ') {
          indentWidth++;
        } else {
          break;
        }
      }
      minIndendWidth = minIndendWidth === -1 || minIndendWidth > indentWidth ? indentWidth : minIndendWidth;
      if (indentWidth === 0)
        break;
    }
  }
  if (minIndendWidth <= 0) {
    return text;
  }
  let result = '';
  for (let lineIndex = 0; lineIndex < lines.length; lineIndex++) {
    const line = lines[lineIndex];
    if (lineIndex > 0)
      result += '\n';
    if (line.length) {
      result += line.substring(minIndendWidth);
    }
  }
  return result;
}

function duration (start, end, full) {
  const time = end - start;
  if (time === 0) {
    return full ? 'instant' : '0s';
  }
  if (time < 1000) {
    return time + (full ? time === 1 ? ' millisecond' : ' milliseconds' : 'ms');
  }
  const totalSeconds = time / 1000;
  const totalMinutes = Math.floor(totalSeconds / 60);

  let seconds = (time - totalMinutes * 60000) / 1000;

  let result = '';
  if (totalMinutes !== 0) {
    if (result.length) result += ' ';
    result += totalMinutes + (full ? totalMinutes !== 1 ? ' minutes' : ' minute' : 'm');
  }
  if (seconds !== 0) {
    if (result.length) result += ' ';
    result += (seconds % 1 !== 0 ? seconds.toFixed(1) : seconds) + (full ? seconds !== 1 ? ' seconds' : ' second' : 's');
  }

  return result;
}

async function traceMaxApkVersionCode (sdkVariant, abiVariant, versionCode, uploadDate, platform) {
  const type = sdkVariant !== 'latest' ? abiVariant + ucfirst(sdkVariant) : abiVariant;
  const isDefault = platform === 'googlePlay';
  const id = isDefault ? type : platform + '-' + type;
  const maxId = isDefault ? 'max' : platform + '-max';
  const cur = await getObject('apk', id);
  const max = await getObject('apk', maxId);
  if (!max || versionCode > max.versionCode) {
    await storeObject('apk', {versionCode, uploadDate, platform}, maxId);
  }
  if (!cur || versionCode > cur.versionCode) {
    await storeObject('apk', {versionCode, uploadDate, platform}, id);
  }
}

async function canUploadApk (sdkVariant, abiVariant, versionCode, platforms) {
  const type = sdkVariant !== 'latest' ? abiVariant + ucfirst(sdkVariant) : abiVariant;
  for (let i = 0; i < platforms.length; i++) {
    const platform = platforms[i];
    const isDefault = platform === 'googlePlay';
    const max = type === 'universal' ? await getObject('apk', isDefault ? 'max' : platform + '-max') : null;
    const id = isDefault ? type : platform + '-' + type;
    const cur = await getObject('apk', id);
    const maxVersion = Math.max(cur ? cur.versionCode : 0, type === 'universal' && platform === 'googlePlay' && max ? max.versionCode : 0);
    if (versionCode <= maxVersion) {
      return false;
    }
  }
  return true;
}

async function traceDuration (type, name, startTime, endTime, isComplete) {
  if (typeof endTime !== 'number')
    endTime = endTime.getTime();
  if (typeof startTime !== 'number')
    startTime = startTime.getTime();
  if (!isComplete) {
    type += '_failed';
  }
  let value = await getObject(type, name);
  if (!value) {
    value = {
      total: 0,
      items: []
    };
  }
  value.total += (endTime - startTime);
  value.items.push([startTime, endTime]);
  await storeObject(type, value, name);
}

function main () {
  db.get('build_count', (err, value) => {
    cur.build_no = err ? 0 : parseInt(value);
  });
  db.get('uploaded_version', (err, value) => {
    cur.uploaded_version = err ? 0 : parseInt(value);
  });
}

async function estimateBuildDuration (build) {
  let haveMissing = false;
  let totalEstimate = 0;
  for (let i = 0; i < build.tasks.length; i++) {
    const task = build.tasks[i];
    const stat = await getObject('task_stat', task.name);
    if (stat && stat.total) {
      task.estimateDuration = stat.total / stat.items.length;
      totalEstimate += task.estimateDuration;
    } else {
      haveMissing = true;
    }
  }
  if (!haveMissing) {
    build.estimateDuration = totalEstimate;
  }
}

async function killTask (task) {
  setTimeout(async () => {
    if (!task.processTerminated && task.process) {
      await task.process.kill('SIGKILL');
      task.processTerminated = true;
    }
  }, 2500);
  if (task.process) {
    await task.process.kill();
    task.processTerminated = true;
  }
}

function findFile (dir, regexp, callback) {
  fs.readdir(dir, {withFileTypes: true}, (err, files) => {
    if (err) {
      console.error('Cannot lookup for file', dir);
      callback(null);
    } else {
      for (let i = 0; i < files.length; i++) {
        const fileName = files[i].name;
        let match = fileName.match(regexp);
        if (match && match.length) {
          if (match[0].length === fileName.length) {
            callback(fileName);
            return;
          }
        }
      }
      console.error('None of the files match regexp!', regexp, JSON.stringify(files));
      callback(null);
    }
  });
}

function toDisplayAlgorithm (algorithm) {
  switch (algorithm) {
    case 'md5': return 'MD5';
    case 'sha1': return 'SHA-1';
    case 'sha256': return 'SHA-256';
    default: return algorithm;
  }
}

function getDisplayVariant (variant) {
  switch (variant) {
    case 'arm64': return 'arm64-v8a';
    case 'arm32': return 'armeabi-v7a';
    default: return variant;
  }
}

function getBuildFiles (build, sdkVariant, abiVariant, callback) {
  const folder = sdkVariant + ucfirst(abiVariant) ; // latestUniversalRelease
  const architecture = getDisplayVariant(abiVariant);
  
  const outputsDir = settings.TGX_SOURCE_PATH + '/app/build/outputs';

  const mappingDir = outputsDir + '/mapping/' + folder + 'Release';
  const apkDir = outputsDir + '/apk/' + folder + '/release';

  const nativeDebugSymbolsFile = outputsDir + '/native-debug-symbols/' + folder + 'Release' + '/native-debug-symbols.zip';

  const result = { };

  const check = () => {
    if (result.nativeDebugSymbolsFile !== undefined && result.apkFile !== undefined && (result.apkFile === null || (result.apkFile.checksum && result.apkFile.checksum.md5 !== undefined && result.apkFile.checksum.sha1 !== undefined && result.apkFile.checksum.sha256 !== undefined)) && result.mappingFile !== undefined && result.metadata !== undefined) {
      if (result.nativeDebugSymbolsFile && result.apkFile && (result.apkFile.checksum && result.apkFile.checksum.sha256 && result.apkFile.checksum.sha1 && result.apkFile.checksum.md5) && (result.mappingFile || build.outputApplication.dontObfuscate) && result.metadata) {
        callback(result);
      } else {
        console.error('Cannot find build files for #' + build.version.name, JSON.stringify(result));
        callback(null);
      }
    }
  };

  const prefix = '^' + escapeRegExp(build.outputApplication.name || 'Telegram X')
    .replace(/ /g, '-')
    .replace(/#/g, '') + '-' +
    build.version.name.replace(/\./gi, '\\.') + '(?:\\+[0-9,]+)?' +
    (sdkVariant !== 'latest' ? '(?:-' + sdkVariant + ')?' : '') +
    (architecture ? '(?:-' + architecture + ')?' : '') +
    (build.outputApplication.extension ? '(?:-' + build.outputApplication.extension + ')?' : '');
  fs.exists(nativeDebugSymbolsFile, (exists) => {
    result.nativeDebugSymbolsFile = exists ? {path: nativeDebugSymbolsFile} : null;
    check();
  });
  findFile(apkDir, RegExp(prefix + '\\.apk$'), (apkFile) => {
    if (apkFile) {
      result.apkFile = {path: apkDir + '/' + apkFile};
      ['sha256', 'sha1', 'md5'].forEach((algorithm) => {
        checksum(result.apkFile.path, (err, checksum) => {
          if (!result.apkFile.checksum) {
            result.apkFile.checksum = {};
          }
          result.apkFile.checksum[algorithm] = checksum ? checksum : null;
          check();
        }, algorithm);
      });
    } else {
      result.apkFile = null;
      check();
    }
  });
  findFile(apkDir, RegExp('^output-metadata\\.json$'), (metadataFile) => {
    if (metadataFile) {
      fs.readFile(apkDir + '/' + metadataFile, 'utf-8', (err, data) => {
        const metadata = err ? null : JSON.parse(data);
        if (err || !(metadata &&
            metadata.elements &&
            metadata.elements.length === 1 &&
            metadata.elements[0].versionCode)) {
          console.error('Cannot read metadata file', err, data);
          result.metadata = null;
          check();
        } else {
          result.metadata = metadata.elements[0];
          check();
        }
      });
    } else {
      result.metadata = null;
      check();
    }
  });
  findFile(mappingDir, RegExp(prefix + '\\.txt$'), (mappingFile) => {
    result.mappingFile = mappingFile ? {path: mappingDir + '/' + mappingFile} : null;
    check();
  });
}

function sshToHttpUrl (a) {
  if (a.startsWith('ssh://git@')) {
    return 'https://' + a.substring(10);
  }
  if (a.startsWith('git@')) {
    let index = a.indexOf(':', 4);
    let domain = a.substring(4, index);
    let endIndex = a.endsWith('.git') ? a.length - 4 : a.length;
    return 'https://' + domain + '/' + a.substring(index + 1, endIndex);
  }
  return a;
}

function compareRemoteUrls (a, b) {
  if (a === b) {
    return true;
  }
  const aHttp = sshToHttpUrl(a);
  const bHttp = sshToHttpUrl(b);
  return aHttp === bHttp || a.toLowerCase() === b.toLowerCase();
}

function getFromToCommit (build, allowProduction) {
  if (build.outputApplication && build.outputApplication.isPRBuild)
    return null;
  if (build.googlePlayTrack) {
    let googlePlayBuild = allowProduction ? build.previousGooglePlayProductionBuild : null;
    if (!(googlePlayBuild &&
        compareRemoteUrls(googlePlayBuild.remoteUrl, build.git.remoteUrl) &&
        googlePlayBuild.branch === build.git.branch)) {
      googlePlayBuild = build.previousGooglePlayBuild;
    }
    if (googlePlayBuild &&
        compareRemoteUrls(googlePlayBuild.remoteUrl, build.git.remoteUrl) &&
        googlePlayBuild.branch === build.git.branch) {
      return {
        commit_range: googlePlayBuild.commit.short + '...' + build.git.commit.short,
        from_version: googlePlayBuild.version,
        build_information: googlePlayBuild
      };
    }
  } else if (build.telegramTrack) {
    const telegramBuild = build.previousTelegramBuild;
    if (telegramBuild &&
        compareRemoteUrls(telegramBuild.remoteUrl, build.git.remoteUrl) &&
        telegramBuild.branch === build.git.branch) {
      return {
        commit_range: telegramBuild.commit.short + '...' + build.git.commit.short,
        from_version: telegramBuild.version,
        build_information: telegramBuild
      };
    }
  }
  return null;
}

function getBuildCaption (build, sdkVariant, abiVariant, shortenChecksums) {
  const fromToCommit = getFromToCommit(build,
    build.googlePlayTrack && build.previousGooglePlayProductionBuild && build.previousGooglePlayBuild &&
    build.previousGooglePlayBuild.version.code < build.previousGooglePlayProductionBuild.version.code
  );

  let caption = '<b>Version</b>: <code>' +
    build.version.name +
    (sdkVariant !== 'latest' ? '-' + sdkVariant : '') +
    '-' + getDisplayVariant(abiVariant) +
    '</code>';
  if (fromToCommit) {
    caption += '\n<b>Changes from ' + fromToCommit.from_version.code + '</b>: <a href="' + build.git.remoteUrl + '/compare/' + fromToCommit.commit_range + '">' + fromToCommit.commit_range + '</a>';
  } else {
    caption += '\n<b>Commit</b>: <a href="' + build.git.remoteUrl + '/tree/' + build.git.commit.long + '">' + build.git.commit.short + '</a>';
    if (build.git.date) {
      caption += ', ' + toDisplayDate(build.git.date);
    }
  }
  if (build.pullRequestsMetadata || !empty(build.pullRequests)) {
    caption += '\n<b>Pull requests</b>: ' + toDisplayPullRequestList(build);
  }

  switch (sdkVariant) {
    case 'latest': {
      caption += '\n<b>Supports</b>: Android N+'
      break;
    }
    case 'marshmallow': {
      caption += '\n<b>Supports</b>: Android Marshmallow only'
      break;
    }
    case 'lollipop': {
      caption += '\n<b>Supports</b>: Android Lollipop only'
      break;
    }
    case 'legacy': {
      caption += '\n<b>Supports</b>: Android Jelly Bean & KitKat only'
      break;
    }
  }

  if (abiVariant === 'x86' || abiVariant == 'arm32') {
    caption += ' (32-bit devices)';
  } else if (abiVariant === 'arm64' || abiVariant === 'x64') {
    caption += ' (64-bit devices)'
  }

  const checksumAlgorithms = ['md5', 'sha1', 'sha256'];
  if (!shortenChecksums) {
    caption += '\n';
    checksumAlgorithms.forEach((algorithm) => {
      const hash = build.files[sdkVariant][abiVariant].apkFile.checksum[algorithm];
      const url = 'https://t.me/tgx_bot?start=' + hash;
      caption += '\n<b>' + toDisplayAlgorithm(algorithm) + '</b>: <a href="' + url + '">' + hash + '</a>';
    });
  }

  caption += '\n\n';
  caption += '#' + abiVariant + (sdkVariant !== 'latest' ? ucfirst(sdkVariant) : '');
  switch (build.googlePlayTrack) {
    case 'production': caption += ' #stable'; break;
    case 'beta': caption += ' #beta'; break;
    case 'alpha': caption += ' #alpha'; break;
  }
  caption += ' #apk';
  if (shortenChecksums) {
    caption += ' (';
    checksumAlgorithms.forEach((algorithm, index) => {
      const hash = build.files[sdkVariant][abiVariant].apkFile.checksum[algorithm];
      const url = 'https://t.me/tgx_bot?start=' + hash;
      caption += '<b>';
      if (index > 0) {
        caption += ', ';
      }
      caption += '<a href="' + url + '">' + toDisplayAlgorithm(algorithm) + '</a>';
      caption += '</b>';
    });
    caption += ')';
  }
  return caption;
}

function publishToTelegram (bot, task, build, sdkVariant, onDone, chatId, onlyPrivate, disableNotification, shortenChecksums) {
  const docs = [];
  const variants = [];
  for (const abiVariant in build.files[sdkVariant]) {
    const file_id = build.files[sdkVariant][abiVariant].apkFile.remote_id;
    if (file_id) {
      const doc = {
        type: 'document',
        media: file_id,
        caption: getBuildCaption(build, sdkVariant, abiVariant, shortenChecksums),
        parse_mode: 'HTML'
      };
      let ok =
        (sdkVariant === 'latest' && abiVariant !== 'universal' && abiVariant !== 'x86' && abiVariant !== 'x64') ||
        (build.variants.length === 1 && build.variants[0].abi.length === 1);
      if (onlyPrivate) {
        ok = !ok;
      }
      if (ok) {
        docs.push(doc);
        variants.push(abiVariant);
      }
    } else {
      console.log('Some of docs do not have file_id available!');
      onDone(1);
      return;
    }
  }
  if (docs.length > 1) {
    bot.sendMediaGroup(chatId, docs, {
      disable_notification: disableNotification
    }).then((messages) => {
      if (!build.publicMessages) {
        build.publicMessages = [];
      }
      for (let i = 0; i < messages.length; i++) {
        const messageId = messages[i].message_id;
        build.publicMessages.push({
          sdkVariant,
          abiVariant: variants[i],
          message_id: messageId,
          url: messages[i].sender_chat && messages[i].sender_chat.username ? 
            'https://t.me/' + messages[i].sender_chat.username + '/' + messageId :
            null
        });
      }
      if (!onlyPrivate) {
        tracePublishedTelegramBuild(build).then(() => {
          onDone(0);
        });
      } else {
        onDone(0);
      }
    }).catch((error) => {
      onDone(1);
      globalErrorHandler()(error);
    });
  } else if (docs.length === 1) {
    bot.sendDocument(chatId, docs[0].media, {
      caption: docs[0].caption,
      parse_mode: docs[0].parse_mode,
      disable_notification: disableNotification
    }).then((message) => {
      if (!build.publicMessages) {
        build.publicMessages = [];
      }
      build.publicMessages.push({
        sdkVariant,
        abiVariant: variants[0],
        message_id: message.message_id,
        url: message.sender_chat && message.sender_chat.username ?
          'https://t.me/' + message.sender_chat.username + '/' + message.message_id :
          null
      });
      if (!onlyPrivate) {
        tracePublishedTelegramBuild(build).then(() => {
          onDone(0);
        });
      } else {
        onDone(0);
      }
    }).catch((error) => {
      onDone(1);
      globalErrorHandler()(error);
    });
  } else {
    onDone(0);
  }
}

function uploadToTelegram (bot, task, build, sdkVariant, abiVariant, onDone) {
  const files = build.files[sdkVariant][abiVariant];
  if (!files) {
    console.log('Build files not found to upload');
    onDone(1);
    return;
  }

  const failWithError = (message, e) => {
    if (!task.endTime) {
      console.error(message, e);
      onDone(1);
    }
  };

  const maxUploadAttemptCount = 5;

  const onMappingUploaded = (mappingMessage) => {
    onDone(0);
  };

  const onSymbolsUploaded = (symbolsMessage) => {
    if (!files.mappingFile) { // Mapping file doesn't exist for builds made with --dontobfuscate option
      onDone(0);
      return;
    }
    attemptAction(maxUploadAttemptCount, (accept, reject) => {
      bot.sendDocument(build.serviceChatId, fs.createReadStream(files.mappingFile.path), {
        reply_to_message_id: symbolsMessage.message_id
      }, {
        contentType: 'text/plain'
      }).then(accept).catch(reject);
    }, (e, attemptNo) => {
      console.log('[RETRY]', 'Trying again to upload mapping file to Telegram, attemptNo:', attemptNo, e);
    }).then(onMappingUploaded).catch((e) => {
      failWithError('Cannot upload mapping file', e);
    })
  };

  const onApkUploaded = (apkMessage) => {
    files.apkFile.remote_id = apkMessage.document.file_id;
    modifyNativeDebugSymbolsArchive(files.nativeDebugSymbolsFile.path).then((nativeDebugSymbolsPath) => {
      attemptAction(maxUploadAttemptCount, (accept, reject) => {
        const nativeDebugSymbolsStream = fs.createReadStream(nativeDebugSymbolsPath);
        bot.sendDocument(build.serviceChatId, nativeDebugSymbolsStream, {
          reply_to_message_id: apkMessage.message_id
        }, {
          contentType: 'application/zip'
        }).then(accept).catch(reject);
      }, (e, attemptNo) => {
        console.log('[RETRY]', 'Trying again to upload native-debug-symbols.zip to Telegram, attemptNo:', attemptNo, e);
      }).then(onSymbolsUploaded).catch((e) => {
        failWithError('Cannot upload native-debug-symbols.zip', e);
      });
    });
  };

  attemptAction(maxUploadAttemptCount, (accept, reject) => {
    bot.sendDocument(build.serviceChatId, fs.createReadStream(files.apkFile.path), {
      reply_to_message_id: build.serviceMessageId,
      caption: getBuildCaption(build, sdkVariant, abiVariant, true),
      parse_mode: 'HTML'
    }, {
      contentType: APK_MIME_TYPE
    }).then(accept).catch(reject);
  }, (e, attemptNo) => {
    console.log('[RETRY]', 'Trying again to upload APK to Telegram, attemptNo:', attemptNo, e);
  }).then(onApkUploaded).catch((e) => {
    failWithError('Cannot upload telegram file', e);
  });

  return async () => {
    if (!task.endTime) {
      failWithError('Aborted', new Error());
    }
  };
}

function traceBuiltApk (build, task, sdkVariant, abiVariant, checksum, onDone) {
  for (let algorithm in checksum) {
    const hash = checksum[algorithm];
    const data = toShotBuildInfo(build);
    Object.assign(data, {
      sdkVariant: sdkVariant,
      abiVariant: abiVariant,
      hashAlgorithm: algorithm
    });
    ALL_PLATFORMS.forEach((platform) => {
      data[platform + 'Track'] = build[platform + 'Track'];
    })
    db.put('hash_' + hash, data, {valueEncoding: 'json'});
  }
}

function findApkByHash (hash, callback) {
  db.get('hash_' + hash, {valueEncoding: 'json'}, callback);
}

function toShotBuildInfo (build) {
  const buildData = {
    version: build.version
  };
  Object.assign(buildData, build.git);
  if (!empty(build.pullRequests)) {
    buildData.pullRequests = build.pullRequests;
  }
  return buildData;
}

async function tracePublishedTelegramBuild (build) {
  await storeObject('telegram', toShotBuildInfo(build), build.telegramTrack);
}

async function findPublishedTelegramBuild (build) {
  if (build.telegramTrack) {
    return await getObject('telegram', build.telegramTrack);
  }
  return null;
}

async function tracePublishedGooglePlayBuild (build) {
  await storeObject('google_play', toShotBuildInfo(build), build.googlePlayTrack);
}

async function findPublishedGooglePlayBuild (build, forcedTrack) {
  const track = forcedTrack || build.googlePlayTrack;
  if (track) {
    return await getObject('google_play', track);
  }
  return null;
}

async function fetchAvailableLanguageCodes () {
  try {
    const result = await fetchHttp('https://translations.telegram.org/languages/list/android_x');
    if (typeof result === 'string') {
      return JSON.parse(result);
    } else {
      console.error('fetchAvailableLanguageCodes result is not a string', result);
    }
  } catch (e) {
    console.log('fetchAvailableLanguageCodes failed', e);
  }
  return ['en'];
}

async function modifyNativeDebugSymbolsArchive (filePath) {
  let allowExtraDebugSymbols = false;

  const tdlibPath = path.join(settings.TGX_SOURCE_PATH, 'tdlib');
  const extraNativeDebugSymbolsPath = settings.TDLIB_SYMBOLS_PATH || path.join(tdlibPath, 'source', 'build', 'native-debug-symbols');
  if (settings.add_tdlib_debug_symbols === true && fs.existsSync(extraNativeDebugSymbolsPath)) {
    // Make sure tdlib/version.txt and tdlib/source/build/native-debug-symbols/version.txt match
    const tdlibVersionPath = path.join(tdlibPath, 'version.txt');
    const extraNativeDebugSymbolsVersionPath = path.join(extraNativeDebugSymbolsPath, 'version.txt');
    if (fs.existsSync(tdlibVersionPath) && fs.existsSync(extraNativeDebugSymbolsVersionPath)) {
      const tdlibVersion = fs.readFileSync(tdlibVersionPath);
      const extraNativeDebugSymbolsVersion = fs.readFileSync(extraNativeDebugSymbolsVersionPath);
      allowExtraDebugSymbols = tdlibVersion.equals(extraNativeDebugSymbolsVersion);
      console.log('TDLib and native-debug-symbols match:', allowExtraDebugSymbols);
    }
  }

  if (settings.modify_debug_symbols !== true && !allowExtraDebugSymbols) {
    console.log('Using original native-debug-symbols.zip');
    return filePath;
  }

  const existingArchivePath = path.parse(filePath);
  const temporaryExtractedDirPath = path.join(existingArchivePath.dir, existingArchivePath.name + '-unzipped-temp');
  const modifiedArchivePath = path.join(existingArchivePath.dir, existingArchivePath.name + '-modified' + existingArchivePath.ext);

  const existingZip = new AdmZip(filePath);

  if (fs.existsSync(modifiedArchivePath)) {
    fs.unlinkSync(modifiedArchivePath)
  }
  if (fs.existsSync(temporaryExtractedDirPath)) {
    fs.rmdirSync(temporaryExtractedDirPath, { recursive: true, force: true });
  }

  existingZip.extractAllTo(temporaryExtractedDirPath, true);

  if (fs.existsSync(temporaryExtractedDirPath)) {
    let addedCount = 0;
    if (allowExtraDebugSymbols) {
      // Copy *.so.dbg related to TDLib to extracted directory
      const copyFiles = (dirPath, relativeDirPath) => {
        const files = fs.readdirSync(dirPath);
        files.forEach((fileName) => {
          const childFilePath = path.join(dirPath, fileName);
          if (fs.statSync(childFilePath).isDirectory()) {
            copyFiles(childFilePath, relativeDirPath ? path.join(relativeDirPath, fileName) : fileName);
          } else if (fileName.match(/^.+\.so\.dbg$/g)) {
            const toFilePath = relativeDirPath ?
              path.join(temporaryExtractedDirPath, relativeDirPath, fileName) :
              path.join(temporaryExtractedDirPath, fileName);
            if (!fs.existsSync(toFilePath)) {
              fs.copyFileSync(childFilePath, toFilePath);
              addedCount++;
            }
          }
        });
      };
      copyFiles(extraNativeDebugSymbolsPath);
    }

    let renamedCount = 0;
    if (settings.modify_debug_symbols === true) {
      // Rename *.so.dbg to just *.so
      // DEPRECATED
      /*const renameFiles = (dirPath) => {
        const files = fs.readdirSync(dirPath);
        files.forEach((fileName) => {
          const childFilePath = path.join(dirPath, fileName);
          if (fs.statSync(childFilePath).isDirectory()) {
            renameFiles(childFilePath)
          } else if (fileName.match(/^.+\.so\.dbg$/g)) {
            const newFilePath = path.join(dirPath, fileName.substring(0, fileName.length - '.dbg'.length));
            if (!fs.existsSync(newFilePath)) {
              fs.copyFileSync(childFilePath, newFilePath);
              renamedCount++;
            }
          }
        });
      };
      renameFiles(temporaryExtractedDirPath);*/
    }

    if (renamedCount > 0 || addedCount > 0) {
      const newZip = new AdmZip();
      newZip.addLocalFolder(temporaryExtractedDirPath);
      newZip.writeZip(modifiedArchivePath);
      // fs.rmdirSync(temporaryExtractedDirPath, { recursive: true, force: true });
      console.log('Modified native-debug-symbols.zip, added:', addedCount, 'renamed:', renamedCount);
      return modifiedArchivePath;
    }
  }

  console.log('Fallback to original native-debug-symbols.zip');
  return filePath;
}

async function attemptAction (maxAttemptsCount, act, onRetry) {
  let error = null;
  for (let i = 0; i < maxAttemptsCount; i++) {
    if (i > 0 && onRetry) {
      onRetry(error, i + 1);
      await sleep(i * 1000);
    }
    try {
      const result = await new Promise(act);
      return result;
    } catch (e) {
      error = e;
    }
  }
  throw error;
}

function prepareForPublishing (task, build, onDone) {
  if (LOCAL || !build.files || !build.variants) {
    onDone(1);
    return;
  }

  let variantsToCheck = build.variants.length;
  let onVariantChecked = () => {
    if (--variantsToCheck !== 0 || task.endTime)
      return;

    // at this point we are sure that no apks were uploaded yet

    const releaseNotes = [];

    const changeLogVersionName = build.version.name;
    let changeLogText = changeLogVersionName + '\n\n' + 'https://t.me/tgx_android';
    const productionFromToCommit = getFromToCommit(build, true);
    const viewSourceUrl = build.git.remoteUrl + '/tree/' + build.git.commit.long;
    if (productionFromToCommit) {
      const betaFromToCommit = getFromToCommit(build);
      if (betaFromToCommit && betaFromToCommit.commit_range !== productionFromToCommit.commit_range) {
        const betaDiffUrl = build.git.remoteUrl + '/compare/' + betaFromToCommit.commit_range;
        changeLogText += '\n\nChanges from ' + betaFromToCommit.from_version.name + ':\n';
        changeLogText += betaDiffUrl;
      }
      const diffUrl = build.git.remoteUrl + '/compare/' + productionFromToCommit.commit_range;
      changeLogText += '\n\nChanges from ' + productionFromToCommit.from_version.name + ':\n';
      changeLogText += diffUrl;
      build.fallbackReleaseNotes = diffUrl;
      if (build.pullRequestsMetadata || !empty(build.pullRequests)) {
        changeLogText += '\n\nThis version also includes these pull requests:';
        if (build.pullRequestsMetadata) {
          build.pullRequestsMetadata.forEach((pullRequestMetadata) => {
            const pullRequestId = pullRequestMetadata.id;
            const pullRequest = build.pullRequests ? build.pullRequests[pullRequestId] : null;
            changeLogText += '\n';
            changeLogText += build.git.remoteUrl + '/pull/' + pullRequestId + ' at ' + pullRequest.commit.short;
          });
        } else if (!empty(build.pullRequests)) {
          const pullRequestIds = Object.keys(build.pullRequests);
          pullRequestIds.forEach((pullRequestId) => {
            const pullRequest = build.pullRequests[pullRequestId];
            changeLogText += '\n';
            changeLogText += build.git.remoteUrl + '/pull/' + pullRequestId + ' at ' + pullRequest.commit.short;
          });
        }
      }
    } else {
      build.fallbackReleaseNotes = 'This version is based on this source code: ' + viewSourceUrl;
    }
    releaseNotes.push({
      language: 'en-US', // TODO more languages via translations.telegram.org
      text: changeLogText
    });
    build.releaseNotes = releaseNotes;

    onDone(0);
  };

  for (let i = 0; i < build.variants.length; i++) {
    const variant = build.variants[i];
    if (!build.files[variant.name]) {
      console.error('Passed variant is not built', variant);
      onDone(1);
      return;
    }
    for (let abiIndex = 0; abiIndex < variant.abi.length; abiIndex++) {
      const abiVariant = variant.abi[abiIndex];
      const files = build.files[variant.name][abiVariant];
      if (!files) {
        console.error('Passed variant is not built', variant.name, abiVariant);
        onDone(1);
        return;
      }
      if (files.metadata.versionCode < cur.maximumApkVersionCode) {
        console.error('Version code is lower than maximum', variant, files.metadata.versionCode, cur.maximumApkVersionCode);
        onDone(1);
        return;
      }
      canUploadApk(variant.name, abiVariant, files.metadata.versionCode, build.distributionPlatforms).then((success) => {
        if (success || build.forceUploadApk) {
          onVariantChecked();
        } else {
          const msg = 'APK #' + build.version.name + ' was already published to ' + build.distributionPlatform + '. Version bump required.';
          task.logPublicly(msg);
          console.error(msg);
          onDone(1);
        }
      });
    }
  }

  return async () => {
    if (!task.endTime) {
      // TODO abort upload somehow??

      onDone(1);
    }
  };
}

function uploadToGooglePlay (task, build, draftOnly, onDone) {
  play.edits.insert().then((appEdit) => {
    console.log('Created an AppEdit', JSON.stringify(appEdit));
    const editId = appEdit.data.id;

    let remainingApkCount = 0;
    build.variants.forEach((variant) => {
      variant.abi.forEach((abi) => {
        remainingApkCount++;
      });
    });

    const uploadedVersionCodes = [];
    let onBuildUploaded = (uploadedBuildVariant) => {
      if (--remainingApkCount !== 0)
        return;

      // Setting track
      play.edits.tracks.update({
        editId: editId,
        track: build.googlePlayTrack,
        requestBody: {
          track: build.googlePlayTrack,
          releases: [{
            name: build.version.name + ' ' + build.googlePlayTrack,
            status: draftOnly ? 'draft' : 'completed',
            releaseNotes: build.releaseNotes,
            versionCodes: uploadedVersionCodes
          }]
        }
      }).then((updatedTrack) => {
        const appSubmitted = (appEdit) => {
          console.log('Successfully commited google play changes', JSON.stringify(appEdit));
          tracePublishedGooglePlayBuild(build).then(() => {
            onDone(0);
          });
        };
        const appSubmitFailed = (e) => {
          console.error('Failed to commit changes to Google Play', build.googlePlayTrack, e);
          onDone(1);
        };
        console.log('Successfully updated track', JSON.stringify(updatedTrack));
        play.edits.commit({
          editId: editId
        }).then(appSubmitted)
          .catch((e) => {
          console.error('Failed to commit changes to Google Play, retrying with changesNotSentForReview = true', build.googlePlayTrack, e);
          play.edits.commit({
            editId: editId,
            changesNotSentForReview: true
          }).then(appSubmitted).catch(appSubmitFailed);
        });
      }).catch((updatedTrackError) => {
        console.error('Failed to update track', build.googlePlayTrack, updatedTrackError);
        onDone(1);
      });
    };
    for (let i = 0; i < build.variants.length; i++) {
      const variant = build.variants[i];
      for (let abiIndex = 0; abiIndex < variant.abi.length; abiIndex++) {
        const abiVariant = variant.abi[abiIndex];
        if (abiVariant === 'universal') {
          onBuildUploaded(variant, abiVariant);
          continue;
        }
        const files = build.files[variant.name][abiVariant];
        const apkStream = fs.createReadStream(files.apkFile.path);

        play.edits.apks.upload({
          editId: editId,
          media: {
            mimeType: APK_MIME_TYPE,
            body: apkStream
          }
        }).then((uploadedApk) => {
          console.log('Successfully uploaded APK', JSON.stringify(uploadedApk));
          traceMaxApkVersionCode(variant.name, abiVariant, uploadedApk.data.versionCode, new Date(), 'googlePlay');
          if (uploadedApk.data.binary.sha256 !== files.apkFile.checksum.sha256) {
            console.error('SHA-256 mismatch!', variant.name, abiVariant);
            task.logPublicly('SHA-256 mismatch!');
            onDone(1);
            return;
          }
          uploadedVersionCodes.push(uploadedApk.data.versionCode);
          modifyNativeDebugSymbolsArchive(files.nativeDebugSymbolsFile.path).then((nativeDebugSymbolsPath) => {
            attemptAction(5, (accept, reject) => {
              const nativeDebugSymbolsStream = fs.createReadStream(nativeDebugSymbolsPath);
              play.edits.deobfuscationfiles.upload({
                editId: editId,
                deobfuscationFileType: 'nativeCode',
                apkVersionCode: uploadedApk.data.versionCode,
                media: {
                  mimeType: ZIP_MIME_TYPE,
                  body: nativeDebugSymbolsStream
                }
              })
                .then(accept)
                .catch(reject);
            }, (e, attemptNo) => {
              console.log('[RETRY]', 'Trying again to upload native-debug-symbols.zip, attemptNo:', attemptNo, e);
            }).then((uploadedNativeDebugSymbols) => {
              console.log('[!!!]', 'native-debug-symbols.zip uploaded', variant.name, abiVariant, JSON.stringify(uploadedNativeDebugSymbols));
              const mappingStream = fs.createReadStream(files.mappingFile.path);
              play.edits.deobfuscationfiles.upload({
                editId: editId,
                deobfuscationFileType: 'proguard',
                apkVersionCode: uploadedApk.data.versionCode,
                media: {
                  mimeType: TXT_MIME_TYPE,
                  body: mappingStream
                }
              }).then((uploadedMappingFile) => {
                mappingStream.close();
                console.log('Mapping file uploaded', variant.name, abiVariant, JSON.stringify(uploadedMappingFile));
                // Success! Now we can proceed.
                onBuildUploaded(variant);
              }).catch((mappingFileUploadError) => {
                console.error('Failed to upload mapping file.', variant.name, abiVariant, mappingFileUploadError);
                onDone(1);
              });
            }).catch((nativeDebugSymbolsUploadError) => {
              console.error('Failed to upload native-debug-symbols.zip', variant.name, abiVariant, nativeDebugSymbolsUploadError);
              onDone(1);
            });
          });
        }).catch((apkUploadError) => {
          console.error('Failed to upload apk', variant.name, abiVariant, apkUploadError);
          onDone(1);
        });
      }
    }
  }).catch((appEditError) => {
    console.error('Failed to create AppEdit', appEditError);
    onDone(1);
  });

  return async () => {
    if (!task.endTime) {
      // TODO abort upload somehow??

      onDone(1);
    }
  };
}

async function obtainHuaweiAccessToken () {
  try {
    const data = {
      client_id: settings.huawei.client_id,
      client_secret: settings.huawei.key,
      grant_type: 'client_credentials'
    };
    const response = await postHttp('https://connect-api.cloud.huawei.com/api/oauth2/v1/token', data, false, {
      headers: {
        'User-Agent': 'Telegram-X-Publisher'
      }
    });
    if (response.statusCode < 200 || response.statusCode >= 300) {
      console.error('AGC auth failed', response.statusCode, response.statusMessage, response.contentType, response.content);
      return null;
    }
    return JSON.parse(response.content);
  } catch (e) {
    console.error('Failed to obtain AGC credentials', e);
    return null;
  }
}

async function obtainHuaweiUploadUrl (accessToken, needPhasedRelease) {
  try {
    const response = await fetchHttp(
      'https://connect-api.cloud.huawei.com/api/publish/v2/upload-url' +
      '?appId=' + settings.huawei.app_id + 
      '&suffix=apk' +
      '&releaseType=' + (needPhasedRelease ? 3 : 1), false, {
        headers: {
          'client_id': settings.huawei.client_id,
          'Authorization': 'Bearer ' + accessToken,
          'User-Agent': 'Telegram-X-Publisher'
        }
      }
    );
    if (response.statusCode < 200 || response.statusCode >= 300) {
      console.error('AGC obtain upload URL failed', response.statusCode, response.statusMessage, response.contentType, response.content);
      return null;
    }
    return JSON.parse(response.content);
  } catch (e) {
    console.error('Failed to obtain AGC upload URL', e);
    return null;
  }
}

function postHuaweiForm (url, form, needBinary) {
  return new Promise((accept, reject) => {
    const parsed = new URL(url);
    const protocol = (parsed.protocol === 'https:' ? https : http);
    const options = {
      host: parsed.host,
      path: parsed.pathname + parsed.search,
      method: 'POST',
      headers: Object.assign(form.getHeaders(), {
        'accept': 'application/json',
        'User-Agent': 'Telegram-X-Publisher'
      })
    };
    const req = protocol.request(options, (res) => {
      toUtf8(res, (contentType, content) => {
        accept({statusCode: res.statusCode, statusMessage: res.statusMessage, content, contentType});
      }, needBinary);
    }).on('error', reject);
    form.pipe(req);
  });
}

async function uploadHuaweiApk (build, targetFiles, accessToken, uploadUrl, authCode) {
  const apkFilePath = targetFiles.apkFile.path;
  try {
    const apkFileStream = fs.createReadStream(apkFilePath);
    const form = new FormData();
    form.append('file', apkFileStream);
    form.append('authCode', authCode);
    form.append('fileCount', '1');
    const response = await postHuaweiForm(uploadUrl, form);
    if (response.statusCode !== 200) {
      console.error('AGC upload failed', response.statusCode, response.statusMessage, response.contentType, response.content);
      return null;
    }
    return JSON.parse(response.content);
  } catch (e) {
    console.error('Failed to upload huawei APK', e);
    return null;
  }
}

async function updateHuaweiAppFileInfo (build, targetFiles, accessToken, fileInfo) {
  try {
    const apiUrl = 'https://connect-api.cloud.huawei.com/api/publish/v2/app-file-info' +
      '?appId=' + settings.huawei.app_id;
    const fileName = build.version.name + '.' + build.git.commit.short + '.apk';
    const data = {
      fileType: 5,
      files: [{
        fileName: fileName,
        // The typo in the second "URL" (ULR) is intended ...
        fileDestUrl: fileInfo.fileDestUlr
      }]
    };
    const response = await postHttp(apiUrl, data, false, {
      headers: {
        'client_id': settings.huawei.client_id,
        'Authorization': 'Bearer ' + accessToken,
        'User-Agent': 'Telegram-X-Publisher'
      }
    }, 'PUT');
    if (response.statusCode !== 200) {
      console.error('AGC update failed', response.statusCode, response.statusMessage, response.contentType, response.content);
      return null;
    }
    return JSON.parse(response.content);
  } catch (e) {
    console.error('Failed to publish AGC update', e);
    return null;
  }
}

async function updateHuaweiAppLanguageInfo (accessToken, info) {
  try {
    const apiUrl = 'https://connect-api.cloud.huawei.com/api/publish/v2/upload-url' +
      '?appId=' + settings.huawei.app_id;
    const response = await postHttp(apiUrl, info, false, {
      headers: {
        'client_id': settings.huawei.client_id,
        'Authorization': 'Bearer ' + accessToken,
        'User-Agent': 'Telegram-X-Publisher'
      }
    });
    if (response.statusCode !== 200) {
      console.error('AGC update langauge info failed', response.statusCode, response.statusMessage, response.contentType, response.content);
      return null;
    }
    return JSON.parse(response.content);
  } catch (e) {
    console.error('Unable to update AGC language info', e);
    return null;
  }
}

async function submitHuaweiAppUpdate (accessToken) {
  try {
    const apiUrl = 'https://connect-api.cloud.huawei.com/api/publish/v2/app-submit' +
      '?appId=' + settings.huawei.app_id;
    const response = await postHttp(apiUrl, info, false, {
      headers: {
        'client_id': settings.huawei.client_id,
        'Authorization': 'Bearer ' + accessToken,
        'User-Agent': 'Telegram-X-Publisher'
      }
    });
    if (response.statusCode !== 200) {
      console.error('AGC update langauge info failed', response.statusCode, response.statusMessage, response.contentType, response.content);
      return null;
    }
    return JSON.parse(response.content);
  } catch (e) {
    console.error('Unable to submit AGC app for review', e);
    return null;
  }
}

function uploadToHuaweiAppGallery (task, build, onDone, draftOnly) {
  (async () => {
    const sdkVariant = 'latest';
    const abiVariant = 'universal';
    const targetFiles = build.files[sdkVariant][abiVariant];
    // Step 1. Obtain access_token
    const auth = await obtainHuaweiAccessToken();
    if (!auth || !auth.access_token) {
      onDone(1);
      return;
    }
    // Step 2. Obtain upload_url
    const upload = await obtainHuaweiUploadUrl(auth.access_token);
    if (!upload || !upload.uploadUrl || !upload.authCode) {
      onDone(1);
      return;
    }
    // Step 3. Upload APK to the provided URL
    const uploadedFile = await uploadHuaweiApk(
      build,
      targetFiles,
      auth.access_token,
      upload.uploadUrl,
      upload.authCode
    );
    if (!uploadedFile) {
      onDone(1);
      return;
    }
    const fileInfo = uploadedFile.result.UploadFileRsp.fileInfoList[0];

    // Step 4. Update file info
    const updatedFileInfo = await updateHuaweiAppFileInfo(
      build,
      targetFiles,
      auth.access_token,
      fileInfo
    );
    if (!updatedFileInfo) {
      onDone(1);
      return;
    }

    // Step 5. Update change logs
    if (build.releaseNotes && build.releaseNotes.length > 0) {
      for (let index = 0; index < build.releaseNotes.length; index++) {
        const releaseNotes = build.releaseNotes[index];
        let changeLogText = releaseNotes.text;
        if (changeLogText.length > 500) {
          task.logPrivately(releaseNotes.language + ' did not fit');
          changeLogText = build.fallbackReleaseNotes || '';
        }
        // lang String(64): Language. https://developer.huawei.com/consumer/en/doc/development/AppGallery-connect-References/agcapi-reference-langtype-0000001158245079
        // appName String(64): App name in a language. This parameter is mandatory when a language type is added.
        // appDesc String(8000): Full introduction in a language.
        // briefInfo String(80): Brief introduction in a language.
        // newFeatures String(500): New features in a language.
        await updateHuaweiAppLanguageInfo(
          auth.access_token, {
            lang: releaseNotes.language,
            newFeatures: changeLogText
        });
      }
    }

    // Step 6. Submit for review
    if (!draftOnly) {
      const submittedApp = await submitHuaweiAppUpdate(
        auth.access_token
      );
      if (!submittedApp) {
        onDone(1);
        return;
      }
    }

    await traceMaxApkVersionCode(sdkVariant, abiVariant, build.version.code, new Date(), 'huawei');
    console.log('Successfully published Huawei AppGallery');
    onDone(0);
  })();

  return async () => {
    if (!task.endTime) {
      // TODO abort upload somehow??

      onDone(1);
    }
  };
}

async function createGitHubRelease (owner, repository, tagName, releaseName, releaseNotes, isDraft, isPrerelease) {
  isDraft = !!isDraft;
  isPrerelease = !!isPrerelease;
  
  const data = {
    tag_name: tagName,
    // unused target_commitish: build.commit.long,
    name: releaseName,
    body: releaseNotes,
    draft: isDraft,
    prerelease: isPrerelease
  };
  const apiUrl = 'https://api.github.com/repos/' + owner + '/' + repository + '/releases';
  try {
    const response = await postHttp(apiUrl, data, false, {
      headers: {
        'Accept': 'application/vnd.github+json',
        'Authorization': 'Bearer ' + settings.github.access_token,
        'X-GitHub-Api-Version': '2022-11-28',
        'User-Agent': 'Telegram-X-Publisher'
      }
    });
    if (response.statusCode < 200 || response.statusCode >= 300) {
      console.error('Create GitHub release failed', response.statusCode, response.statusMessage, response.contentType, response.content);
      return null;
    }
    return JSON.parse(response.content);
  } catch (e) {
    console.error('Failed to create GitHub release', e);
    return null;
  }
}

async function updateGitHubRelease (owner, repository, releaseId, isDraft, isPrerelease) {
  const data = {};
  if (isDraft !== undefined) {
    data.draft = isDraft;
  }
  if (isPrerelease !== undefined) {
    data.prerelease = isPrerelease;
  }

  const apiUrl = 'https://api.github.com/repos/' + owner + '/' + repository + '/releases/' + releaseId;
  try {
    const response = await postHttp(apiUrl, data, false, {
      headers: {
        'Accept': 'application/vnd.github+json',
        'Authorization': 'Bearer ' + settings.github.access_token,
        'X-GitHub-Api-Version': '2022-11-28',
        'User-Agent': 'Telegram-X-Publisher'
      }
    });
    if (response.statusCode < 200 || response.statusCode >= 300) {
      console.error('Create GitHub release failed', response.statusCode, response.statusMessage, response.contentType, response.content);
      return null;
    }
    return JSON.parse(response.content);
  } catch (e) {
    console.error('Failed to create GitHub release', e);
    return null;
  }
}

async function deleteGitHubRelease (owner, repository, releaseId) {
  const apiUrl = 'https://api.github.com/repos/' + owner + '/' + repository + '/releases/' + releaseId;
  try {
    const response = await fetchHttp(apiUrl, false, {
      headers: {
        'Accept': 'application/vnd.github+json',
        'Authorization': 'Bearer ' + settings.github.access_token,
        'X-GitHub-Api-Version': '2022-11-28',
        'User-Agent': 'Telegram-X-Publisher'
      },
      method: 'DELETE'
    });
    if (response.statusCode < 200 || response.statusCode >= 300) {
      console.error('Delete GitHub release failed', response.statusCode, response.statusMessage, response.contentType, response.content);
      return false;
    }
    return true;
  } catch (e) {
    console.error('Failed to delete GitHub release', e);
    return false;
  }
}

async function deletePastGitHubPrereleases (owner, repository, newReleaseId) {
  const githubId = owner + '/' + repository;
  let pastReleases = await getObject('github', githubId);
  if (pastReleases && pastReleases.ids) {
    while (pastReleases.ids.length) {
      const releaseIdToDelete = pastReleases.ids.pop();
      console.log('Deleting past GitHub pre-release...', releaseIdToDelete);
      const isDeleted = await deleteGitHubRelease(owner, repository, releaseIdToDelete);
      if (!isDeleted) {
        return false;
      }
      await storeObject('github', pastReleases, githubId);
    }
  }
  if (newReleaseId) {
    pastReleases = {
      ids: [newReleaseId]
    };
    await storeObject('github', pastReleases, githubId);
  }
  return true;
}

async function uploadGitHubAsset (release, sourceFilePath, fileName, label) {
  try {
    const uploadUrlTemplate = UriTemplate.parse(release.upload_url);
    const uploadUrl = uploadUrlTemplate.expand({
      name: fileName,
      label
    });

    const response = await uploadHttpFile(uploadUrl, sourceFilePath, {
      'Accept': 'application/vnd.github+json',
      'Authorization': 'Bearer ' + settings.github.access_token,
      'X-GitHub-Api-Version': '2022-11-28',
      'User-Agent': 'Telegram-X-Publisher'
    });
    if (response.statusCode < 200 || response.statusCode >= 300) {
      console.error('Upload GitHub asset failed', response.statusCode, response.statusMessage, response.contentType, response.content);
      return null;
    }

    return JSON.parse(response.content);
  } catch (e) {
    console.error('Failed to upload GitHub asset', e);
    return null;
  }
}

function uploadToGithub (task, build, onDone, commandArgsRaw, isPrerelease, tagName, draftOnly) {
  const versionName = settings.app.name + ' ' +
    build.version.name +
    (isPrerelease ? ' ' + build.githubTrack : '');

  let changeLog = '**' + settings.app.name + '** `' + versionName + '` has been released.';
  const fromToCommit = getFromToCommit(build, true);
  if (fromToCommit) {
    const changesUrl = build.git.remoteUrl + '/compare/' + fromToCommit.commit_range;
    changeLog += ' You can review all changes in the source code [here](' + changesUrl + ').'
  }
  changeLog += '\n\n';

  if (build.pullRequestsMetadata || !empty(build.pullRequests)) {
    changeLog += '### Pull requests\n\n';
    changeLog += 'This version includes the following unmerged pull requests. Review the source code changes separately:';
    changeLog += '\n\n';

    changeLog += toDisplayPullRequestList(build, true);
    changeLog += '\n\n';
  }

  if (commandArgsRaw) {
    changeLog += '## Changes\n';
    changeLog += commandArgsRaw.trim() + '\n\n';
  }

  changeLog += '## Download\n';
  ALL_PLATFORMS.forEach((platform) => {
    const track = build[platform + 'Track'];
    if (track || platform === 'telegram') {
      changeLog += '\n* ';
      switch (platform) {
        case 'googlePlay': {
          changeLog += '**[Google Play](' + settings.app.market_url.google + ')**';
          changeLog += ' ([subscribe to beta](' + settings.url.testing + '))';
          break;
        }
        case 'huawei': {
          changeLog += '**[Huawei AppGallery](' + settings.app.market_url.huawei + ')**';
          break;
        }
        case 'github': {
          changeLog += '**[GitHub Releases](' + build.git.remoteUrl + '/releases)**';
          break;
        }
        case 'telegram': {
          changeLog += '**[Telegram X APKs & Build Info](https://t.me/tgx_log)**';
          break;
        }
      }
    }
  });
  changeLog += '\n\n';

  changeLog += '## Checksums\n\n';
  changeLog += 'You can always check if checksum of an APK you downloaded corresponds to any official Telegram X build via [@tgx_bot](https://t.me/tgx_bot).\n\n';

  changeLog += '<details><summary>Checksums for <code>' + versionName + '</code>. Tap to expand</summary>';

  const allSdkFlavors = [
    'latest',
    'marshmallow',
    'lollipop',
    'legacy'
  ];
  const allAbiFlavors = ['universal', 'arm64', 'arm32', 'x64', 'x86'];
  const sortBy = (variants) => {
    return (a, b) => {
      const aIndex = variants.indexOf(a);
      const bIndex = variants.indexOf(b);
      const aKnown = aIndex !== -1;
      const bKnown = bIndex !== -1;
      if (aKnown !== bKnown) {
        return aKnown ? -1 : 1;
      }
      if (aIndex !== bIndex) {
        return aIndex < bIndex ? -1 : 1;
      }
      return 0;
    }
  };
  const builtVariants = Object.keys(build.files)
      .sort(sortBy(allSdkFlavors))
      .map((sdkFlavor) => {
    const abiVariants = Object.keys(build.files[sdkFlavor]).sort(sortBy(allAbiFlavors));
    return {name: sdkFlavor, abi: abiVariants};
  });
  builtVariants.forEach((variant) => {
    variant.abi.forEach((abiVariant) => {
      const files = build.files[variant.name][abiVariant];
      changeLog += '\n\n---';
      changeLog += '\n\n#### ';
      if (variant.name !== 'latest') {
        changeLog += variant.name + '-';
      }
      changeLog += getDisplayVariant(abiVariant) + '\n';
      ['sha256', 'sha1', 'md5'].forEach((algorithm) => {
        const hash = files.apkFile.checksum[algorithm];
        if (hash) {
          changeLog += '\n**' + toDisplayAlgorithm(algorithm) + '**: ';
          changeLog += '[' + hash + '](https://t.me/tgx_bot?start=' + hash + ')';
        }
      });
    });
  });

  changeLog += '\n\n</details>';

  (async () => {
    try {
      const githubData = build.git.remoteUrl.replace(/^https?:\/\/github\.com\//gi, '').split('/');
      const owner = githubData[0];
      const repository = githubData[1];

      console.log('Creating GitHub release...', 'owner:', owner, 'repository:', repository, 'remote:', build.git.remoteUrl);

      const release = await createGitHubRelease(owner, repository, tagName, versionName, changeLog, true, isPrerelease);
      if (!release) {
        onDone(1);
        return;
      }

      console.log('Created GitHub release, uploading asset...');

      for (const sdkFlavor in build.files) {
        for (const abiFlavor in build.files[sdkFlavor]) {
          const files = build.files[sdkFlavor][abiFlavor];
          if (files && GITHUB_BUILDS[sdkFlavor] && GITHUB_BUILDS[sdkFlavor].includes(abiFlavor)) {
            const apkFileName = settings.app.name.replace(/ /gi, '-') + '-' +
              build.version.name + (sdkFlavor !== 'latest' ? '-' + sdkFlavor : '') +
              (isPrerelease ? '-' + build.githubTrack : '') + '.apk';
            const apkLabel = settings.app.name + ' ' +
              build.version.name + (sdkFlavor !== 'latest' ? '-' + sdkFlavor : '') +
              (isPrerelease ? ' ' + build.githubTrack : '');
            let uploadResult = null;
            let attemptCount = 0;
            while (!uploadResult && ++attemptCount <= 3) {
              try {
                uploadResult = await uploadGitHubAsset(release, files.apkFile.path, apkFileName, apkLabel);
              } catch (err) {
                if (attemptCount > 3) {
                  console.error('Upload GitHub asset failed...', err);
                } else {
                  console.error('Upload GitHub asset failed, retrying...', attemptCount, err);
                  await sleep(attemptCount * 1000);
                }
              }
            }
            if (!uploadResult) {
              console.error('Upload GitHub asset failed, deleting release...');
              await deleteGitHubRelease(owner, repository, release.id);

              onDone(1);
              return;
            }
          }
        }
      }

      if (!draftOnly) {
        console.log('Uploaded GitHub asset, updating release...');
        const updatedRelease = await updateGitHubRelease(owner, repository, release.id, false);
        if (!updatedRelease) {
          onDone(1);
          return;
        }
        for (const sdkFlavor in build.files) {
          const files = build.files[sdkFlavor].universal;
          if (files) {
            await traceMaxApkVersionCode(sdkFlavor, 'universal', build.version.code, new Date(), 'github');
          }
        }
      }

      console.log('Cleaning up previous GitHub pre-releases...');
      await deletePastGitHubPrereleases(owner, repository, isPrerelease ? release.id : undefined);

      console.log('GitHub published successfully!');
      onDone(0);
    } catch (e) {
      console.error('GitHub publishing failed', e);
      onDone(1);
    }
  })();

  return async () => {
    if (!task.endTime) {
      // TODO abort upload somehow??

      onDone(1);
    }
  };
}

main();

function sendArray (bot, chatId, array, parseMode, delimiter) {
  if (!array || !array.length) {
    bot.sendMessage(chatId, '<b>Nothing found!</b>', {parse_mode: 'HTML'}).catch(globalErrorHandler());
    return;
  }
  if (!delimiter) {
    delimiter = '\n';
  }
  let remaining = array.length;
  let text = '';
  while (remaining > 0) {
    const item = array[array.length - remaining];
    if (text.length + item.length + (text.length ? delimiter.length : 0) > MAX_TEXT_MESSAGE_LENGTH) {
      bot.sendMessage(chatId, text, {parse_mode: parseMode}).catch(globalErrorHandler());
      text = item;
    } else {
      if (text.length) {
        text += delimiter;
      }
      text += item;
    }
    remaining--;
    if (remaining == 0) {
      bot.sendMessage(chatId, text, {parse_mode: parseMode}).catch(globalErrorHandler());
    }
  }
}

function sleep (milliseconds) {
  return new Promise(resolve => setTimeout(resolve, milliseconds))
}

function toDisplayDate (seconds) {
  return new Date(seconds * 1000).toLocaleString('en-GB', {
    day: 'numeric',
    month: 'numeric',
    year: 'numeric',
    hour: 'numeric',
    minute: '2-digit',
    timeZoneName: 'short',
    timeZone: 'UTC'
  });
}

function toDisplayPullRequestList (build, isGitHubRelease) {
  const remoteUrl = build.remoteUrl || (build.git ? build.git.remoteUrl : '');
  const toItem = (pullRequestId, pullRequestCommit, pullRequest, nextPullRequest) => {
    const pullRequestUrl = remoteUrl + '/pull/' + pullRequestId;
    let text = null;
    if (isGitHubRelease) {
      text = '**#' + pullRequestId + '**';
    } else {
      text = '<a href="' + pullRequestUrl + '"><b>' + pullRequestId + '</b></a>';
    }
    if (pullRequest) {
      const pullRequestSourceUrl = pullRequestUrl + '/files/' + pullRequest.commit.long;
      text += ' / ';
      if (isGitHubRelease) {
        text += '[' + pullRequest.commit.short + '](' + pullRequestSourceUrl + ')';
      } else {
        text += '<a href="' + pullRequestSourceUrl + '">' + pullRequest.commit.short + '</a>';
      }
      if (pullRequest.github) {
        if (Math.max(pullRequest.github.additions || pullRequest.github.deletions) > 0) {
          text += ' (';
          text += isGitHubRelease ? '`' : '<code>';
          text += [pullRequest.github.additions, -pullRequest.github.deletions].filter((item) => item !== 0).map((item) => item > 0 ? '+' + item : item.toString());
          text += isGitHubRelease ? '`' : '</code>'
          text += ')';
        }
        if (!nextPullRequest || !nextPullRequest.github || nextPullRequest.github.name !== pullRequest.github.name) {
          if (isGitHubRelease) {
            text += ' by @' + pullRequest.github.name;
          } else {
            text += ' by <a href="' + (pullRequest.github.url || 'https://github.com/' + pullRequest.github.name) + '">' + pullRequest.github.name + '</a>';
          }
        }
      }
    } else if (pullRequestCommit) {
      const pullRequestSourceUrl = pullRequestUrl + '/files/' + pullRequestCommit;
      text += ' / ';
      if (isGitHubRelease) {
        text += '[' + pullRequestCommit + '](' + pullRequestSourceUrl + ')';
      } else {
        text += '<a href="' + pullRequestSourceUrl + '">' + pullRequestCommit + '</a>';
      }
    }
    return text;
  };
  const separator = isGitHubRelease ? '\n' : ', ';
  const prefix = isGitHubRelease ? '* ' : '';
  if (build.pullRequestsMetadata) {
    return build.pullRequestsMetadata.map((pullRequestMetadata, index) => {
      const pullRequestId = pullRequestMetadata.id;
      const pullRequest = build.pullRequests ? build.pullRequests[pullRequestId] : null;
      const nextPullRequestId = index + 1 < build.pullRequestsMetadata.length ? build.pullRequestsMetadata[index + 1].id : null;
      const nextPullRequest = nextPullRequestId !== null ? build.pullRequests[nextPullRequestId] : null;
      return prefix + toItem(pullRequestId, pullRequestMetadata.commit, pullRequest, nextPullRequest);
    }).join(separator);
  } else if (build.pullRequests) {
    const pullRequestIds = Object.keys(build.pullRequests);
    return pullRequestIds.map((pullRequestId, index) => {
      const pullRequest = build.pullRequests[pullRequestId];
      const nextPullRequest = index + 1 < pullRequestIds.length ? build.pullRequests[pullRequestIds[index + 1]] : null;
      return prefix + toItem(parseInt(pullRequestId), null, pullRequest, nextPullRequest);
    }).join(separator);
  } else {
    return '';
  }
}

function processPrivateCommand (botId, bot, msg, command, commandArgsRaw) {
  if (msg.chat.id !== ADMIN_USER_ID) {
    return;
  }
  switch (command) {
    case '/start': {
      // TODO?
      break;
    }
    case '/value': {
      if (commandArgsRaw) {
        db.get(commandArgsRaw, {valueEncoding: 'json'}, (err, value) => {
          if (err) {
            bot.sendMessage(msg.chat.id, '*Key not found!*', {parse_mode: 'MarkdownV2'}).catch(globalErrorHandler());
          } else {
            bot.sendMessage(msg.chat.id, '<code>' + JSON.stringify(value) + '</code>', {parse_mode: 'HTML'}).catch(globalErrorHandler());
          }
        });
      } else {
        bot.sendMessage(msg.chat.id, 'Key not specified.').catch(globalErrorHandler());
      }
      break;
    }
    case '/keys': {
      let keys = [];
      db.createReadStream({values: false})
      .on('data', (data)  => {
        keys.push('<code>' + data + '</code>');
      })
      .on('end', () => {
        sendArray(bot, msg.chat.id, keys, 'HTML');
      });
      break;
    }
    case '/values': {
      let values = [];
      db.createReadStream()
      .on('data', (data) => {
        values.push('<code>' + data.key + '</code>:\n<pre>' + data.value + '</pre>');
      })
      .on('end', () => {
        sendArray(bot, msg.chat.id, values, 'HTML', '\n\n');
      });
      break;
    }
    case '/abort': {
      if (!cur.pending_build) {
        bot.sendMessage(msg.chat.id, 'No build is in progress!').catch(globalErrorHandler());
        return;
      }
      cur.pending_build.abort();
      break;
    }
    case '/version': {
      getGitData((gitData) => {
        getAppVersion((version) => {
          let text = '<b>App Version</b>: <code>' + version.name + '</code>\n';
          text += '<b>Commit</b>: <a href="' + gitData.remoteUrl + '/tree/' + gitData.commit.long + '">' + gitData.commit.short + '</a>';
          if (gitData.branch) {
            text += '\n<b>Branch</b>: <code>' + gitData.branch + '</code>';
          }
          bot.sendMessage(msg.chat.id, text, {parse_mode: 'HTML'}).catch(globalErrorHandler());
        });
      }, true);
      break;
    }
    case '/clear': {
      db.clear();
      break;
    }
    case '/changes': {
      getLocalChanges((changes) => {
        if (changes) {
          bot.sendMessage(msg.chat.id, 'Current changes:\n\n<pre>' + escapeHtml(changes) + '</pre>', {parse_mode: 'HTML'}).catch(globalErrorHandler());
        } else {
          bot.sendMessage(msg.chat.id, 'No local changes found!').catch(globalErrorHandler());
        }
      });
      break;
    }
    case '/pull': {
      if (!cur.pending_build) {
        gitPull((log) => {
          bot.sendMessage(msg.chat.id, '<code>' + log + '</code>', {parse_mode: 'HTML'}).catch(globalErrorHandler());
        });
      } else {
        bot.sendMessage(msg.chat.id, 'Cannot pull fresh code, as some build is in progress. Use /abort to cancel it.');
      }
      break;
    }
    case '/deploy_stable':
    case '/deploy_huawei':
    case '/deploy_github':
    case '/deploy_beta':
    case '/deploy_alpha': // same as universal
    case '/deploy_pr':
    
    case '/build':
    case '/build_arm32':
    case '/build_arm64':
    case '/build_x86':
    case '/build_x64':
    case '/build_latest':
    case '/build_latestArm32':
    case '/build_latestArm64':
    case '/build_latestX86':
    case '/build_latestX64':
    case '/build_marshmallow':
    case '/build_marshmallowArm32':
    case '/build_marshmallowArm64':
    case '/build_marshmallowX86':
    case '/build_marshmallowX64':
    case '/build_lollipop':
    case '/build_lollipopArm32':
    case '/build_lollipopArm64':
    case '/build_lollipopX86':
    case '/build_lollipopX64':
    case '/build_legacy':
    case '/build_legacyArm32':
    case '/build_legacyX86':
    case '/build_huawei':
    case '/build_universal':

    case '/checkout':
    case '/bump':

    case '/upgrade_tdlib':
    case '/update_sdk': {
      const simpleCommands = [
        '/upgrade_tdlib',
        '/update_sdk',
        '/bump'
      ];
      const isSimpleCommand = simpleCommands.includes(command);
      if (cur.build_no === -1 || cur.uploaded_version === -1) {
        bot.sendMessage(msg.chat.id, 'Please try again.').catch(globalErrorHandler());
        return;
      }

      if (LOCAL && command.startsWith('/deploy_')) {
        bot.sendMessage(msg.chat.id, command + ' is unavailable when running locally.').catch(globalErrorHandler());
        return;
      }

      getAppVersion((_version) => { getGitData((_gitData) => {
        if (!_version) {
          bot.sendMessage(msg.chat.id, 'Cannot detect app version!').catch(globalErrorHandler());
          return;
        }

        if (cur.pending_build) {
          bot.sendMessage(msg.chat.id, 'Another build is in progress! Abort with /abort').catch(globalErrorHandler());
          return;
        }

        const buildType = command === '/build' ? 'all' :
          command.startsWith('/deploy') || command.startsWith('/build') ?
          (command.includes('_') ? command.substring(command.indexOf('_') + 1) : 'all') :
          'none';

        const allVariants = [
          {name: 'latest', abi: [ 'universal', 'arm64', 'arm32', 'x64', 'x86' ]},
          {name: 'marshmallow', abi: [ 'universal', 'arm64', 'arm32', 'x64', 'x86' ]},
          {name: 'lollipop', abi: [ 'universal', 'arm64', 'arm32', 'x64', 'x86' ]},
          {name: 'legacy', abi: [ 'arm32', 'x86' ]}
        ];

        let selectedVariants = [];
        switch (buildType) {
          case 'none':
            break;
          case 'all':
          case 'alpha':
          case 'beta':
          case 'stable':
            selectedVariants = allVariants;
            break;
          case 'latest':
          case 'marshmallow':
          case 'lollipop':
          case 'legacy':
            selectedVariants = allVariants.filter((variant) =>
              variant.name === buildType
            );
            break;
          case 'universal':
          case 'arm64':
          case 'arm32':
          case 'x86':
          case 'x64':
            selectedVariants = [{name: 'latest', abi: [buildType]}];
            break;
          case 'pr':
          case 'huawei':
            selectedVariants = [{name: 'latest', abi: ['universal']}];
            break;
          case 'github':
            selectedVariants = [];
            for (const sdkVariant in GITHUB_BUILDS) {
              const abi = GITHUB_BUILDS[sdkVariant];
              selectedVariants.push({name: sdkVariant, abi});
            }
            break;
          default: {
            allVariants.forEach((variant) => {
              variant.abi.forEach(abi => {
                const prefix = variant.name + ucfirst(abi);
                if (buildType === prefix) {
                  selectedVariants = [{name: variant.name, abi: [abi]}];
                }
              });
            });
            break;
          }
        }
        selectedVariants = selectedVariants.filter((variant) =>
          variant.abi.length > 0
        );

        const commandArgsList = commandArgsRaw ? commandArgsRaw.split(/[,\s]+/) : [];
        const commandArgs = commandArgsList.filter((arg) => arg.startsWith('--')).reduce((result, item) => {
          const index = item.indexOf('=');
          if (index !== -1) {
            const key = item.substring(2, index);
            const value = item.substring(index + 1);
            result[key] = value.match(/^[0-9]+$/g) ? parseInt(value) :
              value.match(/^[0-9]+\.[0-9]+$/g) ? parseFloat(value) :
              value;
          } else {
            const key = item.substring(2);
            result[key] = true;
          }
          return result;
        }, {});

        const isPRBuild = command === '/deploy_pr';
        const isPrivate = !(['/deploy_beta', '/deploy_pr'].includes(command));
        const skipBuild = isSimpleCommand;
        const outputChatId = isPRBuild ? PR_CHAT_ID : (buildType === 'alpha' ? ALPHA_CHAT_ID : ADMIN_USER_ID);
        const buildId = nextBuildId();
        const isSetup = '/checkout' === command;

        const gradlewArgs = commandArgsList.filter((arg) =>
          arg.startsWith('-D')
        );

        const pullRequestsMetadata = !isSetup ? null : commandArgsList.filter((arg) =>
          arg.match(/^[0-9]+$/gi)
        ).map((prId) =>
          parseInt(prId)
        ).filter((prId) => prId > 0)
         .sort()
         .map((id) => {
           return {id};
         })
         .concat(commandArgsList.filter((arg) =>
           arg.match(/^[0-9]+:[a-zA-Z0-9]+$/gi)
         ).map((idWithCommit) => {
           const data = idWithCommit.split(':');
           return {id: parseInt(data[0]), commit: data[1]};
         }).filter((pullRequest) => pullRequest.id > 0));

        const build = {
          id: buildId,
          type: buildType,
          version: _version,
          git: _gitData,
          serviceChatId: msg.chat.id,
          googlePlayTrack: null,
          huaweiTrack: null,
          githubTrack: null,
          files: {}
        };
        // Google Play
        if (buildType === 'stable') {
          build.googlePlayTrack = 'production';
        } else if (['beta', 'alpha'].includes(buildType)) {
          build.googlePlayTrack = buildType;
        }
        // Huawei AppGallery, Github Releases
        ['huawei', 'github'].forEach((distributionPlatform) => {
          const supportedTracks = settings[distributionPlatform] ? settings[distributionPlatform].tracks : null;
          let track = null;
          if (command === '/deploy_' + distributionPlatform) {
            track = 'production';
          } else if (distributionPlatform !== 'huawei' && Array.isArray(supportedTracks) && supportedTracks.includes(buildType)) {
            track = buildType === 'stable' ? 'production' : buildType;
          }
          if (track) {
            build[distributionPlatform + 'Track'] = track;
          }
        });
        if (pullRequestsMetadata && pullRequestsMetadata.length) {
          build.pullRequestsMetadata = pullRequestsMetadata;
          build.pullRequests = {};
        }
        if (outputChatId !== build.serviceChatId) {
          build.publicChatId = outputChatId;
        }
        cur.pending_build = build;
        if (build.googlePlayTrack) {
          build.telegramTrack = build.googlePlayTrack;
        } else if (build.publicChatId && !isPRBuild) {
          build.telegramTrack = 'private' + build.publicChatId;
        } else if (isPRBuild && build.pullRequestsMetadata) {
          build.telegramTrack = 'PR#' + build.pullRequestsMetadata.map((pullRequestsMetadata) => pullRequestsMetadata.id).join(',');
        }

        if (build.git.branch !== 'main' && ['production'/*, 'beta'*/].includes(build.googlePlayTrack)) {
          bot.sendMessage(msg.chat.id,
            'You are currently on a <b>' + build.git.branch + '</b> branch. Only <b>main</b> branch can be published.'
          );
          return;
        }

        build.variants = selectedVariants;
        build.tasks = [];
        const initTask = {
          name: 'init',
          displayName: 'Gradle cleanup',
          script: 'gradlew',
          args: gradlewArgs.concat([
            'clean',
            LOCAL ? '--info' : '--quiet',
            '--stacktrace',
            '--console=plain'
          ])
        };
        const refreshInfoTask = {
          name: 'refreshInfo',
          displayName: 'Check local data',
          act: (task, callback) => {
            getGitData((newGitData) => {
              if (!newGitData) {
                callback(1);
                return;
              }
              build.git = newGitData;

              getAppVersion(async (newVersion) => {
                if (!newVersion) {
                  callback(1);
                  return;
                }
                build.version = newVersion;
                const previousGooglePlayProductionBuild =
                  build.googlePlayTrack !== 'production' ?
                    await findPublishedGooglePlayBuild(build, 'production') :
                    null;
                const previousGooglePlayBuild = await findPublishedGooglePlayBuild(build);
                const previousTelegramBuild = await findPublishedTelegramBuild(build);
                if (!isPRBuild && (
                  (previousGooglePlayBuild && previousGooglePlayBuild.version.code >= build.version.code) ||
                  (previousTelegramBuild && previousTelegramBuild.version.code >= build.version.code)
                )) {
                  task.logPrivately(
                    'Version bump required. Current: ' + build.version.code +
                    ', previous: ' + Math.max(
                      previousGooglePlayBuild ? previousGooglePlayBuild.version.code : 0,
                      previousTelegramBuild ? previousTelegramBuild.version.code : 0
                    )
                  );
                  callback(1);
                  return;
                }
                build.previousTelegramBuild = previousTelegramBuild;
                build.previousGooglePlayBuild = previousGooglePlayBuild;
                build.previousGooglePlayProductionBuild = previousGooglePlayProductionBuild;
                callback(0);
              });
            });
          }
        };
        const buildDependenciesTask = {
          name: 'buildDependencies',
          displayName: 'Build dependencies',
          silence: true,
          script: 'scripts/setup.sh',
          args: [
            '--skip-sdk-setup'
          ]
        };
        build.forceUploadApk = !!commandArgs.force;
        const currentBranch = commandArgs.branch || 'main';
        const remote = commandArgs.remote || 'origin';
        const checkoutTask = {
          name: 'checkout' + (currentBranch !== 'main' ? 'Branch' : ''),
          displayName: 'Fetch source code',
          description: 'checkout',
          cmd: [
            '(git reset -q --hard || true)',
            '(git checkout -q -- . || true)',
            `git remote get-url ${remote} > /dev/null`,
            `git fetch ${remote} -q --prune`,
            `git checkout -q -B ${currentBranch} ${remote}/${currentBranch}`,
            `git reset --hard -q ${remote}/${currentBranch}`,
            'git clean -ffd',
            'git submodule deinit -q -f --all',
            'git submodule sync -q --recursive',
            'git submodule update -q --init --recursive',
            `git submodule foreach -q --recursive 'git reset -q --hard && git checkout -q -- . && git clean -ffd'`,
            'echo "Using commit $(git rev-parse --short HEAD) ($(git rev-parse --abbrev-ref HEAD)): $(git show -s --format=%s)"'
          ].join(' && ')
        };
        const newFetchGithubDetailsTask = (pullRequestId) => {
          return {
            name: 'fetchGithubDetails',
            displayName: 'Get GitHub user info',
            act: (task, callback) => {
              const infoUrl = build.git.remoteUrl.replace(/(?<=(^https?:\/\/))github\.com(?=\/)/gi, 'api.github.com/repos') + '/pulls/' + pullRequestId;
              const url = new URL(infoUrl);
              fetchHttp(url, false, {
                headers: {
                  'User-Agent': 'Telegram-X-Publisher'
                }
              }).then((response) => {
                if (response.statusCode < 200 || response.statusCode >= 300) {
                  console.log('fetchHttp failed', response.statusCode, response.statusMessage, response.contentType, response.content);
                  callback(1);
                  return;
                }
                const githubInfo = JSON.parse(response.content);
                const author = githubInfo.user.login;
                const authorUrl = githubInfo.user.html_url;
                const pullRequest = build.pullRequests[pullRequestId];
                pullRequest.github = {
                  name: author,
                  url: authorUrl,
                  additions: githubInfo.additions || 0,
                  deletions: githubInfo.deletions || 0
                };
                callback(0);
              }).catch((e) => {
                console.log('fetchHttp failed', infoUrl, e);
                callback(1);
              })
            }
          };
        };
        if (command === '/checkout') {
          let appId = commandArgs['app.id'] || settings.app.id;
          let appName = commandArgs['app.name'] || settings.app.name;
          const extensionName = (commandArgs['tgx.extension'] !== 'none' && commandArgs['tgx.extension']) || false;

          const updateSettingsTask = {
            name: 'updateSettings',
            displayName: 'Update local.properties',
            act: (task, callback) => {
              let marketUrls = '';
              if (settings.app.market_url) {
                for (const key in settings.app.market_url) {
                  const marketUrl = settings.app.market_url[key];
                  marketUrls += 'app.' + key + '_download_url=' + marketUrl + '\n';
                }
              }
              let properties = 'sdk.dir=' + settings.ANDROID_SDK_ROOT + '\n' +
                'keystore.file=' + settings.TGX_KEYSTORE_PATH + '\n' +
                'app.sources_url=' + settings.app.sources_url + '\n' +
                'app.download_url=' + settings.app.download_url + '\n' +
                marketUrls +
                'telegram.api_id=' + settings.telegram.app.api_id + '\n' +
                'telegram.api_hash=' + settings.telegram.app.api_hash + '\n' +
                'youtube.api_key=' + settings.youtube.api_key + '\n';
              if (settings.extra) {
                for (const extraGroupKey in settings.extra) {
                  const extraGroup = settings.extra[extraGroupKey];
                  if (typeof extraGroup === 'string') {
                    properties += extraGroupKey + '=' + extraGroup + '\n';
                  } else if (typeof extraGroup === 'object') {
                    for (const extraKey in extraGroup) {
                      properties += extraGroupKey + '.' + extraKey + '=' + extraGroup[extraKey] + '\n';
                    }
                  }
                }
              }
              if (!empty(build.pullRequests)) {
                const prIds = build.pullRequestsMetadata.map((pullRequestMetadata) => pullRequestMetadata.id);
                const prAuthors = [... new Set(build.pullRequestsMetadata.map((pullRequestMetadata) => {
                  const pullRequest = build.pullRequests[pullRequestMetadata.id];
                  return pullRequest.github.name;
                }).filter((author) => author && author.length))];
                if (commandArgs.contest) {
                  if (prAuthors.length !== 1) {
                    console.log('Contest builds should be made by 1 author', !prAuthors.length ? 'empty' : prAuthors.join(', '));
                    callback(1);
                    return;
                  }
                  appName = 'X #' + prIds.join(',') + ' by ' + prAuthors.join(' & ');
                  const prAuthorsList = prAuthors.map((author) => author.toLowerCase().replace(/[^a-zA-Z0-9_]/gi, '_')).sort().join('_');
                  appId = 'com.contest.' + prAuthorsList;
                  if (commandArgs.standalone) {
                    appId += '.pr_' + prIds.join('_');
                  }
                }

                properties += 'pr.ids=' + prIds.join(',') + '\n';
                for (const pullRequestId in build.pullRequests) {
                  const pullRequest = build.pullRequests[pullRequestId];
                  if (!pullRequest.github) {
                    callback(1);
                    return;
                  }
                  properties += 'pr.' + pullRequestId + '.commit_short=' + pullRequest.commit.short + '\n';
                  properties += 'pr.' + pullRequestId + '.commit_long=' + pullRequest.commit.long + '\n';
                  if (pullRequest.github) {
                    properties += 'pr.' + pullRequestId + '.author=' + pullRequest.github.name + '\n';
                    properties += 'pr.' + pullRequestId + '.author_url=' + pullRequest.github.url + '\n';
                    properties += 'pr.' + pullRequestId + '.additions=' + pullRequest.github.additions + '\n';
                    properties += 'pr.' + pullRequestId + '.deletions=' + pullRequest.github.deletions + '\n';
                  }
                  if (pullRequest.date) {
                    properties += 'pr.' + pullRequestId + '.date=' + pullRequest.date + '\n';
                  }
                }
              }
              const isExperimental = (appId !== settings.app.id || !!commandArgs.experimental);
              const dontObfuscate = !!commandArgs.dontobfuscate;
              properties +=
                'app.id=' + appId + '\n' +
                'app.name=' + appName + '\n' +
                'app.experimental=' + isExperimental + '\n' +
                'app.dontobfuscate=' + dontObfuscate + '\n';
              if (extensionName) {
                properties += 'tgx.extension=' + extensionName + '\n';
              }
              build.outputApplication = {
                id: appId,
                name: appName,
                extension: extensionName,
                experimental: isExperimental,
                dontObfuscate,
                isPRBuild
              };
              fs.writeFile(settings.TGX_SOURCE_PATH + '/local.properties',
                properties,
                'utf-8',
                (err) => {
                  if (err) {
                    console.error('Cannot create local.properties file', err);
                    callback(1);
                  } else {
                    callback(0);
                  }
                }
              );
            }
          }

          build.tasks.push(checkoutTask);
          if (build.pullRequestsMetadata) {
            if (LOCAL)
              throw Error('Unsupported!');

            for (let i = 0; i < build.pullRequestsMetadata.length; i++) {
              const isSecondary = i > 0;
              const pullRequest = build.pullRequestsMetadata[i];
              const pullRequestId = pullRequest.id;

              const preparePrTask = {
                name: 'fetchPr-' + pullRequestId + (pullRequest.commit ? ':' + pullRequest.commit : ''),
                displayName: 'Fetch PR info',
                description: 'fetch_pr',
                cmd: '(git branch -D pr-' + pullRequestId + ' || true) && \
                      ' + (commandArgs.force ?
                            '(git fetch -f origin pull/' + pullRequestId + '/head:pr-' + pullRequestId + ' || git rev-parse --quiet --verify pr-' + pullRequestId + ')' :
                            'git fetch -f origin pull/' + pullRequestId + '/head:pr-' + pullRequestId
                          ) + '&& \
                      ' + (isSecondary ? 'git stash &&' : '') + ' \
                      git checkout pr-' + pullRequestId + (
                        pullRequest.commit ? ' && \
                        git reset --hard ' + pullRequest.commit : ''
                      )
              };
              build.tasks.push(preparePrTask);

              const updatePrInfoTask = {
                name: 'refreshPrInfo-' + pullRequestId,
                act: (task, callback) => {
                  getGitData((newGitData) => {
                    if (newGitData) {
                      build.pullRequests[pullRequestId] = {
                        commit: newGitData.commit,
                        date: newGitData.date
                      };
                      callback(0);
                    } else {
                      callback(1);
                    }
                  });
                }
              };
              build.tasks.push(updatePrInfoTask);

              const fetchGithubDetailsTask = newFetchGithubDetailsTask(pullRequestId);
              build.tasks.push(fetchGithubDetailsTask);

              const squashPrTask = {
                name: 'squashPr-' + pullRequestId,
                description: 'squash_pr',
                cmd: 'git merge ' + currentBranch + ' -m "Sync with ' + currentBranch + '" && \
                      git checkout ' + currentBranch + ' && \
                      ' + (isSecondary ? 'git stash pop &&' : '') + ' \
                      git merge pr-' + pullRequestId + ' --squash --autostash && \
                      git branch -D pr-' + pullRequestId
              };
              build.tasks.push(squashPrTask);
            }
          }
          build.tasks.push(refreshInfoTask);
          build.tasks.push(updateSettingsTask);
          build.tasks.push(initTask);
          build.tasks.push(buildDependenciesTask);
        } else {
          build.tasks.push(refreshInfoTask);
        }
        if (!command.startsWith('/checkout') && !isSimpleCommand) {
          const restorePullRequestsListTask = {
            name: 'restorePullRequestsList',
            displayName: 'Check included PRs',
            act: (task, callback) => {
              fs.readFile(settings.TGX_SOURCE_PATH + '/local.properties', 'utf-8',  (err, data) => {
                if (err) {
                  callback(1);
                  return;
                }
                build.outputApplication = {
                  id: getProperty(data, 'app.id') || settings.app.id,
                  name: getProperty(data, 'app.name') || settings.app.name,
                  extension: getProperty(data, 'tgx.extension') || false,
                  experimental: getProperty(data, 'app.experimental') === 'true',
                  dontObfuscate: getProperty(data, 'app.dontobfuscate') === 'true',
                  isPRBuild
                };
                let prIds = getProperty(data, 'pr.ids');
                if (prIds) {
                  prIds = prIds.split(',').map((id) => parseInt(id)).filter((id) => id > 0).sort();
                }
                if (!prIds || !prIds.length) {
                  callback(0);
                  return;
                }
                if (isPRBuild && !build.telegramTrack) {
                  build.telegramTrack = 'PR#' + prIds.join(',');
                }
                build.pullRequests = {};
                for (let i = 0; i < prIds.length; i++) {
                  const pullRequestId = prIds[i];
                  build.pullRequests[pullRequestId] = {
                    commit: {
                      short: getProperty(data, 'pr.' + pullRequestId + '.commit_short'),
                      long: getProperty(data, 'pr.' + pullRequestId + '.commit_long'),
                    },
                    date: getProperty(data, 'pr.' + pullRequestId + '.date'),
                    github: {
                      name: getProperty(data, 'pr.' + pullRequestId + '.author'),
                      url: getProperty(data, 'pr.' + pullRequestId + '.author_url'),
                      additions: parseInt(getProperty(data, 'pr.' + pullRequestId + '.additions')) || 0,
                      deletions: parseInt(getProperty(data, 'pr.' + pullRequestId + '.deletions')) || 0
                    }
                  }
                }
                build.pullRequestsMetadata = prIds.map((id) => {
                  const pullRequest = build.pullRequests[id];
                  if (pullRequest) {
                    return {id, commit: pullRequest.commit.short};
                  } else {
                    return {id};
                  }
                });
                let remaining = prIds.length;
                let finished = false;
                for (let i = 0; i < prIds.length; i++) {
                  const fetchGithubDetailsTask = newFetchGithubDetailsTask(prIds[i]);
                  fetchGithubDetailsTask.act(task, (code) => {
                    if (finished)
                      return;
                    if (code !== 0) {
                      finished = true;
                      callback(code);
                      return;
                    }
                    remaining--;
                    if (remaining === 0) {
                      finished = true;
                      callback(0);
                    }
                  })
                }
                callback(0);
              });
            }
          };
          build.tasks.push(restorePullRequestsListTask);

          /*if (!skipBuild) {
            const args = [];
            let totalBuildCount = 0;
            build.variants.forEach((variant) => {
              totalBuildCount += variant.abi.length;
              variant.abi.forEach((abi) => {
                args.push('assemble' + ucfirst(variant.name) + ucfirst(abi) + 'Release');
              });
            });
            const firstVariant = build.variants[0];
            const variantsSuffix = build.variants.length === 1 ?
              ucfirst(firstVariant.name) +
              firstVariant.abi.map(ucfirst).join('+') :
              'All' + totalBuildCount;
            const buildTask = {
              name: 'assemble' + variantsSuffix,
              script: 'gradlew',
              args: args.concat([
                LOCAL ? '--info' : '--quiet',
                '--stacktrace',
                '--console=plain'
              ])
            };
            build.tasks.push(buildTask);
          }*/

          if (!skipBuild) {
            build.tasks.push({
              name: 'stopGradle',
              displayName: 'Stop Gradle',
              script: 'gradlew',
              args: gradlewArgs.concat([
                '--stop'
              ])
            });

            const firstVariant = build.variants[0];
            const lintSuffix = ucfirst(firstVariant.name) + ucfirst(firstVariant.abi[0]);
            build.tasks.push({
              name: 'lint' + lintSuffix,
              displayName: 'Check critical issues',
              script: 'gradlew',
              args: gradlewArgs.concat([
                'lint' + lintSuffix + 'Release'
              ])
            });
          }

          build.variants.forEach((variant) => {
            variant.abi.forEach((abi) => {
              const variantSuffix = ucfirst(variant.name) + ucfirst(abi);
              const variantPrefix = '[' + variant.name + ',' + abi + ']';

              if (!skipBuild) {
                build.tasks.push({
                  name: 'assemble' + variantSuffix,
                  displayName: variantPrefix + ' Assemble',
                  script: 'gradlew',
                  args: gradlewArgs.concat(variant.name === 'legacy' ? [
                    '-PuseLegacyNdk=true'
                  ] : []).concat([
                    'assemble' + variantSuffix + 'Release',
                    LOCAL ? '--info' : '--quiet',
                    '--stacktrace',
                    '--console=plain'
                  ])
                });
              }

              build.tasks.push({
                name: 'verify' + variantSuffix,
                displayName: variantPrefix + ' Verify',
                act: (task, callback) => {
                  getBuildFiles(build, variant.name, abi, (files) => {
                    if (!build.aborted && files) {
                      if (!build.files[variant.name]) {
                        build.files[variant.name] = {};
                      }
                      build.files[variant.name][abi] = files;
                      if (files.apkFile.checksum) {
                        traceBuiltApk(build, task, variant.name, abi, files.apkFile.checksum);
                        if (files.apkFile.checksum.sha256) {
                          task.logPublicly(files.apkFile.checksum.sha256);
                        }
                      }
                      callback(0);
                    } else {
                      callback(1);
                    }
                  });
                }
              });
              build.tasks.push({
                name: 'upload' + variantSuffix,
                displayName: variantPrefix + ' Upload',
                isAsync: true,
                act: (task, callback) => {
                  return uploadToTelegram(bot, task, build, variant.name, abi, callback);
                }
              });
            });

            if (variant.name === 'latest' && build.publicChatId && (build.telegramTrack || isPRBuild) && (build.variants.length > 1 || variant.abi.length > 1)) {
              build.tasks.push({
                name: 'publishTelegramInternal',
                displayName: 'Publish to Telegram (private)',
                needsAwait: true,
                act: (task, callback) => {
                  return publishToTelegram(bot, task, build, variant.name, callback, isPRBuild ? INTERNAL_CHAT_ID : ALPHA_CHAT_ID, true, true);
                }
              });
            }

            if (build.publicChatId && (build.telegramTrack || isPRBuild)) {
              const id = isPRBuild ? 'PR' : build.telegramTrack.startsWith('private') ? 'Private' : ucfirst(build.telegramTrack);
              const targetChatId = (build.googlePlayTrack === 'production') ? ALPHA_CHAT_ID : build.publicChatId;
              build.tasks.push({
                name: 'publishTelegram' + id +
                  (variant.name !== 'latest' ? ucfirst(variant.name) : '') +
                  (build.googlePlayTrack === 'production' ? 'Draft' : ''),
                displayName: 'Publish to Telegram',
                needsAwait: true,
                act: (task, callback) => {
                  return publishToTelegram(bot, task, build, variant.name, callback, targetChatId, false, true, true);
                }
              });
            }
          });

          if (!skipBuild) {
            build.tasks.push({
              name: 'killGradle',
              displayName: 'Memory cleanup',
              cmd: [
                './gradlew --stop',
                'sleep 3',
                'pkill -f [K]otlin[C]ompile[D]aemon 2>/dev/null',
                'true'
              ].join('; ')
            });
          }

          if (!LOCAL && (build.googlePlayTrack || build.huaweiTrack || build.githubTrack)) {
            build.distributionPlatforms = ALL_PLATFORMS.filter((platform) =>
              (platform !== 'telegram' && !!build[platform + 'Track'])
            );
            build.tasks.push({
              name: 'prepareForPublishing',
              displayName: 'Prepare for publishing',
              needsAwait: true,
              act: (task, callback) => {
                return prepareForPublishing(task, build, callback);
              }
            });

            if (build.googlePlayTrack) {
              const draftOnly = build.googlePlayTrack === 'production' || commandArgs.draft;
              const uploadTaskSuffix = ucfirst(build.googlePlayTrack) + (draftOnly ? 'Draft' : ''); 
              build.tasks.push({
                name: 'publishGooglePlay' + uploadTaskSuffix,
                displayName: 'Upload to Google Play',
                isAsync: true,
                act: (task, callback) => {
                  return uploadToGooglePlay(task, build, draftOnly, callback);
                }
              });
            }

            if (build.huaweiTrack) {
              const draftOnly = build.huaweiTrack === 'production';
              const uploadTaskSuffix = (build.huaweiTrack !== 'production' ? ucfirst(build.huaweiTrack) : '') + (draftOnly ? 'Draft' : '');
              build.tasks.push({
                name: 'publishHuaweiAppGallery' + uploadTaskSuffix,
                displayName: 'Upload to AppGallery',
                isAsync: true,
                act: (task, callback) => {
                  return uploadToHuaweiAppGallery(task, build, callback, draftOnly);
                }
              })
            }

            if (build.githubTrack) {
              // Mark all builds as pre-release, unless they are uploaded to GitHub stable
              const isPrerelease = build.googlePlayTrack !== 'production';
              // Force draft, if it a production update
              const draftOnly = !isPrerelease;

              const tagName = 'v' + build.version.name + (isPrerelease ? '-' + build.githubTrack : '');
              const createTagTask = {
                name: 'createTag',
                displayName: 'Create git tag',
                description: 'createTag',
                cmd: 'git fetch && \
                      git tag -f ' + tagName + ' ' + build.git.commit.long + ' && \
                      git push origin --tags -f'
              };
              build.tasks.push(createTagTask);

              const uploadTaskSuffix = isPrerelease ? ucfirst(build.githubTrack) : '';
              build.tasks.push({
                name: 'publishGithub' + uploadTaskSuffix,
                displayName: 'Upload to GitHub',
                act: (task, callback) => {
                  return uploadToGithub(task, build, callback, commandArgsRaw, isPrerelease, tagName, draftOnly);
                }
              });

              const cleanupTagsTask = {
                name: 'cleanupTags',
                displayName: 'Delete obsolete git tags',
                description: 'cleanupTags',
                cmd: '(git tag | grep "beta" | grep -v ' + tagName + ' | xargs -I% sh -c \'git tag -d % && git push origin :refs/tags/% && echo "Deleted tag %"\') && (git push origin --tags -f)'
              };
              build.tasks.push(cleanupTagsTask);
            }
          }
        }

        // Simple commands
        switch (command) {
          case '/update_sdk': {
            build.tasks.push({
              name: 'updateSdk',
              displayName: 'Update SDK',
              script: 'scripts/setup-sdk.sh'
            });
            break;
          }
          case '/upgrade_tdlib': {
            build.tasks.push({
              name: 'upgradeTdlib',
              displayName: 'Upgrade TDLib',
              script: 'tdlib/upgrade.sh',
              args: [
                settings.github.username,
                settings.github.access_token
              ]
            });
            break;
          }
          case '/bump': {
            const checkoutVersionsTask = {
              name: 'checkoutVersion',
              displayName: 'Fetch latest version',
              description: 'checkoutVersion',
              cmd: '(git fetch && git checkout -f origin/main version.properties)'
            };
            build.tasks.push(checkoutVersionsTask);
            build.tasks.push({
              name: 'bumpVersion',
              displayName: 'Bump version code',
              script: 'scripts/version_bump.sh'
            });
            break;
          }
        }
        
        const replyMarkup = JSON.stringify({inline_keyboard: [[{text: 'Cancel', callback_data: 'abort' + buildId}]]});
        build.asString = (isPublic, shorten) => {
          const commitUrl = '<a href="' + build.git.remoteUrl + '/tree/' + build.git.commit.long + '">' + build.git.commit.short + '</a>';
          const fromToCommit = getFromToCommit(build,
            build.googlePlayTrack && build.previousGooglePlayProductionBuild && build.previousGooglePlayBuild &&
            build.previousGooglePlayBuild.version.code < build.previousGooglePlayProductionBuild.version.code
          );
          const changesUrl = fromToCommit ? '<a href="' + build.git.remoteUrl + '/compare/' + fromToCommit.commit_range + '">' + fromToCommit.commit_range + '</a>' : null;
          let result = null;
          if (isPublic) {
            const displayTrack =
              build.googlePlayTrack === 'production' ? 'stable' :
              build.googlePlayTrack ? build.googlePlayTrack :
              build.telegramTrack ? build.telegramTrack :
              null;
            result = '<code>' + build.version.name + (displayTrack ? ' ' + displayTrack : '') + '</code>';
            if (build.aborted) {
              if (build.endTime) {
                result += ' <b>canceled</b>.';
              } else {
                result += ' is canceling…';
              }
            } else if (build.endTime) {
              result += build.error ? ' <b>deploy incomplete</b>.' :
                build.googlePlayTrack ? ' <a href="' + MARKET_URL + '"><b>' + (build.googlePlayTrack === 'production' ? 'sent to review' : 'released') + '</b></a>.' :
                ' <b>released</b>.';
            } else {
              result += ' is assembling…';
            }

            result += '\n';
          } else {
            result = '<code>' + command + (isPrivate && commandArgsRaw ? ' ' + commandArgsRaw : '') + '</code>';
            if (build.aborted) {
              if (build.endTime) {
                result += ' <b>canceled</b>.';
              } else {
                result += ' is canceling…';
              }
            } else if (build.endTime) {
              result += ' <b>done.</b>';
            } else {
              result += ' in progress…';
            }
            result += '\n\n';
            result += '<b>Version</b>: ' + '<code>' + build.version.name + '</code>';
          }
          if (changesUrl) {
            result += '\n<b>Changes from ' + fromToCommit.from_version.code + '</b>: ' + changesUrl;
          } else {
            result += '\n<b>Commit</b>: ' + commitUrl;
            if (build.git.date) {
              result += ', ' + toDisplayDate(build.git.date);
            }
          }
          if (build.pullRequestsMetadata || !empty(build.pullRequests)) {
            result += '\n<b>Pull requests</b>: ' + toDisplayPullRequestList(build);
          }
          if (commandArgsRaw && ((isPublic && build.endTime && !build.error && !build.aborted) || (!isPublic && !isPrivate))) {
            result += '\n\n' + commandArgsRaw.trim();
          }
          result += '\n\n';
          if (build.endTime && !build.error && isPublic && !build.aborted) {
            if (build.googlePlayTrack === 'alpha' || build.googlePlayTrack === 'beta') {
              result += 'Google Play <b>' + (build.googlePlayTrack === 'beta' ? '<a href="' + TESTING_URL + '">' : '') + build.googlePlayTrack + (build.googlePlayTrack === 'beta' ? '</a>' : '') + '</b> will be available after passing the review process.\n';
            } else if (build.googlePlayTrack === 'production') {
              result += 'An update will be available for all users after passing the review process.\n';
            }
            const variantLinks = {};
            let variantLinksCount = 0;
            if (build.publicMessages) {
              for (let i = 0; i < build.publicMessages.length; i++) {
                const publicMessage = build.publicMessages[i];
                if (publicMessage.url) {
                  const links = variantLinks[publicMessage.sdkVariant] || (variantLinks[publicMessage.sdkVariant] = []);
                  links.push('<a href="' + publicMessage.url + '">' + publicMessage.abiVariant + '</a>');
                  variantLinksCount++;
                }
              }
            }
            if (variantLinksCount > 0) {
              let legacyWarning = false;
              for (const sdkVariant in variantLinks) {
                const links = variantLinks[sdkVariant];
                if (!legacyWarning && sdkVariant !== 'latest' && variantLinks['latest']) {
                  legacyWarning = true;
                  result += '\n\n';
                  result += 'If you\'re using an old Android version, wait for an update on Google Play, or use one of the special APKs below:\n'
                }
                switch (sdkVariant) {
                  case 'latest':
                    result += 'You can install the same <b>APKs</b> without waiting';
                    break;
                  case 'marshmallow':
                    result += '\nAndroid 6.0 (Marshmallow)';
                    break;
                  case 'lollipop':
                    result += '\nAndroid 5.0–5.1 (Lollipop)';
                    break;
                  case 'legacy':
                    result += '\nAndroid 4.1–4.4 (Jelly Bean – KitKat)';
                    break;
                }
                result += ': ';
                if (sdkVariant === 'latest') {
                  result += links.map((item) => '<b><u>' + item + '</u></b>').join(', ');
                } else {
                  result += links.join(', ');
                }
                result += '.';
              }
            } else if (build.googlePlayTrack === 'production') {
              result += '<b>APKs</b> will be published separately.';
            } else {
              result += 'You can find <b>APKs</b> below.';
            }
          } else if (build.endTime && (build.error || build.aborted) && isPublic) {
            result += 'Another build might be made soon.';
          } else {
            for (let i = 0; i < build.tasks.length; i++) {
              let task = build.tasks[i];
              let needBold = false;
              if (i > 0)
                result += '\n';
              let taskStatus = '';
              if (task.finished) {
                taskStatus = '<b>' + duration(task.startTime, task.endTime) + '</b>';
              } else if (task.interrupted) {
                taskStatus = task.endTime ? '<b>aborted in ' + duration(task.startTime, task.endTime) + '</b>' : 'aborting…';
              } else if (task.error) {
                taskStatus = '<b>failed in ' + duration(task.startTime, task.endTime) + '!</b>';
                needBold = true;
              } else if (task.startTime) {
                needBold = true;
                taskStatus = 'in progress…';
                if (task.progress) {
                  taskStatus += ' <b>' + task.progress + '</b>';
                }
              } else if (build.aborted || build.error) {
                taskStatus = ''; // '<i>canceled</i>';
              } else {
                taskStatus = '';
              }
              const internalTaskName = task.displayName || task.name;
              let taskName = needBold ? '<b>' + internalTaskName + '</b>' : internalTaskName;
              if (taskStatus.length > 0) {
                result += '• ' + taskName + ': ' + taskStatus;
              } else {
                result += '• ' + taskName;
              }
              const logs = isPublic ? task.publicLog : task.privateLog;
              if (logs) {
                if (shorten) {
                  if (logs.length) {
                    result += '\n&gt; ' + logs.length + ' log message' + (logs.length !== 1 ? 's' : '');
                  }
                } else {
                  logs.forEach((log) => {
                    result += '\n&gt; <code>' + escapeHtml(trimIndent(log).trim()) + '</code>';
                  });
                }
              }
            }
          }
          const time = (build.endTime || build.estimateDuration) ? (build.endTime ? duration(build.startTime, build.endTime, true) : '~' + duration(0, Math.round(build.estimateDuration / 1000) * 1000, true)) : null;
          if (isPublic) {
            if (time) {
              result += build.endTime ? '\n\n<i>Done in <b>' + time + '</b></i>' : '\n\n<i>Finishing in ' + time + '</i>';
            }
          } else {
            result += '\n\n<i>' + cpuSignature + '</i>';
            if (time) {
              result += ': <i> ' + time + '</i>';
            }
          }
          result = result.trim();
          if (messageLength(result) > MAX_TEXT_MESSAGE_LENGTH) {
            if (!shorten) {
              return build.asString(isPublic, true);
            }
            result = limitMessageLength(result, MAX_TEXT_MESSAGE_LENGTH);
          }
          return result;
        };
        build.updateMessage = async (isFinal) => {
          if (build.publicChatId && build.publicMessageId) {
            const text = build.asString(true);
            let params = {
              chat_id: build.publicChatId,
              message_id: build.publicMessageId,
              parse_mode: 'HTML',
              disable_web_page_preview: true
            };
            if (build.publicMessage !== text) {
              build.publicMessage = text;
              try {
                await bot.editMessageText(text, params);
              } catch (e) {
                console.error('Cannot update message', JSON.stringify(params), e);
                if (isFinal) {
                  let timeout = 0;
                  let success = false;
                  let retryCount = 10;
                  do {
                    timeout += 1500;
                    await sleep(Math.min(10000, timeout));
                    try {
                      await bot.editMessageText(text, params);
                      success = true;
                    } catch (e) {
                      console.error('Cannot retry update message', JSON.stringify(params), e, retryCount);
                    }
                  } while (!success && --retryCount > 0);
                }
              }
            }
          }
          if (build.serviceChatId && build.serviceMessageId) {
            const needMarkup = !build.aborted && !build.endTime;
            const text = build.asString();
            let params = {
              chat_id: build.serviceChatId,
              message_id: build.serviceMessageId,
              parse_mode: 'HTML',
              disable_web_page_preview: true
            };
            if (needMarkup) {
              params.reply_markup = replyMarkup;
            }
            if (build.message !== text || build.canBeCanceled !== needMarkup) {
              build.message = text;
              build.canBeCanceled = needMarkup;
              try {
                await bot.editMessageText(text, params);
              } catch (e) {
                console.error('Cannot update message', JSON.stringify(params), e);
              }
            }
          }
        };
        build.after = (callback) => {
          if (callback) {
            if (build.endTime) {
              callback();
              return;
            }
            if (!build.invokeAfter) {
              build.invokeAfter = [callback];
            } else {
              build.invokeAfter.push(callback);
            }
          }
        };
        build.abort = async (after) => {
          if (build.aborted || build.endTime) {
            build.after(after);
            return;
          }
          console.log('Aborting build ' + build.version.name);
          build.aborted = true;
          await build.updateMessage(true);
          if (build.publicMessages) {
            // Deleting APKs
            for (let i = 0; i < build.publicMessages.length; i++) {
              const messageId = build.publicMessages[i].message_id;
              if (messageId != 0) {
                await bot.deleteMessage(build.publicChatId, messageId);
                build.publicMessages[i] = 0;
              }
            }
          }
          if (build.publicMessageId && (new Date() - build.startTime) <= Math.round(1.5 * 60 * 1000) /*posted less than 1.5 minutes ago*/) {
            // Deleting build log
            const publicMessageId = build.publicMessageId;
            build.publicMessageId = 0;
            await bot.deleteMessage(build.publicChatId, publicMessageId);
          }
          for (let i = 0; i < build.tasks.length; i++) {
            const task = build.tasks[i];
            if (!task.endTime && task.startTime) {
              task.interrupted = true;
              if (task.process) {
                await killTask(task);
                await build.updateMessage(true);
              } else if (task.cancel) {
                await task.cancel();
              }
              break;
            }
          }
          build.after(after);
        };
        build.cleanup = async () => {
          await build.updateMessage(true);
          if (cur.pending_build && cur.pending_build.id === build.id) {
            cur.pending_build = null;
          }
        };
        build.step = () => {
          if (!build.startTime) {
            if (build.aborted)
              return true;
            build.startTime = new Date();
          }
          if (build.endTime) {
            return true;
          }
          let havePendingAsyncTasks = false;
          let haveErrors = false;
          let completeTaskCount = 0;
          for (let i = 0; i < build.tasks.length; i++) {
            const task = build.tasks[i];
            if (task.error) {
              haveErrors = true;
            }
            if (!task.error && task.startTime && task.endTime) {
              completeTaskCount++;
            }
            if (!build.aborted && !task.startTime && !haveErrors) {
              if (task.needsAwait && havePendingAsyncTasks) {
                return false;
              }
              task.startTime = new Date();
              task.privateLog = [];
              task.publicLog = [];
              task.logPrivately = (message) => {
                message = escapeHtml(trimIndent(message).trim());
                if (message) {
                  task.privateLog.push(message);
                  build.updateMessage();
                }
              };
              task.logPublicly = (message) => {
                task.logPrivately(message);
                message = escapeHtml(trimIndent(message).trim());
                if (message) {
                  task.publicLog.push(message);
                  build.updateMessage();
                }
              };
              const onDone = (code, signal) => {
                if (task.endTime)
                  return;
                console.log('Done task ' + task.name + ' with code ' + code + ' signal ' + signal);
                if (code != 0 && task.privateLog) {
                  console.log('Private task ' + task.name + ' log:\n' + task.privateLog.join('\n'));
                }
                task.endTime = new Date();
                task.process = null;
                task.exitCode = code;
                task.error = code != 0;
                if (task.error) {
                  build.error = true;
                }
                task.finished = !task.error;
                build.updateMessage();
                traceDuration('task_stat', task.name, task.startTime, task.endTime, task.finished);
                build.step();
              };
              if (task.cmd || task.script) {
                if (task.script) {
                  const args = task.args ? [task.script, ...task.args] : [task.script];
                  console.log('Running script', task.script);
                  task.process = spawn('/bin/bash', args, {cwd: settings.TGX_SOURCE_PATH});
                } else {
                  const command = task.cmd + (task.args ? ' ' + task.args.join(' ') : '');
                  console.log('Executing bash -c', task.description || '...');
                  task.process = spawn('/bin/bash', ['-c', command], {cwd: settings.TGX_SOURCE_PATH});
                }
                task.process.stdout.on('data', (data) => {
                  if (!task.silence || LOCAL) {
                    console.log(`${data}`);
                  }
                });
                task.process.stderr.on('data', (data) => {
                  if (task.silence) {
                    console.error(`${data}`);
                  } else {
                    task.logPrivately(`${data}`);
                  }
                });
                task.process.on('close', onDone);
              } else {
                task.cancel = task.act(task, onDone);
              }

              build.updateMessage();
              if (task.isAsync) {
                havePendingAsyncTasks = true;
                continue;
              }
              return false;
            }

            if (task.startTime && !task.endTime) {
              if (task.isAsync) {
                havePendingAsyncTasks = true;
                continue;
              }
              return false;
            }
          }
          if (havePendingAsyncTasks) {
            return false;
          }
          if (completeTaskCount === build.tasks.length) {
            build.aborted = false;
          }
          build.endTime = new Date();
          build.cleanup().then(async () => {
            if (build.publicChatId && build.publicMessageId && !(build.aborted || build.error || isPRBuild)) {
              try {
                await bot.pinChatMessage(build.publicChatId, build.publicMessageId);
              } catch (e) {
                console.log('Cannot pin chat message', e);
              }
            }
          });

          traceDuration('build_stat', build.type, build.startTime, build.endTime, !haveErrors);
          if (build.invokeAfter) {
            for (let i = 0; i < build.invokeAfter.length; i++) {
              build.invokeAfter[i]();
            }
          }

          return true;
        };
        estimateBuildDuration(build).then(() => {
          build.step();

          build.message = build.asString();
          build.canBeCanceled = true;

          bot.sendMessage(msg.chat.id, build.message, {
            parse_mode: 'HTML',
            reply_markup: replyMarkup,
            disable_web_page_preview: true
          }).then((message) => {
            build.serviceMessageId = message.message_id;
            build.updateMessage();
          }).catch(globalErrorHandler());

          if (build.publicChatId) {
            build.publicMessage = build.asString(true);
            bot.sendMessage(build.publicChatId, build.publicMessage, {
              parse_mode: 'HTML',
              disable_notification: true,
              disable_web_page_preview: true
            }).then((message) => {
              build.publicMessageId = message.message_id;
              build.updateMessage();
            }).catch(globalErrorHandler());
          }
        });
      }); });
      break;
    }
    default: {
      bot.sendMessage(
        msg.chat.id,
        'Unknown command:\n' + 
        '<pre><code class="language-javascript">' +
          escapeHtml(JSON.stringify(msg, null, 2)) +
        '</code></pre>',
        {parse_mode: 'HTML'}
      ).catch(globalErrorHandler());
      break;
    }
  }
}

function matchChecksum (text) {
  const result = text.length ? text.match(/^[a-fA-F0-9]+$/gi) : null;
  return result && result[0] ? result[0].toLowerCase() : null;
}

function getChecksumMessage (checksum, apk, displayChecksum) {
  let text = '';
  if (displayChecksum) {
    text += '<code>' + checksum + '</code> is a ';
    if (apk.hashAlgorithm) {
      text += '<b>' + toDisplayAlgorithm(apk.hashAlgorithm) + '</b> ';
    }
    text += 'hash that ';
  } else {
    text += 'This ';
    if (apk.hashAlgorithm) {
      text += '<b>' + toDisplayAlgorithm(apk.hashAlgorithm) + '</b> ';
    }
    text += 'hash ';
  }

  text += 'corresponds to ';
  text += '<b>' + (!apk.branch || apk.branch === 'main' ? 'official' : 'unofficial') + ' Telegram X</b> build.';

  ALL_PLATFORMS.forEach((platform) => {
    if (apk[platform + 'Track']) {
      switch (platform) {
        case 'googlePlay': {
          text += '\n\n';
          text += 'This build was published to <b>Google Play' + (apk.googlePlayTrack === 'stable' ? '' : ' ' + ucfirst(apk.googlePlayTrack)) + '</b>.';
          break;
        }
        case 'huawei': {
          text += '\n\n';
          text += 'This build was published to <b>Huawei AppGallery</b>.';
        }
      }
    }
  })

  text += '\n\n';
  text += '<b>Version</b>: <code>' + apk.version.name +
    (apk.sdkVariant && apk.sdkVariant !== 'latest' ? '-' + apk.sdkVariant : '') +
    '-' + getDisplayVariant(apk.abiVariant || apk.variant || 'unknown') +
    '</code>\n';
  text += '<b>Commit</b>: <a href="' + apk.remoteUrl + '/tree/' + apk.commit.long + '">' + apk.commit.short + '</a>';
  if (apk.date) {
    text += ', ' + toDisplayDate(apk.date);
  }
  if (apk.pullRequestsMetadata || !empty(apk.pullRequests)) {
    text += '\n';
    text += '<b>Pull requests</b>: ' + toDisplayPullRequestList(apk);
  }
  return text;
}

function processPublicCommand (botId, bot, msg, command, commandArgs) {
  if (msg.text) {
    if (command === '/start') {
      const welcome = () => {
        bot.sendMessage(msg.chat.id,
          'Hello! I am the official <b>Telegram X</b> bot.\n\n' +
          'You can send me <b>checksum</b> of an <b>APK file</b> you downloaded, and I can tell whether it corresponds to any <b>Telegram X</b> build I am aware of.\n\n' + 
          '<b>Note</b>: you can always grab a fresh APK from @tgx_log.',
          {parse_mode: 'HTML'}
        ).catch(globalErrorHandler());
      };
      if (commandArgs === 'crash') {
        // Do nothing. Wait for incoming crash file.
      } else if (commandArgs === 'feedback') {
        bot.sendMessage(msg.chat.id, 'Hello! I am the official <b>Telegram X</b> bot.\n\n' +
          'It seems that you want to leave feedback on <b>Telegram X</b>.\n\n' +
          'If you want to just write a public app review, you can leave it on <a href="' + MARKET_URL + '">Google Play</a>.\n\n' + 
          'Meanwhile you can send me <b>checksum</b> of an <b>APK file</b> you downloaded from anywhere, and I can tell whether it corresponds to any <b>Telegram X</b> build I am aware of.',
          {parse_mode: 'HTML'}
        ).catch(globalErrorHandler());
      } else if (matchChecksum(commandArgs)) {
        const checksum = matchChecksum(commandArgs);
        findApkByHash(checksum, (err, apk) => {
          if (err) {
            bot.sendMessage(msg.chat.id,
              '<code>' + checksum + '</code> seems to be a hash, but it does not correspond to any <b>Telegram X</b> build I am aware of.',
              {parse_mode: 'HTML'/*, reply_to_message_id: msg.message_id*/}
            ).catch(globalErrorHandler());
          } else {
            bot.sendMessage(msg.chat.id, getChecksumMessage(checksum, apk, true),
              {
                parse_mode: 'HTML',
                disable_web_page_preview: true /*, reply_to_message_id: msg.message_id*/
              }
            ).catch(globalErrorHandler());
          }
        });
      } else {
        welcome();
      }
      return true;
    }
    if (!command) {
      const checksum = matchChecksum(msg.text);
      if (checksum) {
        findApkByHash(checksum, (err, apk) => {
          if (err) {
            bot.sendMessage(msg.chat.id,
              'This hash does not correspond to any <b>Telegram X</b> I am aware of.',
              {parse_mode: 'HTML', reply_to_message_id: msg.message_id}
            ).catch(globalErrorHandler());
          } else {
            bot.sendMessage(msg.chat.id, getChecksumMessage(checksum, apk, false),
              {
                parse_mode: 'HTML',
                disable_web_page_preview: true,
                reply_to_message_id: msg.message_id
              }
            ).catch(globalErrorHandler());
          }
        });
        return true;
      }
    }
  } else if (msg.document) {
    bot.sendMessage(msg.chat.id,
      'Sorry, I can currently process only <b>checksums</b>, not files themselves.',
      {parse_mode: 'HTML', reply_to_message_id: msg.message_id}
    ).catch(globalErrorHandler());
    return (msg.document.file_name && msg.document.file_name.endsWith('.apk')) ||
      (msg.document.mime_type && msg.document.mime_type === APK_MIME_TYPE);
  }
}

function messageCallback (botId, bot, msg) {
  if (msg.chat.type !== 'private')
    return;

  if (msg.from && msg.from.is_bot) {
    console.error('Received message from bot',
      'from:', JSON.stringify(msg.from),
      'chat:', JSON.stringify(msg.chat),
      'text:', msg.text || 'null'
    );
    return;
  }
  
  storeObject('user', msg.from);
  storeObject('user', msg.forward_from);
  storeObject('chat', msg.sender_chat);
  storeObject('chat', msg.chat);

  let command = null, commandArgs = '';

  if (msg.text && msg.entities && msg.entities.length) {
    for (let i = 0; i < msg.entities.length; i++) {
      const entity = msg.entities[i];
      if (entity.type === 'bot_command' && entity.offset === 0) {
        command = entity.length === msg.text.length ? msg.text : msg.text.substring(0, entity.length);
        commandArgs = msg.text.length > command.length + 1 ? msg.text.substring(command.length + 1) : '';
        break;
      }
    }
  }

  if (botId === 'public' && (msg.chat.username == null || ![BETA_CHAT_ID, PR_CHAT_ID].includes(msg.chat.username))) {
    try {
      const success = processPublicCommand(botId, bot, msg, command, commandArgs);
      if (success) {
        return;
      }
    } catch (e) {
      console.log(e);
      return;
    }
  }
  if (botId === 'private' && msg.chat.id === ADMIN_USER_ID && !msg.reply_to_message) {
    processPrivateCommand(botId, bot, msg, command, commandArgs);
    return;
  }

  // Chat through forwarded messages

  /*if (!msg.from || msg.from.id !== ADMIN_USER_ID) {
    bot.forwardMessage(ADMIN_USER_ID, msg.chat.id, msg.message_id).then((forwardedMessage) => {
      db.put('origin_' + botId + '_' + forwardedMessage.message_id, [msg.chat.id, msg.message_id], {valueEncoding: 'json'});
    }).catch(globalErrorHandler());
    return;
  }
  if (msg.chat.id === ADMIN_USER_ID && msg.reply_to_message) {
    db.get('origin_' + botId + '_' + msg.reply_to_message.message_id, {valueEncoding: 'json'}, (err, origin) => {
      if (err)
        return;
      let chatId = origin[0];
      let messageId = origin.length > 1 ? origin[1] : 0;
      bot.copyMessage(chatId, msg.chat.id, msg.message_id, {
        reply_to_message_id: messageId,
      }).catch(globalErrorHandler());
    });
    return;
  }*/
}

function queryCallback (botId, bot, query) {
  storeObject('user', query.from);
  storeObject('user', query.message ? query.message.from : null);
  storeObject('chat', query.chat);

  if (botId === 'private' && query.from.id === ADMIN_USER_ID &&
      cur.pending_build && query.data === 'abort' + cur.pending_build.id) {
    cur.pending_build.abort(() => {
      bot.answerCallbackQuery(query.id);
    });
    return;
  }

  bot.answerCallbackQuery(query.id);
}

bots.forEach((bot) => {
  bot.bot.on('callback_query', (query) => queryCallback(bot.id, bot.bot, query));
  bot.bot.on('message', (msg) => messageCallback(bot.id, bot.bot, msg));
  bot.bot.on('channel_post', (msg) => messageCallback(bot.id, bot.bot, msg));
  bot.bot.on('error', globalErrorHandler());
  bot.bot.on('polling_error', (error) => {
    bot.bot.sendMessage(ADMIN_USER_ID, 'Polling error…\n' + error).catch(globalErrorHandler());
  });
});
/*bot.on('inline_query', (query) => {
  console.log('inline query', JSON.stringify(query));
});
bot.on('chosen_inline_result', (result) => {
  console.log('inline result', JSON.stringify(result));
});*/

async function onExit (signal, arg1, arg2, callback) {
  cur.exiting = true;
  if (cur.pending_build && cur.pending_build.abort) {
    console.log('Aborting current build manually…');
    cur.pending_build.abort(() => {
      onExit(signal, arg1, arg2, callback);
    });
    return;
  }
  if (!isOffline()) {
    try {
      await botMap['private'].sendMessage(ADMIN_USER_ID, 'Bot stopped.');
    } catch (ignored) {}
  }
  await stopServer();
  await db.close();
  callback();
}

['SIGTERM', 'SIGINT', 'uncaughtException', 'unhandledRejection'].forEach((signal) => {
  process.on(signal, (arg1, arg2) => {
    console.log('Received', signal, arg1, arg2);
    if (signal === 'unhandledRejection')
      return;

    if (!isOffline()) {
      botMap['private'].sendMessage(ADMIN_USER_ID, '*' + signal + '* received, bot is stopping\\.\\.\\.', {parse_mode: 'MarkdownV2'}).catch(globalErrorHandler());
    }

    onExit(signal, arg1, arg2, () => {
      process.exit(signal === 'uncaughtException' || signal === 'unhandledRejection' ? 1 : 0);
    });
  });
});

// EXIT handling
process.on('exit', () => {
  // Cleanup
  console.log('App is closing…');
});

function sorted (unordered) {
  return Object.keys(unordered).sort().reduce(
    (obj, key) => { 
      const val = unordered[key];
      if (typeof val === 'object') {
        obj[key] = JSON.stringify(sorted(val), null, 2);
      } else {
        obj[key] = val;
      }
      return obj;
    }, 
    {}
  );
}

botMap['private'].sendMessage(ADMIN_USER_ID,
  '<b>Bot has started.</b>\n\nPID: <code>' + process.pid +
  '</code>\npwd: <code>' + process.cwd() + '</code>\nenv:\n<pre>' +
  JSON.stringify(sorted(process.env), null, 2) +
  '</pre>', {parse_mode: 'HTML'}
).catch(globalErrorHandler());