import { NextRequest, NextResponse } from 'next/server'
import { PrismaClient } from '../../../../../src/generated/prisma'

const prisma = new PrismaClient()

// Get all layers for a session
export async function GET(
  request: NextRequest,
  { params }: { params: Promise<{ sessionId: string }> }
) {
  try {
    const { sessionId } = await params
    const layers = await prisma.layer.findMany({
      where: { sessionId },
      orderBy: { orderIndex: 'asc' }
    })
    
    return NextResponse.json(layers)
  } catch (error) {
    console.error('Failed to get layers:', error)
    return NextResponse.json(
      { error: 'Failed to get layers' },
      { status: 500 }
    )
  }
}

// Add a new layer to a session
export async function POST(
  request: NextRequest,
  { params }: { params: Promise<{ sessionId: string }> }
) {
  try {
    const { sessionId } = await params
    const body = await request.json()
    
    // Get the next order index
    const lastLayer = await prisma.layer.findFirst({
      where: { sessionId },
      orderBy: { orderIndex: 'desc' }
    })
    
    const nextOrderIndex = (lastLayer?.orderIndex ?? -1) + 1
    
    const layer = await prisma.layer.create({
      data: {
        sessionId,
        title: body.title,
        prompt: body.prompt,
        audioUrl: body.audioUrl,
        clipId: body.clipId,
        status: body.status || 'processing',
        volume: body.volume || 1.0,
        muted: body.muted || false,
        orderIndex: nextOrderIndex
      }
    })
    
    return NextResponse.json(layer)
  } catch (error) {
    console.error('Failed to create layer:', error)
    return NextResponse.json(
      { error: 'Failed to create layer' },
      { status: 500 }
    )
  }
}

// Update layer (for volume, mute, etc.)
export async function PATCH(
  request: NextRequest,
  { params }: { params: Promise<{ sessionId: string }> }
) {
  try {
    const { sessionId } = await params
    const body = await request.json()
    const { clipId, ...updateData } = body
    
    if (!clipId) {
      return NextResponse.json(
        { error: 'clipId required' },
        { status: 400 }
      )
    }
    
    const layer = await prisma.layer.update({
      where: { 
        sessionId_clipId: {
          sessionId: sessionId,
          clipId: clipId
        }
      },
      data: updateData
    })
    
    return NextResponse.json(layer)
  } catch (error) {
    console.error('Failed to update layer:', error)
    return NextResponse.json(
      { error: 'Failed to update layer' },
      { status: 500 }
    )
  }
}

// Delete a layer
export async function DELETE(
  request: NextRequest,
  { params }: { params: Promise<{ sessionId: string }> }
) {
  try {
    const { sessionId } = await params
    const { searchParams } = new URL(request.url)
    const clipId = searchParams.get('clipId')
    
    if (!clipId) {
      return NextResponse.json(
        { error: 'clipId required' },
        { status: 400 }
      )
    }
    
    await prisma.layer.delete({
      where: { 
        sessionId_clipId: {
          sessionId: sessionId,
          clipId: clipId
        }
      }
    })
    
    return NextResponse.json({ success: true })
  } catch (error) {
    console.error('Failed to delete layer:', error)
    return NextResponse.json(
      { error: 'Failed to delete layer' },
      { status: 500 }
    )
  }
}