/* Any copyright is dedicated to the Public Domain.
 * https://creativecommons.org/publicdomain/zero/1.0/ */

"use strict";

ChromeUtils.defineLazyGetter(this, "nsLocalFile", () =>
  Components.Constructor("@mozilla.org/file/local;1", "nsIFile", "initWithPath")
);

const BACKUP_DIR_PREF_NAME = "browser.backup.location";

const TEST_PASSWORD = "correcthorsebatterystaple";

const kKnownMappings = Object.freeze({
  OneDrPD: "onedrive",
  Docs: "documents",
});

const gDirectoryServiceProvider = {
  getFile(prop, persistent) {
    persistent.value = false;

    // We only expect a narrow range of calls.
    let folder = gBase.clone();
    if (prop === "ProfD") {
      return folder;
    }

    if (prop in kKnownMappings) {
      folder.append("dirsvc");
      folder.append(prop + "-dir");
      return folder;
    }

    console.error(`Access to unexpected directory '${prop}'`);
    return Cr.NS_ERROR_FAILURE;
  },
  QueryInterface: ChromeUtils.generateQI([Ci.nsIDirectoryServiceProvider]),
};

let gBase;
add_setup(function setup() {
  setupProfile();
  gBase = do_get_profile();

  Services.dirsvc
    .QueryInterface(Ci.nsIDirectoryService)
    .registerProvider(gDirectoryServiceProvider);
});

/**
 * Gets a telemetry event and checks that it looks the same between Glean and
 * legacy telemetry, i.e. that the extra data is equal.
 *
 * @param {string} name
 *   The Glean programming name of the event, e.g. turnOn instead of turn_on.
 * @returns {object}
 *   The extra data associated with the event.
 */
function assertSingleTelemetryEvent(name) {
  let value = Glean.browserBackup[name].testGetValue();
  Assert.equal(value.length, 1, `${name} Glean event was recorded once.`);

  let snakeName = name.replace(/([A-Z])/g, "_$1").toLowerCase();
  let legacy = TelemetryTestUtils.getEvents(
    { category: "browser.backup", method: snakeName, object: "BackupService" },
    { process: "parent" }
  );
  Assert.equal(legacy.length, 1, `${name} legacy event was recorded once.`);

  Assert.deepEqual(
    legacy[0].extra,
    value[0].extra,
    "Legacy telemetry measured the same data as Glean."
  );
  return value[0].extra;
}

/**
 * Checks that the recorded event's 'encrypted' and 'location' extra keys
 * match `destPath` and `encrypted`. Reset telemetry before if needed!
 *
 * @param {string} name
 *   The name of the Glean event that should have been recorded.
 * @param {string} destPath
 *   The path that the backup was stored to.
 * @param {boolean} encrypted
 *   Whether the backup was encrypted or not.
 */
function assertEventMatches(name, destPath, encrypted) {
  let extra = assertSingleTelemetryEvent(name);
  Assert.equal(
    extra.encrypted,
    String(encrypted),
    `Glean event indicates the backup is ${encrypted ? "" : "NOT "}encrypted.`
  );

  // This is returned from the mock of classifyLocationForTelemetry, and
  // checks that the correct path was passed in.
  Assert.equal(
    extra.location,
    `[classifying: ${relativeToProfile(destPath)}]`,
    "Glean event has right location"
  );

  return extra;
}

/**
 * Determines the path to 'source' from the profile directory to reduce the
 * length and avoid truncation within legacy telemetry.
 *
 * @param {string} path
 *   The file that should be pointed to.
 * @returns {string}
 *   The relative path from 'base' to 'source'.
 */
function relativeToProfile(path) {
  let file = nsLocalFile(path);
  return file.getRelativePath(gBase);
}

add_task(function test_relativeToProfile() {
  // This aims to check that the direction is right.
  const file = gBase.clone();
  file.append("abc");
  Assert.equal(
    relativeToProfile(file.path),
    "abc",
    "relativeToProfile computes the right path."
  );
});

add_task(async function test_created_encrypted_noreason() {
  await template("testCreatedEncryptedNoReason", true, undefined);
});

add_task(async function test_created_nonencrypted_noreason() {
  await template("testCreatedNonencryptedNoReason", false, undefined);
});

add_task(async function test_created_encrypted_with_reason() {
  await template("testCreatedEncryptedWithReason", true, "I said so");
});

