// route.test.ts
import { describe, it, expect, beforeEach } from "vitest";
import { route, Routes } from "./route";

function matchesCurrentPathTest(
  location: string,
  testRoute: string,
  result: boolean
) {
  it(`matchesCurrentPath renvoie ${result} si location vaut ${location} et route vaut ${testRoute}`, () => {
    window.history.pushState({}, "", location);
    Routes.register({ page: testRoute });
    expect(route("page").matchesCurrentPath()).toBe(result);
  });
}

describe("Route", () => {
  // Avant chaque test, on réinitialise l'URL et les routes enregistrées
  beforeEach(() => {
    window.history.back();
    // On positionne l'URL par défaut sur la racine
    window.history.pushState({}, "", "/");
    // On "réinitialise" les routes en enregistrant un objet vide (pour éviter des interférences entre tests)
    Routes.register({}, "");
  });

  describe("Méthodes de Route", () => {
    //ex : matchesCurrentPathTest(location, testedRoute, expectedResult);
    matchesCurrentPathTest("/pageA", "/pageB", false);
    matchesCurrentPathTest("#page", "/", false);
    matchesCurrentPathTest("/page", "/", false);
    matchesCurrentPathTest("/", "/page", false);
    matchesCurrentPathTest("/", "#page", false);
    matchesCurrentPathTest("/a/b/page", "/page", true);
    matchesCurrentPathTest("/page", "a/b/page", false);
    matchesCurrentPathTest("/page", "/page", true);
    matchesCurrentPathTest("/page/124", "/page/:id", true);
    matchesCurrentPathTest("/page", "/page/:id", false);
    //Optionalité des paramètres
    matchesCurrentPathTest("/page/", "/page/(:id)", true);
    matchesCurrentPathTest("/page/1234", "/page/(:id)", true);
    //
    matchesCurrentPathTest("/page", "/page/a/:id", false);
    //
    //Le match ne pas en compter la query string
    //
    matchesCurrentPathTest("/page?query1=hey&query2=hello", "/page", true);

    return;
    it("fill remplace les paramètres dynamiques de la route", () => {
      Routes.register({ user: "/user/:id" });
      const testedRoute = route("user");
      testedRoute.fill({ id: "123" });
      expect(route.toString()).toBe("/user/123");
    });

    it("query ajoute des paramètres de requête", () => {
      Routes.register({ home: "/home" });
      const testedRoute = route("home");
      testedRoute.query({ foo: "bar" });
      // On vérifie que le résultat contient bien le paramètre "foo=bar"
      expect(testedRoute.toString()).toMatch(/\?foo=bar/);
    });

    it("hash ajoute un fragment à l'URL", () => {
      Routes.register({ home: "/home" });
      const testedRoute = route("home");
      testedRoute.hash("section");
      expect(testedRoute.toString()).toMatch(/#section$/);
    });

    it("appendPath ajoute un segment de chemin", () => {
      Routes.register({ home: "/home" });
      const testedRoute = route("home");
      testedRoute.appendPath("profile");
      expect(testedRoute.toString()).toBe("/home/profile");
    });

    it("hasHash et getHash détectent et renvoient le hash de l'URL", () => {
      Routes.register({ home: "/home" });
      const testedRoute = route("home");
      testedRoute.hash("section");
      expect(testedRoute.hasHash()).toBe(true);
      expect(testedRoute.getHash()).toBe("#section");
    });

    it("hasSameBaseAs retourne true pour des routes ayant la même base", () => {
      Routes.register({ home: "/home" });
      const testedRoute1 = route("home");
      const testedRoute2 = route("home");
      // On ajoute des éléments différents qui n'influenceront pas la base (pathname)
      testedRoute1.query({ foo: "bar" });
      testedRoute2.hash("section");
      expect(testedRoute1.hasSameBaseAs(testedRoute2)).toBe(true);
    });

    it("hasSameBaseAs retourne false si les bases sont différentes ou si la route comparée est undefined", () => {
      Routes.register({ home: "/home", about: "/about" });
      const testedRoute1 = route("home");
      const testedRoute2 = route("about");
      expect(testedRoute1.hasSameBaseAs(testedRoute2)).toBe(false);
      expect(testedRoute1.hasSameBaseAs(undefined as any)).toBe(false);
    });

    it("goTo modifie window.location.href", () => {
      // Sauvegarde de la valeur originale de window.location
      const originalLocation = window.location;
      let hrefValue = "";
      // Création d'un objet factice pour window.location avec un getter et setter pour href
      const fakeLocation = {
        get href() {
          return hrefValue;
        },
        set href(val: string) {
          hrefValue = val;
        },
        origin: "http://localhost",
      };

      // Redéfinition de window.location avec notre objet factice
      Object.defineProperty(window, "location", {
        configurable: true,
        enumerable: true,
        value: fakeLocation,
      });

      Routes.register({ home: "/home" });
      const testedRoute = route("home");
      testedRoute.goTo();

      expect(hrefValue).toBe("/home");

      // Restauration de window.location
      Object.defineProperty(window, "location", {
        configurable: true,
        enumerable: true,
        value: originalLocation,
      });
    });
  });
  /*
  describe("Méthodes statiques de Routes", () => {
    it("Routes.get renvoie la route correcte avec propertyMap", () => {
      Routes.register({ user: "/user/:id" });
      const result = Routes.get("user", { propertyMap: { id: "456" } });
      expect(result).toBe("/user/456");
    });

    it("Routes.get renvoie la route correcte avec query et hash", () => {
      Routes.register({ home: "/home" });
      const result = Routes.get("home", {
        query: { foo: "bar" },
        hash: "section",
      });
      expect(result).toMatch(/\?foo=bar/);
      expect(result).toMatch(/#section$/);
    });

    it("fillURLPattern remplit correctement une URL avec paramètres", () => {
      const filled = Routes.fillURLPattern("/user/:id", { id: "789" });
      expect(filled).toBe("/user/789");
    });
  });
  */
});