import test from "node:test";
import assert from "node:assert/strict";

import * as hashRouteTabs from "../src/utils/hashRouteTabs.mjs";
import { EXTENSION_ROUTE_NAME } from "../src/router/routeConstants.mjs";

const { createTabRouteLocation, getValidHashTab } = hashRouteTabs;

test("getValidHashTab returns the tab name for a valid route hash", () => {
  const validTabs = ["installed", "market", "mcp"];

  assert.equal(getValidHashTab("#market", validTabs), "market");
});

test("getValidHashTab rejects empty and unknown hashes", () => {
  const validTabs = ["installed", "market", "mcp"];

  assert.equal(getValidHashTab("", validTabs), null);
  assert.equal(getValidHashTab("#unknown", validTabs), null);
});

test("getValidHashTab uses the last hash segment when multiple hashes are present", () => {
  const validTabs = ["installed", "market", "mcp"];

  assert.equal(
    getValidHashTab("#/extension#foo#installed", validTabs),
    "installed",
  );
});

test("createTabRouteLocation preserves the current path and query", () => {
  const query = { open_config: "sample-plugin", page: "2" };
  const location = createTabRouteLocation(
    {
      path: "/extension",
      query,
    },
    "market",
  );

  assert.deepEqual(location, {
    path: "/extension",
    query: { open_config: "sample-plugin", page: "2" },
    hash: "#market",
  });
  assert.notEqual(location.query, query);
});

test("createTabRouteLocation falls back to the extension route name", () => {
  const location = createTabRouteLocation(undefined, "installed");

  assert.deepEqual(location, {
    name: EXTENSION_ROUTE_NAME,
    query: {},
    hash: "#installed",
  });
});

test("createTabRouteLocation prefers route name and preserves params", () => {
  const params = { pluginId: "demo-plugin" };
  const location = createTabRouteLocation(
    {
      name: "ExtensionDetails",
      path: "/extension/demo-plugin",
      params,
      query: { tab: "details" },
    },
    "market",
  );

  assert.deepEqual(location, {
    name: "ExtensionDetails",
    params: { pluginId: "demo-plugin" },
    query: { tab: "details" },
    hash: "#market",
  });
  assert.notEqual(location.params, params);
});

test("createTabRouteLocation omits params for path-based routes", () => {
  const params = { pluginId: "demo-plugin" };
  const location = createTabRouteLocation(
    {
      path: "/extension/demo-plugin",
      params,
    },
    "installed",
  );

  assert.deepEqual(location, {
    path: "/extension/demo-plugin",
    query: {},
    hash: "#installed",
  });
  assert.equal(location.params, undefined);
});

test("replaceTabRoute catches rejected router updates", async () => {
  assert.equal(typeof hashRouteTabs.replaceTabRoute, "function");

  const error = new Error("blocked");
  let logged;
  const router = {
    replace: async () => {
      throw error;
    },
  };
  const logger = {
    warn: (message, cause) => {
      logged = { message, cause };
    },
  };

  const result = await hashRouteTabs.replaceTabRoute(
    router,
    { name: EXTENSION_ROUTE_NAME, query: { page: "1" } },
    "installed",
    logger,
  );

  assert.equal(result, false);
  assert.deepEqual(logged, {
    message: "Failed to update extension tab route:",
    cause: error,
  });
});