import assert from "node:assert";
import { describe, it } from "node:test";
import { isErrorInstance } from "./isErrorInstance";

describe("isErrorInstance", () => {

  it("returns true for Error instance", () => {
    const error = new Error("Test error");
    assert.ok(isErrorInstance(error));
  });

  it("returns true for TypeError instance", () => {
    const error = new TypeError("Type error");
    assert.ok(isErrorInstance(error));
  });

  it("returns true for RangeError instance", () => {
    const error = new RangeError("Range error");
    assert.ok(isErrorInstance(error));
  });

  it("returns true for ReferenceError instance", () => {
    const error = new ReferenceError("Reference error");
    assert.ok(isErrorInstance(error));
  });

  it("returns true for SyntaxError instance", () => {
    const error = new SyntaxError("Syntax error");
    assert.ok(isErrorInstance(error));
  });

  it("returns true for custom Error subclass", () => {
    class CustomError extends Error {

      constructor(message: string) {
        super(message);
        this.name = "CustomError";
      }

    }
    const error = new CustomError("Custom error");
    assert.ok(isErrorInstance(error));
  });

  it("returns false for string", () => {
    assert.ok(!isErrorInstance("error string"));
  });

  it("returns false for number", () => {
    assert.ok(!isErrorInstance(123));
  });

  it("returns false for boolean", () => {
    assert.ok(!isErrorInstance(true));
  });

  it("returns false for null", () => {
    assert.ok(!isErrorInstance(null));
  });

  it("returns false for undefined", () => {
    assert.ok(!isErrorInstance(undefined));
  });

  it("returns false for plain object", () => {
    assert.ok(!isErrorInstance({ message: "error" }));
  });

  it("returns false for object with Error-like properties", () => {
    const fakeError = {
      message: "I look like an error",
      stack: "fake stack trace",
      name: "FakeError",
    };
    assert.ok(!isErrorInstance(fakeError));
  });

  it("returns false for array", () => {
    assert.ok(!isErrorInstance([]));
  });

  it("returns false for function", () => {
    assert.ok(!isErrorInstance(() => {}));
  });

  it("returns false for Date instance", () => {
    assert.ok(!isErrorInstance(new Date()));
  });

  it("returns false for RegExp instance", () => {
    assert.ok(!isErrorInstance(/test/));
  });

  it("has correct TypeScript type narrowing", () => {
    const value: unknown = new Error("test");

    if (isErrorInstance(value)) {
      // TypeScript should recognize value as Error here
      const message: string = value.message;
      assert.strictEqual<string>(message, "test");
    }
  });

});