/**
 * Campus home against every seeded sign-in flow.
 *
 * The picker in the profile menu is `SEEDED_FLOWS`. Campus has to honour what
 * each of those sessions hands over: role, granted apps, People / Courses /
 * Personnel (inside Your App), the console, Open as, and whether More from
 * Exxat can receive an app this campus does not license.
 */

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

import { SEEDED_FLOWS, flowSession } from "@/lib/login-flow"
import {
  DEFAULT_LOGIN_SESSION,
  getLoginSession,
  setLoginSession,
  type LoginSession,
} from "@/lib/login-session"
import { buildProductHomeInventory } from "@/lib/product-home"
import { canReadDirectory, isScopeFixed, isWorkspaceAdmin } from "@/lib/workspace-role"

import { splitCampusOwned } from "./campus-home"
import { openableDoors } from "./product-home-parts"

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

function activate(flowId: string, overrides: Partial<LoginSession> = {}) {
  const flow = SEEDED_FLOWS.find(entry => entry.id === flowId)
  if (!flow) throw new Error(`${flowId} is not a seeded flow`)
  const session = flowSession(flow)
  setLoginSession({
    ...DEFAULT_LOGIN_SESSION,
    products: session.products,
    showYourApp: session.showYourApp,
    showMoreFromExxat: session.showMoreFromExxat,
    role: session.role,
    opensAs: session.opensAs,
    administeredProgramIds: session.administeredProgramIds,
    ...overrides,
  })
}

function campus(parentId: string, childId: string) {
  const { owned, available } = buildProductHomeInventory([], [])
  const { onCampus, offCampus } = splitCampusOwned(
    owned,
    parentId,
    childId,
    getLoginSession().showMoreFromExxat,
  )
  return { owned, available, onCampus, offCampus }
}

function productsOf(cards: { product: string }[]): string[] {
  return cards.map(card => card.product)
}

beforeEach(() => {
  window.localStorage.clear()
})

describe("every seeded sign-in flow reaches Campus", () => {
  it("covers the ten flows in the profile menu", () => {
    expect(SEEDED_FLOWS.map(flow => flow.id)).toEqual([
      "direct",
      "product",
      "role",
      "role-faculty",
      "role-admin",
      "role-super-admin",
      "role-student",
      "role-student-two-apps",
      "role-student-admin",
      "role-exam-workspace",
    ])
  })
})

describe("Straight in, Admin, Super Admin", () => {
  it.each(["direct", "role-admin", "role-super-admin"] as const)(
    "%s: console and Directory, Exxat One leaves Your App at Public Health",
    flowId => {
      activate(flowId)

      expect(isWorkspaceAdmin()).toBe(true)
      expect(canReadDirectory()).toBe(true)
      expect(isScopeFixed()).toBe(false)

      const { onCampus, offCampus, owned } = campus(JHU.parent, JHU.publicHealth)

      expect(productsOf(owned)).toEqual([
        "exxat-prism",
        "exxat-one-schools",
        "exxat-curriculum-mapping",
        "exxat-compliance",
        "exxat-admin",
      ])
      expect(productsOf(onCampus)).toEqual([
        "exxat-prism",
        "exxat-curriculum-mapping",
        "exxat-compliance",
        "exxat-admin",
      ])
      expect(productsOf(offCampus)).toEqual(["exxat-one-schools"])
    },
  )

  it("keeps Exxat One on campus at Nursing, which it licenses", () => {
    activate("role-admin")
    const { offCampus, onCampus } = campus(JHU.parent, JHU.nursing)

    expect(productsOf(onCampus)).toEqual([
      "exxat-prism",
      "exxat-one-schools",
      "exxat-curriculum-mapping",
      "exxat-compliance",
      "exxat-admin",
    ])
    expect(offCampus).toEqual([])
  })
})

describe("Faculty", () => {
  it("hides the console, keeps Directory, and still moves Exxat One at Public Health", () => {
    activate("role-faculty")

    expect(isWorkspaceAdmin()).toBe(false)
    expect(canReadDirectory()).toBe(true)
    expect(isScopeFixed()).toBe(false)

    const { onCampus, offCampus, owned } = campus(JHU.parent, JHU.publicHealth)

    expect(productsOf(owned)).toEqual([
      "exxat-prism",
      "exxat-one-schools",
      "exxat-curriculum-mapping",
      "exxat-compliance",
    ])
    expect(productsOf(onCampus)).toEqual([
      "exxat-prism",
      "exxat-curriculum-mapping",
      "exxat-compliance",
    ])
    expect(productsOf(offCampus)).toEqual(["exxat-one-schools"])
  })
})

