const _ = require('lodash');
require('dotenv').config()
const mongoose = require("mongoose");
const { User } = require('../../models/user');
const { Role } = require('../../models/role');
const { apiResponse } = require("../../core/response/response")
const { CronEmail } = require('../../models/email')
const { dateFormat } = require('../../core/utilities/commonService');
const { SUCCESS, REDIRECTION, CLIENT_ERROR, SERVER_ERROR } = require("../../core/response/statusCode")
const { ERROR_MSG, SUCCESS_MSG } = require("../../core/response/messages")
const { sendEmail } = require('../../core/utilities/emailService');
const { addAdminTemplate, spaceAccountTemplate } = require('../../core/email-templates/email-admin');
const {RegisteredByAdmin} = require("../../core/email-templates/email-web");
export { };

exports.usersListing = async (req, res) => {
    var title_lang = 'en';


    try {
        const { clinic_name, clinic_contact, custom_selected_speciality, list_type, first_name, last_name, is_account_active_string_status, dob, phone_number, gender, email, user_account_status, created, updated, clinic_municipality , clinic_department,selected_speciality , createdAt , updatedAt} = req.body;

        const fetchUserRole = await Role.findOne({ title: list_type });
        if (fetchUserRole) {
            var filteredQuery = {}
            let page, limit: number;
            let clinic_name_regex = new RegExp(clinic_name, 'i');
            let clinic_contact_regex = new RegExp(clinic_contact, 'i');
            let first_name_regex = new RegExp(first_name, 'i');
            let last_name_regex = new RegExp(last_name, 'i');
            let dob_regex = new RegExp(dob, 'i');
            let phone_number_regex = new RegExp(phone_number, 'i');
            let gender_regex = gender?.toLowerCase();
            let email_regex = new RegExp(email, 'i');
            // let user_account_status_regex = new RegExp(user_account_status, 'i');
            var createdDate = new Date(dateFormat(created, 'yyyy-MM-dd'));
            var updatedDate = new Date(dateFormat(updated, 'yyyy-MM-dd'));
            createdDate.setDate(createdDate.getDate() + 1)
            updatedDate.setDate(updatedDate.getDate() + 1)
            page = req.query.page ? parseInt(req.query.page) - 1 : 0;
            limit = 10;
            const filter_clinic_name = (clinic_name && clinic_name != 'undefined') ? { clinic_name: clinic_name_regex } : {};
            const filter_clinic_contact = (clinic_contact && clinic_contact != 'undefined') ? { clinic_contact: clinic_contact_regex } : {};
            const filter_first_name = (first_name && first_name != 'undefined') ? { first_name: first_name_regex } : {};
            const filter_last_name = (last_name && last_name != 'undefined') ? { last_name: last_name_regex } : {};
            const filter_dob = (dob && dob != 'undefined') ? { dob: dob_regex } : {};
            const filter_phone_number = (phone_number && phone_number != 'undefined') ? { 'phone_number.e164Number': phone_number_regex } : {};
            const filter_gender = (gender && gender != 'undefined') ? { gender: gender_regex } : {};
            const filter_email = (email && email != 'undefined') ? { email: email_regex } : {};
            // const filter_user_account_status = (user_account_status && user_account_status != 'undefined') ? { user_account_status: user_account_status_regex } : {};

            const filter_createdAt = (created && created != 'undefined') ? { createdAt: { $gte: new Date(dateFormat(created, 'yyyy-MM-dd')), $lt: new Date(dateFormat(createdDate, 'yyyy-MM-dd')) } } : {};
            const filter_updatedAt = (updated && updated != 'undefined') ? { updatedAt: { $gte: new Date(dateFormat(updated, 'yyyy-MM-dd')), $lt: new Date(dateFormat(updatedDate, 'yyyy-MM-dd')) } } : {};

            if(createdAt)
            {
                filteredQuery["createdAt"] = { $gte : new Date( (new Date(createdAt)).setUTCHours(0 , 0 , 0)) , $lte :  new Date((new Date(createdAt)).setUTCHours(23 , 59 , 59))};
            }

            if(updatedAt)
            {
                filteredQuery["updatedAt"] = { $gte : new Date((new Date(updatedAt)).setUTCHours(0 , 0 , 0)) , $lte :  new Date((new Date(updatedAt)).setUTCHours(23 , 59 , 59))};
            }

            filteredQuery = { ...filter_clinic_name, ...filter_clinic_contact, ...filter_first_name, ...filter_last_name, ...filter_createdAt, ...filter_updatedAt, ...filter_dob, ...filter_phone_number, ...filter_gender, ...filter_email, is_deleted: false , ...filteredQuery  }
           


            if (is_account_active_string_status) {
                filteredQuery['is_account_active'] = is_account_active_string_status == "true" ? true : false;
            }else{
                filteredQuery['is_account_active'] = true;
            }

            if (custom_selected_speciality) {
                filteredQuery['primary_specialty'] = {
                    $in: [new mongoose.Types.ObjectId(custom_selected_speciality)]
                }
            }
            if(user_account_status){
                filteredQuery['user_account_status'] = user_account_status
            }

            if(clinic_municipality)
            {
                filteredQuery['clinic_municipality.commune_en'] = clinic_municipality;
            }
            if(clinic_department)
            {
                filteredQuery['clinic_department.wilaya_en'] = clinic_department;
            }
            if(selected_speciality)
            {
                filteredQuery['primary_specialty'] =   { $in : [new mongoose.Types.ObjectId(selected_speciality)]};
            }
            

            filteredQuery['user_role'] = new mongoose.Types.ObjectId(fetchUserRole._id);
            // filteredQuery['is_completed'] = true
            let skip = parseInt(page) * limit;
            const [data, count, pending_count,approved_count,rejected_count] = await Promise.all([
                User.aggregate([
                    { $match: filteredQuery },
                    { $sort: { createdAt: -1 } },
                    { $skip: skip },
                    { $limit: limit },

                    {
                        $lookup: {
                            from: "roles",
                            as: "role_of_user",
                            let: { user_role: "$user_role" },
                            pipeline: [
                                {
                                    $match: {

                                        $expr: { $eq: ["$$user_role", "$_id"] },
                                    }
                                },
                            ],
                        },
                    },
                    {
                        $unwind: {
                            path: '$role_of_user',
                            preserveNullAndEmptyArrays: true,
                        },
                    },
                    {
                        $lookup: {
                            from: "categories",
                            as: "selected_speciality",
                            let: { primary_specialty: "$primary_specialty" },
                            pipeline: [
                                {
                                    $match: {
                                        $expr: {
                                            $and: [
                                                { $ne: ["$$primary_specialty", []] },
                                                {
                                                    $cond: {
                                                        if: { $isArray: "$$primary_specialty" },
                                                        then: { $in: ["$_id", "$$primary_specialty"] },
                                                        else: { $eq: ["$_id", "$$primary_specialty"] }
                                                    }
                                                }
                                            ]
                                        }
                                    }
                                },
                                {
                                    $project: {
                                        _id: 1,
                                        title_ar: 1,
                                        title_en: 1,
                                        title_fr: 1,
                                        image: 1
                                    }
                                }
                            ],
                        },

                    },

                    {
                        $lookup: {
                            from: "bookings",
                            as: "appointment_count",
                            let: { user_id: "$_id" },
                            pipeline: [
                                {
                                    $match: {
                                        $expr: { $eq: ["$hospital_doctor_id", "$$user_id"] }
                                    }
                                },
                                {
                                    $count: "totalAppointments"
                                }
                            ]
                        }
                    },

                    {
                        $addFields: {
                            appointmentCount: {
                                $ifNull: [{ $arrayElemAt: ["$appointment_count.totalAppointments", 0] }, 0]
                            }
                        }
                    },


                    {
                        $lookup: {
                            from: "bookings",
                            as: "patient_appointment_count",
                            let: { user_id: "$_id" },
                            pipeline: [
                                {
                                    $match: {
                                        $expr: { $eq: ["$patient_id", "$$user_id"] }
                                    }
                                },
                                {
                                    $count: "totalAppointments"
                                }
                            ]
                        }
                    },

                    {
                        $addFields: {
                            patientAppointmentCount: {
                                $ifNull: [{ $arrayElemAt: ["$patient_appointment_count.totalAppointments", 0] }, 0]
                            }
                        }
                    },

                    {
                        $lookup : 
                        {
                            from : "users",
                            localField : "guardian_id",
                            foreignField : "_id",
                            as : "guardian_details"
                        }
                    },
                    {
                        $unwind : { path : "$guardian_details" , preserveNullAndEmptyArrays : true}
                    }


                    
                ]),
                User.countDocuments(filteredQuery),
                User.countDocuments({
                    user_account_status: "PENDING",
                    user_role: new mongoose.Types.ObjectId(fetchUserRole._id),
                    is_completed: true,
                    is_deleted:false,
                    is_account_active:true
                    
                }),
                User.countDocuments({
                    user_account_status: "APPROVED",
                    user_role: new mongoose.Types.ObjectId(fetchUserRole._id),
                    is_completed: true,
                    is_deleted:false,
                    is_account_active:true
                    
                }),
                User.countDocuments({
                    user_account_status: "REJECTED",
                    user_role: new mongoose.Types.ObjectId(fetchUserRole._id),
                    is_completed: true,
                    is_deleted:false,
                    is_account_active:true
                    
                })
            ]);

            return res.json({
                count: count,
                pending_count: pending_count,
                approved_count:approved_count,
                rejected_count:rejected_count,
                data: data,
                errors: [],
                is_error: false,
                message: "",
                responseCode: 200
            })

            // return apiResponse(res, false, [], '', SUCCESS.OK, count, data, req)
        } else {
            return apiResponse(res, false, [], '', SUCCESS.OK, 0, [], req)
        }


    } catch (error) {
        console.log(error);
        return apiResponse(res, true, [], ERROR_MSG[`SYSTEM-ERROR-${title_lang}`], SERVER_ERROR.internalServerError, 0, [], req)
    }
}


