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

const { REGION, ALERT_TYPE } = require('../index')
const { sendNotification } = require('./notifications')
const {
  ORDER_TYPES,
  ORDER_STATUS,
  ORDERS_COLLECTION,
  createOrderDocument,
  normalizeAmount,
} = require('./helpers/orders')

const USERS_COLLECTION = 'users'

const formatCoinsText = (value) => {
  if (typeof value !== 'number' || Number.isNaN(value)) {
    return null
  }

  const absoluteValue = Math.abs(value)
  if (!Number.isFinite(absoluteValue)) {
    return null
  }

  const formatted = Number.isInteger(absoluteValue) ? `${absoluteValue}` : absoluteValue.toFixed(2)
  const suffix = absoluteValue === 1 ? 'crédit' : 'crédits'

  return `${formatted} ${suffix}`
}

const buildOrderNotificationContent = ({ amount, orderType, balanceAfter }) => {
  if (typeof amount !== 'number' || Number.isNaN(amount) || amount === 0) {
    return null
  }

  const coinsText = formatCoinsText(amount)
  if (!coinsText) {
    return null
  }

  const balanceText = formatCoinsText(balanceAfter)
  const balanceSentence = balanceText ? ` Ton solde est maintenant de ${balanceText}.` : ''

  if (amount > 0) {
    if (orderType === ORDER_TYPES.COINS) {
      return {
        title: 'Crédits achetés',
        message: `Ton achat de ${coinsText} est confirmé.${balanceSentence}`,
        action: 'PURCHASED',
      }
    }

    if (orderType === ORDER_TYPES.GIFT) {
      return {
        title: 'Crédits reçus',
        message: `Tu as reçu ${coinsText}.${balanceSentence}`,
        action: 'EARNED',
      }
    }

    return {
      title: 'Crédits ajoutés',
      message: `Ton solde augmente de ${coinsText}.${balanceSentence}`,
      action: 'CREDITED',
    }
  }

  const reason = orderType === ORDER_TYPES.SONG ? ' pour générer un nouveau son' : ''

  return {
    title: 'Crédits dépensés',
    message: `Tu as dépensé ${coinsText}${reason}.${balanceSentence}`,
    action: 'SPENT',
  }
}

const notifyOrderApplied = async ({
  userId,
  orderId,
  amount,
  orderType,
  balanceBefore,
  balanceAfter,
  metadata = {},
}) => {
  const content = buildOrderNotificationContent({
    amount,
    orderType,
    balanceAfter,
  })

  if (!content || !userId) {
    return
  }

  try {
    await sendNotification({
      sender: 'SYSTEM',
      receiver: userId,
      receiverCollection: USERS_COLLECTION,
      title: content.title,
      message: content.message,
      data: {
        type: ALERT_TYPE?.CREDITS_UPDATED || 'CREDITS_UPDATED',
        orderId,
        orderType: orderType || null,
        amount,
        balanceBefore,
        balanceAfter,
        action: content.action,
        source: typeof metadata?.source === 'string' ? metadata.source : null,
        metadata: metadata || {},
      },
    })
  } catch (error) {
    console.error('[orders-onOrderCreated] Failed to send notification', orderId, error)
  }
}

