import prismadb from "@/lib/prismadb"
import { auth } from '@clerk/nextjs/server'
import { NextResponse } from "next/server"
import { v4 as uuidv4 } from 'uuid';

export async function GET (
    req: Request,
    { params }: {params: {productId: string}}
) {
    try {
        if (!params.productId) {
            return new NextResponse("Product id is required", {status: 400})
        }

        const product = await prismadb.products.findUnique({
            where: {
                id: params.productId,
            },
            include: {
                image: true,
                category: true,
                variant: true,
                imagedetail: true,
            }
        })
        console.log('products', product); 

        return NextResponse.json(product)
    } catch (error) {
        console.log('[PRODUCT_GET', error)
        return new NextResponse("Internal error", {status: 500})
    }
}

export async function PATCH(
  req: Request,
  { params }: { params: { storeId: string; productId: string } }
) {
  try {
    const { userId } = auth();
    const body = await req.json();

    const {
      name,
      colour,
      description,
      price,
      priceDlr,
      categoryId,
      variantId,
      images,
      imageDetail,
      isFeatured,
      isArchived,
    } = body;

    console.log('body', body);

    // Validate required fields
    if (!userId) {
      return new NextResponse("Unauthenticated", { status: 401 });
    }
    if (!name || !colour || !description || !price || !priceDlr || !categoryId || !variantId) {
      return new NextResponse("All required fields must be provided", { status: 400 });
    }
    if (!imageDetail || !imageDetail.fullBody || !imageDetail.close1 || !imageDetail.close2 || !imageDetail.close3) {
      return new NextResponse('All image details are required', { status: 400 });
    }
    if (!Array.isArray(images) || images.length === 0 || !images.every(img => img.url)) {
      return new NextResponse("Images are required and must have valid URLs", { status: 400 });
    }
    if (!params.storeId) {
      return new NextResponse("Store id is required", { status: 400 });
    }

    // Check store authorization
    const storeByUserId = await prismadb.store.findFirst({
      where: {
        id: params.storeId,
        userId,
      },
    });

    if (!storeByUserId) {
      return new NextResponse("Unauthorized", { status: 403 });
    }

    // Update the product
    await prismadb.products.update({
      where: {
        id: params.productId,
      },
      data: {
        name,
        colour,
        description,
        price: Number(price),
        priceDlr: Number(priceDlr),
        category: { connect: { id: categoryId } },
        variant: { connect: { id: variantId } },
        isFeatured,
        isArchived,
        image: {
          deleteMany: {}, 
          createMany: {
            data: images.map((img: { url: string }) => ({
              id: uuidv4(),
              url: img.url,
              updatedAt: new Date().toISOString(),
            })),
          },
        },
        imagedetail: {
          upsert: {
            create: {
              id: uuidv4(),
              fullBody: imageDetail.fullBody,
              close1: imageDetail.close1,
              close2: imageDetail.close2,
              close3: imageDetail.close3,
              updatedAt: new Date().toISOString(),
            },
            update: {
              fullBody: imageDetail.fullBody,
              close1: imageDetail.close1,
              close2: imageDetail.close2,
              close3: imageDetail.close3,
              updatedAt: new Date().toISOString(),
            },
            where: { id: params.productId },
          },
        },
      },
      include: {
        image: true,
        category: true,
        variant: true,
        imagedetail: true,
      },
    });

    // Retrieve the updated product
    const product = await prismadb.products.findUnique({
      where: {
        id: params.productId,
      },
      include: {
        image: true,
        category: true,
        variant: true,
        imagedetail: true,
      },
    });

    return NextResponse.json(product);
  } catch (error) {
    console.log("[PRODUCT_PATCH]", error);
    return new NextResponse("Internal error", { status: 500 });
  }
}
  

  export async function DELETE (
    req: Request,
    { params }: {params: {storeId: string, productId: string}}
  ) {
    try {
        const {userId} = auth()

        if (!userId) {
            return new NextResponse("Unauthenticated", {status: 401})
        }

        if (!params.productId) {
            return new NextResponse("Product id is required", {status: 400})
        }
        
        const storeByUserId = await prismadb.store.findFirst({
            where:{
                id: params.storeId,
                userId
            }
        })

        const product = await prismadb.products.deleteMany({
            where: {
                id: params.productId,
            }
        });
        return NextResponse.json(product);
    } catch (error) {
        console.log('[PRODUCT_DELETE', error)
        return new NextResponse("Internal error", {status: 500})
    }
  }