// delete User
exports.deleteUser = async (req, res) => {

    let lang = 'en'
    try {
        const id = req.body.id;
        let cres = await User.findOneAndUpdate({ _id: new mongoose.Types.ObjectId(id) }, { $set: { is_deleted: true } }, { new: true })
        if (cres) {
            return apiResponse(res, false, [], '', SUCCESS.OK, 0, [cres], req);
        } else {
            return apiResponse(res, true, [], ERROR_MSG[`SYSTEM-ERROR-${lang}`], SERVER_ERROR.internalServerError, 0, [], req)
        }

    } catch (err) {
        return apiResponse(res, true, [], ERROR_MSG[`SYSTEM-ERROR-${lang}`], SERVER_ERROR.internalServerError, 0, [])
    }
}

// delete selected User
exports.deleteSelectedUser = async (req, res) => {
    let lang = 'en';
    let ids = req.body.id;
    try {
        let cres = await User.updateMany({ _id: { $in: ids } }, { $set: { is_deleted: true, updatedAt: new Date() } }, { multi: true, upsert: true, new: true })
        if (cres) {
            return apiResponse(res, false, [], '', SUCCESS.OK, 0, [], req);
        } else {
            return apiResponse(res, true, [], ERROR_MSG[`SYSTEM-ERROR-${lang}`], SERVER_ERROR.internalServerError, 0, [])
        }

    } catch (err) {
        return apiResponse(res, true, [], ERROR_MSG[`SYSTEM-ERROR-${lang}`], SERVER_ERROR.internalServerError, 0, [])
    }
}

