import { prisma } from "../../lib/prisma.js";
import { Prisma } from "@prisma/client";
import { AppError } from "../../utils/app_error.js";

const createSupportIntoDB = async (payload: any) => {
  const result = await prisma.support.create({ data: payload });
  return result;
};

const getAllSupportFromDB = async (
  user_id: string,
  role: string,
  search?: string,
  type?: string,
  status?: string,
  page: number = 1,
  limit: number = 10,
) => {
  const andCondition: Prisma.SupportWhereInput[] = [];

  if (search) {
    andCondition.push({
      OR: [
        {
          issueName: {
            contains: search,
            mode: "insensitive",
          },
        },
        {
          description: {
            contains: search,
            mode: "insensitive",
          },
        },
      ],
    });
  }
  if (type) {
    andCondition.push({
      type: type as any,
    });
  }

  if (status) {
    andCondition.push({
      status: status as any,
    });
  }

  if (role !== "ADMIN") {
    andCondition.push({
      storeAccountId: user_id,
    });
  }

  const whereCondition: Prisma.SupportWhereInput =
    andCondition.length > 0 ? { AND: andCondition } : {};

  const skip = (page - 1) * limit;

  const [data, total] = await Promise.all([
    prisma.support.findMany({
      where: whereCondition,
      skip,
      take: limit,
      orderBy: {
        createdAt: "desc",
      },
    }),
    prisma.support.count({
      where: whereCondition,
    }),
  ]);

  return {
    meta: {
      page,
      limit,
      total,
      totalPage: Math.ceil(total / limit),
    },
    data,
  };
};

const getSingleSupportFromDB = async (
  id: string,
  userId: string,
  role: string,
) => {
  const support = await prisma.support.findUnique({
    where: { id },
  });
  if (!support) {
    throw new AppError("Support not found", 404);
  }

  if (role !== "ADMIN" && support.storeAccountId !== userId) {
    throw new AppError("You are not authorized", 403);
  }
  return support;
};

const updateSupportIntoDB = async (
  id: string,
  userId: string,
  role: string,
  payload: any,
) => {
  const support = await prisma.support.findUnique({
    where: { id },
  });

  if (!support) {
    throw new AppError("Support not found", 404);
  }

  if (role !== "ADMIN" && support.storeAccountId !== userId) {
    throw new AppError("You are not authorized", 403);
  }

  const result = await prisma.support.update({
    where: { id },
    data: payload,
  });

  return result;
};

const deleteSupportFromDB = async (
  id: string,
  userId: string,
  role: string,
) => {
  const support = await prisma.support.findUnique({
    where: { id },
  });
  if (!support) {
    throw new AppError("Support not found", 404);
  }
  if (role !== "ADMIN" && support.storeAccountId !== userId) {
    throw new AppError("You are not authorized", 403);
  }

  const result = await prisma.support.delete({
    where: { id },
  });
  return result;
};

export const support_service = {
  createSupportIntoDB,
  getAllSupportFromDB,
  getSingleSupportFromDB,
  updateSupportIntoDB,
  deleteSupportFromDB,
};