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 {CategoryType, Prisma} from "@prisma/client";
import {getLogger} from "@/utils/logger";

const logger = getLogger("/api/user/review/[id]");


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

    const review = await db.review.findUnique({
      where: { id: parseInt(params.id) },
        include: {
            profile: true
        }
    });

    if (!session || session.user.profileId !== review?.profile?.id) {
      return new NextResponse("Forbidden", { status: 403 });
    }

    await db.review.delete({
      where: { id: parseInt(params.id) },
    });


    return new NextResponse("Review deleted successfully", { status: 200 });
  } catch (error: any) {
    if (error instanceof Prisma.PrismaClientValidationError) {
      logger.error("Prisma Validation Error ", { error: error.message});
    } else {
      logger.error("Error deleting review", { errorMsg: error.message, errorData: error.config.data });
    }
    return new NextResponse("Internal server Error", { status: 500 });
  }
}


export const PUT = async (req: NextRequest, { params }: { params: { id: string } }) => {
  try {

    const session = await getServerSession(authOptions);

    const review = await db.review.findUnique({
        where: { id: parseInt(params.id) },
        include: {
            profile: true
        }
    });

    if (!session || session.user.profileId !== review?.profile?.id) {
      return new NextResponse("Forbidden", { status: 403 });
    }

    const d = await req.json()

    const rev = d.review
    const rating = d.rating

    
    const updatedReview = await db.review.update({
        where: {
            id: parseInt(params.id)
        },
        data: {
            review: rev,
            rating: parseInt(rating)
        }
    })


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



export const GET = async (req: NextRequest, { params }: { params: { categoryUUID: string } }) => {
  try {
    // console.log('CategoryUUID:', params);
    const category = await db.categories.findUnique({
      where: {
        uuid: params.categoryUUID,
      },
      include: {
        children: {
          include: {
            children: {
              include: {
                children: true,
              },
            },
          },
        },
      },

    })

    if (!category) {
      return NextResponse.json({ error: "Category not found" }, { status: 404 });
    }
    return NextResponse.json(category, { status: 200})
  }
  catch(error: any){
    if (error instanceof Prisma.PrismaClientValidationError) {
      logger.error("Prisma Validation Error ", { error: error.message});
    } else {
      logger.error("Error fetching category ", { errorMsg: error.message, errorData: error.config.data });
    }
    return NextResponse.json({ error: "Internal Server Error" }, { status: 500 });
  }
}