const onOrderCreated = onDocumentCreated(`${ORDERS_COLLECTION}/{orderId}`, async (event) => {
  const orderRef = event?.data?.ref
  const orderData = event?.data?.data()

  if (!orderRef || !orderData) {
    return
  }

  if (orderData?.processedAt) {
    return
  }

  const userId = typeof orderData.userId === 'string' ? orderData.userId.trim() : ''
  const amount = normalizeAmount(orderData.amount)

  if (!userId) {
    await orderRef.set(
      {
        status: ORDER_STATUS.REJECTED,
        processedAt: FieldValue.serverTimestamp(),
        failureReason: 'USER_NOT_FOUND',
      },
      { merge: true }
    )
    return
  }

  if (amount === null || amount === 0) {
    await orderRef.set(
      {
        status: ORDER_STATUS.REJECTED,
        processedAt: FieldValue.serverTimestamp(),
        failureReason: 'INVALID_AMOUNT',
      },
      { merge: true }
    )
    return
  }

  const userRef = admin.firestore().collection(USERS_COLLECTION).doc(userId)

  let notificationContext = null

  try {
    await admin.firestore().runTransaction(async (transaction) => {
      const userSnapshot = await transaction.get(userRef)
      const userData = userSnapshot?.data() || {}
      const currentBalanceValue = normalizeAmount(userData?.coins)
      const currentBalance = currentBalanceValue !== null ? currentBalanceValue : 0

      const nextBalance = currentBalance + amount

      if (amount < 0 && nextBalance < 0 && orderData?.type === ORDER_TYPES.SONG) {
        transaction.set(
          orderRef,
          {
            status: ORDER_STATUS.REJECTED,
            processedAt: FieldValue.serverTimestamp(),
            failureReason: 'INSUFFICIENT_FUNDS',
            balanceBefore: currentBalance,
            balanceAfter: currentBalance,
          },
          { merge: true }
        )
        return
      }

      if (userSnapshot?.exists) {
        transaction.update(userRef, {
          coins: nextBalance,
          updatedAt: FieldValue.serverTimestamp(),
        })
      } else {
        transaction.set(
          userRef,
          {
            coins: nextBalance,
            createdAt: FieldValue.serverTimestamp(),
            updatedAt: FieldValue.serverTimestamp(),
          },
          { merge: true }
        )
      }

      transaction.set(
        orderRef,
        {
          status: ORDER_STATUS.APPLIED,
          processedAt: FieldValue.serverTimestamp(),
          balanceBefore: currentBalance,
          balanceAfter: nextBalance,
        },
        { merge: true }
      )

      notificationContext = {
        balanceBefore: currentBalance,
        balanceAfter: nextBalance,
      }
    })
  } catch (error) {
    console.error('[orders-onOrderCreated] Failed to process order', orderRef.id, error)

    await orderRef.set(
      {
        status: ORDER_STATUS.REJECTED,
        processedAt: FieldValue.serverTimestamp(),
        failureReason: 'PROCESSING_ERROR',
        errorMessage: error?.message || String(error),
      },
      { merge: true }
    )
    return
  }

  if (notificationContext) {
    await notifyOrderApplied({
      userId,
      orderId: orderRef.id,
      amount,
      orderType: typeof orderData?.type === 'string' ? orderData.type : null,
      balanceBefore: notificationContext.balanceBefore,
      balanceAfter: notificationContext.balanceAfter,
      metadata: orderData?.metadata || {},
    })
  }
})

const createSongOrder = onCall({ region: REGION }, async (request) => {
  const { auth, data } = request || {}

  if (!auth?.uid) {
    throw new HttpsError('unauthenticated', 'Authentification requise.')
  }

  const amount = normalizeAmount(data?.amount)

  if (amount === null || amount >= 0) {
    throw new HttpsError(
      'invalid-argument',
      'Le montant doit être négatif pour un achat de musique.'
    )
  }

  const songId = typeof data?.songId === 'string' && data.songId.trim() ? data.songId.trim() : null

  const userRef = admin.firestore().collection(USERS_COLLECTION).doc(auth.uid)
  const userSnapshot = await userRef.get()
  const currentCoinsValue = normalizeAmount(userSnapshot?.data()?.coins)
  const currentCoins = currentCoinsValue !== null ? currentCoinsValue : 0

  if (currentCoins + amount < 0) {
    throw new HttpsError('failed-precondition', "Crédits insuffisants pour finaliser l'opération.")
  }

  const metadata = {
    source:
      typeof data?.source === 'string' && data.source.trim()
        ? data.source.trim()
        : 'music_generation',
  }

  if (typeof data?.requestId === 'string' && data.requestId.trim()) {
    metadata.requestId = data.requestId.trim()
  }

  const { orderId } = await createOrderDocument({
    userId: auth.uid,
    type: ORDER_TYPES.SONG,
    amount,
    songId,
    createdBy: auth.uid,
    metadata,
  })

  return { orderId }
})

module.exports = {
  onOrderCreated,
  createSongOrder,
}