async function template(name, encrypted, reason) {
  let bs = new BackupService();
  let profilePath = await IOUtils.createUniqueDirectory(
    PathUtils.tempDir,
    name
  );

  const backupDir = PathUtils.join(PathUtils.tempDir, name + "_dest");
  Services.prefs.setStringPref(BACKUP_DIR_PREF_NAME, backupDir);

  if (encrypted) {
    await bs.enableEncryption(TEST_PASSWORD, profilePath);
  }

  sinon.stub(bs, "classifyLocationForTelemetry").callsFake(file => {
    return `[classifying: ${relativeToProfile(file)}]`;
  });

  // To ensure that the backup_start event happens before the actual backup,
  // take the lock for ourselves. Then we can unblock the backup once we've
  // checked the telemetry is finished.
  let resolver = Promise.withResolvers();
  locks.request(BackupService.WRITE_BACKUP_LOCK_NAME, () => {
    Services.fog.testResetFOG();
    Services.telemetry.clearEvents();

    let promise = bs.createBackup({ profilePath, reason });

    let startedEvents = Glean.browserBackup.backupStart.testGetValue();
    Assert.equal(
      startedEvents.length,
      1,
      "Found the backup_start Glean event."
    );
    Assert.equal(
      startedEvents[0].extra.reason,
      reason ?? "unknown",
      "Found the reason for starting the backup in the Glean event."
    );

    // Don't await on it, since createBackup needs the lock!
    resolver.resolve(promise);
  });

  await resolver.promise;

  let value = assertEventMatches("created", backupDir, encrypted);
  // Not sure how big it is, and we're not testing the fuzzByteSize
  // function, so just check that it's plausible.
  Assert.greater(Number(value.size), 0, "Telemetry event has nonzero size");
}

add_task(async function test_toggleOn() {
  let bs = new BackupService();

  let backupDir = PathUtils.join(PathUtils.tempDir, "toggleOn_dest");
  Services.prefs.setStringPref(BACKUP_DIR_PREF_NAME, backupDir);

  let profilePath = await IOUtils.createUniqueDirectory(
    PathUtils.tempDir,
    "toggleOn"
  );

  if (bs.state.scheduledBackupsEnabled) {
    // The test assumes that this is false. Do this before resetting telemetry
    // so it doesn't affect the results.
    bs.onUpdateScheduledBackups(false);
  }

  sinon.stub(bs, "classifyLocationForTelemetry").callsFake(file => {
    return `[classifying: ${relativeToProfile(file)}]`;
  });

  Services.fog.testResetFOG();
  Services.telemetry.clearEvents();
  bs.onUpdateScheduledBackups(true);
  assertEventMatches("toggleOn", backupDir, false);

  Services.fog.testResetFOG();
  Services.telemetry.clearEvents();
  bs.onUpdateScheduledBackups(false);
  assertSingleTelemetryEvent("toggleOff");

  await bs.enableEncryption(TEST_PASSWORD, profilePath);
  Services.fog.testResetFOG();
  Services.telemetry.clearEvents();
  bs.onUpdateScheduledBackups(true);
  assertEventMatches("toggleOn", backupDir, true);

  Services.fog.testResetFOG();
  Services.telemetry.clearEvents();
  bs.onUpdateScheduledBackups(false);
  assertSingleTelemetryEvent("toggleOff");
});

add_task(async function test_classifyLocationForTelemetry() {
  let bs = new BackupService();
  for (const prop of Object.keys(kKnownMappings)) {
    let file = Services.dirsvc.get(prop, Ci.nsIFile);
    Assert.equal(
      bs.classifyLocationForTelemetry(file.path),
      "other",
      `'${file.path}' was correctly classified.`
    );

    file.append("child");
    Assert.equal(
      bs.classifyLocationForTelemetry(file.path),
      kKnownMappings[prop],
      `'${file.path}' was correctly classified.`
    );

    file = file.parent.parent;
    Assert.equal(
      bs.classifyLocationForTelemetry(file.path),
      "other",
      `'${file.path}' was correctly classified.`
    );
  }

  Assert.equal(
    bs.classifyLocationForTelemetry(gBase.path),
    "other",
    "Unrelated path is not classified anywhere."
  );

  Assert.equal(
    bs.classifyLocationForTelemetry("path"),
    "Error: NS_ERROR_FILE_UNRECOGNIZED_PATH",
    "Invalid path returns an error name."
  );
});

add_task(async function test_idleDispatchPassesOptionsThrough() {
  let bs = new BackupService();
  let stub = sinon.stub(bs, "createBackupOnIdleDispatch").resolves();

  let options = {};
  bs.createBackupOnIdleDispatch(options);
  Assert.equal(
    stub.firstCall.args[0],
    options,
    "Options were passed as-is into createBackup."
  );
});