import { TestConfiguration, mocks, structures } from "../../../../tests"

const licensing = mocks.pro.licensing
const quotas = mocks.pro.quotas

describe("/api/global/license", () => {
  const config = new TestConfiguration()

  async function createNonAdminUser() {
    const user = await config.createUser()
    await config.login(user)
    return user
  }

  async function createBuilderUser() {
    const user = await config.createUser(structures.users.builderUser())
    await config.login(user)
    return user
  }

  async function createCreatorUser() {
    const user = await config.createUser(
      structures.users.user({ builder: { creator: true } })
    )
    await config.login(user)
    return user
  }

  beforeAll(async () => {
    await config.beforeAll()
  })

  afterAll(async () => {
    await config.afterAll()
  })

  beforeEach(() => {
    mocks.licenses.useUnlimited()
  })

  afterEach(() => {
    jest.resetAllMocks()
  })

  describe("POST /api/global/license/refresh", () => {
    it("returns 200", async () => {
      const res = await config.api.license.refresh()
      expect(res.status).toBe(200)
      expect(licensing.cache.refresh).toHaveBeenCalledTimes(1)
    })
  })

  describe("GET /api/global/license/usage", () => {
    it("returns 200 + usage", async () => {
      const usage = structures.quotas.usage()
      quotas.getQuotaUsage.mockResolvedValue(usage)
      const res = await config.api.license.getUsage()
      expect(res.status).toBe(200)
      expect(res.body).toEqual(usage)
    })

    it("allows non-admin access", async () => {
      const user = await createNonAdminUser()
      const usage = structures.quotas.usage()
      quotas.getQuotaUsage.mockResolvedValue(usage)

      const res = await config.withUser(user, () =>
        config.api.license.getUsage()
      )

      expect(res.status).toBe(200)
      expect(res.body).toEqual(usage)
    })
  })

  describe("POST /api/global/license/key", () => {
    it("returns 200", async () => {
      const res = await config.api.license.activateLicenseKey({
        licenseKey: "licenseKey",
      })
      expect(res.status).toBe(200)
      expect(licensing.keys.activateLicenseKey).toHaveBeenCalledWith(
        "licenseKey"
      )
    })
  })

  describe("GET /api/global/license/key", () => {
    it("returns 404 when not found", async () => {
      const res = await config.api.license.getLicenseKey()
      expect(res.status).toBe(404)
    })

    it("allows builder access", async () => {
      const user = await createBuilderUser()
      licensing.keys.getLicenseKey.mockResolvedValue("licenseKey")

      const res = await config.withUser(user, () =>
        config.api.license.getLicenseKey()
      )

      expect(res.status).toBe(200)
      expect(res.body).toEqual({
        licenseKey: "*",
      })
    })

    it("allows creator access", async () => {
      const user = await createCreatorUser()
      licensing.keys.getLicenseKey.mockResolvedValue("licenseKey")

      const res = await config.withUser(user, () =>
        config.api.license.getLicenseKey()
      )

      expect(res.status).toBe(200)
      expect(res.body).toEqual({
        licenseKey: "*",
      })
    })

    it("returns 200 + license key", async () => {
      licensing.keys.getLicenseKey.mockResolvedValue("licenseKey")
      const res = await config.api.license.getLicenseKey()
      expect(res.status).toBe(200)
      expect(res.body).toEqual({
        licenseKey: "*",
      })
    })
  })

  describe("DELETE /api/global/license/key", () => {
    it("returns 204", async () => {
      const res = await config.api.license.deleteLicenseKey()
      expect(licensing.keys.deleteLicenseKey).toHaveBeenCalledTimes(1)
      expect(res.status).toBe(204)
    })
  })

  describe("POST /api/global/license/offline", () => {
    it("activates offline license", async () => {
      const res = await config.api.license.activateOfflineLicense({
        offlineLicenseToken: "offlineLicenseToken",
      })
      expect(
        licensing.offline.activateOfflineLicenseToken
      ).toHaveBeenCalledWith("offlineLicenseToken")
      expect(res.status).toBe(200)
    })
  })

  describe("GET /api/global/license/offline", () => {
    it("returns 404 when not found", async () => {
      const res = await config.api.license.getOfflineLicense()
      expect(res.status).toBe(404)
    })
    it("returns 200 + offline license token", async () => {
      licensing.offline.getOfflineLicenseToken.mockResolvedValue(
        "offlineLicenseToken"
      )
      const res = await config.api.license.getOfflineLicense()
      expect(res.status).toBe(200)
      expect(res.body).toEqual({
        offlineLicenseToken: "*",
      })
    })
  })

  describe("DELETE /api/global/license/offline", () => {
    it("returns 204", async () => {
      const res = await config.api.license.deleteOfflineLicense()
      expect(res.status).toBe(204)
      expect(licensing.offline.deleteOfflineLicenseToken).toHaveBeenCalledTimes(
        1
      )
    })
  })

  describe("GET /api/global/license/offline/identifier", () => {
    it("returns 200 + identifier base64", async () => {
      licensing.offline.getIdentifierBase64.mockResolvedValue("base64")
      const res = await config.api.license.getOfflineLicenseIdentifier()
      expect(res.status).toBe(200)
      expect(res.body).toEqual({
        identifierBase64: "base64",
      })
    })
  })

  describe("authorisation", () => {
    it.each([
      [
        "GET /api/global/license/key",
        () => config.api.license.getLicenseKey(),
        { message: "Admin/Builder user only endpoint.", status: 403 },
      ],
      [
        "POST /api/global/license/refresh",
        () => config.api.license.refresh(),
        config.adminOnlyResponse(),
      ],
      [
        "GET /api/global/install",
        () => config.api.license.getInstallInfo(),
        config.adminOnlyResponse(),
      ],
      [
        "POST /api/global/license/key",
        () =>
          config.api.license.activateLicenseKey({
            licenseKey: "licenseKey",
          }),
        config.adminOnlyResponse(),
      ],
      [
        "DELETE /api/global/license/key",
        () => config.api.license.deleteLicenseKey(),
        config.adminOnlyResponse(),
      ],
      [
        "POST /api/global/license/offline",
        () =>
          config.api.license.activateOfflineLicense({
            offlineLicenseToken: "offlineLicenseToken",
          }),
        config.adminOnlyResponse(),
      ],
      [
        "GET /api/global/license/offline",
        () => config.api.license.getOfflineLicense(),
        config.adminOnlyResponse(),
      ],
      [
        "DELETE /api/global/license/offline",
        () => config.api.license.deleteOfflineLicense(),
        config.adminOnlyResponse(),
      ],
      [
        "GET /api/global/license/offline/identifier",
        () => config.api.license.getOfflineLicenseIdentifier(),
        config.adminOnlyResponse(),
      ],
    ])(
      "returns 403 for non-admin access to %s",
      async (_path, request, expectedBody) => {
        const user = await createNonAdminUser()

        const res = await config.withUser(user, () => request())

        expect(res.status).toBe(403)
        expect(res.body).toEqual(expectedBody)
      }
    )
  })
})