import { NextRequest, NextResponse } from 'next/server'
import { withAuth } from '@/lib/auth'
import path from 'path'
import fs from 'fs'
import { generateUniqueFilename, isValidImageType, isValidVideoType } from '@/lib/fileUtils'

async function handleUpload(request: NextRequest, user: any) {
  try {
    const formData = await request.formData()

    const uploadedFiles: { images: string[], video?: string } = {
      images: [],
    }

    // Handle uploaded images
    const imageFiles = formData.getAll('images') as File[]
    if (imageFiles && imageFiles.length > 0) {
      // Debug: Log current working directory
      console.log('Current working directory:', process.cwd())
      console.log('__dirname:', __dirname)

      const imagesDir = path.join(process.cwd(), 'public', 'images', 'products')
      console.log('Images directory path:', imagesDir)

      if (!fs.existsSync(imagesDir)) {
        fs.mkdirSync(imagesDir, { recursive: true })
        console.log('Created images directory:', imagesDir)
      }

      for (const file of imageFiles) {
        // Validate file type
        if (!isValidImageType(file.type)) {
          return NextResponse.json(
            { message: 'Invalid image file type. Only images are allowed.' },
            { status: 400 }
          )
        }

        // Check file size (50MB limit)
        if (file.size > 50 * 1024 * 1024) {
          return NextResponse.json(
            { message: 'Image file too large. Maximum size is 50MB.' },
            { status: 400 }
          )
        }

        const fileName = generateUniqueFilename(file.name, file.type)
        console.log('Generated filename:', fileName)

        const filePath = path.join(imagesDir, fileName)
        console.log('Full file path:', filePath)

        // Convert file to buffer and save
        const buffer = Buffer.from(await file.arrayBuffer())
        fs.writeFileSync(filePath, buffer)
        console.log('File saved successfully')

        const imageUrl = `/images/products/${fileName}`
        console.log('Generated URL:', imageUrl)
        uploadedFiles.images.push(imageUrl)
      }
    }

    // Handle uploaded video
    const videoFile = formData.get('video') as File
    if (videoFile) {
      // Validate file type
      if (!isValidVideoType(videoFile.type)) {
        return NextResponse.json(
          { message: 'Invalid video file type. Only videos are allowed.' },
          { status: 400 }
        )
      }

      // Check file size (50MB limit)
      if (videoFile.size > 50 * 1024 * 1024) {
        return NextResponse.json(
          { message: 'Video file too large. Maximum size is 50MB.' },
          { status: 400 }
        )
      }

      const videosDir = path.join(process.cwd(), 'public', 'videos', 'products')
      if (!fs.existsSync(videosDir)) {
        fs.mkdirSync(videosDir, { recursive: true })
      }

      const fileName = generateUniqueFilename(videoFile.name, videoFile.type)
      const filePath = path.join(videosDir, fileName)

      // Convert file to buffer and save
      const buffer = Buffer.from(await videoFile.arrayBuffer())
      fs.writeFileSync(filePath, buffer)

      uploadedFiles.video = `/videos/products/${fileName}`
    }

    return NextResponse.json({
      message: 'Files uploaded successfully',
      files: uploadedFiles,
    })

  } catch (error: any) {
    console.error('Upload error:', error)
    return NextResponse.json(
      { message: error.message || 'Upload failed' },
      { status: 500 }
    )
  }
}

export const POST = withAuth(handleUpload)