import { NextRequest, NextResponse } from 'next/server'
import { createClient } from '@/lib/supabase/server'
import { createClient as createStorageClient } from '@supabase/supabase-js'

// Cliente con service role para storage (bypassa RLS)
function adminStorage() {
  return createStorageClient(
    process.env.NEXT_PUBLIC_SUPABASE_URL!,
    process.env.SUPABASE_SERVICE_ROLE_KEY!,
    { auth: { autoRefreshToken: false, persistSession: false } }
  )
}

// POST /api/barberos/[id]/foto
export async function POST(
  req: NextRequest,
  { params }: { params: Promise<{ id: string }> }
) {
  try {
    const { id: barberoId } = await params

    // Verificar que el usuario es admin
    const supabase = await createClient()
    const { data: { user } } = await supabase.auth.getUser()
    if (!user) return NextResponse.json({ error: 'No autenticado' }, { status: 401 })

    const { data: perfil } = await supabase
      .from('perfiles').select('rol').eq('id', user.id).single()
    if (perfil?.rol !== 'admin') {
      return NextResponse.json({ error: 'Sin permisos' }, { status: 403 })
    }

    const formData = await req.formData()
    const file = formData.get('file') as File | null
    if (!file) return NextResponse.json({ error: 'No se recibió archivo' }, { status: 400 })

    if (!file.type.startsWith('image/')) {
      return NextResponse.json({ error: 'Solo se permiten imágenes' }, { status: 400 })
    }
    if (file.size > 5 * 1024 * 1024) {
      return NextResponse.json({ error: 'Máximo 5MB por imagen' }, { status: 400 })
    }

    const admin = adminStorage()

    // Asegurar que el bucket existe
    const { data: buckets } = await admin.storage.listBuckets()
    const bucketExiste = buckets?.some(b => b.id === 'fotos-citas')

    if (!bucketExiste) {
      const { error: bucketErr } = await admin.storage.createBucket('fotos-citas', {
        public: true,
        fileSizeLimit: 10 * 1024 * 1024,
      })
      if (bucketErr && !bucketErr.message.includes('already exists')) {
        return NextResponse.json({ error: 'Error creando bucket: ' + bucketErr.message }, { status: 500 })
      }
    }

    // Eliminar foto anterior si existe
    const { data: barberoActual } = await supabase
      .from('barberos').select('foto_url').eq('id', barberoId).single()

    if (barberoActual?.foto_url) {
      // Extraer el path del storage desde la URL pública
      const url = new URL(barberoActual.foto_url)
      const storagePath = url.pathname.split('/fotos-citas/')[1]
      if (storagePath) {
        await admin.storage.from('fotos-citas').remove([storagePath])
      }
    }

    // Subir nueva foto
    const ext = file.name.split('.').pop()?.toLowerCase() ?? 'jpg'
    const storagePath = `barberos/${barberoId}-${Date.now()}.${ext}`
    const buffer = await file.arrayBuffer()

    const { error: uploadErr } = await admin.storage
      .from('fotos-citas')
      .upload(storagePath, buffer, { contentType: file.type, upsert: true })

    if (uploadErr) {
      return NextResponse.json({ error: 'Error al subir: ' + uploadErr.message }, { status: 500 })
    }

    // Obtener URL pública
    const { data: { publicUrl } } = admin.storage
      .from('fotos-citas')
      .getPublicUrl(storagePath)

    // Actualizar barbero en BD
    const { error: dbErr } = await supabase
      .from('barberos')
      .update({ foto_url: publicUrl })
      .eq('id', barberoId)

    if (dbErr) {
      return NextResponse.json({ error: dbErr.message }, { status: 500 })
    }

    return NextResponse.json({ foto_url: publicUrl })
  } catch (err: any) {
    console.error(err)
    return NextResponse.json({ error: err.message ?? 'Error interno' }, { status: 500 })
  }
}