"use strict";

const { TelemetryUtils } = ChromeUtils.importESModule(
  "resource://gre/modules/TelemetryUtils.sys.mjs"
);
const { TelemetryTestUtils } = ChromeUtils.importESModule(
  "resource://testing-common/TelemetryTestUtils.sys.mjs"
);

const { TelemetryArchiveTesting } = ChromeUtils.importESModule(
  "resource://testing-common/TelemetryArchiveTesting.sys.mjs"
);

const { TestUtils } = ChromeUtils.importESModule(
  "resource://testing-common/TestUtils.sys.mjs"
);

// All tests run privileged unless otherwise specified not to.
function createExtension(backgroundScript, permissions, isPrivileged = true) {
  let extensionData = {
    background: backgroundScript,
    manifest: { permissions },
    isPrivileged,
  };

  return ExtensionTestUtils.loadExtension(extensionData);
}

async function testNoOp(methodNames, run) {
  if (!Array.isArray(methodNames)) {
    methodNames = [methodNames];
  }
  ExtensionTestUtils.failOnSchemaWarnings(false);

  const { messages } = await promiseConsoleOutput(run);
  AddonTestUtils.checkMessages(messages, {
    expected: methodNames.map(methodName => ({
      message: new RegExp(
        "`" +
          methodName +
          "` is a no-op since Firefox 134 \\(see bug 1930196\\)"
      ),
    })),
    forbidUnexpected: true,
  });

  ExtensionTestUtils.failOnSchemaWarnings(true);
}

async function run(test) {
  let extension = createExtension(
    test.backgroundScript,
    test.permissions || ["telemetry"],
    test.isPrivileged
  );
  await extension.startup();
  await extension.awaitFinish(test.doneSignal);
  await extension.unload();
}

