import { describe, it, expect, beforeEach } from "vitest";
import router from "~/router/index";

describe("Router Integration Tests", () => {
  const testRoutes = [
    { path: "/", name: "home", lazyLoaded: false },
    { path: "/about", name: "about", lazyLoaded: true },
    { path: "/settings", name: "settings", lazyLoaded: true },
  ];

  beforeEach(async () => {
    await router.push("/");
    await router.isReady();
  });

  describe("General", () => {
    it("has hash history mode", () => {
      expect(router.options.history.base).toContain("#");
    });

    it("has 3 routes configured", () => {
      const routes = router.getRoutes();
      expect(routes).toHaveLength(3);
    });

    it("creates a router instance", () => {
      expect(router).toBeDefined();
      expect(router).toHaveProperty("currentRoute");
      expect(router).toHaveProperty("push");
      expect(router).toHaveProperty("replace");
    });

    it("does not have undefined routes", () => {
      expect(router.hasRoute("nonexistent")).toBe(false);
    });

    it("maintains navigation history", async () => {
      await router.push("/");
      await router.push("/about");

      expect(router.currentRoute.value.path).toBe("/about");

      router.back();
      await router.isReady();

      expect(router.back).toBeDefined();
    });

    it("handles programmatic navigation with replace", async () => {
      await router.push("/");
      await router.replace("/about");
      await router.isReady();

      expect(router.currentRoute.value.path).toBe("/about");
    });

    it("matches routes case-sensitively", () => {
      const routes = router.getRoutes();
      const upperCaseRoute = routes.find(route => route.path === "/ABOUT");

      expect(upperCaseRoute).toBeUndefined();
    });

    it("provides route metadata access", () => {
      const routes = router.getRoutes();

      for (const route of routes) {
        expect(route).toHaveProperty("path");
        expect(route).toHaveProperty("name");
        expect(route).toHaveProperty("meta");
      }
    });

    it("is ready after initialization", async () => {
      const ready = await router.isReady();

      // Note: isReady() returns void when resolved
      expect(ready).toBeUndefined();
    });

    it("handles navigation to current route", async () => {
      await router.push("/");

      try {
        await router.push("/");
      } catch (error: any) {
        expect(error.message).toContain("Avoided redundant navigation to current location");
      }
    });
  });

  for (const r of testRoutes) {
    describe(r.name, () => {
      it("has route", () => {
        const routes = router.getRoutes();
        const currentRoute = routes.find(route => route.path === r.path);

        expect(currentRoute).toBeDefined();
        expect(currentRoute?.name).toBe(r.name);
      });

      it("checks if route exists", () => {
        expect(router.hasRoute(r.name)).toBe(true);
      });

      it("navigates to route", async () => {
        await router.push(r.path);
        await router.isReady();

        expect(router.currentRoute.value.path).toBe(r.path);
        expect(router.currentRoute.value.name).toBe(r.name);
      });

      it("navigates using route name", async () => {
        await router.push({ name: r.name });
        await router.isReady();

        expect(router.currentRoute.value.name).toBe(r.name);
        expect(router.currentRoute.value.path).toBe(r.path);
      });

      it("resolves route correctly", () => {
        const resolved = router.resolve(r.path);

        expect(resolved.name).toBe(r.name);
        expect(resolved.path).toBe(r.path);
      });

      it("has (lazy) loaded component", () => {
        const routes = router.getRoutes();
        const currentRoute = routes.find(route => route.path === r.path);

        if (r.lazyLoaded) {
          expect(currentRoute?.components).toBeDefined();
        } else {
          expect(currentRoute?.components?.default).toBeDefined();
        }
      });
    });
  }
});