import { describe, expect, it } from "vitest"

import type { Product } from "@/contexts/product-context"
import type { ProductHomeCard } from "@/lib/product-home"
import { productLicensesScope } from "@/lib/scope-switcher"

import { campusRecordCards, splitCampusOwned } from "./campus-home"

const JHU = { parent: "jhu", medicine: "som", nursing: "son", publicHealth: "sph" }

function card(product: Product): ProductHomeCard {
  return {
    product,
    label: product,
    tagline: "",
    scopeLabel: "",
    icon: "fa-grid-2",
    scoped: true,
    entitled: true,
    brandColor: "var(--brand-color)",
    slug: product.replace(/^exxat-/, ""),
  }
}

const OWNED = [
  card("exxat-prism"),
  card("exxat-one-schools"),
  card("exxat-exam-management"),
  card("exxat-personnel"),
]

describe("productLicensesScope", () => {
  it("is true for an unrestricted school product at any program", () => {
    expect(productLicensesScope("exxat-prism", JHU.parent, JHU.publicHealth)).toBe(true)
  })

  it("is false when the product does not serve that program", () => {
    expect(productLicensesScope("exxat-exam-management", JHU.parent, JHU.medicine)).toBe(
      false,
    )
    expect(productLicensesScope("exxat-one-schools", JHU.parent, JHU.publicHealth)).toBe(
      false,
    )
  })

  it("is false for a site-family product, which has no program", () => {
    expect(productLicensesScope("exxat-personnel", JHU.parent, JHU.nursing)).toBe(false)
  })
})

describe("splitCampusOwned", () => {
  it("keeps every owned app when More from Exxat is hidden", () => {
    const { onCampus, offCampus } = splitCampusOwned(
      OWNED,
      JHU.parent,
      JHU.publicHealth,
      false,
    )

    expect(onCampus.map(c => c.product)).toEqual(OWNED.map(c => c.product))
    expect(offCampus).toEqual([])
  })

  it("moves school-family apps that do not serve Public Health to More from Exxat", () => {
    const { onCampus, offCampus } = splitCampusOwned(
      OWNED,
      JHU.parent,
      JHU.publicHealth,
      true,
    )

    expect(onCampus.map(c => c.product)).toEqual(["exxat-prism", "exxat-personnel"])
    expect(offCampus.map(c => c.product)).toEqual([
      "exxat-one-schools",
      "exxat-exam-management",
    ])
  })

  it("keeps Exam Management on campus when Nursing is selected", () => {
    const { onCampus, offCampus } = splitCampusOwned(
      OWNED,
      JHU.parent,
      JHU.nursing,
      true,
    )

    expect(onCampus.map(c => c.product)).toEqual([
      "exxat-prism",
      "exxat-one-schools",
      "exxat-exam-management",
      "exxat-personnel",
    ])
    expect(offCampus).toEqual([])
  })

  it("keeps Compliance on campus at Medicine, which its grant does not serve", () => {
    const owned = [...OWNED, card("exxat-compliance"), card("exxat-curriculum-mapping")]
    const { onCampus, offCampus } = splitCampusOwned(
      owned,
      JHU.parent,
      JHU.medicine,
      true,
    )

    expect(onCampus.map(c => c.product)).toEqual([
      "exxat-prism",
      "exxat-one-schools",
      "exxat-personnel",
      "exxat-compliance",
      "exxat-curriculum-mapping",
    ])
    expect(offCampus.map(c => c.product)).toEqual(["exxat-exam-management"])
  })

  it("leaves the list unchanged when no program is chosen yet", () => {
    const { onCampus, offCampus } = splitCampusOwned(OWNED, null, null, true)

    expect(onCampus).toEqual(OWNED)
    expect(offCampus).toEqual([])
  })
})

describe("campusRecordCards", () => {
  it("is the three shared record hubs as Open cards", () => {
    const cards = campusRecordCards()

    expect(cards.map(c => c.label)).toEqual([
      "People Management",
      "Course Management",
      "Program Management",
    ])
    expect(cards.every(c => Boolean(c.href))).toBe(true)
    expect(cards.every(c => c.scoped === false)).toBe(true)
  })

  it("does not duplicate Course Management when that product is already in Your App", () => {
    expect(campusRecordCards(["exxat-courses"]).map(c => c.product)).toEqual([
      "exxat-people",
      "exxat-programs",
    ])
  })

  // The Workspace list prints the name and nothing else. A queue length here
  // is a number the reader did not ask for and cannot act on from the home
  // page, so these cards arrive without one and the hub states it in context.
  it("carries no second line on a record", () => {
    for (const card of campusRecordCards()) {
      expect(card.tagline).toBe("")
    }
  })
})