import Event from '../../../models/event.js'
import Member from '../../../models/member.js'
import { connectDB } from '../../../utils/mongoose.js'
import mongoose from 'mongoose'

export default defineEventHandler(async (event) => {
  try {
    // Ensure database connection
    await connectDB()
    const identifier = getRouterParam(event, 'id')
    const body = await readBody(event)
    
    if (!identifier) {
      throw createError({
        statusCode: 400,
        statusMessage: 'Event identifier is required'
      })
    }
    
    // Validate required fields
    if (!body.name || !body.email) {
      throw createError({
        statusCode: 400,
        statusMessage: 'Name and email are required'
      })
    }
    
    // Fetch the event - try by slug first, then by ID
    let eventData
    
    // Check if identifier is a valid MongoDB ObjectId
    if (mongoose.Types.ObjectId.isValid(identifier)) {
      eventData = await Event.findById(identifier)
    }
    
    // If not found by ID or not a valid ObjectId, try by slug
    if (!eventData) {
      eventData = await Event.findOne({ slug: identifier })
    }
    
    if (!eventData) {
      throw createError({
        statusCode: 404,
        statusMessage: 'Event not found'
      })
    }
    
    // Check if event is full
    if (eventData.maxAttendees && eventData.registrations.length >= eventData.maxAttendees) {
      throw createError({
        statusCode: 400,
        statusMessage: 'Event is full'
      })
    }
    
    // Check if already registered
    const alreadyRegistered = eventData.registrations.some(
      reg => reg.email.toLowerCase() === body.email.toLowerCase()
    )
    
    if (alreadyRegistered) {
      throw createError({
        statusCode: 400,
        statusMessage: 'You are already registered for this event'
      })
    }
    
    // Check member status and handle different registration scenarios
    const member = await Member.findOne({ email: body.email.toLowerCase() })
    
    if (eventData.membersOnly && !member) {
      throw createError({
        statusCode: 403,
        statusMessage: 'This event is for members only. Please become a member to register.'
      })
    }
    
    // If event requires payment and user is not a member, redirect to payment flow
    if (eventData.pricing.paymentRequired && !eventData.pricing.isFree && !member) {
      throw createError({
        statusCode: 402, // Payment Required
        statusMessage: 'This event requires payment. Please use the payment registration endpoint.'
      })
    }
    
    // Set member status and membership level
    let isMember = false
    let membershipLevel = 'non-member'
    
    if (member) {
      isMember = true
      membershipLevel = `${member.circle}-${member.contributionTier}`
    }
    
    // Add registration
    eventData.registrations.push({
      name: body.name,
      email: body.email.toLowerCase(),
      membershipLevel,
      isMember,
      paymentStatus: 'not_required', // Free events or member registrations
      amountPaid: 0,
      dietary: body.dietary || false,
      registeredAt: new Date()
    })
    
    // Save the updated event
    await eventData.save()
    
    // TODO: Send confirmation email using Resend
    // await sendEventRegistrationEmail(body.email, eventData)
    
    return {
      success: true,
      message: 'Successfully registered for the event',
      registrationId: eventData.registrations[eventData.registrations.length - 1]._id
    }
  } catch (error) {
    console.error('Error registering for event:', error)
    
    if (error.statusCode) {
      throw error
    }
    
    throw createError({
      statusCode: 500,
      statusMessage: 'Failed to register for event'
    })
  }
})