exports.changeDoctorPatientStatus = async (req, res) => {

    let lang = 'en'
    const { id, status } = req.body
    let condition = {}
    condition['_id'] = id;
    let record = await User.findOne(condition, { _id: 1 });
    if (record) {
        const updateUser = await User.findOneAndUpdate(condition, { $set: { is_account_active: status } }, { new: true })
        return apiResponse(res, false, [], '', SUCCESS.OK, 0, [updateUser], req);
    }
    return apiResponse(res, true, [], ERROR_MSG[`NO-RECORD-FOUND-${lang}`], CLIENT_ERROR.badRequest, 0, [], req);

}


exports.changeUserAccountStatus = async (req, res) => {

    let lang = 'en'
    const { userId, user_account_status } = req.body
    let condition = {}
    condition['_id'] = new mongoose.Types.ObjectId(userId);
    let record = await User.findOne(condition, { _id: 1 });
    if (record) {
        const updateUser = await User.findOneAndUpdate(condition, { $set: { user_account_status: user_account_status } }, { new: true })
        return apiResponse(res, false, [], '', SUCCESS.OK, 0, [updateUser], req);
    }
    return apiResponse(res, true, [], ERROR_MSG[`NO-RECORD-FOUND-${lang}`], CLIENT_ERROR.badRequest, 0, [], req);

}
exports.paymentDetails = async (req, res) => {

    let lang = 'en'
    const { userId, payment_details } = req.body
    let condition = {}
    condition['_id'] = new mongoose.Types.ObjectId(userId);
    let record = await User.findOne(condition, { _id: 1 });
    if (record) {
        const updateUser = await User.findOneAndUpdate(condition, { $set: { payment_details: payment_details } }, { new: true })
        return apiResponse(res, false, [], '', SUCCESS.OK, 0, [updateUser], req);
    }
    return apiResponse(res, true, [], ERROR_MSG[`NO-RECORD-FOUND-${lang}`], CLIENT_ERROR.badRequest, 0, [], req);

}
exports.getPaymentDetails = async (req, res) => {
    const { userId } = req.body; 

    if (!userId) {
        return apiResponse(res, true, [], ERROR_MSG[`USER-ID-MISSING`], CLIENT_ERROR.badRequest, 0, [], req);
    }

    let condition = { _id: new mongoose.Types.ObjectId(userId) };

    try {
        let user = await User.findOne(condition, { payment_details: 1, _id: 0 });

        if (user && user.payment_details) {
            return apiResponse(res, false, [], '', SUCCESS.OK, 0, [user.payment_details], req);
        } else {
            return apiResponse(res, true, [], ERROR_MSG[`PAYMENT-DETAILS-NOT-FOUND`], CLIENT_ERROR.badRequest, 0, [], req);
        }
    } catch (error) {
        console.error(error);
        return apiResponse(res, true, [], ERROR_MSG[`SERVER-ERROR`], CLIENT_ERROR.internalServerError, 0, [], req);
    }
}

