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,
} from "./types";

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,
  });

  return privilege;
};