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

import { safeProtectedProcedure } from "../../../procedures"
import { isValidSession } from "../../../utils/session"
import { getEuroBonusProfileData } from "../../partners/sas/getEuroBonusProfile"
import { getBasicUser } from "../utils/getBasicUser"

import type { LoginType } from "@scandic-hotels/common/constants/loginType"
import type { Session } from "next-auth"

import type { TrackingUserData } from "../../types"

export const userTrackingInfo = safeProtectedProcedure.query(async function ({
  ctx,
}) {
  switch (ctx.app) {
    case "partner-sas": {
      const scandicUserToken = await ctx.getScandicUserToken()
      return getSasEurobonusUserTrackingData(ctx.session, scandicUserToken)
    }
    case "scandic-web":
      return getScandicFriendsUserTrackingData(ctx.session)
    default:
      const _exhaustiveCheck: never = ctx.app
      return { loginStatus: "Error" } as const
  }
})

async function getScandicFriendsUserTrackingData(session: Session | null) {
  const userTrackingInfoCounter = createCounter("user.userTrackingInfo")
  const metricsUserTrackingInfo = userTrackingInfoCounter.init()

  metricsUserTrackingInfo.start()

  const memberType = "scandic-friends" as const

  const notLoggedInUserTrackingData: TrackingUserData = {
    loginStatus: "Non-logged in",
    memberType,
  }

  if (!isValidSession(session)) {
    metricsUserTrackingInfo.success({
      reason: "invalid session",
      data: notLoggedInUserTrackingData,
    })
    return notLoggedInUserTrackingData
  }

  try {
    const verifiedUserData = await getBasicUser({ token: session.token })

    if (!verifiedUserData) {
      metricsUserTrackingInfo.success({
        reason: "invalid user data",
        data: notLoggedInUserTrackingData,
      })
      return notLoggedInUserTrackingData
    }

    const loggedInUserTrackingData: TrackingUserData = {
      loginStatus: "logged in",
      loginType: session.token.loginType as LoginType,
      memberId: verifiedUserData.profileId,
      membershipNumber: verifiedUserData.membershipNumber,
      memberLevel: verifiedUserData?.tier,
      loginAction: "login success",
      memberType,
    }

    metricsUserTrackingInfo.success({
      reason: "valid logged in",
      data: loggedInUserTrackingData,
    })

    return loggedInUserTrackingData
  } catch (error) {
    metricsUserTrackingInfo.fail(error)
    return notLoggedInUserTrackingData
  }
}

async function getSasEurobonusUserTrackingData(
  session: Session | null,
  scandicUserToken: string | null
) {
  const notLoggedInUserTrackingData: TrackingUserData = {
    loginStatus: "Non-logged in",
    memberType: "sas-eurobonus",
  }

  if (!isValidSession(session)) {
    return notLoggedInUserTrackingData
  }

  try {
    const [eurobonusProfile, scandicData] = await Promise.all([
      getEuroBonusProfileData({
        accessToken: session.token.access_token,
        loginType: "eurobonus",
      }),
      getScandicFriendsDataHelper(scandicUserToken),
    ])

    const loggedInUserTrackingData: TrackingUserData = {
      loginStatus: "logged in",
      loginType: session.token.loginType,
      loginAction: "login success",
      memberType: "sas-eurobonus",
      eurobonusNumber: eurobonusProfile.eurobonusNumber,
      tier: eurobonusProfile.tier,
      linkStatus: eurobonusProfile.linkStatus,
      memberId: scandicData?.memberId,
      membershipNumber: scandicData?.membershipNumber,
      memberLevel: scandicData?.memberLevel,
    }

    return loggedInUserTrackingData
  } catch (_error) {
    return notLoggedInUserTrackingData
  }
}

async function getScandicFriendsDataHelper(scandicUserToken: string | null) {
  if (!scandicUserToken) return null

  const verifiedUserData = await getBasicUser({
    token: { access_token: scandicUserToken },
  })

  if (!verifiedUserData) {
    return null
  }

  return {
    memberId: verifiedUserData.profileId,
    membershipNumber: verifiedUserData.membershipNumber,
    memberLevel: verifiedUserData.tier,
  }
}