const assert = require(`assert`);

/**
 * Assert class
 */
export class Assert {
  /**
      * Checks if a value is true. Same as Assert.ok()
      * ```js
      *Assert.assert(50 > 70,"Expression is incorrect");
      * ```
      * @param {any} expression Specifies an expression to be evaluated
      * @param {String} message Specifies the error message to be assigned to the AssertionError. If omitted, a default message is assigned
     */
  static async assert(expression: any, message?: string) {
    try {
      if (message == undefined) {
        assert(expression);
      } else {
        assert(expression, message);
      }
    } catch (err) {
      throw err;
    }
  }

  /**
       * Checks if two values are equal, using the equal operator (==)
       * ```js
       *Assert.equal(50, 50, "Values are not equal")
       * ```
       * @param {string | string[] | number} value1 Specifies the first value to be compared
       * @param {string | string[] | number} value2 Specifies the second value to be compared
       * @param {String} message Specifies the error message to be assigned to the AssertionError. If omitted, a default message is assigned
      */
  static async equal(value1: string | string[] | number, value2: string | string[] | number, message?: string) {
    try {
      if (message == undefined) {
        assert.equal(value1, value2);
      } else {
        assert.equal(value1, value2, message);
      }
    } catch (err) {
      throw err;
    }
  }

  /**
       * Checks if a value is true
       * ```js
       *Assert.ok(50 > 70,"Expression is incorrect");
       * ```
       * @param {any} expression Specifies an expression to be evaluated
       * @param {String} message Specifies the error message to be assigned to the AssertionError. If omitted, a default message is assigned
      */
  static async ok(expression: any, message?: string) {
    try {
      if (message == undefined) {
        assert.ok(expression);
      } else {
        assert.ok(expression, message);
      }
    } catch (err) {
      throw err;
    }
  }

  /**
       *Checks if two values are equal, using the strict equal operator (===)
       * ```js
       *Assert.strictEqual(50, "50","Values are not equal")
       * ```
       * @param {string | string[] | number} value1 Specifies the first value to be compared
       * @param {string | string[] | number} value2 Specifies the second value to be compared
       * @param {String} message Specifies the error message to be assigned to the AssertionError. If omitted, a default message is assigned
      */
  static async strictEqual(value1: string | string[] | number, value2: string | string[] | number, message?: string) {
    try {
      if (message == undefined) {
        assert.strictEqual(value1, value2);
      } else {
        assert.strictEqual(value1, value2, message);
      }
    } catch (err) {
      throw err;
    }
  }

  /**
       * Checks if two values are not equal, using the not equal operator (!=)
       * ```js
       *Assert.notEqual(50, 50,"Values are equal");
       * ```
        * @param {string | string[] | number} value1 Specifies the first value to be compared
       * @param {string | string[] | number} value2 Specifies the second value to be compared
       * @param {String} message Specifies the error message to be assigned to the AssertionError. If omitted, a default message is assigned
      */
  static async notEqual(value1: string | string[] | number, value2: string | string[] | number, message?: string) {
    try {
      if (message == undefined) {
        assert.notEqual(value1, value2);
      } else {
        assert.notEqual(value1, value2, message);
      }
    } catch (err) {
      throw err;
    }
  }

  /**
       * Checks if two values are not equal, using the strict not equal operator (!==)
       * ```js
       *Assert.notStrictEqual(50, 50,"Values are equal")
       * ```
       * @param {string | string[] | number} value1 Specifies the first value to be compared
       * @param {string | string[] | number} value2 Specifies the second value to be compared
       * @param {String} message Specifies the error message to be assigned to the AssertionError. If omitted, a default message is assigned
      */
  static async notStrictEqual(value1: string | string[] | number, value2: string | string[] | number, message?: string) {
    try {
      if (message == undefined) {
        assert.notStrictEqual(value1, value2);
      } else {
        assert.notStrictEqual(value1, value2, message);
      }
    } catch (err) {
      throw err;
    }
  }

  /**
       * Checks if two values are equal
       * ```js
       *Assert.deepEqual(x, y,"Values are not equal");
       * ```
       * @param {string | string[] | number} value1 Specifies the first value to be compared
       * @param {string | string[] | number} value2 Specifies the second value to be compared
       * @param {String} message Specifies the error message to be assigned to the AssertionError. If omitted, a default message is assigned
      */
  static async deepEqual(value1: string | string[] | number, value2: string | string[] | number, message?: string) {
    try {
      if (message == undefined) {
        assert.deepEqual(value1, value2);
      } else {
        assert.deepEqual(value1, value2, message);
      }
    } catch (err) {
      throw err;
    }
  }

  /**
       * Checks if two values are equal, using the strict equal operator (===)
       * ```js
       *Assert.deepStrictEqual(x, y,"Values are not equal");
       * ```
       * @param {string | string[] | number} value1 Specifies the first value to be compared
       * @param {string | string[] | number} value2 Specifies the second value to be compared
       * @param {String} message Specifies the error message to be assigned to the AssertionError. If omitted, a default message is assigned
      */
  static async deepStrictEqual(value1: string | string[] | number, value2: string | string[] | number, message?: string) {
    try {
      if (message == undefined) {
        assert.deepStrictEqual(value1, value2);
      } else {
        assert.deepStrictEqual(value1, value2, message);
      }
    } catch (err) {
      throw err;
    }
  }

  /**
       * Checks if two values are not equal
       * ```js
       *Assert.notDeepEqual(x, z,"Values are equal");
       * ```
       * @param {string | string[] | number} value1 Specifies the first value to be compared
       * @param {string | string[] | number} value2 Specifies the second value to be compared
       * @param {String} message Specifies the error message to be assigned to the AssertionError. If omitted, a default message is assigned
      */
  static async notDeepEqual(value1: string | string[] | number, value2: string | string[] | number, message?: string) {
    try {
      if (message == undefined) {
        assert.notDeepEqual(value1, value2);
      } else {
        assert.notDeepEqual(value1, value2, message);
      }
    } catch (err) {
      throw err;
    }
  }

  /**
       * Checks if two values are not equal, using the strict not equal operator (!==)
       * ```js
       *Assert.notDeepStrictEqual(x, z,"Values are equal");
       * ```
       * @param {string | string[] | number} value1 Specifies the first value to be compared
       * @param {string | string[] | number} value2 Specifies the second value to be compared
       * @param {String} message Specifies the error message to be assigned to the AssertionError. If omitted, a default message is assigned
      */
  static async notDeepStrictEqual(value1: string | string[] | number, value2: string | string[] | number, message?: string) {
    try {
      if (message == undefined) {
        assert.notDeepStrictEqual(value1, value2);
      } else {
        assert.notDeepStrictEqual(value1, value2, message);
      }
    } catch (err) {
      throw err;
    }
  }

  /**
       * Throws an Assertion Error
       * ```js
       *Assert.fail()
       * ```
      */
  static async fail() {
    assert.fail();
  }
}