const url = require("url");
const https = require("https");
const moment = require("moment");
const knex = require("../knex");
const config = require("../cfg");

const UPDATE_CHECK_FREQUENCY = 12; // In hours
let updateCheckPromise = null;

async function initUpdatesTable() {
  const row = await knex("updates").first();
  if (! row) {
    await knex("updates").insert({
      available_version: null,
      last_checked: null,
    });
  }
}

/**
 * Update current and available versions in the database.
 * Only works when `repository` in package.json is set to a GitHub repository
 * @returns {Promise<void>}
 */
async function refreshVersions() {
  await initUpdatesTable();
  const { last_checked } = await knex("updates").first();

  // Only refresh available version if it's been more than UPDATE_CHECK_FREQUENCY since our last check
  if (last_checked != null && last_checked > moment.utc().subtract(UPDATE_CHECK_FREQUENCY, "hours").format("YYYY-MM-DD HH:mm:ss")) return;

  const packageJson = require("../../package.json");
  const repositoryUrl = packageJson.repository && packageJson.repository.url;
  if (! repositoryUrl) return;

  const parsedUrl = url.parse(repositoryUrl);
  if (parsedUrl.hostname !== "github.com") return;

  const [, owner, repo] = parsedUrl.pathname.split("/");
  if (! owner || ! repo) return;

  https.get(
    {
      hostname: "api.github.com",
      path: `/repos/${owner}/${repo}/releases`,
      headers: {
        "User-Agent": `Modmail Bot (https://github.com/${owner}/${repo}) (${packageJson.version})`
      }
    },
    async res => {
      if (res.statusCode !== 200) {
        await knex("updates").update({
          last_checked: moment.utc().format("YYYY-MM-DD HH:mm:ss")
        });
        console.warn(`[WARN] Got status code ${res.statusCode} when checking for available updates`);
        return;
      }

      let data = "";
      res.on("data", chunk => data += chunk);
      res.on("end", async () => {
        const parsed = JSON.parse(data);
        if (! Array.isArray(parsed) || parsed.length === 0) return;

        const latestMatchingRelease = parsed.find(r => ! r.draft && (config.updateNotificationsForBetaVersions || ! r.prerelease));
        if (! latestMatchingRelease) return;

        const latestVersion = latestMatchingRelease.name;
        await knex("updates").update({
          available_version: latestVersion,
          last_checked: moment.utc().format("YYYY-MM-DD HH:mm:ss")
        });
      });
    }
  );
}

/**
 * @param {String} a Version string, e.g. "2.20.0"
 * @param {String} b Version string, e.g. "2.20.0"
 * @returns {Number} 1 if version a is larger than b, -1 is version a is smaller than b, 0 if they are equal
 */
function compareVersions(a, b) {
  const aParts = a.split(".");
  const bParts = b.split(".");
  for (let i = 0; i < Math.max(aParts.length, bParts.length); i++) {
    let aPart = parseInt((aParts[i] || "0").match(/\d+/)[0] || "0", 10);
    let bPart = parseInt((bParts[i] || "0").match(/\d+/)[0] || "0", 10);
    if (aPart > bPart) return 1;
    if (aPart < bPart) return -1;
  }
  return 0;
}

async function getAvailableUpdate() {
  await initUpdatesTable();

  const packageJson = require("../../package.json");
  const currentVersion = packageJson.version;
  const { available_version: availableVersion } = await knex("updates").first();
  if (availableVersion == null) return null;
  if (currentVersion == null) return availableVersion;

  const versionDiff = compareVersions(currentVersion, availableVersion);
  if (versionDiff === -1) return availableVersion;

  return null;
}

async function refreshVersionsLoop() {
  await refreshVersions();
  setTimeout(refreshVersionsLoop, UPDATE_CHECK_FREQUENCY * 60 * 60 * 1000);
}

module.exports = {
  getAvailableUpdate,
  startVersionRefreshLoop: refreshVersionsLoop
};