exports.userSignup = async (req, res) => {
    let lang = req.headers["accept-language"] || 'en'
    // If no validation errors, get the req.body objects that were validated and are needed
    const { email, user_role, phone_number } = req.body;

    try {


        let existingPhoneUser
        if (phone_number && phone_number != null) {
            existingPhoneUser = await User.findOne(
                { "phone_number.nationalNumber": phone_number.nationalNumber },
                { _id: 1, is_completed: 1, email: 1, phone_number: 1, is_signup: 1, is_signup_otp_varify: 1, is_verified: 1 }
            );
        }
        let existingEmailUser = await User.findOne(
            { "email": email },
            { _id: 1, is_completed: 1, email: 1, phone_number: 1, is_signup: 1, is_signup_otp_varify: 1, is_verified: 1 }
        );
        let existingUser = (existingPhoneUser && existingPhoneUser != null) ? existingPhoneUser : existingEmailUser
        //fetch Role
        let role = await Role.findOne(
            { title: user_role },
            { _id: 1 }
        );
        if (existingUser && existingUser.is_signup == true && existingUser.is_signup_otp_varify == true) {
            
            if (existingPhoneUser && existingPhoneUser.phone_number != null) {
                return apiResponse(res, true, [], "Phone number already exist !", CLIENT_ERROR.badRequest, 0, existingUser, req);
            }
            else {
                return apiResponse(res, true, [], 'Email address already exist', CLIENT_ERROR.badRequest, 0, existingUser, req);
            }
        }
        // exitingUser profile but not completed
        if (existingUser && existingUser.is_signup == true && existingUser.is_signup_otp_varify == false) {
            
            return apiResponse(res, true, [], 'Email address already exist', CLIENT_ERROR.badRequest, 0, [], req);
        }
        //save user 
        if (!existingUser) {
            req.body['is_signup_otp_varify'] = true ;
            var newUser = new User(_.pick(req.body, ['title', 'first_name', 'middle_name', 'last_name', 'dob', 'phone_number', 'user_role', 'email', 'gender', 'device_data', 'password', 'social_security_number', 'branch_of_medicines', 'primary_specialty', 'additional_specialty', 'qualification', 'year_of_practice', 'additional_qualification', 'spoken_language', 'certificate', 'clinic_name', 'clinic_contact', 'clinic_open_time', 'clinic_close_time', 'street_address', 'location', 'primary_specialty_name', 'show_email', 'doctor_present', 'clinic_timing', 'is_fulltime', 'clinic_municipality', 'clinic_department', 'is_completed' , 'hospital_name' , 'is_signup_otp_varify']));
            newUser['email'] = req.body.email.toLowerCase();
            let templateData = await RegisteredByAdmin(newUser);
            const mailOptions = {
                to: newUser.email,
                subject: templateData.subject,
                html: templateData.html
            };
            let isEmailSent = await sendEmail(mailOptions, res)
            function maskEmail(email) {
                // Split the email address into local part and domain part
                var parts = email.split('@');

                // Replace characters in the local part except for the first two characters
                var maskedLocalPart = parts[0].substring(0, 2) + parts[0].substring(2).replace(/./g, '*');

                // Return the masked email address
                return maskedLocalPart + '@' + parts[1];
            }
            var maskedEmail = maskEmail(req.body.email.toLowerCase());
            newUser['show_email'] = maskedEmail
            if (user_role) {
                newUser['user_role'] = role['_id']
            }
            // || user_role == 'doctor' || user_role == 'hospital'
            if (user_role == "patient" ) {
                newUser['user_account_status'] = 'APPROVED'
            }
            if(user_role == 'doctor' || user_role == 'hospital')
            {
                newUser['is_verified'] = true ;
            }
            newUser['last_digit_phone'] = phone_number.e164Number.slice(-4)
            newUser['is_signup'] = true
            await newUser.save()
                .then(async function (user) {
                    return apiResponse(res, false, [], SUCCESS_MSG[`"User-created-en"`], SUCCESS.OK, 0, user, req);
                })
        }
    } catch (error) {
        console.log(error);
        return apiResponse(res, true, [], ERROR_MSG[`SYSTEM-ERROR-en`], SERVER_ERROR.internalServerError, 0, [], req)
    }
}

