import { expect, test } from "../fixtures";
import { generateRandomTestUser } from "../helpers";
import { AuthPage } from "../pages/auth";

test.describe
  .serial("Guest Session", () => {
    test("Authenticate as guest user when a new session is loaded", async ({
      page,
    }) => {
      const response = await page.goto("/");

      if (!response) {
        throw new Error("Failed to load page");
      }

      let request: ReturnType<typeof response.request> | null =
        response.request();

      const chain: string[] = [];

      while (request) {
        chain.unshift(request.url());
        request = request.redirectedFrom();
      }

      expect(chain).toEqual([
        "http://localhost:3000/",
        "http://localhost:3000/api/auth/guest?redirectUrl=http%3A%2F%2Flocalhost%3A3000%2F",
        "http://localhost:3000/",
      ]);
    });

    test("Log out is not available for guest users", async ({ page }) => {
      await page.goto("/");

      const sidebarToggleButton = page.getByTestId("sidebar-toggle-button");
      await sidebarToggleButton.click();

      const userNavButton = page.getByTestId("user-nav-button");
      await expect(userNavButton).toBeVisible();

      await userNavButton.click();
      const userNavMenu = page.getByTestId("user-nav-menu");
      await expect(userNavMenu).toBeVisible();

      const authMenuItem = page.getByTestId("user-nav-item-auth");
      await expect(authMenuItem).toContainText("Login to your account");
    });

    test("Do not authenticate as guest user when an existing non-guest session is active", async ({
      adaContext,
    }) => {
      const response = await adaContext.page.goto("/");

      if (!response) {
        throw new Error("Failed to load page");
      }

      let request: ReturnType<typeof response.request> | null =
        response.request();

      const chain: string[] = [];

      while (request) {
        chain.unshift(request.url());
        request = request.redirectedFrom();
      }

      expect(chain).toEqual(["http://localhost:3000/"]);
    });

    test("Allow navigating to /login as guest user", async ({ page }) => {
      await page.goto("/login");
      await page.waitForURL("/login");
      await expect(page).toHaveURL("/login");
    });

    test("Allow navigating to /register as guest user", async ({ page }) => {
      await page.goto("/register");
      await page.waitForURL("/register");
      await expect(page).toHaveURL("/register");
    });

    test("Do not show email in user menu for guest user", async ({ page }) => {
      await page.goto("/");

      const sidebarToggleButton = page.getByTestId("sidebar-toggle-button");
      await sidebarToggleButton.click();

      const userEmail = page.getByTestId("user-email");
      await expect(userEmail).toContainText("Guest");
    });
  });

test.describe
  .serial("Login and Registration", () => {
    let authPage: AuthPage;

    const testUser = generateRandomTestUser();

    test.beforeEach(({ page }) => {
      authPage = new AuthPage(page);
    });

    test("Register new account", async () => {
      await authPage.register(testUser.email, testUser.password);
      await authPage.expectToastToContain("Account created successfully!");
    });

    test("Register new account with existing email", async () => {
      await authPage.register(testUser.email, testUser.password);
      await authPage.expectToastToContain("Account already exists!");
    });

    test("Log into account that exists", async ({ page }) => {
      await authPage.login(testUser.email, testUser.password);

      await page.waitForURL("/");
      await expect(page.getByPlaceholder("Send a message...")).toBeVisible();
    });

    test("Display user email in user menu", async ({ page }) => {
      await authPage.login(testUser.email, testUser.password);

      await page.waitForURL("/");
      await expect(page.getByPlaceholder("Send a message...")).toBeVisible();

      const userEmail = await page.getByTestId("user-email");
      await expect(userEmail).toHaveText(testUser.email);
    });

    test("Log out as non-guest user", async () => {
      await authPage.logout(testUser.email, testUser.password);
    });

    test("Do not force create a guest session if non-guest session already exists", async ({
      page,
    }) => {
      await authPage.login(testUser.email, testUser.password);
      await page.waitForURL("/");

      const userEmail = await page.getByTestId("user-email");
      await expect(userEmail).toHaveText(testUser.email);

      await page.goto("/api/auth/guest");
      await page.waitForURL("/");

      const updatedUserEmail = await page.getByTestId("user-email");
      await expect(updatedUserEmail).toHaveText(testUser.email);
    });

    test("Log out is available for non-guest users", async ({ page }) => {
      await authPage.login(testUser.email, testUser.password);
      await page.waitForURL("/");

      authPage.openSidebar();

      const userNavButton = page.getByTestId("user-nav-button");
      await expect(userNavButton).toBeVisible();

      await userNavButton.click();
      const userNavMenu = page.getByTestId("user-nav-menu");
      await expect(userNavMenu).toBeVisible();

      const authMenuItem = page.getByTestId("user-nav-item-auth");
      await expect(authMenuItem).toContainText("Sign out");
    });

    test("Do not navigate to /register for non-guest users", async ({
      page,
    }) => {
      await authPage.login(testUser.email, testUser.password);
      await page.waitForURL("/");

      await page.goto("/register");
      await expect(page).toHaveURL("/");
    });

    test("Do not navigate to /login for non-guest users", async ({ page }) => {
      await authPage.login(testUser.email, testUser.password);
      await page.waitForURL("/");

      await page.goto("/login");
      await expect(page).toHaveURL("/");
    });

    test("Invalidate the previous browser session after a second login", async ({
      browser,
      page,
    }) => {
      const isolatedUser = generateRandomTestUser();
      const secondaryContext = await browser.newContext();
      const secondaryPage = await secondaryContext.newPage();
      const primaryAuthPage = new AuthPage(page);
      const secondaryAuthPage = new AuthPage(secondaryPage);

      try {
        await primaryAuthPage.register(
          isolatedUser.email,
          isolatedUser.password
        );
        await primaryAuthPage.expectToastToContain(
          "Account created successfully!"
        );
        await page.waitForURL("/");

        const beforeInvalidation = await page
          .context()
          .request.get("/api/user/account-center");
        expect(beforeInvalidation.status()).toBe(200);

        await secondaryAuthPage.login(
          isolatedUser.email,
          isolatedUser.password
        );
        await secondaryPage.waitForURL("/");

        const afterInvalidation = await page
          .context()
          .request.get("/api/user/account-center");
        expect(afterInvalidation.status()).toBe(401);

        await page.goto("/login");
        await expect(page).toHaveURL("/login");
      } finally {
        await secondaryContext.close();
      }
    });
  });