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 POST(
  req: Request,
  { params }: { params: { storeId: string } }
) {
  try {
    const { userId } = auth();
    const body = await req.json();

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

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

    // Validasi apakah imageDetail lengkap
    if (!imageDetail || !imageDetail.fullBody || !imageDetail.close1 || !imageDetail.close2 || !imageDetail.close3) {
      return new NextResponse('All image details are required', { status: 400 });
    }

    // Validasi apakah array images ada dan tidak kosong
    if (!Array.isArray(images) || images.length === 0) {
      return new NextResponse("Images are required", { status: 400 });
    }

    if (!name) {
      return new NextResponse("Name is required", { status: 400 });
    }

    if (!colour) {
      return new NextResponse("Colour is required", { status: 400 });
    }

    if (!description) {
      return new NextResponse("Description is required", { status: 400 });
    }

    if (!price) {
      return new NextResponse("Price IDR is required", { status: 400 });
    }
    
    if (!priceDlr) {
      return new NextResponse("Price USD is required", { status: 400 });
    }

    if (!categoryId) {
      return new NextResponse("Category is required", { status: 400 });
    }

    if (!variantId) {
      return new NextResponse("Variant is required", { status: 400 });
    }

    if (!params.storeId) {
      return new NextResponse("Store id is required", { status: 400 });
    }

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

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

    const product = await prismadb.products.create({
      data: {
        id: uuidv4(),
        name,
        colour,
        description,
        price: Number(price),
        priceDlr: Number(priceDlr),
        isFeatured,
        isArchived,
        createdAt: new Date().toISOString(),
        updatedAt: new Date().toISOString(),
        category: {
          connect: { id: categoryId },
        },
        variant: {
          connect: { id: variantId },
        },
        store: {
          connect: { id: params.storeId },
        },
        image: {
          createMany: {
            data: images.map((image: { url: string }) => ({
              id: uuidv4(), 
              url: image.url,
              updatedAt: new Date().toISOString(),
            })),
          },
        },
        imagedetail: {
          create: {
            id: uuidv4(),
            fullBody: imageDetail.fullBody,
            close1: imageDetail.close1,
            close2: imageDetail.close2,
            close3: imageDetail.close3,
            updatedAt: new Date().toISOString(),
          },
        },
      },
      include: {
        image: true,
        category: true,
        imagedetail: true,
      },
    });

    // Konversi Decimal ke Number  
    const responseProduct = {  
      ...product,  
      price: product.price ? product.price.toNumber() : 0, // Jika null, gunakan 0 sebagai default  
      priceDlr: product.priceDlr ? product.priceDlr.toNumber() : 0, // Jika null, gunakan 0 sebagai default  
    };  

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

export async function GET(
  req: Request,
  { params }: { params: { storeId: string } }
) {
  try {
    const { searchParams } = new URL(req.url);

    // Mendapatkan parameter filter
    const categoryId = searchParams.get("categoryId") || undefined;
    const variantId = searchParams.get("variantId") || undefined;
    const isFeatured = searchParams.get("isFeatured") === "true";
    const minPrice = searchParams.get("minPrice");
    const maxPrice = searchParams.get("maxPrice");

    // Mendapatkan parameter sorting
    const sortBy = searchParams.get("sortBy") || "createdAt";
    const sortOrder = searchParams.get("sortOrder") || "desc";

    if (!params.storeId) {
      return new NextResponse("Store id is required", { status: 400 });
    }

    // Query produk dengan filter dan sorting dinamis
    const products = await prismadb.products.findMany({
      where: {
        storeId: params.storeId,
        categoryId,
        variantId,
        isFeatured: isFeatured ? true : undefined,
        isArchived: false,
        // Filter harga
        price: {
          ...(minPrice ? { gte: Number(minPrice) } : {}),
          ...(maxPrice ? { lte: Number(maxPrice) } : {}),
        },
        priceDlr: {
          ...(minPrice ? { gte: Number(minPrice) } : {}),
          ...(maxPrice ? { lte: Number(maxPrice) } : {}),
        },
      },
      include: {
        image: true,
        category: true,
        imagedetail: true,
      },
      orderBy: {
        [sortBy]: sortOrder,
      },
    });

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