musicland/functions/src/stripe.js

const admin = require('firebase-admin')
const { HttpsError, onCall } = require('firebase-functions/https')

let FieldValue = null
try {
  ;({ FieldValue } = require('firebase-admin/firestore'))
} catch (error) {
  console.warn('[stripe] FieldValue import failed', error?.message)
}

const { REGION, refsList } = require('../index')
const STRIPE_MODE = 'test'
const {
  getStripeClient,
  getReturnUrls,
  getReturnBaseUrl,
  buildCheckoutLineItems,
  ensureStripeCustomer,
  formatCheckoutSessionResponse,
  getPortalConfigurationId,
  mapStripeErrorToHttps,
} = require('../helpers/stripe')

const paymentsCollection = admin.firestore().collection('payments')

const getServerTimestamp = () => {
  if (FieldValue?.serverTimestamp) {
    return FieldValue.serverTimestamp()
  }
  const fallback = admin.firestore?.FieldValue
  if (fallback?.serverTimestamp) {
    return fallback.serverTimestamp()
  }
  throw new HttpsError('failed-precondition', 'Firestore FieldValue.serverTimestamp indisponible.')
}

const normalizePaymentIntent = (paymentIntent) => ({
  id: paymentIntent.id,
  object: paymentIntent.object,
  status: paymentIntent.status,
  currency: paymentIntent.currency,
  amount: paymentIntent.amount,
  amount_received: paymentIntent.amount_received,
  customer: paymentIntent.customer,
  created: paymentIntent.created,
  latest_charge: paymentIntent.latest_charge,
  metadata: paymentIntent.metadata,
})

const createCheckoutSession = onCall({ region: REGION }, async (request) => {
  try {
    const uid = request?.auth?.uid
    if (!uid) {
      throw new HttpsError('unauthenticated', 'Connecte-toi pour créer une session Stripe.')
    }

    const requestedUserId =
      typeof request?.data?.userID === 'string' ? request.data.userID.trim() : null

    if (requestedUserId && requestedUserId !== uid) {
      throw new HttpsError(
        'permission-denied',
        'Tu ne peux créer une session que pour ton propre compte.'
      )
    }

    const productList = Array.isArray(request?.data?.productList) ? request.data.productList : []

    const stripe = getStripeClient()
    const { lineItems, summary, hasSubscription } = await buildCheckoutLineItems(productList, {
      stripe,
    })

    const mode = hasSubscription ? 'subscription' : 'payment'
    const { successUrl, cancelUrl } = getReturnUrls(request?.data?.returnUrls)

    const { customerId } = await ensureStripeCustomer({
      uid,
      stripe,
      refsList,
      createIfMissing: true,
    })

    if (!customerId) {
      throw new HttpsError('internal', 'Impossible de retrouver le client Stripe associé.')
    }

    const session = await stripe.checkout.sessions.create({
      mode,
      customer: customerId,
      line_items: lineItems,
      success_url: successUrl,
      cancel_url: cancelUrl,
      allow_promotion_codes: true,
      metadata: {
        firebaseUID: uid,
      },
    })

    await paymentsCollection.doc(session.id).set({
      userId: uid,
      customerId,
      status: session.status || 'created',
      mode,
      createdAt: getServerTimestamp(),
      updatedAt: getServerTimestamp(),
      sessionId: session.id,
      sessionUrl: session.url,
      lineItems: summary,
      amountSubtotal: session.amount_subtotal,
      amountTotal: session.amount_total,
      currency: session.currency,
      paymentStatus: session.payment_status,
    })

    return formatCheckoutSessionResponse(session)
  } catch (error) {
    console.error('[createCheckoutSession] error', error)
    if (error instanceof HttpsError) {
      throw error
    }
    throw mapStripeErrorToHttps(error, 'Création de la session Stripe impossible.')
  }
})

