// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT license.

import * as appInsights from "applicationinsights";
import assert from "assert";
import fs from "fs";
import { beforeEach, describe, it } from "mocha";
import sinon from "sinon";
import os from "os";
import * as defaults from "../src/defaults";
import * as officeAddinUsageData from "../src/usageData";
import * as jsonData from "../src/usageDataSettings";
import * as log from "../src/log";
import { v4 as uuidv4 } from "uuid";

/* global console */

let addInUsageData: officeAddinUsageData.OfficeAddinUsageData;
const err = new Error(
  `this error contains a file path:C:/${os.homedir()}/AppData/Roaming/npm/node_modules/alanced-match/index.js`
);
let usageData: string = "";
const mockDeviceID = uuidv4();
const usageDataObject: officeAddinUsageData.IUsageDataOptions = {
  groupName: "office-addin-usage-data",
  projectName: "office-addin-usage-data",
  instrumentationKey: defaults.instrumentationKeyForOfficeAddinCLITools,
  promptQuestion:
    "-----------------------------------------\nDo you want to opt-in for usage data?[y/n]\n-----------------------------------------",
  raisePrompt: false,
  usageDataLevel: officeAddinUsageData.UsageDataLevel.on,
  method: officeAddinUsageData.UsageDataReportingMethod.applicationInsights,
  isForTesting: true,
  deviceID: mockDeviceID,
};

