import { NextRequest, NextResponse } from 'next/server'
import { db } from '@/lib/db'

// GET /api/produits/[id] - Get a single product
export async function GET(
  request: NextRequest,
  { params }: { params: Promise<{ id: string }> }
) {
  try {
    const { id } = await params
    const produit = await db.produit.findUnique({
      where: { id: id },
      include: {
        fournisseur: {
          select: {
            id: true,
            nom: true,
          },
        },
        fichiers: {
          where: {
            type: 'IMAGE_PRODUIT',
          },
        },
      },
    })

    if (!produit) {
      return NextResponse.json(
        { error: 'Product not found' },
        { status: 404 }
      )
    }

    return NextResponse.json({
      ...produit,
      fournisseurNom: produit.fournisseur?.nom || null,
      fournisseurId: produit.fournisseur?.id || null,
      images: produit.fichiers || [],
    })
  } catch (error) {
    console.error('Error fetching produit:', error)
    return NextResponse.json(
      { error: 'Failed to fetch product' },
      { status: 500 }
    )
  }
}

// PUT /api/produits/[id] - Update a product (full update)
export async function PUT(
  request: NextRequest,
  { params }: { params: Promise<{ id: string }> }
) {
  try {
    const { id } = await params
    const body = await request.json()

    // Check if product exists
    const existingProduit = await db.produit.findUnique({
      where: { id: id },
    })

    if (!existingProduit) {
      return NextResponse.json(
        { error: 'Product not found' },
        { status: 404 }
      )
    }

    // Check if reference is being changed and if it already exists
    if (body.reference && body.reference !== existingProduit.reference) {
      const referenceExists = await db.produit.findUnique({
        where: { reference: body.reference },
      })

      if (referenceExists) {
        return NextResponse.json(
          { error: 'Un produit avec cette référence existe déjà' },
          { status: 400 }
        )
      }
    }

    // Check if barcode is being changed and if it already exists
    if (body.codeBarre && body.codeBarre !== existingProduit.codeBarre) {
      const barcodeExists = await db.produit.findUnique({
        where: { codeBarre: body.codeBarre },
      })

      if (barcodeExists) {
        return NextResponse.json(
          { error: 'Un produit avec ce code-barres existe déjà' },
          { status: 400 }
        )
      }
    }

    const produit = await db.produit.update({
      where: { id: id },
      data: {
        ...(body.reference && { reference: body.reference }),
        ...(body.designation && { designation: body.designation }),
        ...(body.categorie && { categorie: body.categorie }),
        ...(body.fournisseurId !== undefined && { fournisseurId: body.fournisseurId || null }),
        ...(body.prixAchatHT !== undefined && { prixAchatHT: parseFloat(body.prixAchatHT) }),
        ...(body.prixVenteTTC !== undefined && { prixVenteTTC: parseFloat(body.prixVenteTTC) }),
        ...(body.tva !== undefined && { tva: parseFloat(body.tva) }),
        ...(body.stock !== undefined && { stock: parseInt(body.stock) }),
        ...(body.stockMin !== undefined && { stockMin: parseInt(body.stockMin) }),
        ...(body.emplacement !== undefined && { emplacement: body.emplacement || null }),
        ...(body.marque !== undefined && { marque: body.marque || null }),
        ...(body.typeMonture !== undefined && { typeMonture: body.typeMonture || null }),
        ...(body.typeVerre !== undefined && { typeVerre: body.typeVerre || null }),
        ...(body.indice !== undefined && { indice: body.indice ? parseFloat(body.indice) : null }),
        ...(body.materiau !== undefined && { materiau: body.materiau || null }),
        ...(body.couleur !== undefined && { couleur: body.couleur || null }),
        ...(body.dimensions !== undefined && { dimensions: body.dimensions || null }),
        ...(body.description !== undefined && { description: body.description || null }),
        ...(body.codeBarre !== undefined && { codeBarre: body.codeBarre || null }),
        ...(body.actif !== undefined && { actif: body.actif }),
      },
      include: {
        fournisseur: {
          select: {
            id: true,
            nom: true,
          },
        },
      },
    })

    return NextResponse.json({
      ...produit,
      fournisseurNom: produit.fournisseur?.nom || null,
      fournisseurId: produit.fournisseur?.id || null,
    })
  } catch (error) {
    console.error('Error updating produit:', error)
    return NextResponse.json(
      { error: 'Failed to update product' },
      { status: 500 }
    )
  }
}

// PATCH /api/produits/[id] - Partial update of a product
export async function PATCH(
  request: NextRequest,
  { params }: { params: Promise<{ id: string }> }
) {
  try {
    const { id } = await params
    const body = await request.json()

    // Check if product exists
    const existingProduit = await db.produit.findUnique({
      where: { id: id },
    })

    if (!existingProduit) {
      return NextResponse.json(
        { error: 'Product not found' },
        { status: 404 }
      )
    }

    const produit = await db.produit.update({
      where: { id: id },
      data: body,
      include: {
        fournisseur: {
          select: {
            id: true,
            nom: true,
          },
        },
      },
    })

    return NextResponse.json({
      ...produit,
      fournisseurNom: produit.fournisseur?.nom || null,
      fournisseurId: produit.fournisseur?.id || null,
    })
  } catch (error) {
    console.error('Error patching produit:', error)
    return NextResponse.json(
      { error: 'Failed to update product' },
      { status: 500 }
    )
  }
}

// DELETE /api/produits/[id] - Delete a product
export async function DELETE(
  request: NextRequest,
  { params }: { params: Promise<{ id: string }> }
) {
  try {
    const { id } = await params
    // Check if product exists
    const existingProduit = await db.produit.findUnique({
      where: { id: id },
      include: {
        ligneVente: true,
        ligneFacture: true,
      },
    })

    if (!existingProduit) {
      return NextResponse.json(
        { error: 'Product not found' },
        { status: 404 }
      )
    }

    // Check if product is used in sales or purchases
    if (existingProduit.ligneVente.length > 0 || existingProduit.ligneFacture.length > 0) {
      return NextResponse.json(
        { error: 'Ce produit est utilisé dans des ventes ou des achats et ne peut pas être supprimé' },
        { status: 400 }
      )
    }

    // Delete associated files first
    await db.fichier.deleteMany({
      where: { produitId: id },
    })

    // Delete the product
    await db.produit.delete({
      where: { id: id },
    })

    return NextResponse.json({ success: true })
  } catch (error) {
    console.error('Error deleting produit:', error)
    return NextResponse.json(
      { error: 'Failed to delete product' },
      { status: 500 }
    )
  }
}