describe("Student", () => {
  it("fixes scope, hides Directory and the console, and can still move Exxat One", () => {
    activate("role-student")

    expect(isWorkspaceAdmin()).toBe(false)
    expect(canReadDirectory()).toBe(false)
    expect(isScopeFixed()).toBe(true)

    const { onCampus, offCampus } = campus(JHU.parent, JHU.publicHealth)

    expect(productsOf(onCampus)).toEqual([
      "exxat-prism",
      "exxat-curriculum-mapping",
      "exxat-compliance",
    ])
    expect(productsOf(offCampus)).toEqual(["exxat-one-schools"])
  })
})

describe("Student with two apps", () => {
  it("keeps both apps in Your App because More from Exxat is hidden", () => {
    activate("role-student-two-apps")

    expect(canReadDirectory()).toBe(false)
    expect(isWorkspaceAdmin()).toBe(false)
    expect(isScopeFixed()).toBe(true)

    const { onCampus, offCampus, owned, available } = campus(
      JHU.parent,
      JHU.publicHealth,
    )

    expect(productsOf(owned)).toEqual(["exxat-prism", "exxat-one-schools"])
    expect(productsOf(onCampus)).toEqual(["exxat-prism", "exxat-one-schools"])
    expect(offCampus).toEqual([])
    expect(available.some(card => card.product === "exxat-exam-management")).toBe(
      true,
    )
    expect(owned.some(card => card.product === "exxat-admin")).toBe(false)
  })
})

describe("Student with admin access", () => {
  it("asks Open as on school-family rows and does not move apps off campus", () => {
    activate("role-student-admin")

    expect(isWorkspaceAdmin()).toBe(false)
    expect(canReadDirectory()).toBe(false)
    expect(isScopeFixed()).toBe(true)

    const { onCampus, offCampus, owned } = campus(JHU.parent, JHU.publicHealth)
    const prism = owned.find(card => card.product === "exxat-prism")
    const one = owned.find(card => card.product === "exxat-one-schools")
    if (!prism || !one) throw new Error("expected both school-family apps")

    expect(productsOf(onCampus)).toEqual([
      "exxat-prism",
      "exxat-one-schools",
      "exxat-curriculum-mapping",
      "exxat-compliance",
    ])
    expect(offCampus).toEqual([])
    expect(openableDoors(prism)).toEqual(["student", "member"])
    expect(openableDoors(one)).toEqual(["student", "member"])
  })
})

describe("Exam coordinator", () => {
  it("grants Exam Management only, keeps Directory, and hides the console", () => {
    activate("role-exam-workspace")

    expect(isWorkspaceAdmin()).toBe(false)
    expect(canReadDirectory()).toBe(true)
    expect(isScopeFixed()).toBe(false)

    const { owned, available } = campus(JHU.parent, JHU.nursing)

    expect(productsOf(owned)).toEqual(["exxat-exam-management"])
    expect(owned.some(card => card.product === "exxat-admin")).toBe(false)
    expect(available.some(card => card.product === "exxat-prism")).toBe(true)
  })
})

describe("Pick an app", () => {
  it("starts as the workspace administrator, like Straight in", () => {
    activate("product")
    expect(isWorkspaceAdmin()).toBe(true)
    expect(productsOf(campus(JHU.parent, JHU.publicHealth).offCampus)).toEqual([
      "exxat-one-schools",
    ])
  })

  it("after Clinical Education: Public Health keeps that app on campus", () => {
    activate("product", { products: ["exxat-prism"] })
    const { onCampus, offCampus, owned } = campus(JHU.parent, JHU.publicHealth)

    expect(productsOf(owned)).toEqual(["exxat-prism", "exxat-admin"])
    expect(productsOf(onCampus)).toEqual(["exxat-prism", "exxat-admin"])
    expect(offCampus).toEqual([])
  })

  it("after Exxat One: Public Health moves that app to More from Exxat", () => {
    activate("product", { products: ["exxat-one-schools"] })
    const { onCampus, offCampus } = campus(JHU.parent, JHU.publicHealth)

    expect(productsOf(onCampus)).toEqual(["exxat-admin"])
    expect(productsOf(offCampus)).toEqual(["exxat-one-schools"])
  })
})

describe("Pick a role", () => {
  it("starts as the workspace administrator until a branch answers", () => {
    activate("role")
    expect(isWorkspaceAdmin()).toBe(true)
    expect(canReadDirectory()).toBe(true)
  })

  it("after Student: same campus gates as the Student seed", () => {
    activate("role", { role: "student" })
    expect(canReadDirectory()).toBe(false)
    expect(isScopeFixed()).toBe(true)
    expect(productsOf(campus(JHU.parent, JHU.publicHealth).offCampus)).toEqual([
      "exxat-one-schools",
    ])
  })

  it("after School: Faculty campus, without the console", () => {
    activate("role", { role: "member" })
    expect(isWorkspaceAdmin()).toBe(false)
    expect(canReadDirectory()).toBe(true)
    expect(productsOf(campus(JHU.parent, JHU.publicHealth).onCampus)).toEqual([
      "exxat-prism",
      "exxat-curriculum-mapping",
      "exxat-compliance",
    ])
  })
})