describe("Test office-addin-usage data-package", function () {
  this.beforeAll(function () {
    try {
      if (fs.existsSync(defaults.usageDataJsonFilePath)) {
        const fileContent = fs.readFileSync(defaults.usageDataJsonFilePath, "utf8");
        if (fileContent) {
          usageData = JSON.parse(fileContent) || "";
        }
      }
    } catch {
      // do nothing
    }
  });
  this.afterAll(function () {
    if (fs.existsSync(defaults.usageDataJsonFilePath) && usageData !== undefined) {
      fs.writeFileSync(defaults.usageDataJsonFilePath, JSON.stringify(usageData, null, 2));
    } else if (fs.existsSync(defaults.usageDataJsonFilePath)) {
      fs.unlinkSync(defaults.usageDataJsonFilePath);
    }
  });
  beforeEach(function () {
    if (fs.existsSync(defaults.usageDataJsonFilePath)) {
      fs.unlinkSync(defaults.usageDataJsonFilePath);
    }
    addInUsageData = new officeAddinUsageData.OfficeAddinUsageData(usageDataObject);
    addInUsageData.setUsageDataOn();
  });
  describe("Test constructor with minimal options", () => {
    it("Should successfully construct an OfficeAddInUsageData instance", () => {
      assert.doesNotThrow(() => {
        new officeAddinUsageData.OfficeAddinUsageData({
          isForTesting: true,
          usageDataLevel: officeAddinUsageData.UsageDataLevel.off,
          projectName: "office-addin-usage-data",
          groupName: "TestGroupName",
          instrumentationKey: defaults.instrumentationKeyForOfficeAddinCLITools,
        });
      });
    });
  });
  describe("Test reportEvent method", () => {
    it("should track event of object passed in with a project name", () => {
      const testEvent = {
        Test1: [true, 100],
        ScriptType: ["JavaScript", 1],
      };
      addInUsageData.reportEvent("office-addin-usage-data", testEvent);
      assert.equal(addInUsageData.getEventsSent(), 1);
    });
  });
  describe("Test reportError method", () => {
    it("should send usage data exception", () => {
      addInUsageData.reportError("ReportErrorCheck", err);
      assert.equal(addInUsageData.getExceptionsSent(), 1);
    });
  });
  describe("Test promptForUsageData method", () => {
    it("Should return 'true' because usageDataJsonFilePath doesn't exist", () => {
      // delete officeAddinUsageData.json
      if (fs.existsSync(defaults.usageDataJsonFilePath)) {
        fs.unlinkSync(defaults.usageDataJsonFilePath);
      }
      assert.equal(jsonData.needToPromptForUsageData(usageDataObject.groupName as string), true);
    });
  });
  describe("Test promptForUsageData method", () => {
    it("Should return 'false' because usageDataJsonFilePath exists and groupName exists in file", () => {
      jsonData.writeUsageDataJsonData(
        usageDataObject.groupName as string,
        usageDataObject.usageDataLevel as officeAddinUsageData.UsageDataLevel
      );
      assert.equal(jsonData.needToPromptForUsageData(usageDataObject.groupName as string), false);
    });
  });
  describe("Test promptForUsageData method", () => {
    it("Should return 'true' because usageDataJsonFilePath exists but groupName doesn't exist on file", () => {
      jsonData.writeUsageDataJsonData(
        usageDataObject.groupName as string,
        usageDataObject.usageDataLevel as officeAddinUsageData.UsageDataLevel
      );
      assert.equal(jsonData.needToPromptForUsageData("test group name"), true);
    });
  });
  describe("Test usageDataOptIn method", () => {
    it("Should write out file with groupName set to true to usageDataJsonFilePath", () => {
      addInUsageData.usageDataOptIn(usageDataObject.isForTesting, "y");
      const jsonTelemtryData = jsonData.readUsageDataJsonData();
      assert.equal(
        jsonTelemtryData.usageDataInstances[usageDataObject.groupName as string].usageDataLevel,
        usageDataObject.usageDataLevel
      );
    });
  });
  describe("Test setUsageDataOff method", () => {
    it("should change samplingPercentage to 100, turns usage data on", () => {
      addInUsageData.setUsageDataOn();
      addInUsageData.setUsageDataOff();
      assert.equal(addInUsageData.isUsageDataOn(), false);
    });
  });
  describe("Test setUsageDataOn method", () => {
    it("should change samplingPercentage to 100, turns usage data on", () => {
      addInUsageData.setUsageDataOff();
      addInUsageData.setUsageDataOn();
      assert.equal(appInsights.defaultClient.config.samplingPercentage, 100);
    });
  });
  describe("Test isUsageDataOn method", () => {
    it("should return true if samplingPercentage is on(100)", () => {
      appInsights.defaultClient.config.samplingPercentage = 100;
      assert.equal(addInUsageData.isUsageDataOn(), true);
    });
    it("should return false if samplingPercentage is off(0)", () => {
      appInsights.defaultClient.config.samplingPercentage = 0;
      assert.equal(addInUsageData.isUsageDataOn(), false);
    });
  });
  describe("Test getUsageDataKey method", () => {
    it("should return usage data key", () => {
      assert.equal(addInUsageData.getUsageDataKey(), "de0d9e7c-1f46-4552-bc21-4e43e489a015");
    });
  });
  describe("Test getEventsSent method", () => {
    it("should return amount of events successfully sent", () => {
      addInUsageData.setUsageDataOff();
      const testEvent = {
        Test1: [true, 100],
        ScriptType: ["Java", 1],
      };
      addInUsageData.reportEvent("office-addin-usage-data", testEvent);
      assert.equal(addInUsageData.getEventsSent(), 1);
    });
  });
  describe("Test getExceptionsSent method", () => {
    it("should return amount of exceptions successfully sent ", () => {
      addInUsageData.setUsageDataOff();
      addInUsageData.reportError("TestData", err);
      assert.equal(addInUsageData.getExceptionsSent(), 1);
    });
  });
  describe("Test UsageDataLevel method", () => {
    it("should return the usage data level of the object", () => {
      assert.equal("on", addInUsageData.getUsageDataLevel());
    });
  });
  describe("Test maskFilePaths method", () => {
    it("should parse error file paths with slashs", () => {
      addInUsageData.setUsageDataOff();
      const error = new Error(
        `this error contains a file path: C:/${os.homedir()}/AppData/Roaming/npm/node_modules/alanced-match/index.js`
      );
      const compareError = new Error();
      compareError.name = "Error";
      compareError.message = "this error contains a file path: <filepath>";
      // may throw error if change any part of the top of the test file
      compareError.stack = "this error contains a file path: <filepath>";

      addInUsageData.maskFilePaths(error);

      assert.strictEqual(compareError.name, error.name);
      assert.strictEqual(compareError.message, error.message);
      assert.strictEqual((error.stack ?? "").includes(compareError.stack), true);
    });
    it("should parse error file paths with backslashs", () => {
      addInUsageData.setUsageDataOff();
      const errWithBackslash = new Error(
        `this error contains a file path: C:\\Users\\admin\\AppData\\Local\\Temp\\excel file .xlsx`
      );
      const compareErrorWithBackslash = new Error();
      compareErrorWithBackslash.message = "this error contains a file path: <filepath>";
      compareErrorWithBackslash.stack = "this error contains a file path: <filepath>";

      addInUsageData.maskFilePaths(errWithBackslash);

      assert.strictEqual(compareErrorWithBackslash.message, errWithBackslash.message);
      assert.strictEqual((errWithBackslash.stack ?? "").includes(compareErrorWithBackslash.stack), true);
    });
    it("should parse error file paths with slashs and backslashs", () => {
      addInUsageData.setUsageDataOff();
      const error = new Error(
        `this error contains a file path: C:\\Users/\\admin\\AppData\\Local//Temp\\excel_file .xlsx`
      );
      const compareError = new Error();
      compareError.message = "this error contains a file path: <filepath>";
      compareError.stack = "this error contains a file path: <filepath>";

      addInUsageData.maskFilePaths(error);

      assert.strictEqual(compareError.message, error.message);
      assert.strictEqual((error.stack ?? "").includes(compareError.stack), true);
    });
    it("should handle relative paths", () => {
      addInUsageData.setUsageDataOff();
      const error = new Error(`file path: /this is a file path/path/manifestName.xml`);
      const compareError = new Error();
      compareError.message = "file path: <filepath>";
      compareError.stack = "file path: <filepath>";

      addInUsageData.maskFilePaths(error);

      assert.strictEqual(compareError.message, error.message);
      assert.strictEqual((error.stack ?? "").includes(compareError.stack), true);
    });
  });

  describe("Test modifySetting method", () => {
    it("should modify or create specific property to new value", () => {
      const usageDataLevel = usageDataObject.usageDataLevel;
      let jsonObject = {};
      jsonObject[usageDataObject.groupName as string] = usageDataObject.usageDataLevel;
      jsonObject = { usageDataInstances: jsonData };
      jsonObject = {
        usageDataInstances: { [usageDataObject.groupName as string]: { usageDataLevel }, deviceID: mockDeviceID },
      };
      fs.writeFileSync(defaults.usageDataJsonFilePath, JSON.stringify(jsonObject));
      const usageDataJsonData = jsonData.readUsageDataJsonData();
      const testPropertyName = "testProperty";
      usageDataJsonData.usageDataInstances[usageDataObject.groupName as string][testPropertyName] = 0;
      jsonData.modifyUsageDataJsonData(usageDataObject.groupName as string, testPropertyName, 0);
      assert.equal(JSON.stringify(usageDataJsonData), JSON.stringify(jsonData.readUsageDataJsonData()));
    });
  });
  describe("Test readUsageDataJsonData method", () => {
    it("should read and return parsed object object from usage data", () => {
      const usageDataLevel = usageDataObject.usageDataLevel;
      let jsonObject = {};
      jsonObject[usageDataObject.groupName as string] = usageDataObject.usageDataLevel;
      jsonObject = { usageDataInstances: jsonData };
      jsonObject = {
        usageDataInstances: { [usageDataObject.groupName as string]: { usageDataLevel } },
        deviceID: mockDeviceID,
      };
      fs.writeFileSync(defaults.usageDataJsonFilePath, JSON.stringify(jsonObject));
      assert.equal(JSON.stringify(jsonObject), JSON.stringify(jsonData.readUsageDataJsonData()));
    });
  });
  describe("Test readUsageDataLevel method", () => {
    it("should read and return object's usage data level from file", () => {
      const usageDataLevel = usageDataObject.usageDataLevel;
      let jsonObject = {};
      jsonObject[usageDataObject.groupName as string] = usageDataObject.usageDataLevel;
      jsonObject = { usageDataInstances: jsonData };
      jsonObject = {
        usageDataInstances: { [usageDataObject.groupName as string]: { usageDataLevel } },
        deviceID: mockDeviceID,
      };
      fs.writeFileSync(defaults.usageDataJsonFilePath, JSON.stringify(jsonObject));
      assert.equal(
        officeAddinUsageData.UsageDataLevel.on,
        jsonData.readUsageDataLevel(usageDataObject.groupName as string)
      );
    });
  });
  describe("Test readUsageDataObjectProperty method", () => {
    it("should read and return parsed object object from usage data", () => {
      const usageDataLevel = usageDataObject.usageDataLevel;
      let jsonObject = {};
      jsonObject[usageDataObject.groupName as string] = usageDataObject.usageDataLevel;
      jsonObject = { usageDataInstances: jsonData };
      jsonObject = {
        usageDataInstances: { [usageDataObject.groupName as string]: { usageDataLevel } },
        deviceID: mockDeviceID,
      };
      fs.writeFileSync(defaults.usageDataJsonFilePath, JSON.stringify(jsonObject));
      assert.equal(
        officeAddinUsageData.UsageDataLevel.on,
        jsonData.readUsageDataObjectProperty(usageDataObject.groupName as string, "usageDataLevel")
      );
    });
  });
  describe("Test writeUsageDataJsonData method", () => {
    it("should write to already existing file", () => {
      fs.writeFileSync(defaults.usageDataJsonFilePath, "");
      const usageDataLevel = usageDataObject.usageDataLevel;
      let jsonObject = {};
      jsonObject[usageDataObject.groupName as string] = usageDataObject.usageDataLevel;
      jsonObject = { usageDataInstances: jsonData };
      jsonObject = {
        usageDataInstances: { [usageDataObject.groupName as string]: { usageDataLevel }, deviceID: mockDeviceID },
      };
      jsonData.writeUsageDataJsonData(
        usageDataObject.groupName as string,
        usageDataObject.usageDataLevel as officeAddinUsageData.UsageDataLevel
      );
      assert.equal(
        JSON.stringify(jsonObject["usageDataInstances"][usageDataObject.groupName as string], null, 2),
        JSON.stringify(
          JSON.parse(fs.readFileSync(defaults.usageDataJsonFilePath, "utf8"))["usageDataInstances"][
            usageDataObject.groupName as string
          ],
          null,
          2
        )
      );
    });
  });
  describe("Test writeUsageDataJsonData method", () => {
    it("should create new existing file with correct format", () => {
      const usageDataLevel = usageDataObject.usageDataLevel;
      let jsonObject = {};
      jsonObject[usageDataObject.groupName as string] = usageDataObject.usageDataLevel;
      jsonObject = { usageDataInstances: jsonData };
      jsonObject = {
        usageDataInstances: { [usageDataObject.groupName as string]: { usageDataLevel }, deviceID: mockDeviceID },
      };
      jsonData.writeUsageDataJsonData(
        usageDataObject.groupName as string,
        usageDataObject.usageDataLevel as officeAddinUsageData.UsageDataLevel
      );
      assert.equal(
        JSON.stringify(jsonObject["usageDataInstances"][usageDataObject.groupName as string], null, 2),
        JSON.stringify(
          JSON.parse(fs.readFileSync(defaults.usageDataJsonFilePath, "utf8"))["usageDataInstances"][
            usageDataObject.groupName as string
          ],
          null,
          2
        )
      );
    });
  });
  describe("Test groupNameExists method", () => {
    it("should check if groupName exists", () => {
      fs.writeFileSync(defaults.usageDataJsonFilePath, "test");
      const usageDataLevel = usageDataObject.usageDataLevel;
      let jsonObject = {};
      jsonObject[usageDataObject.groupName as string] = usageDataObject.usageDataLevel;
      jsonObject = { usageDataInstances: jsonData };
      jsonObject = {
        usageDataInstances: { [usageDataObject.groupName as string]: { usageDataLevel }, deviceID: mockDeviceID },
      };
      fs.writeFileSync(defaults.usageDataJsonFilePath, JSON.stringify(jsonObject));
      assert.equal(true, jsonData.groupNameExists("office-addin-usage-data"));
    });
  });
  describe("Test readUsageDataSettings method", () => {
    it("should read and return parsed usage data object group settings", () => {
      const usageDataLevel = usageDataObject.usageDataLevel;
      const jsonObject = {
        usageDataInstances: { [usageDataObject.groupName as string]: { usageDataLevel } },
        deviceID: mockDeviceID,
      };
      fs.writeFileSync(defaults.usageDataJsonFilePath, JSON.stringify(jsonObject));
      assert.equal(
        JSON.stringify(jsonObject.usageDataInstances[usageDataObject.groupName as string]),
        JSON.stringify(jsonData.readUsageDataSettings(usageDataObject.groupName))
      );
    });
  });
  describe("Test reportSuccess", () => {
    it("should send success events successfully", () => {
      addInUsageData.reportSuccess("testMethod-reportSuccess", { TestVal: 42, OtherTestVal: "testing" });
      assert.equal(addInUsageData.getEventsSent(), 1);
    });
    it("should send success events successfully, even when there's no additional data", () => {
      addInUsageData.reportSuccess("testMethod-reportSuccess");
      assert.equal(addInUsageData.getEventsSent(), 1);
    });
  });
  describe("Test reportExpectedException", () => {
    it("should send successful fail events successfully", () => {
      addInUsageData.reportExpectedException("testMethod-reportExpectedException", new Error("Test"), {
        TestVal: 42,
        OtherTestVal: "testing",
      });
      assert.equal(addInUsageData.getEventsSent(), 1);
    });
    it("should send successful fail events successfully, even when there's no additional data", () => {
      addInUsageData.reportExpectedException("testMethod-reportExpectedException", new Error("Test"));
      assert.equal(addInUsageData.getEventsSent(), 1);
    });
  });
  describe("Test sendUsageDataEvent", () => {
    it("should send events successfully", () => {
      addInUsageData.sendUsageDataEvent({ TestVal: 42, OtherTestVal: "testing" });
      assert.equal(addInUsageData.getEventsSent(), 1);
    });
    it("should send events successfully, even when there's no data", () => {
      addInUsageData.sendUsageDataEvent();
      assert.equal(addInUsageData.getEventsSent(), 1);
    });
  });
  describe("Test reportException", () => {
    it("should send exceptions successfully", () => {
      addInUsageData.reportException("testMethod-reportException", new Error("Test"), {
        TestVal: 42,
        OtherTestVal: "testing",
      });
      assert.equal(addInUsageData.getExceptionsSent(), 1);
    });
    it("should send exceptions successfully, even when there's no data", () => {
      addInUsageData.reportException("testMethod-reportException", new Error("Test"));
      assert.equal(addInUsageData.getExceptionsSent(), 1);
    });
  });

  describe("log.ts", function () {
    describe("logErrorMessage()", function () {
      it("called with Error", function () {
        const spyConsoleError = sinon.spy(console, "error");
        const spyConsoleLog = sinon.spy(console, "log");

        const message = "This is an error.";
        const error = new Error(message);
        log.logErrorMessage(error);

        assert.ok(spyConsoleError.calledOnceWith(`Error: ${message}`));
        assert.ok(spyConsoleLog.notCalled);

        spyConsoleError.restore();
        spyConsoleLog.restore();
      });
      it("called with string", function () {
        const spyConsoleError = sinon.spy(console, "error");
        const spyConsoleLog = sinon.spy(console, "log");

        const message = "This is the error message.";
        log.logErrorMessage(message);

        assert.ok(spyConsoleError.calledOnceWith(`Error: ${message}`));
        assert.ok(spyConsoleLog.notCalled);

        spyConsoleError.restore();
        spyConsoleLog.restore();
      });
    });
  });
});