"use server"

import { stripe } from "@/lib/stripe"

interface CartItem {
  id: string
  name: string
  description: string | null
  price: number
  quantity: number
  type: "menu_item" | "ticket"
  quantity_sold?: number
  ticket_inclusions?: Array<{
    menu_item_id: string
    quantity: number
  }>
}

export async function createCheckoutSession(
  cartItems: CartItem[],
  currency: string,
  metadata: {
    eventId: string
    customerName: string
    customerEmail: string
    customerPhone?: string
    tableNumber?: string
    checkoutType?: "registered" | "unregistered"
  },
  origin: string,
) {
  try {
    if (!cartItems || cartItems.length === 0) {
      throw new Error("Cart is empty")
    }

    // Validate cart items structure
    cartItems.forEach((item, index) => {
      if (!item.id || !item.name || typeof item.price !== "number" || typeof item.quantity !== "number") {
        console.error("[v0] Invalid cart item at index", index, ":", item)
        throw new Error(`Invalid cart item at index ${index}`)
      }
    })

    console.log("[v0] Creating checkout session for", cartItems.length, "items")

    // Calculate totals
    const subtotal = cartItems.reduce((sum, item) => sum + item.price * item.quantity, 0)
    const taxAmount = subtotal * 0.1
    const total = subtotal + taxAmount

    console.log("[v0] Order totals - Subtotal:", subtotal, "Tax:", taxAmount, "Total:", total)

    // Create line items for Stripe
    const lineItems = cartItems.map((item) => ({
      price_data: {
        currency: currency.toLowerCase(),
        product_data: {
          name: item.name,
          description: item.description || undefined,
        },
        unit_amount: Math.round(item.price * 100),
      },
      quantity: item.quantity,
    }))

    // Add tax as a separate line item
    lineItems.push({
      price_data: {
        currency: currency.toLowerCase(),
        product_data: {
          name: "Tax (10%)",
          description: "Service tax",
        },
        unit_amount: Math.round(taxAmount * 100),
      },
      quantity: 1,
    })

    // For inclusions, only store menu_item_id and quantity (not the full menu_items object)
    const minimalCartData = cartItems.map((item) => {
      const simplified: Record<string, unknown> = {
        id: item.id,
        p: item.price,
        q: item.quantity,
        t: item.type === "ticket" ? "t" : "m",
      }

      // Simplify inclusions to only store menu_item_id and quantity
      if (item.ticket_inclusions && item.ticket_inclusions.length > 0) {
        simplified.i = item.ticket_inclusions.map((inc: { menu_item_id: string; quantity: number }) => ({
          m: inc.menu_item_id,
          q: inc.quantity,
        }))
      }

      return simplified
    })

    const cartDataJson = JSON.stringify(minimalCartData)
    console.log("[v0] Cart data length:", cartDataJson.length)

    const checkoutType = metadata.checkoutType || "registered"

    const sessionMetadata: Record<string, string> = {
      eventId: metadata.eventId,
      customerName: metadata.customerName,
      customerEmail: metadata.customerEmail,
      customerPhone: metadata.customerPhone || "",
      tableNumber: metadata.tableNumber || "",
      itemCount: cartItems.length.toString(),
      subtotal: subtotal.toFixed(2),
      taxAmount: taxAmount.toFixed(2),
      total: total.toFixed(2),
      checkoutType: checkoutType,
    }

    // Split cart data if it exceeds 450 characters
    if (cartDataJson.length <= 450) {
      sessionMetadata.cartData = cartDataJson
    } else {
      // Split into chunks of 450 characters each
      const chunks: string[] = []
      for (let i = 0; i < cartDataJson.length; i += 450) {
        chunks.push(cartDataJson.slice(i, i + 450))
      }

      sessionMetadata.cartDataChunks = chunks.length.toString()
      chunks.forEach((chunk, index) => {
        sessionMetadata[`cartData${index}`] = chunk
      })

      console.log("[v0] Cart data split into", chunks.length, "chunks")
    }

    console.log("[v0] Creating Stripe session with metadata, checkoutType:", checkoutType)

    const session = await stripe.checkout.sessions.create({
      ui_mode: "embedded",
      return_url: `${origin}/e/${metadata.eventId}/checkout/success?session_id={CHECKOUT_SESSION_ID}`,
      line_items: lineItems,
      mode: "payment",
      customer_email: metadata.customerEmail,
      metadata: sessionMetadata,
    })

    console.log("[v0] Stripe session created successfully:", session.id)

    return { clientSecret: session.client_secret, sessionId: session.id }
  } catch (error) {
    console.error("[v0] Stripe checkout session creation failed:", error)
    const errorMessage = error instanceof Error ? error.message : "Failed to create checkout session"
    throw new Error(errorMessage)
  }
}