export default defineUnlistedScript(() => {
  const printError =
    "InstallTrigger" in window // detect Firefox
      ? (e) => e.message + "\n" + e.stack
      : (e) => e.stack || e.message;

  function printString(arg) {
    if (arg === undefined) {
      return "undefined";
    }
    if (arg === null) {
      return "null";
    }
    if (arg instanceof Error) {
      return printError(arg);
    }
    if (Array.isArray(arg)) {
      return `Array(${arg.length})`;
    }
    return String(arg);
  }

  function printFloat(arg) {
    if (typeof arg !== "number") return "NaN";
    return arg.toString();
  }

  function printInt(arg) {
    if (typeof arg !== "number") return "NaN";
    return Math.floor(arg).toString();
  }

  function printObject(arg) {
    if (arg === undefined) {
      return "undefined";
    }
    if (arg === null) {
      return "null";
    }
    if (arg instanceof Error) {
      return printError(arg);
    }
    if (Array.isArray(arg)) {
      const length = arg.length;
      const values = arg.slice(0, 10).map(printString).join(", ");
      return `Array(${length})[${values}]`;
    }
    if (typeof arg === "object") {
      const res = [];
      let i = 0;
      for (const k in arg) {
        if (++i === 10) {
          break;
        }
        const v = arg[k];
        res.push(k + ": " + printString(v));
      }
      return "{" + res.join(", ") + "}";
    }
    return arg.toString();
  }

  function printf(args) {
    if (typeof args[0] === "string") {
      args.unshift(
        args.shift().replace(/%(o|s|f|d|i)/g, (s, t) => {
          const arg = args.shift();
          if (arg === undefined) return s;
          switch (t) {
            case "o":
              return printObject(arg);
            case "s":
              return printString(arg);
            case "f":
              return printFloat(arg);
            case "d":
            case "i":
              return printInt(arg);
            default:
              return s;
          }
        }),
      );
    }
    return args.map(printObject).join(" ");
  }

  const consoleMethods = ["log", "info", "warn", "error", "debug", "assert"];

  const patchConsole = (console, ctx) => {
    if (window.revokeSpotPatch || window.__or_proxy_revocable) {
      return;
    }
    let n = 0;
    const reset = () => {
      n = 0;
    };
    let int = setInterval(reset, 1000);

    const sendConsoleLog = (level, args) => {
      const msg = printf(args);
      const truncated =
        msg.length > 5000 ? `Truncated: ${msg.slice(0, 5000)}...` : msg;
      const logs = [{ level, msg: truncated, time: Date.now() }];
      window.postMessage({ type: "ort:bump-logs", logs }, "*");
    };

    const handler = (level) => ({
      apply: function (target, thisArg, argumentsList) {
        Reflect.apply(target, ctx, argumentsList);
        n = n + 1;
        if (n > 10) {
          return;
        } else {
          sendConsoleLog(level, argumentsList); // Pass the correct level
        }
      },
    });

    window.__or_proxy_revocable = [];
    consoleMethods.forEach((method) => {
      if (consoleMethods.indexOf(method) === -1) {
        return;
      }
      const fn = ctx.console[method];
      // is there any way to preserve the original console trace?
      const revProxy = Proxy.revocable(fn, handler(method));
      console[method] = revProxy.proxy;
      window.__or_proxy_revocable.push(revProxy);
    });

    return () => {
      clearInterval(int);
      window.__or_proxy_revocable.forEach((revocable) => {
        revocable.revoke();
      });
    };
  };

  window.addEventListener("message", (event) => {
    if (event.data.type === "injected:start") {
      if (!window.__or_revokeSpotPatch) {
        window.__or_revokeSpotPatch = patchConsole(console, window);
      }
    }
    if (event.data.type === "injected:stop") {
      if (window.__or_revokeSpotPatch) {
        window.__or_revokeSpotPatch();
        window.__or_revokeSpotPatch = null;
      }
    }
  });
});