const getPremiumStatus = onCall({ region: REGION }, async (request) => {
  try {
    const uid = request?.auth?.uid
    if (!uid) {
      throw new HttpsError('unauthenticated', 'Connecte-toi pour consulter ton statut Stripe.')
    }

    const stripe = getStripeClient()
    const { customerId } = await ensureStripeCustomer({
      uid,
      stripe,
      refsList,
      createIfMissing: false,
    })

    if (!customerId) {
      return {
        customerId: null,
        subscriptions: [],
        invoices: [],
      }
    }

    const [subscriptions, invoices] = await Promise.all([
      stripe.subscriptions.list({
        customer: customerId,
        status: 'all',
        expand: ['data.items.data.price'],
        limit: 20,
      }),
      stripe.invoices.list({
        customer: customerId,
        limit: 20,
      }),
    ])

    const formattedSubscriptions = subscriptions.data.map((subscription) => ({
      id: subscription.id,
      status: subscription.status,
      created: subscription.created,
      current_period_start: subscription.current_period_start,
      current_period_end: subscription.current_period_end,
      cancel_at_period_end: subscription.cancel_at_period_end,
      items: subscription.items.data.map((item) => ({
        id: item.id,
        quantity: item.quantity,
        price: item.price?.id,
        product: item.price?.product,
        unit_amount: item.price?.unit_amount,
        currency: item.price?.currency,
        recurring: item.price?.recurring,
      })),
    }))

    const formattedInvoices = invoices.data.map((invoice) => ({
      id: invoice.id,
      status: invoice.status,
      amount_due: invoice.amount_due,
      amount_paid: invoice.amount_paid,
      amount_remaining: invoice.amount_remaining,
      currency: invoice.currency,
      hosted_invoice_url: invoice.hosted_invoice_url,
      invoice_pdf: invoice.invoice_pdf,
      created: invoice.created,
    }))

    return {
      customerId,
      subscriptions: formattedSubscriptions,
      invoices: formattedInvoices,
    }
  } catch (error) {
    console.error('[getPremiumStatus] error', error)
    if (error instanceof HttpsError) {
      throw error
    }
    throw mapStripeErrorToHttps(error, 'Impossible de récupérer le statut Stripe.')
  }
})

const createStripeCustomerPortalSession = onCall({ region: REGION }, async (request) => {
  try {
    const uid = request?.auth?.uid
    if (!uid) {
      throw new HttpsError('unauthenticated', 'Connecte-toi pour ouvrir le portail client Stripe.')
    }

    const stripe = getStripeClient()
    const { customerId } = await ensureStripeCustomer({
      uid,
      stripe,
      refsList,
      createIfMissing: false,
    })

    if (!customerId) {
      throw new HttpsError('failed-precondition', 'Aucun client Stripe associé à cet utilisateur.')
    }

    const portalConfigurationId = await getPortalConfigurationId(stripe)
    if (!portalConfigurationId) {
      const modeLabel = STRIPE_MODE === 'prod' ? 'production' : 'test'
      const envKeySuffix = STRIPE_MODE === 'prod' ? 'PROD' : 'TEST'
      throw new HttpsError(
        'failed-precondition',
        `Configure le portail client Stripe en mode ${modeLabel} ou renseigne STRIPE_PORTAL_CONFIGURATION_${envKeySuffix}.`
      )
    }

    const { successUrl } = getReturnUrls()

    const portalSession = await stripe.billingPortal.sessions.create({
      customer: customerId,
      return_url: successUrl,
      configuration: portalConfigurationId,
    })

    return {
      id: portalSession.id,
      url: portalSession.url,
      created: portalSession.created,
    }
  } catch (error) {
    console.error('[createStripeCustomerPortalSession] error', error)
    if (error instanceof HttpsError) {
      throw error
    }
    throw mapStripeErrorToHttps(error, 'Ouverture du portail Stripe impossible.')
  }
})

const resolveStripeConnectAccountId = (userData) => {
  if (!userData || typeof userData !== 'object') {
    return null
  }

  const candidatePaths = [
    ['stripeConnectAccountId'],
    ['stripeConnectId'],
    ['stripeAccountId'],
    ['stripeConnectAccount'],
    ['stripeAccount'],
    ['stripe', 'connectAccountId'],
    ['stripe', 'accountId'],
    ['providers', 'stripeConnect', 'accountId'],
  ]

  for (const path of candidatePaths) {
    let current = userData
    for (const key of path) {
      if (!current || typeof current !== 'object') {
        current = null
        break
      }
      current = current[key]
    }

    if (typeof current === 'string' && current.trim()) {
      return current.trim()
    }
  }

  return null
}