exports.editProfile = async ( req , res ) => 
{
    try
    {
        const { id } = req.body;
        let updateProfile = await User.findOneAndUpdate({ _id: id }, { $set: req.body }, { new: true })
        return apiResponse(res, false, [], 'Profile created successfully.', SUCCESS.OK, 0, updateProfile, req);

    }
    catch(error)
    {
        console.error(error);
        return apiResponse(res, true, [], ERROR_MSG[`SERVER-ERROR`], CLIENT_ERROR.internalServerError, 0, [], req);
    }
}



exports.childUsersListing = async (req, res) => {
    var title_lang = 'en';


    try {
        const {  first_name, last_name, is_account_active_string_status, dob, gender, user_account_status, createdAt , updatedAt , guardian_id} = req.body;

        const fetchUserRole = await Role.findOne({ title: 'patient' });
        if (fetchUserRole) {
            var filteredQuery = {}
            let page, limit: number;
            let first_name_regex = new RegExp(first_name, 'i');
            let last_name_regex = new RegExp(last_name, 'i');
            let dob_regex = new RegExp(dob, 'i');
            let gender_regex = gender?.toLowerCase();
            page = req.query.page ? parseInt(req.query.page) - 1 : 0;
            limit = 10;
            const filter_first_name = (first_name && first_name != 'undefined') ? { first_name: first_name_regex } : {};
            const filter_last_name = (last_name && last_name != 'undefined') ? { last_name: last_name_regex } : {};
            const filter_dob = (dob && dob != 'undefined') ? { dob: dob_regex } : {};
           const filter_gender = (gender && gender != 'undefined') ? { gender: gender_regex } : {};
           


            if(createdAt)
            {
                filteredQuery["createdAt"] = { $gte : new Date( (new Date(createdAt)).setUTCHours(0 , 0 , 0)) , $lte :  new Date((new Date(createdAt)).setUTCHours(23 , 59 , 59))};
            }

            if(updatedAt)
            {
                filteredQuery["updatedAt"] = { $gte : new Date((new Date(updatedAt)).setUTCHours(0 , 0 , 0)) , $lte :  new Date((new Date(updatedAt)).setUTCHours(23 , 59 , 59))};
            }

            filteredQuery = {  ...filter_first_name, ...filter_last_name, ...filter_dob,  ...filter_gender, is_deleted: false , ...filteredQuery  };
           


            if (is_account_active_string_status) {
                filteredQuery['is_account_active'] = is_account_active_string_status == "true" ? true : false;
            }else{
                filteredQuery['is_account_active'] = true;
            }

            if(user_account_status){
                filteredQuery['user_account_status'] = user_account_status
            }

            

            filteredQuery['user_role'] = new mongoose.Types.ObjectId(fetchUserRole._id);
            if(guardian_id)
            {
                filteredQuery['guardian_id'] = new mongoose.Types.ObjectId(guardian_id);
            }
            else
            {
                filteredQuery['guardian_id'] = { $ne : null };
            }
            let skip = parseInt(page) * limit;
            const [data, count] = await Promise.all([
                User.aggregate([
                    { $match: filteredQuery },
                    { $sort: { createdAt: -1 } },
                    { $skip: skip },
                    { $limit: limit },

                    {
                        $lookup: {
                            from: "roles",
                            as: "role_of_user",
                            let: { user_role: "$user_role" },
                            pipeline: [
                                {
                                    $match: {

                                        $expr: { $eq: ["$$user_role", "$_id"] },
                                    }
                                },
                            ],
                        },
                    },
                    {
                        $unwind: {
                            path: '$role_of_user',
                            preserveNullAndEmptyArrays: true,
                        },
                    },

                    {
                        $lookup: {
                            from: "bookings",
                            as: "appointment_count",
                            let: { user_id: "$_id" },
                            pipeline: [
                                {
                                    $match: {
                                        $expr: { $eq: ["$hospital_doctor_id", "$$user_id"] }
                                    }
                                },
                                {
                                    $count: "totalAppointments"
                                }
                            ]
                        }
                    },

                    {
                        $addFields: {
                            appointmentCount: {
                                $ifNull: [{ $arrayElemAt: ["$appointment_count.totalAppointments", 0] }, 0]
                            }
                        }
                    },


                    {
                        $lookup: {
                            from: "bookings",
                            as: "patient_appointment_count",
                            let: { user_id: "$_id" },
                            pipeline: [
                                {
                                    $match: {
                                        $expr: { $eq: ["$patient_id", "$$user_id"] }
                                    }
                                },
                                {
                                    $count: "totalAppointments"
                                }
                            ]
                        }
                    },

                    {
                        $addFields: {
                            patientAppointmentCount: {
                                $ifNull: [{ $arrayElemAt: ["$patient_appointment_count.totalAppointments", 0] }, 0]
                            }
                        }
                    },

                    {
                        $lookup : 
                        {
                            from : "users",
                            localField : "guardian_id",
                            foreignField : "_id",
                            as : "guardian_details"
                        }
                    },
                    {
                        $unwind : { path : "$guardian_details" , preserveNullAndEmptyArrays : true}
                    },
                    {
                        $project : 
                        {
                            patientAppointmentCount :1,
                            appointmentCount:1,
                            role_of_user:1,
                            profile_pic : 1 , 
                            first_name : 1 , 
                            last_name : 1 ,
                            dob : 1 ,
                            social_security_number : 1 , 
                            gender : 1 ,
                            guardian_details : 1,
                            createdAt : 1,
                            updatedAt : 1,
                            is_account_active : 1
                        }
                    }


                    
                ]),
                User.countDocuments(filteredQuery),
            ]);

            return res.json({
                count: count,
                data: data,
                errors: [],
                is_error: false,
                message: "",
                responseCode: 200
            })

            // return apiResponse(res, false, [], '', SUCCESS.OK, count, data, req)
        } else {
            return apiResponse(res, false, [], '', SUCCESS.OK, 0, [], req)
        }


    } catch (error) {
        console.log(error);
        return apiResponse(res, true, [], ERROR_MSG[`SYSTEM-ERROR-${title_lang}`], SERVER_ERROR.internalServerError, 0, [], req)
    }
}

exports.guardianPatientListing = async ( req , res ) => 
{
    var title_lang = 'en';
    try 
    {
        const fetchUserRole = await Role.findOne({ title: 'patient' });
        let filteredQuery={};
        filteredQuery['user_role'] = new mongoose.Types.ObjectId(fetchUserRole._id);
        filteredQuery['guardian_id'] = { $eq : null };
        filteredQuery['is_account_active'] = true;
        filteredQuery['is_deleted'] = false;

        const [data , count ] = await Promise.all([
            User.aggregate([
                {
                    $match : filteredQuery
                },
                {
                    $project : 
                    {
                        _id : 1 ,
                        first_name : 1, 
                        last_name : 1 ,
                        email : 1,
                        phone_number : 1
                    }
                }
            ]),
            User.countDocuments(filteredQuery)
        ]);
        return apiResponse(res, false, [], '', SUCCESS.OK, count, data, req)
    }
    catch (error) {
        console.log(error);
        return apiResponse(res, true, [], ERROR_MSG[`SYSTEM-ERROR-${title_lang}`], SERVER_ERROR.internalServerError, 0, [], req)
    }
}