import { Types } from "mongoose";

import { PrivilegeModel } from "@/models/privilege.model";

import { validateEmptyFields } from "@/utils/validate-empty-fields";
import { convertPrivilegiesToMap, defineGetAllPrivilegiesFormat, validatePrivilege } from "./helpers";

import type { FastifyReply } from "fastify";
import type {
  GetAllPrivilegiesRequest,
  GetServicePrivilegiesRequest,
  RegisterPrivilegeRequest,
  GetPrivilegeRequest,
  RegisterPrivilegiesRequest,
} from "./types";

export const registerPrivilegies = async (request: RegisterPrivilegiesRequest, reply: FastifyReply) => {
  const [requestBody, errorEmpty] = validateEmptyFields(request.body || {}, ["privilegies"]);

  if (errorEmpty) {
    reply.status(400);
    return errorEmpty;
  }

  if (!requestBody.privilegies.length) {
    reply.status(400);
    return new Error("empty privilege array");
  }

  for (const rawPrivilege of requestBody.privilegies) {
    const errorInvalid = validatePrivilege(rawPrivilege);

    if (errorInvalid) {
      reply.status(400);
      return errorInvalid;
    }
  }

  const updatePrivilegeRequests = requestBody.privilegies.map(async (privilege) => {
    await PrivilegeModel.updateOne(
      { privilegeId: privilege.privilegeId },
      {
        $set: {
          name: privilege.name,
          privilegeId: privilege.privilegeId,
          serviceKey: privilege.serviceKey,
          description: privilege.description,
          type: privilege.type,
          value: privilege.value,
          price: privilege.price,
          isDeleted: false,
          createdAt: new Date(),
        },
      },
      { upsert: true }
    ).lean();

    return privilege;
  });

  return Promise.all(updatePrivilegeRequests);
};

export const registerPrivilege = async (request: RegisterPrivilegeRequest, reply: FastifyReply) => {
  const [requestBody, errorEmpty] = validateEmptyFields(
    request.body || {},
    ["name", "privilegeId", "serviceKey", "type", "description", "price", "value"],
    false
  );

  if (errorEmpty) {
    reply.status(400);
    return errorEmpty;
  }

  const errorInvalid = validatePrivilege(requestBody);

  if (errorInvalid) {
    reply.status(400);
    return errorInvalid;
  }

  const privilege = await PrivilegeModel.findOne({ privilegeId: requestBody.privilegeId }).lean();

  if (privilege) {
    reply.status(409);
    return new Error("privilege already exist");
  }

  const newPrivilege = new PrivilegeModel({
    name: requestBody.name,
    privilegeId: requestBody.privilegeId,
    serviceKey: requestBody.serviceKey,
    description: requestBody.description,
    type: requestBody.type,
    value: requestBody.value,
    price: requestBody.price,
  });

  return newPrivilege.save();
};

export const getAllPrivilegies = async (request: GetAllPrivilegiesRequest, reply: FastifyReply) => {
  const format = defineGetAllPrivilegiesFormat(request.query?.format);
  const privilegies = await PrivilegeModel.find({}).lean();

  if (format === "array") {
    return privilegies;
  }

  if (format === "map" && !privilegies.length) {
    return {};
  }

  if (format === "map" && privilegies.length) {
    return convertPrivilegiesToMap(privilegies);
  }

  reply.status(500);

  return new Error("format not defined");
};

export const getServicePrivilegies = async (request: GetServicePrivilegiesRequest, reply: FastifyReply) => {
  const [requestParams, error] = validateEmptyFields(request.params || {}, ["serviceKey"]);

  if (error) {
    reply.status(400);
    return error;
  }

  return PrivilegeModel.find({ serviceKey: requestParams.serviceKey });
};

export const getPrivilege = async (request: GetPrivilegeRequest, reply: FastifyReply) => {
  const [requestParams, error] = validateEmptyFields(request.params || {}, ["id"]);

  if (error) {
    reply.status(400);
    return error;
  }

  if (!Types.ObjectId.isValid(requestParams.id)) {
    reply.status(400);
    return new Error("invalid id");
  }

  const privilege = await PrivilegeModel.findOne({ privilegeId: requestParams.id });

  if (!privilege) {
    reply.status(404);
    return new Error("privilege not found");
  }

  return privilege;
};

export const replacePrivilege = async (request: RegisterPrivilegeRequest, reply: FastifyReply) => {
  const [requestBody, errorEmpty] = validateEmptyFields(
    request.body || {},
    ["name", "privilegeId", "serviceKey", "type", "description", "price", "value"],
    false
  );

  if (errorEmpty) {
    reply.status(400);
    return errorEmpty;
  }

  const errorInvalid = validatePrivilege(requestBody);

  if (errorInvalid) {
    reply.status(400);
    return errorInvalid;
  }

  const privilege = await PrivilegeModel.findOne({ privilegeId: requestBody.privilegeId });

  if (!privilege) {
    reply.status(404);
    return new Error("privilege not found");
  }

  await privilege.replaceOne({
    name: requestBody.name,
    privilegeId: requestBody.privilegeId,
    serviceKey: requestBody.serviceKey,
    description: requestBody.description,
    type: requestBody.type,
    value: requestBody.value,
    price: requestBody.price,
    updatedAt: new Date(),
  });

  return privilege;
};

export const replacePrivilegies = async (request: RegisterPrivilegiesRequest, reply: FastifyReply) => {
  const [requestBody, errorEmpty] = validateEmptyFields(request.body || {}, ["privilegies"]);

  if (errorEmpty) {
    reply.status(400);
    return errorEmpty;
  }

  if (!requestBody.privilegies.length) {
    reply.status(400);
    return new Error("empty privilege array");
  }

  for (const rawPrivilege of requestBody.privilegies) {
    const errorInvalid = validatePrivilege(rawPrivilege);

    if (errorInvalid) {
      reply.status(400);
      return errorInvalid;
    }
  }

  const replacePrivilegeRequests = requestBody.privilegies.map(async (privilege) => {
    await PrivilegeModel.replaceOne(
      { privilegeId: privilege.privilegeId },
      {
        $set: {
          name: privilege.name,
          privilegeId: privilege.privilegeId,
          serviceKey: privilege.serviceKey,
          description: privilege.description,
          type: privilege.type,
          value: privilege.value,
          price: privilege.price,
          updatedAt: new Date(),
          isDeleted: false,
        },
      }
    ).lean();

    return privilege;
  });

  return Promise.all(replacePrivilegeRequests);
};

export const removePrivilege = async (request: GetPrivilegeRequest, reply: FastifyReply) => {
  const [requestParams, error] = validateEmptyFields(request.params || {}, ["id"]);

  if (error) {
    reply.status(400);
    return error;
  }

  if (!Types.ObjectId.isValid(requestParams.id)) {
    reply.status(400);
    return new Error("invalid id");
  }

  const privilege = await PrivilegeModel.findOneAndUpdate(
    { privilegeId: requestParams.id },
    { $set: { isDeleted: true, deletedAt: new Date() } }
  );

  if (!privilege) {
    reply.status(404);
    return new Error("privilege not found");
  }

  return privilege;
};