/**
 * Tests to ensure page metadata stays in sync with leftnav configuration
 * This catches issues when leftnav structure changes but page_utils/page_metadata aren't updated
 */

import { describe, it, expect } from "vitest";
import { getAvailablePages } from "./page_utils";
import { menuGroups } from "./leftnav";
import { pageDescriptions } from "./page_metadata";
import { internalUserRoles } from "@/utils/roles";

/**
 * Check if a page is accessible to internal users
 * A page is accessible if:
 * 1. It has no role restrictions, OR
 * 2. Its roles include at least one internal user role
 */
const isPageAccessibleToInternalUsers = (pageRoles?: string[]): boolean => {
  if (!pageRoles || pageRoles.length === 0) {
    return true; // No role restrictions
  }

  // Check if any of the page's roles match internal user roles
  return pageRoles.some((role) => internalUserRoles.includes(role));
};

describe("Page Utils - LeftNav Sync", () => {
  it("should return all pages from leftnav configuration", () => {
    const availablePages = getAvailablePages();

    // Should have pages
    expect(availablePages.length).toBeGreaterThan(0);

    // Each page should have required fields
    availablePages.forEach((page) => {
      expect(page).toHaveProperty("page");
      expect(page).toHaveProperty("label");
      expect(page).toHaveProperty("group");
      expect(page).toHaveProperty("description");
      expect(typeof page.page).toBe("string");
      expect(typeof page.label).toBe("string");
      expect(typeof page.group).toBe("string");
      expect(typeof page.description).toBe("string");
    });
  });

  it("should include all navigable pages from menuGroups", () => {
    const availablePages = getAvailablePages();
    const availablePageKeys = availablePages.map((p) => p.page);

    // Collect all page keys from menuGroups (excluding parent containers and pages not accessible to internal users)
    const menuPageKeys: string[] = [];
    const excludedParents = ["tools", "experimental", "settings"];

    menuGroups.forEach((group) => {
      group.items.forEach((item) => {
        if (item.page && !excludedParents.includes(item.page) && isPageAccessibleToInternalUsers(item.roles)) {
          menuPageKeys.push(item.page);
        }

        // Add children (only if accessible to internal users)
        if (item.children) {
          item.children.forEach((child) => {
            if (isPageAccessibleToInternalUsers(child.roles)) {
              menuPageKeys.push(child.page);
            }
          });
        }
      });
    });

    // Every menu page accessible to internal users should be in available pages
    menuPageKeys.forEach((pageKey) => {
      expect(availablePageKeys, `Page "${pageKey}" from menuGroups should be in getAvailablePages() output`).toContain(
        pageKey,
      );
    });
  });

  it("should not include parent container pages (tools, experimental, settings)", () => {
    const availablePages = getAvailablePages();
    const availablePageKeys = availablePages.map((p) => p.page);

    const excludedParents = ["tools", "experimental", "settings"];

    excludedParents.forEach((parent) => {
      expect(availablePageKeys, `Parent container "${parent}" should not be in available pages`).not.toContain(parent);
    });
  });

  it("should have descriptions for all pages", () => {
    const availablePages = getAvailablePages();

    availablePages.forEach((page) => {
      expect(page.description, `Page "${page.page}" should have a description`).toBeTruthy();

      expect(page.description, `Page "${page.page}" should not have placeholder description`).not.toBe(
        "No description available",
      );
    });
  });

  it("should have pageDescriptions entry for all navigable pages in menuGroups", () => {
    // Collect all page keys from menuGroups
    const menuPageKeys: string[] = [];
    const excludedParents = ["tools", "experimental", "settings"];

    menuGroups.forEach((group) => {
      group.items.forEach((item) => {
        if (item.page && !excludedParents.includes(item.page)) {
          menuPageKeys.push(item.page);
        }

        if (item.children) {
          item.children.forEach((child) => {
            menuPageKeys.push(child.page);
          });
        }
      });
    });

    // Every menu page should have a description
    const missingDescriptions: string[] = [];
    menuPageKeys.forEach((pageKey) => {
      if (!pageDescriptions[pageKey]) {
        missingDescriptions.push(pageKey);
      }
    });

    expect(
      missingDescriptions,
      `These pages are missing descriptions in page_metadata.ts: ${missingDescriptions.join(", ")}`,
    ).toHaveLength(0);
  });

  it("should not have orphaned descriptions (descriptions for pages not in menuGroups)", () => {
    // Collect all page keys from menuGroups
    const menuPageKeys: string[] = [];
    const excludedParents = ["tools", "experimental", "settings"];

    menuGroups.forEach((group) => {
      group.items.forEach((item) => {
        if (item.page && !excludedParents.includes(item.page)) {
          menuPageKeys.push(item.page);
        }

        if (item.children) {
          item.children.forEach((child) => {
            menuPageKeys.push(child.page);
          });
        }
      });
    });

    // Check for descriptions that don't match any menu page
    const orphanedDescriptions: string[] = [];
    Object.keys(pageDescriptions).forEach((descKey) => {
      if (!menuPageKeys.includes(descKey)) {
        orphanedDescriptions.push(descKey);
      }
    });

    expect(
      orphanedDescriptions,
      `These descriptions don't match any page in menuGroups: ${orphanedDescriptions.join(", ")}. Remove them or add the pages to leftnav.`,
    ).toHaveLength(0);
  });

  it("should have proper group hierarchy for nested pages", () => {
    const availablePages = getAvailablePages();

    // Find pages that should be nested (children of Tools, Experimental, Settings)
    const nestedPages = availablePages.filter((page) => page.group.includes(" > "));

    // Each nested page should have parent > child format
    nestedPages.forEach((page) => {
      const parts = page.group.split(" > ");
      expect(parts.length, `Nested page "${page.page}" should have exactly 2 parts in group hierarchy`).toBe(2);

      // Parent should be one of the group labels
      const parentGroup = parts[0];
      const groupLabels = menuGroups.map((g) => g.groupLabel);
      expect(
        groupLabels,
        `Parent group "${parentGroup}" for page "${page.page}" should be a valid group label`,
      ).toContain(parentGroup);
    });
  });

  it("should have unique page keys", () => {
    const availablePages = getAvailablePages();
    const pageKeys = availablePages.map((p) => p.page);
    const uniquePageKeys = new Set(pageKeys);

    expect(pageKeys.length, "All page keys should be unique (no duplicates)").toBe(uniquePageKeys.size);
  });

  it("should match the structure expected by PageVisibilitySettings component", () => {
    const availablePages = getAvailablePages();

    // Group pages by their group (same logic as in PageVisibilitySettings)
    const grouped: Record<string, typeof availablePages> = {};
    availablePages.forEach((page) => {
      if (!grouped[page.group]) {
        grouped[page.group] = [];
      }
      grouped[page.group].push(page);
    });

    // Should have multiple groups
    expect(Object.keys(grouped).length).toBeGreaterThan(1);

    // Each group should have at least one page
    Object.entries(grouped).forEach(([groupName, pages]) => {
      expect(pages.length, `Group "${groupName}" should have at least one page`).toBeGreaterThan(0);
    });
  });
});