import { NextRequest, NextResponse } from "next/server";
import { authOptions } from "@/app/api/auth/[...nextauth]/auth-options";
import { getServerSession } from "next-auth";
import { db } from "@/lib/db";
import { Prisma } from "@prisma/client";
import { getLogger } from "@/utils/logger";

const logger = getLogger("/api/cart/[variantUuid]")


export const POST = async (req: NextRequest, { params }: { params: { variantId: string } }) => {
    try {
        const session = await getServerSession(authOptions);

        const user = await db.user.findUnique({
            where: {
                uuid: session?.user.uuid
            },
            include: {
                profile: {
                    include: {
                        Cart: true
                    }
                },

            },
        })

        const profileId = user?.profile?.id

        const cart_id = user?.profile?.Cart?.id

        const variant = await db.productVariant.findUnique({
            where: {
                id: parseInt(params.variantId)
            }
        })

        if (!profileId) {
            return NextResponse.json({ mssg: 'Not authorized' }, { status: 403 })
        }

        const cartItem = await db.cartItem.findUnique({
            where: {
                cart_id_variant_id: {
                    cart_id: cart_id as number,
                    variant_id: parseInt(params.variantId)
                }
            }
        })

        var updatedCart

        if (cartItem && cartItem.quantity > 1) {
            const updatedCartItem = await db.cartItem.update({
                where: {
                    cart_id_variant_id: {
                        cart_id: cart_id as number,
                        variant_id: parseInt(params.variantId)
                    }
                },
                data: {
                    quantity: cartItem.quantity - 1
                },
                include: {
                    variant: {
                        include: {
                            variant_images: true
                        }
                    }
                }
            })

            updatedCart = await db.cart.update({
                where: {
                    id: user.profile?.Cart?.id
                },
                data: {
                    totalPrice: (user.profile?.Cart?.totalPrice ?? 0) - (variant?.special_price ?? 0),
                    totalQuantity: (user.profile?.Cart?.totalQuantity ?? 0) - 1
                },
                include: {
                    CartItem: {
                        orderBy: {
                            price: Prisma.SortOrder.desc
                        },
                        include: {
                            variant: {
                                include: {
                                    variant_images: true
                                }
                            }
                        }
                    }
                }
            })


            return NextResponse.json({ mssg: { cartItem: updatedCartItem }, updatedCart }, { status: 200 })

        }
        else if (cartItem && cartItem.quantity == 1) {

            await db.cartItem.delete({
                where: {
                    cart_id_variant_id: {
                        cart_id: cart_id as number,
                        variant_id: parseInt(params.variantId)
                    }
                }
            })

            updatedCart = await db.cart.update({
                where: {
                    id: user.profile?.Cart?.id
                },

                data: {
                    totalPrice: (user.profile?.Cart?.totalPrice ?? 0) - (variant?.special_price ?? 0),
                    totalQuantity: (user.profile?.Cart?.totalQuantity ?? 0) - 1
                },
                include: {
                    CartItem: {
                        orderBy: {
                            price: Prisma.SortOrder.desc
                        },
                        include: {
                            variant: {
                                include: {
                                    variant_images: true
                                }
                            }
                        }
                    }
                }
            })
        }

        return NextResponse.json({ updatedCart }, { status: 200 })



    } catch (error: any) {
        if (error instanceof Prisma.PrismaClientValidationError) {
            logger.error("Prisma Validation Error ", { error: error.message });
        } else {
            logger.error("Error removing Cart Item", { errorMsg: error.message, errorData: error.config.data });
        }
        return new NextResponse("Internal server Error", { status: 500 });
    }
}



export const DELETE = async (request: NextRequest, { params }: { params: { variantId: string } }) => {
    try {

        const session = await getServerSession(authOptions);

        const user = await db.user.findUnique({
            where: {
                uuid: session?.user.uuid
            },
            include: {
                profile: {
                    include: {
                        Cart: true
                    }
                },

            },
        })

        const profileId = user?.profile?.id

        const cart_id = user?.profile?.Cart?.id

        const cartItem = await db.cartItem.findUnique({
            where: {
                cart_id_variant_id: {
                    cart_id: cart_id as number,
                    variant_id: parseInt(params.variantId)
                }
            }
        })

        await db.cartItem.delete({
            where: {
                cart_id_variant_id: {
                    cart_id: cart_id as number,
                    variant_id: parseInt(params.variantId)
                }
            }
        })

        const updatedCart = await db.cart.update({
            where: {
                id: cart_id
            },
            data: {
                totalQuantity: (user?.profile?.Cart?.totalQuantity ?? 0) - (cartItem?.quantity ?? 0),
                totalPrice: (user?.profile?.Cart?.totalPrice ?? 0) - (cartItem?.quantity ?? 0) * (cartItem?.price ?? 0)
            },
            include: {
                CartItem: {
                    orderBy: {
                        price: Prisma.SortOrder.desc
                    },
                    include: {
                        variant: {
                            include: {
                                variant_images: true
                            }
                        }
                    }
                }
            }
        })

        var stockout = false

        updatedCart.CartItem.forEach(item => {
            if (item.variant.quantity <= 0) {
                stockout = true
            }
        })


        return NextResponse.json({ mssg: "CartItem removed successfully", updatedCart, stockout }, { status: 200 })

    }
    catch (error: any) {
        return new NextResponse("Internal server Error", { status: 500 })
    }
}