const ensureStripeConnectAccount = async ({ uid, stripe, userRef, userData }) => {
  if (!uid || !stripe) {
    return { connectAccountId: null, userData, createdAccount: false }
  }

  let connectAccountId = resolveStripeConnectAccountId(userData)
  if (connectAccountId) {
    return { connectAccountId, userData, createdAccount: false }
  }

  let authRecord = null
  try {
    authRecord = await admin.auth().getUser(uid)
  } catch (error) {
    console.warn('[ensureStripeConnectAccount] Impossible de récupérer auth user', error)
  }

  const email = userData?.email || authRecord?.email || undefined

  const accountParams = {
    type: 'express',
    capabilities: {
      card_payments: { requested: true },
      transfers: { requested: true },
    },
    metadata: {
      firebaseUID: uid,
      appMode: STRIPE_MODE || 'test',
    },
  }

  if (email) {
    accountParams.email = email
  }

  const account = await stripe.accounts.create(accountParams)
  connectAccountId = account?.id

  if (!connectAccountId) {
    throw new HttpsError('internal', 'Stripe n’a pas renvoyé d’identifiant de compte Connect.')
  }

  const providersConnect = {
    ...(userData?.providers?.stripeConnect || {}),
    accountId: connectAccountId,
  }

  if (userRef) {
    await userRef.set(
      {
        stripeConnectAccountId: connectAccountId,
        providers: {
          ...(userData?.providers || {}),
          stripeConnect: {
            ...providersConnect,
            updatedAt: getServerTimestamp(),
          },
        },
      },
      { merge: true }
    )
  }

  return {
    connectAccountId,
    userData: {
      ...(userData || {}),
      stripeConnectAccountId: connectAccountId,
      providers: {
        ...(userData?.providers || {}),
        stripeConnect: providersConnect,
      },
    },
    createdAccount: true,
  }
}

const createStripeConnectLoginLink = onCall({ region: REGION }, async (request) => {
  try {
    const uid = request?.auth?.uid
    if (!uid) {
      throw new HttpsError('unauthenticated', 'Connecte-toi pour ouvrir Stripe Connect.')
    }

    const userRef = refsList?.users?.doc(uid)
    const snapshot = userRef ? await userRef.get() : null
    let userData = snapshot?.exists ? snapshot.data() : null

    const stripe = getStripeClient()
    const ensureResult = await ensureStripeConnectAccount({
      uid,
      stripe,
      userRef,
      userData,
    })

    const connectAccountId = ensureResult.connectAccountId
    userData = ensureResult.userData

    if (!connectAccountId) {
      throw new HttpsError(
        'failed-precondition',
        'Impossible de créer un compte Stripe Connect pour cet utilisateur.'
      )
    }

    const redirectUrl = getReturnBaseUrl()

    const loginLink = await stripe.accounts.createLoginLink(
      connectAccountId,
      redirectUrl
        ? {
            redirect_url: redirectUrl,
          }
        : undefined
    )

    if (!loginLink?.url) {
      throw new HttpsError('internal', 'Stripe Connect n’a pas renvoyé de lien de connexion.')
    }

    return {
      id: loginLink.id,
      url: loginLink.url,
      created: loginLink.created,
      connectAccountId,
      createdAccount: ensureResult.createdAccount,
    }
  } catch (error) {
    console.error('[createStripeConnectLoginLink] error', error)
    if (error instanceof HttpsError) {
      throw error
    }
    throw mapStripeErrorToHttps(error, 'Ouverture de Stripe Connect impossible.')
  }
})

