// app/api/vendors/[id]/route.ts (PUT handler)
import { NextRequest, NextResponse } from 'next/server'
import { prisma } from '@/lib/prisma'
import { VendorType, VendorStatus } from '@prisma/client'

export async function PUT(
  request: NextRequest,
  { params }: { params: { id: string } }
) {
  try {
    const id = params.id
    const body = await request.json()
    
    // Check if vendor exists
    const existingVendor = await prisma.vendor.findUnique({
      where: { id },
      include: { address: true }
    })
    
    if (!existingVendor) {
      return NextResponse.json(
        { error: 'Vendor not found' },
        { status: 404 }
      )
    }
    
    // Parse numeric values
    const parseFloatOrNull = (value: any): number | null => {
      if (value === null || value === undefined || value === '') return null
      const num = parseFloat(value)
      return isNaN(num) ? null : num
    }
    
    const parseDateOrNull = (value: any): Date | null => {
      if (!value) return null
      const date = new Date(value)
      return isNaN(date.getTime()) ? null : date
    }
    
    // Handle address update/creation
    let addressId = existingVendor.addressId
    const hasAddress = body.street && body.city && body.state && body.postalCode
    
    if (hasAddress) {
      if (existingVendor.address) {
        // Update existing address
        await prisma.address.update({
          where: { id: existingVendor.addressId! },
          data: {
            street: body.street,
            city: body.city,
            state: body.state,
            zip: parseInt(body.postalCode),
          }
        })
      } else {
        // Create new address
        const newAddress = await prisma.address.create({
          data: {
            street: body.street,
            city: body.city,
            state: body.state,
            zip: parseInt(body.postalCode),
          }
        })
        addressId = newAddress.id
      }
    } else if (existingVendor.address) {
      // Remove address if it existed but now doesn't
      await prisma.address.delete({
        where: { id: existingVendor.addressId! }
      })
      addressId = null
    }
    
    // Prepare update data
    const updateData: any = {
      name: body.name,
      type: body.type as VendorType,
      description: body.description || null,
      website: body.website || null,
      contactPerson: body.contactPerson || null,
      email: body.email || null,
      phone: body.phone || null,
      status: (body.status as VendorStatus) || 'CONTACTING',
      isBooked: Boolean(body.isBooked),
      bookedDate: parseDateOrNull(body.bookedDate),
      quotedPrice: parseFloatOrNull(body.quotedPrice),
      finalCost: parseFloatOrNull(body.finalCost),
      depositPaid: parseFloatOrNull(body.depositPaid),
      depositDueDate: parseDateOrNull(body.depositDueDate),
      finalPaymentDue: parseDateOrNull(body.finalPaymentDue),
      paymentNotes: body.paymentNotes || null,
      contractUrl: body.contractUrl || null,
      proposalUrl: body.proposalUrl || null,
      notes: body.notes || null,
    }
    
    // Only include addressId if we have one
    if (addressId) {
      updateData.addressId = addressId
    } else {
      updateData.addressId = null
    }
    
    // Update vendor
    const updatedVendor = await prisma.vendor.update({
      where: { id },
      data: updateData,
      include: {
        address: !!addressId
      }
    })
    
    return NextResponse.json(updatedVendor)
    
  } catch (error: any) {
    console.error('Error updating vendor:', error)
    return NextResponse.json(
      { error: 'Failed to update vendor', details: error.message },
      { status: 500 }
    )
  }
}