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/admin/deliveryCost/[uuid]");


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

    if (!session || session.user.role !== "ADMIN") {
      logger.warn("Forbidden", { userRole: session?.user.role });
      return new NextResponse("Forbidden", { status: 403 });
    }

    await db.deliveryCost.delete({
      where: { uuid: params.uuid },
    });

    logger.info("DeliveryCost deleted successfully ", { DeliveryCostUUID: params.uuid});
    return new NextResponse("Category deleted", { status: 200 });
  } catch (error: any) {
    if (error instanceof Prisma.PrismaClientValidationError) {
      logger.error("Prisma Validation Error ", { error: error.message});
    } else {
      logger.error("Error deleting Delivery Cost data", { errorMsg: error.message, errorData: error.config.data });
    }
    return new NextResponse("Internal server Error", { status: 500 });
  }
}


export const PUT = async (req: NextRequest, { params }: { params: { uuid: string } }) => {
  try {
    const session = await getServerSession(authOptions);
    if (!session || session.user.role !== "ADMIN") {
      logger.warn("Forbidden", { status: 403, session: session, userRole: session?.user.role });
      return new NextResponse("Forbidden", { status: 403 });
    }

    const data = await req.formData();

    const city = data.get("city");
    const district = data.get("district");
    const division = data.get("division");
    const post_code = data.get("post_code");
    const shipping_zone = data.get('shipping_zone')
    const courier_company_name = data.get('courier_company_name')
    const delivery_cost = data.get('delivery_cost')
    const per_kg_cost = data.get('per_kg_cost')

    const deliveryCost = await db.deliveryCost.update({
        where: {
            uuid: params.uuid
        },
        data: {
            city: city?.toString(),
            district: district?.toString(),
            division: division?.toString(),
            post_code: post_code?.toString(),
            shipping_zone: shipping_zone?.toString(),
            courier_company_name: courier_company_name?.toString(),
            per_kg_cost: per_kg_cost ? parseFloat(per_kg_cost as string) : 0,
            delivery_cost: delivery_cost ? parseFloat(delivery_cost as string) : undefined 
        }
    })
    // console.log("Parent", parent);

 

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



export const GET = async (req: NextRequest, { params }: { params: { uuid: string } }) => {
  try {
    // console.log('CategoryUUID:', params);
    const delivery_cost = await db.deliveryCost.findUnique({
      where: {
        uuid: params.uuid,
      },
    })

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