const verifyStripePayment = onCall({ region: REGION }, async (request) => {
  try {
    const uid = request?.auth?.uid
    if (!uid) {
      throw new HttpsError('unauthenticated', 'Connecte-toi pour vérifier un paiement Stripe.')
    }

    const rawPaymentId =
      typeof request?.data?.paymentId === 'string' ? request.data.paymentId.trim() : ''

    if (!rawPaymentId) {
      throw new HttpsError('invalid-argument', 'Fournis un identifiant de paiement Stripe.')
    }

    const stripe = getStripeClient()

    const fetchPaymentIntent = async (paymentIntentId) =>
      stripe.paymentIntents.retrieve(paymentIntentId, {
        expand: ['latest_charge'],
      })

    const fetchCheckoutSession = async (sessionId) =>
      stripe.checkout.sessions.retrieve(sessionId, {
        expand: ['payment_intent'],
      })

    let paymentIntent = null
    let checkoutSession = null
    let paymentType = null

    if (rawPaymentId.startsWith('pi_')) {
      paymentIntent = await fetchPaymentIntent(rawPaymentId)
      paymentType = 'payment_intent'
    } else if (rawPaymentId.startsWith('cs_')) {
      checkoutSession = await fetchCheckoutSession(rawPaymentId)
      paymentIntent =
        checkoutSession?.payment_intent && typeof checkoutSession.payment_intent === 'object'
          ? checkoutSession.payment_intent
          : checkoutSession?.payment_intent
            ? await fetchPaymentIntent(checkoutSession.payment_intent)
            : null
      paymentType = 'checkout_session'
    } else {
      try {
        paymentIntent = await fetchPaymentIntent(rawPaymentId)
        paymentType = 'payment_intent'
      } catch (intentError) {
        try {
          checkoutSession = await fetchCheckoutSession(rawPaymentId)
          paymentType = 'checkout_session'
          paymentIntent =
            checkoutSession?.payment_intent && typeof checkoutSession.payment_intent === 'object'
              ? checkoutSession.payment_intent
              : checkoutSession?.payment_intent
                ? await fetchPaymentIntent(checkoutSession.payment_intent)
                : null
        } catch (sessionError) {
          console.error('[verifyStripePayment] lookup failure', {
            intentError,
            sessionError,
          })
          throw new HttpsError('not-found', 'Aucun paiement Stripe trouvé avec cet identifiant.')
        }
      }
    }

    if (!paymentIntent && !checkoutSession) {
      throw new HttpsError('not-found', 'Aucun paiement Stripe trouvé avec cet identifiant.')
    }

    const normalizedIntent = paymentIntent ? normalizePaymentIntent(paymentIntent) : null

    const response = {
      type: paymentType,
      payment_intent: normalizedIntent,
      checkout_session: checkoutSession
        ? {
            id: checkoutSession.id,
            status: checkoutSession.status,
            payment_status: checkoutSession.payment_status,
            amount_total: checkoutSession.amount_total,
            amount_subtotal: checkoutSession.amount_subtotal,
            currency: checkoutSession.currency,
            customer: checkoutSession.customer,
            created: checkoutSession.created,
            expires_at: checkoutSession.expires_at,
          }
        : null,
      amount_received: normalizedIntent?.amount_received ?? null,
      status:
        normalizedIntent?.status ??
        checkoutSession?.payment_status ??
        checkoutSession?.status ??
        null,
      currency: normalizedIntent?.currency ?? checkoutSession?.currency ?? null,
    }

    const paymentDocId =
      paymentType === 'checkout_session' ? checkoutSession?.id : normalizedIntent?.id

    if (paymentDocId) {
      const paymentDocRef = paymentsCollection.doc(paymentDocId)
      const existing = await paymentDocRef.get()
      if (existing.exists) {
        await paymentDocRef.set(
          {
            status: response.status,
            paymentStatus: checkoutSession?.payment_status,
            amountTotal: checkoutSession?.amount_total ?? normalizedIntent?.amount,
            amountReceived: normalizedIntent?.amount_received,
            currency: response.currency,
            updatedAt: getServerTimestamp(),
          },
          { merge: true }
        )
      }
    }

    return response
  } catch (error) {
    console.error('[verifyStripePayment] error', error)
    if (error instanceof HttpsError) {
      throw error
    }
    throw mapStripeErrorToHttps(error, 'Vérification du paiement impossible.')
  }
})

module.exports = {
  createCheckoutSession,
  getPremiumStatus,
  createStripeCustomerPortalSession,
  createStripeConnectLoginLink,
  verifyStripePayment,
}