Event Management

router.post(
  '/',
  authenticate,
  requireOrganizer,
  asyncHandler(async (req: AuthenticatedRequest, res) => {
    const body = req.body
    const title: string = body?.title
    const description: string | undefined = body?.description
    const venue: string = body?.venue
    const address: string | undefined = body?.address
    const city: string | undefined = body?.city
    const country: string | undefined = body?.country
    const latitude: number | undefined = body?.latitude
    const longitude: number | undefined = body?.longitude
    const startDateIso: string | undefined = body?.startDate
    const endDateIso: string | undefined = body?.endDate
    const categoryRaw: string | undefined = body?.category
    const tiers: Array<{
      name: string
      description?: string
      price: number
      quantity: number
      maxPerPerson?: number
    }> = Array.isArray(body?.tiers) ? body.tiers : []

    if (!title || !venue || !startDateIso) {
      throw createError('Missing required fields: title, venue, startDate', 400)
    }

    const startDate = new Date(startDateIso)
    const endDate = endDateIso ? new Date(endDateIso) : new Date(startDate.getTime() + 2 * 60 * 60 * 1000)

    const categoryMap: Record<string, string> = {
      conference: 'CONFERENCE',
      concert: 'MUSIC',
      workshop: 'WORKSHOP',
      networking: 'MEETUP',
      festival: 'FESTIVAL',
      sports: 'SPORTS',
      theater: 'THEATER',
      other: 'OTHER',
    }
    const category = (categoryMap[(categoryRaw || '').toLowerCase()] || 'OTHER') as any

    const totalSupply = tiers.length 
      ? tiers.reduce((sum, t) => sum + Number(t.quantity || 0), 0) 
      : Number(body?.maxCapacity || 0) || 0
    const minPrice = tiers.length 
      ? Math.min(...tiers.map((t) => Number(t.price || 0))) 
      : Number(body?.ticketPrice || 0) || 0

    try {
      const event = await prisma.event.create({
        data: {
          title,
          description,
          venue,
          address,
          city,
          country,
          latitude,
          longitude,
          eventDate: startDate,
          saleStart: new Date(),
          saleEnd: endDate,
          totalSupply,
          ticketPrice: minPrice,
          currency: 'USD',
          contractAddress: body?.contractAddress || null,
          chainId: body?.chainId || 137,
          imageUrl: body?.image || null,
          metadataUri: body?.metadataUri || null,
          category,
          tags: '',
          isPublic: true,
          allowTransfers: true,
          requireKYC: false,
          status: 'PUBLISHED',
          organizerId: req.user!.id
        }
      })
      
      // Create ticket tiers
      for (const t of tiers) {
        await prisma.ticketTier.create({
          data: {
            name: t.name,
            description: t.description,
            price: t.price,
            availableQuantity: t.quantity,
            maxPerPerson: t.maxPerPerson || 5,
            saleStart: startDate,
            saleEnd: endDate,
            eventId: event.id
          }
        })
      }
      
      return res.status(201).json({ event })
    } catch {
      throw createError('Failed to create event', 500)
    }
  })
)

router.get(
  '/',
  asyncHandler(async (req, res) => {
    const q = req.query
    const lat = q.lat ? Number(q.lat) : undefined
    const lng = q.lng ? Number(q.lng) : undefined
    const radiusKm = q.radiusKm ? Number(q.radiusKm) : 50
    const minPrice = q.minPrice ? Number(q.minPrice) : undefined
    const maxPrice = q.maxPrice ? Number(q.maxPrice) : undefined
    const startDate = q.startDate ? new Date(q.startDate as string) : undefined
    const endDate = q.endDate ? new Date(q.endDate as string) : undefined

    let events = await prisma.event.findMany({
      where: {
        isPublic: true,
        status: 'PUBLISHED',
        ...(q.category ? { category: q.category } : {}),
        ...(q.q ? {
          OR: [
            { title: { contains: q.q } },
            { description: { contains: q.q } },
            { city: { contains: q.q } },
            { venue: { contains: q.q } }
          ]
        } : {}),
        ...(startDate || endDate ? {
          eventDate: {
            ...(startDate ? { gte: startDate } : {}),
            ...(endDate ? { lte: endDate } : {})
          }
        } : {})
      },
      include: { tiers: true }
    })

    // Apply price filters
    if (minPrice != null || maxPrice != null) {
      events = events.filter((e) => {
        const lowestTier = e.tiers.length 
          ? e.tiers.reduce((a, b) => (Number(a.price) < Number(b.price) ? a : b)) 
          : null
        const price = lowestTier ? Number(lowestTier.price) : Number(e.ticketPrice)
        
        if (minPrice != null && price < minPrice) return false
        if (maxPrice != null && price > maxPrice) return false
        return true
      })
    }

    // Apply distance filter if location provided
    if (lat != null && lng != null && radiusKm != null) {
      events = events
        .filter((e) => {
          if (e.latitude == null || e.longitude == null) return false
          const distance = haversineKm(
            { lat, lng }, 
            { lat: e.latitude, lng: e.longitude }
          )
          return distance <= radiusKm
        })
        .sort((a, b) => {
          const distA = haversineKm({ lat, lng }, { lat: a.latitude!, lng: a.longitude! })
          const distB = haversineKm({ lat, lng }, { lat: b.latitude!, lng: b.longitude! })
          return distA - distB
        })
    }

    res.json({ events })
  })
)