const _ = require('lodash');
require('dotenv').config({ path: __dirname + '../../.env' })
const { Contact } = require('../../models/admin/contact');
const { ContactReply } = require('../../models/admin/contact-reply');
const { dateFormat } = require('../../core/utilities/commonService');
const { apiResponse } = require("../../core/response/response")
const { SUCCESS, REDIRECTION, CLIENT_ERROR, SERVER_ERROR } = require("../../core/response/statusCode")
const { ERROR_MSG, SUCCESS_MSG } = require("../../core/response/messages")

export { };

exports.contactListing = async (req, res) => {
    const lang = req.headers["accept-language"] || 'en'
    try {

        console.log("req.body", req.body);
        const { first_name, last_name, name, email, subject, description, createdAt, phone, updatedAt, admin_id } = req.body
        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 subject_regex = new RegExp(subject, 'i');
        let description_regex = new RegExp(description, 'i');
        let email_regex = new RegExp(email, 'i');
        let phone_regex = new RegExp(phone, 'i');
        console.log(admin_id)
        if (req.query.search) {
            var createdDate = new Date(dateFormat(createdAt, 'yyyy-MM-dd'));
            var updatedDate = new Date(dateFormat(updatedAt, '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_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_phone = (phone && phone != 'undefined') ? { phone: phone_regex } : {};
            // const filter_name = (name && name != 'undefined')  ? { first_name: name_regex } : {};
            const filter_subject = (subject && subject != 'undefined') ? { subject: subject_regex } : {};
            const filter_message = (description && description != 'undefined') ? { description: description_regex } : {};
            const filter_email = (email && email != 'undefined') ? { email: email_regex } : {};
            const filter_createdAt = (createdAt && createdAt != 'undefined') ? { createdAt: { $gte: new Date(dateFormat(createdAt, 'yyyy-MM-dd')), $lt: new Date(dateFormat(createdDate, 'yyyy-MM-dd')) } } : {};
            const filter_updatedAt = (updatedAt && updatedAt != 'undefined') ? { updatedAt: { $gte: new Date(dateFormat(updatedAt, 'yyyy-MM-dd')), $lt: new Date(dateFormat(updatedDate, 'yyyy-MM-dd')) } } : {};
            const mongoose = require('mongoose');
            const filter_admin_id = (admin_id && admin_id != 'undefined' && mongoose.Types.ObjectId.isValid(admin_id))
                ? { admin_id: new mongoose.Types.ObjectId(admin_id) }
                : {};
            filteredQuery = { ...filter_last_name, ...filter_first_name, ...filter_phone, ...filter_subject, ...filter_message, ...filter_email, ...filter_createdAt, ...filter_updatedAt, ...filter_admin_id, is_deleted: false }
        } else {
            page = req.query.page ? parseInt(req.query.page) - 1 : 0;
            limit = 10;
            filteredQuery = {
                is_deleted: false
            }
        }

        const [data, count] = await Promise.all([
            Contact.find(filteredQuery).sort({ createdAt: -1 }).skip(page * limit).limit(limit).populate("user_id", "first_name last_name"),
            Contact.countDocuments(filteredQuery)
        ]);
        return apiResponse(res, false, [], '', SUCCESS.OK, count, data, req)
    } catch (error) {
        return apiResponse(res, true, [], ERROR_MSG[`SYSTEM-ERROR-${lang}`], SERVER_ERROR.internalServerError, 0, [], req)
    }
}

// delete contact
exports.deleteContact = async (req, res) => {
    const lang = req.headers["accept-language"] || 'en'
    try {

        const id = req.body.id;
        await Contact.findOneAndUpdate({ _id: id }, { $set: { is_deleted: true, updatedAt: new Date() } }, { upsert: true, new: true }).then(cres => {
            if (cres) {
                return apiResponse(res, false, [], '', SUCCESS.OK, 0, [], 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, [], req)
    }
}

// delete selected contact
exports.deleteSelectedContact = async (req, res) => {
    const lang = req.headers["accept-language"] || 'en'
    try {
        await Contact.updateMany({ _id: { $in: req.body.ids } }, { $set: { is_deleted: true, updatedAt: new Date() } }, { multi: true, upsert: true, new: true }).then(cres => {
            if (cres) {
                return apiResponse(res, false, [], '', SUCCESS.OK, 0, [], 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, [], req)
    }
}

// create function for updateContact
exports.updateContact = async (req, res) => {
    const lang = req.headers["accept-language"] || 'en'
    console.log(req.body);
    try {
        const id = req.body.id;

        // insert contact_id, comment, attachment , status, assigned_by_admin_id, assigned_to_admin_id in contactReply and also update  admin_id, admin_notes, status in contact model

        const contactReply = new ContactReply({
            contact_id: id,
            comment: req.body.comment,
            status: req.body.status,
            attachment: req.body.attachment,
            assigned_by_admin_id: req.body.assigned_by_admin_id,
            assigned_to_admin_id: req.body.assigned_to_admin_id
        });

        await contactReply.save();

        // Define updateData object for Contact model update
        const updateData = {
            admin_id: req.body.assigned_to_admin_id,
            admin_notes: req.body.comment,
            status: req.body.status
        };

        await Contact.findOneAndUpdate({ _id: id }, { $set: updateData }, { upsert: true, new: true }).then(cres => {
            if (cres) {
                return apiResponse(res, false, [], '', SUCCESS.OK, 0, [], 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, [], req)
    }



}

exports.contactDetails = async (req, res) => {
    const lang = req.headers["accept-language"] || 'en'
    try {
        const { ticketId } = req.params;
        const contact = await Contact.findById(ticketId).populate("user_id", "first_name last_name");
        if (!contact) {
            return apiResponse(res, true, [], ERROR_MSG[`CONTACT-NOT-FOUND-${lang}`], SERVER_ERROR.notFound, 0, [], req)
        }

        const replies = await ContactReply.find({
            contact_id: ticketId,
            is_deleted: false
        }).populate("assigned_by_admin_id assigned_to_admin_id", "first_name last_name email");

        const merged = {
            ...contact.toObject(),
            contactReply: replies
        };
        return apiResponse(res, false, [], '', SUCCESS.OK, 1, merged, req)
    } catch (error) {
        return apiResponse(res, true, [], ERROR_MSG[`SYSTEM-ERROR-${lang}`], SERVER_ERROR.internalServerError, 0, [], req)
    }
}