import { createCounter } from "@scandic-hotels/common/telemetry"

import * as api from "../../api"
import { cache } from "../../DUPLICATED/cache"
import { isValidSession } from "../../utils/session"
import { getUserSchema } from "./output"

import type { Session } from "next-auth"

export async function getMembershipNumber(
  session: Session | null
): Promise<string | undefined> {
  if (!isValidSession(session)) return undefined

  const verifiedUser = await getVerifiedUser({ session })
  if (!verifiedUser || "error" in verifiedUser) {
    return undefined
  }

  return verifiedUser.data.membershipNumber
}

export const getVerifiedUser = cache(
  async ({
    session,
    includeExtendedPartnerData,
  }: {
    session: Session
    includeExtendedPartnerData?: boolean
  }) => {
    const getVerifiedUserCounter = createCounter("user", "getVerifiedUser")
    const metricsGetVerifiedUser = getVerifiedUserCounter.init()

    metricsGetVerifiedUser.start()

    const now = Date.now()
    if (session.token.expires_at && session.token.expires_at < now) {
      metricsGetVerifiedUser.dataError(`Token expired`)
      return { error: true, cause: "token_expired" } as const
    }

    const apiResponse = await api.get(
      api.endpoints.v2.Profile.profile,
      {
        headers: {
          Authorization: `Bearer ${session.token.access_token}`,
        },
      },
      includeExtendedPartnerData
        ? { includes: "extendedPartnerInformation" }
        : {}
    )

    if (!apiResponse.ok) {
      await metricsGetVerifiedUser.httpError(apiResponse)

      if (apiResponse.status === 401) {
        return { error: true, cause: "unauthorized" } as const
      } else if (apiResponse.status === 403) {
        return { error: true, cause: "forbidden" } as const
      } else if (apiResponse.status === 404) {
        return { error: true, cause: "notfound" } as const
      }

      return {
        error: true,
        cause: "unknown",
        status: apiResponse.status,
      } as const
    }

    const apiJson = await apiResponse.json()
    if (!apiJson.data?.attributes) {
      metricsGetVerifiedUser.dataError(
        `Missing data attributes in API response`,
        {
          data: apiJson,
        }
      )
      return null
    }

    const verifiedData = getUserSchema.safeParse(apiJson)
    if (!verifiedData.success) {
      metricsGetVerifiedUser.validationError(verifiedData.error)
      return null
    }

    metricsGetVerifiedUser.success()

    return verifiedData
  }
)