// Currently unsupported on Android: blocked on 1220177.
// See 1280234 c67 for discussion.
if (AppConstants.MOZ_BUILD_APP === "browser") {
  AddonTestUtils.init(this);

  add_task(async function test_telemetry_without_telemetry_permission() {
    await run({
      backgroundScript: () => {
        browser.test.assertTrue(
          !browser.telemetry,
          "'telemetry' permission is required"
        );
        browser.test.notifyPass("telemetry_permission");
      },
      permissions: [],
      doneSignal: "telemetry_permission",
      isPrivileged: false,
    });
  });

  add_task(
    async function test_telemetry_without_telemetry_permission_privileged() {
      await run({
        backgroundScript: () => {
          browser.test.assertTrue(
            !browser.telemetry,
            "'telemetry' permission is required"
          );
          browser.test.notifyPass("telemetry_permission");
        },
        permissions: [],
        doneSignal: "telemetry_permission",
      });
    }
  );

  add_task(async function test_telemetry_scalar_add() {
    Services.telemetry.clearScalars();

    await testNoOp("scalarAdd", async () => {
      await run({
        backgroundScript: async () => {
          await browser.telemetry.scalarAdd(
            "telemetry.test.unsigned_int_kind",
            1
          );
          browser.test.notifyPass("scalar_add");
        },
        doneSignal: "scalar_add",
      });

      TelemetryTestUtils.assertScalarUnset(
        TelemetryTestUtils.getProcessScalars("parent", false, true),
        "telemetry.test.unsigned_int_kind"
      );
    });
  });

  add_task(async function test_telemetry_scalar_add_unknown_name() {
    ExtensionTestUtils.failOnSchemaWarnings(false);

    await testNoOp("scalarAdd", async () => {
      await run({
        backgroundScript: async () => {
          await browser.telemetry.scalarAdd("telemetry.test.does_not_exist", 1);
          browser.test.notifyPass("scalar_add_unknown_name");
        },
        doneSignal: "scalar_add_unknown_name",
      });
    });
  });

  add_task(async function test_telemetry_scalar_add_illegal_value() {
    ExtensionTestUtils.failOnSchemaWarnings(false);

    await testNoOp("scalarAdd", async () => {
      await run({
        backgroundScript: () => {
          browser.test.assertThrows(
            () =>
              browser.telemetry.scalarAdd(
                "telemetry.test.unsigned_int_kind",
                {}
              ),
            /Incorrect argument types for telemetry.scalarAdd/,
            "The second 'value' argument to scalarAdd must be an integer, string, or boolean"
          );
          browser.test.notifyPass("scalar_add_illegal_value");
        },
        doneSignal: "scalar_add_illegal_value",
      });
    });
  });

  add_task(async function test_telemetry_scalar_add_invalid_keyed_scalar() {
    ExtensionTestUtils.failOnSchemaWarnings(false);

    await testNoOp("scalarAdd", async () => {
      await run({
        backgroundScript: async () => {
          await browser.telemetry.scalarAdd(
            "telemetry.test.keyed_unsigned_int",
            1
          );
          browser.test.notifyPass("scalar_add_invalid_keyed_scalar");
        },
        doneSignal: "scalar_add_invalid_keyed_scalar",
      });
    });
  });

  add_task(async function test_telemetry_scalar_set_bool_true() {
    Services.telemetry.clearScalars();
    await testNoOp("scalarSet", async () => {
      await run({
        backgroundScript: async () => {
          await browser.telemetry.scalarSet(
            "telemetry.test.boolean_kind",
            true
          );
          browser.test.notifyPass("scalar_set_bool_true");
        },
        doneSignal: "scalar_set_bool_true",
      });
      TelemetryTestUtils.assertScalarUnset(
        TelemetryTestUtils.getProcessScalars("parent", false, true),
        "telemetry.test.boolean_kind"
      );
    });
  });

  add_task(async function test_telemetry_scalar_set_bool_false() {
    Services.telemetry.clearScalars();
    await testNoOp("scalarSet", async () => {
      await run({
        backgroundScript: async () => {
          await browser.telemetry.scalarSet(
            "telemetry.test.boolean_kind",
            false
          );
          browser.test.notifyPass("scalar_set_bool_false");
        },
        doneSignal: "scalar_set_bool_false",
      });
      TelemetryTestUtils.assertScalarUnset(
        TelemetryTestUtils.getProcessScalars("parent", false, true),
        "telemetry.test.boolean_kind"
      );
    });
  });

  add_task(async function test_telemetry_scalar_unset_bool() {
    Services.telemetry.clearScalars();
    TelemetryTestUtils.assertScalarUnset(
      TelemetryTestUtils.getProcessScalars("parent", false, true),
      "telemetry.test.boolean_kind"
    );
  });

  add_task(async function test_telemetry_scalar_set_unknown_name() {
    await testNoOp("scalarSet", async () => {
      await run({
        backgroundScript: async () => {
          await browser.telemetry.scalarSet(
            "telemetry.test.does_not_exist",
            true
          );
          browser.test.notifyPass("scalar_set_unknown_name");
        },
        doneSignal: "scalar_set_unknown_name",
      });
    });
  });

  add_task(async function test_telemetry_scalar_set_zero() {
    Services.telemetry.clearScalars();
    await testNoOp("scalarSet", async () => {
      await run({
        backgroundScript: async () => {
          await browser.telemetry.scalarSet(
            "telemetry.test.unsigned_int_kind",
            0
          );
          browser.test.notifyPass("scalar_set_zero");
        },
        doneSignal: "scalar_set_zero",
      });
      TelemetryTestUtils.assertScalarUnset(
        TelemetryTestUtils.getProcessScalars("parent", false, true),
        "telemetry.test.unsigned_int_kind"
      );
    });
  });

  add_task(async function test_telemetry_scalar_set_maximum() {
    Services.telemetry.clearScalars();
    await testNoOp("scalarSetMaximum", async () => {
      await run({
        backgroundScript: async () => {
          await browser.telemetry.scalarSetMaximum(
            "telemetry.test.unsigned_int_kind",
            123
          );
          browser.test.notifyPass("scalar_set_maximum");
        },
        doneSignal: "scalar_set_maximum",
      });
      TelemetryTestUtils.assertScalarUnset(
        TelemetryTestUtils.getProcessScalars("parent", false, true),
        "telemetry.test.unsigned_int_kind"
      );
    });
  });

  add_task(async function test_telemetry_scalar_set_maximum_unknown_name() {
    await testNoOp("scalarSetMaximum", async () => {
      await run({
        backgroundScript: async () => {
          await browser.telemetry.scalarSetMaximum(
            "telemetry.test.does_not_exist",
            1
          );
          browser.test.notifyPass("scalar_set_maximum_unknown_name");
        },
        doneSignal: "scalar_set_maximum_unknown_name",
      });
    });
  });

  add_task(async function test_telemetry_scalar_set_maximum_illegal_value() {
    await testNoOp("scalarSetMaximum", async () => {
      await run({
        backgroundScript: () => {
          browser.test.assertThrows(
            () =>
              browser.telemetry.scalarSetMaximum(
                "telemetry.test.unsigned_int_kind",
                "string"
              ),
            /Incorrect argument types for telemetry.scalarSetMaximum/,
            "The second 'value' argument to scalarSetMaximum must be a scalar"
          );
          browser.test.notifyPass("scalar_set_maximum_illegal_value");
        },
        doneSignal: "scalar_set_maximum_illegal_value",
      });
    });
  });

  add_task(async function test_telemetry_keyed_scalar_add() {
    Services.telemetry.clearScalars();
    await testNoOp("keyedScalarAdd", async () => {
      await run({
        backgroundScript: async () => {
          await browser.telemetry.keyedScalarAdd(
            "telemetry.test.keyed_unsigned_int",
            "foo",
            1
          );
          browser.test.notifyPass("keyed_scalar_add");
        },
        doneSignal: "keyed_scalar_add",
      });
      TelemetryTestUtils.assertScalarUnset(
        TelemetryTestUtils.getProcessScalars("parent", true, true),
        "telemetry.test.keyed_unsigned_int"
      );
    });
  });

  add_task(async function test_telemetry_keyed_scalar_add_unknown_name() {
    await testNoOp("keyedScalarAdd", async () => {
      await run({
        backgroundScript: async () => {
          await browser.telemetry.keyedScalarAdd(
            "telemetry.test.does_not_exist",
            "foo",
            1
          );
          browser.test.notifyPass("keyed_scalar_add_unknown_name");
        },
        doneSignal: "keyed_scalar_add_unknown_name",
      });
    });
  });

  add_task(async function test_telemetry_keyed_scalar_add_illegal_value() {
    await testNoOp("keyedScalarAdd", async () => {
      await run({
        backgroundScript: () => {
          browser.test.assertThrows(
            () =>
              browser.telemetry.keyedScalarAdd(
                "telemetry.test.keyed_unsigned_int",
                "foo",
                {}
              ),
            /Incorrect argument types for telemetry.keyedScalarAdd/,
            "The second 'value' argument to keyedScalarAdd must be an integer, string, or boolean"
          );
          browser.test.notifyPass("keyed_scalar_add_illegal_value");
        },
        doneSignal: "keyed_scalar_add_illegal_value",
      });
    });
  });

  add_task(async function test_telemetry_keyed_scalar_add_invalid_scalar() {
    await testNoOp("keyedScalarAdd", async () => {
      await run({
        backgroundScript: async () => {
          await browser.telemetry.keyedScalarAdd(
            "telemetry.test.unsigned_int_kind",
            "foo",
            1
          );
          browser.test.notifyPass("keyed_scalar_add_invalid_scalar");
        },
        doneSignal: "keyed_scalar_add_invalid_scalar",
      });
    });
  });

  add_task(async function test_telemetry_keyed_scalar_add_long_key() {
    await testNoOp("keyedScalarAdd", async () => {
      await run({
        backgroundScript: async () => {
          await browser.telemetry.keyedScalarAdd(
            "telemetry.test.keyed_unsigned_int",
            "X".repeat(73),
            1
          );
          browser.test.notifyPass("keyed_scalar_add_long_key");
        },
        doneSignal: "keyed_scalar_add_long_key",
      });
    });
  });

  add_task(async function test_telemetry_keyed_scalar_set() {
    Services.telemetry.clearScalars();
    await testNoOp("keyedScalarSet", async () => {
      await run({
        backgroundScript: async () => {
          await browser.telemetry.keyedScalarSet(
            "telemetry.test.keyed_boolean_kind",
            "foo",
            true
          );
          browser.test.notifyPass("keyed_scalar_set");
        },
        doneSignal: "keyed_scalar_set",
      });
      TelemetryTestUtils.assertScalarUnset(
        TelemetryTestUtils.getProcessScalars("parent", true, true),
        "telemetry.test.keyed_boolean_kind"
      );
    });
  });

  add_task(async function test_telemetry_keyed_scalar_set_unknown_name() {
    await testNoOp("keyedScalarSet", async () => {
      await run({
        backgroundScript: async () => {
          await browser.telemetry.keyedScalarSet(
            "telemetry.test.does_not_exist",
            "foo",
            true
          );
          browser.test.notifyPass("keyed_scalar_set_unknown_name");
        },
        doneSignal: "keyed_scalar_set_unknown_name",
      });
    });
  });

  add_task(async function test_telemetry_keyed_scalar_set_long_key() {
    await testNoOp("keyedScalarSet", async () => {
      await run({
        backgroundScript: async () => {
          await browser.telemetry.keyedScalarSet(
            "telemetry.test.keyed_unsigned_int",
            "X".repeat(73),
            1
          );
          browser.test.notifyPass("keyed_scalar_set_long_key");
        },
        doneSignal: "keyed_scalar_set_long_key",
      });
    });
  });

  add_task(async function test_telemetry_keyed_scalar_set_maximum() {
    Services.telemetry.clearScalars();
    await testNoOp("keyedScalarSetMaximum", async () => {
      await run({
        backgroundScript: async () => {
          await browser.telemetry.keyedScalarSetMaximum(
            "telemetry.test.keyed_unsigned_int",
            "foo",
            123
          );
          browser.test.notifyPass("keyed_scalar_set_maximum");
        },
        doneSignal: "keyed_scalar_set_maximum",
      });
      TelemetryTestUtils.assertScalarUnset(
        TelemetryTestUtils.getProcessScalars("parent", true, true),
        "telemetry.test.keyed_unsigned_int"
      );
    });
  });

  add_task(
    async function test_telemetry_keyed_scalar_set_maximum_unknown_name() {
      await testNoOp("keyedScalarSetMaximum", async () => {
        await run({
          backgroundScript: async () => {
            await browser.telemetry.keyedScalarSetMaximum(
              "telemetry.test.does_not_exist",
              "foo",
              1
            );
            browser.test.notifyPass("keyed_scalar_set_maximum_unknown_name");
          },
          doneSignal: "keyed_scalar_set_maximum_unknown_name",
        });
      });
    }
  );

  add_task(
    async function test_telemetry_keyed_scalar_set_maximum_illegal_value() {
      await testNoOp("keyedScalarSetMaximum", async () => {
        await run({
          backgroundScript: () => {
            browser.test.assertThrows(
              () =>
                browser.telemetry.keyedScalarSetMaximum(
                  "telemetry.test.keyed_unsigned_int",
                  "foo",
                  "string"
                ),
              /Incorrect argument types for telemetry.keyedScalarSetMaximum/,
              "The third 'value' argument to keyedScalarSetMaximum must be a scalar"
            );
            browser.test.notifyPass("keyed_scalar_set_maximum_illegal_value");
          },
          doneSignal: "keyed_scalar_set_maximum_illegal_value",
        });
      });
    }
  );

  add_task(async function test_telemetry_keyed_scalar_set_maximum_long_key() {
    await testNoOp("keyedScalarSetMaximum", async () => {
      await run({
        backgroundScript: async () => {
          await browser.telemetry.keyedScalarSetMaximum(
            "telemetry.test.keyed_unsigned_int",
            "X".repeat(73),
            1
          );
          browser.test.notifyPass("keyed_scalar_set_maximum_long_key");
        },
        doneSignal: "keyed_scalar_set_maximum_long_key",
      });
    });
  });

  add_task(async function test_telemetry_record_event() {
    Services.telemetry.clearEvents();

    ExtensionTestUtils.failOnSchemaWarnings(false);

    await run({
      backgroundScript: async () => {
        await browser.telemetry.recordEvent(
          "telemetry.test",
          "test1",
          "object1"
        );
        browser.test.notifyPass("record_event_ok");
      },
      doneSignal: "record_event_ok",
    });

    const snapshot = Services.telemetry.snapshotEvents(
      Ci.nsITelemetry.DATASET_PRERELEASE_CHANNELS,
      true
    );
    if ("parent" in snapshot) {
      Assert.ok(
        snapshot.parent.every(
          ([, /*timestamp*/ category, method, object /* value, extra */]) =>
            category != "telemetry.test" &&
            method != "test1" &&
            object != "object1"
        )
      );
    }

    ExtensionTestUtils.failOnSchemaWarnings(true);

    Services.telemetry.clearEvents();
  });

  // Bug 1536877
  add_task(async function test_telemetry_record_event_value_must_be_string() {
    Services.telemetry.clearEvents();

    ExtensionTestUtils.failOnSchemaWarnings(false);

    await run({
      backgroundScript: async () => {
        try {
          await browser.telemetry.recordEvent(
            "telemetry.test",
            "test1",
            "object1",
            "value1"
          );
          browser.test.notifyPass("record_event_string_value");
        } catch (ex) {
          browser.test.fail(
            `Unexpected exception raised during record_event_value_must_be_string: ${ex}`
          );
          browser.test.notifyPass("record_event_string_value");
          throw ex;
        }
      },
      doneSignal: "record_event_string_value",
    });

    const snapshot = Services.telemetry.snapshotEvents(
      Ci.nsITelemetry.DATASET_PRERELEASE_CHANNELS,
      true
    );
    const testEvents =
      snapshot.parent?.filter(
        ([, category, method, object]) =>
          category == "telemetry.test" &&
          method == "test1" &&
          object == "object1"
      ) ?? [];
    Assert.equal(
      testEvents.length,
      0,
      "Deprecated telemetry.recordEvent should be no-op."
    );

    ExtensionTestUtils.failOnSchemaWarnings(true);

    Services.telemetry.clearEvents();
  });

  add_task(async function test_telemetry_register_scalars_string() {
    Services.telemetry.clearScalars();
    await testNoOp(["registerScalars", "scalarSet"], async () => {
      await run({
        backgroundScript: async () => {
          await browser.telemetry.registerScalars("telemetry.test.dynamic", {
            webext_string: {
              kind: browser.telemetry.ScalarType.STRING,
              keyed: false,
              record_on_release: true,
            },
          });
          await browser.telemetry.scalarSet(
            "telemetry.test.dynamic.webext_string",
            "hello"
          );
          browser.test.notifyPass("register_scalars_string");
        },
        doneSignal: "register_scalars_string",
      });
      TelemetryTestUtils.assertScalarUnset(
        TelemetryTestUtils.getProcessScalars("dynamic", false, true),
        "telemetry.test.dynamic.webext_string"
      );
    });
  });

  add_task(async function test_telemetry_register_scalars_multiple() {
    Services.telemetry.clearScalars();
    await testNoOp(["registerScalars", "scalarSet", "scalarSet"], async () => {
      await run({
        backgroundScript: async () => {
          await browser.telemetry.registerScalars("telemetry.test.dynamic", {
            webext_string: {
              kind: browser.telemetry.ScalarType.STRING,
              keyed: false,
              record_on_release: true,
            },
            webext_string_too: {
              kind: browser.telemetry.ScalarType.STRING,
              keyed: false,
              record_on_release: true,
            },
          });
          await browser.telemetry.scalarSet(
            "telemetry.test.dynamic.webext_string",
            "hello"
          );
          await browser.telemetry.scalarSet(
            "telemetry.test.dynamic.webext_string_too",
            "world"
          );
          browser.test.notifyPass("register_scalars_multiple");
        },
        doneSignal: "register_scalars_multiple",
      });
      const scalars = TelemetryTestUtils.getProcessScalars(
        "dynamic",
        false,
        true
      );
      TelemetryTestUtils.assertScalarUnset(
        scalars,
        "telemetry.test.dynamic.webext_string"
      );
      TelemetryTestUtils.assertScalarUnset(
        scalars,
        "telemetry.test.dynamic.webext_string_too"
      );
    });
  });

  add_task(async function test_telemetry_register_scalars_boolean() {
    Services.telemetry.clearScalars();
    await testNoOp(["registerScalars", "scalarSet"], async () => {
      await run({
        backgroundScript: async () => {
          await browser.telemetry.registerScalars("telemetry.test.dynamic", {
            webext_boolean: {
              kind: browser.telemetry.ScalarType.BOOLEAN,
              keyed: false,
              record_on_release: true,
            },
          });
          await browser.telemetry.scalarSet(
            "telemetry.test.dynamic.webext_boolean",
            true
          );
          browser.test.notifyPass("register_scalars_boolean");
        },
        doneSignal: "register_scalars_boolean",
      });
      TelemetryTestUtils.assertScalarUnset(
        TelemetryTestUtils.getProcessScalars("dynamic", false, true),
        "telemetry.test.dynamic.webext_boolean"
      );
    });
  });

  add_task(async function test_telemetry_register_scalars_count() {
    Services.telemetry.clearScalars();
    await testNoOp(["registerScalars", "scalarSet"], async () => {
      await run({
        backgroundScript: async () => {
          await browser.telemetry.registerScalars("telemetry.test.dynamic", {
            webext_count: {
              kind: browser.telemetry.ScalarType.COUNT,
              keyed: false,
              record_on_release: true,
            },
          });
          await browser.telemetry.scalarSet(
            "telemetry.test.dynamic.webext_count",
            123
          );
          browser.test.notifyPass("register_scalars_count");
        },
        doneSignal: "register_scalars_count",
      });
      TelemetryTestUtils.assertScalarUnset(
        TelemetryTestUtils.getProcessScalars("dynamic", false, true),
        "telemetry.test.dynamic.webext_count"
      );
    });
  });

  add_task(async function test_telemetry_register_events() {
    Services.telemetry.clearEvents();

    ExtensionTestUtils.failOnSchemaWarnings(false);

    const { messages } = await promiseConsoleOutput(async () => {
      await run({
        backgroundScript: async () => {
          await browser.telemetry.registerEvents("telemetry.test.dynamic", {
            test1: {
              methods: ["test1"],
              objects: ["object1"],
              extra_keys: [],
            },
          });
          await browser.telemetry.recordEvent(
            "telemetry.test.dynamic",
            "test1",
            "object1"
          );
          browser.test.notifyPass("register_events");
        },
        doneSignal: "register_events",
      });
    });

    const expectedRegisterEventsMessage =
      /`registerEvents` is a no-op since Firefox 132 \(see bug 1894533\)/;
    const expectedRecordEventMessage =
      /`recordEvent` is a no-op since Firefox 132 \(see bug 1894533\)/;

    AddonTestUtils.checkMessages(messages, {
      expected: [
        { message: expectedRegisterEventsMessage },
        { message: expectedRecordEventMessage },
      ],
      forbidUnexpected: true,
    });

    ExtensionTestUtils.failOnSchemaWarnings(true);
  });

  add_task(async function test_telemetry_submit_ping() {
    let archiveTester = new TelemetryArchiveTesting.Checker();
    await archiveTester.promiseInit();

    await run({
      backgroundScript: async () => {
        await browser.telemetry.submitPing("webext-test", {}, {});
        browser.test.notifyPass("submit_ping");
      },
      doneSignal: "submit_ping",
    });

    await TestUtils.waitForCondition(
      () => archiveTester.promiseFindPing("webext-test", []),
      "Failed to find the webext-test ping"
    );
  });

  add_task(async function test_telemetry_can_upload_enabled() {
    Services.prefs.setBoolPref(
      TelemetryUtils.Preferences.FhrUploadEnabled,
      true
    );

    await run({
      backgroundScript: async () => {
        const result = await browser.telemetry.canUpload();
        browser.test.assertTrue(result);
        browser.test.notifyPass("can_upload_enabled");
      },
      doneSignal: "can_upload_enabled",
    });

    Services.prefs.clearUserPref(TelemetryUtils.Preferences.FhrUploadEnabled);
  });

  add_task(async function test_telemetry_can_upload_disabled() {
    Services.prefs.setBoolPref(
      TelemetryUtils.Preferences.FhrUploadEnabled,
      false
    );

    await run({
      backgroundScript: async () => {
        const result = await browser.telemetry.canUpload();
        browser.test.assertFalse(result);
        browser.test.notifyPass("can_upload_disabled");
      },
      doneSignal: "can_upload_disabled",
    });

    Services.prefs.clearUserPref(TelemetryUtils.Preferences.FhrUploadEnabled);
  });
}