require('dotenv').config();
const fs = require('fs');
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")
const {Ticket} = require("../../models/ticket");
const {TicketComments} = require("../../models/ticket-comments")
const mongoose = require("mongoose");
export {};

exports.createTicket = async ( req , res ) =>
{
    try
    {
        const { title , description , media , user_id } = req.body;

        if(!title || !description || !user_id)
        {
            return apiResponse(res, true, [], 'All fields are required !', CLIENT_ERROR.badRequest, 0, [])
        }

        const ticket = await Ticket.create({title , description , media , createdBy : user_id});

        ticket.populate('createdBy');

        return apiResponse(res, false, [], '', SUCCESS.OK, 0, ticket,req);   

    }
    catch(error)
    {
      console.log(error)
        return apiResponse(res, true, [], ERROR_MSG['SYSTEM-ERROR'], SERVER_ERROR.internalServerError, 0, [])
    }
}

exports.setTicketStatus = async ( req , res ) => 
{
    try
    {
        const {id , status } = req.body;
        
        let ticketDetails :any;
        if(status == 'COMPLETED')
        {
            ticketDetails=  await Ticket.findOneAndUpdate({_id : id } , { is_completed : true , status : status  } , { new : true});
        }
        else 
        {
            ticketDetails = await Ticket.findOneAndUpdate({_id : id } , { status } , { new : true});
        }
        ticketDetails.populate('createdBy');

        return apiResponse(res, false, [], '', SUCCESS.OK, 0, ticketDetails,req);   

    }
    catch(error)
    {
        return apiResponse(res, true, [], ERROR_MSG['SYSTEM-ERROR'], SERVER_ERROR.internalServerError, 0, [])
    }
}

exports.addCommentToTicket = async ( req , res ) => 
{
    try
    {
        const {comment , media , user_id  , ticket_id} = req.body;
        
        const ticketDetails = await Ticket.findById(ticket_id);
        if(!ticketDetails)
        {

        return apiResponse(res, true, [], ERROR_MSG['SYSTEM-ERROR'], CLIENT_ERROR.badRequest, 0, [])
        }
       
        const commentDetails = await TicketComments.create({comment , media , user : user_id , ticket_id : ticket_id });
        await Ticket.findByIdAndUpdate({ _id : ticket_id} , {$push : { comments : commentDetails._id} } , { new : true });
        return apiResponse(res, false, [], '', SUCCESS.OK, 0, [],req);   

    }
    catch(error)
    {
        return apiResponse(res, true, [], ERROR_MSG['SYSTEM-ERROR'], SERVER_ERROR.internalServerError, 0, [])
    }
}


exports.fetchTicketDetails = async ( req , res ) => 
{
    try
    {
        const { ticket_id } = req.params;
        const record = await Ticket.aggregate([
          {
            $match: {
              _id: new mongoose.Types.ObjectId(ticket_id),
              is_deleted: false
            }
          },
          {
            $lookup: {
              from: 'users',
              localField: 'createdBy',
              foreignField: '_id',
              as: 'createdBy'
            }
          },
          {
            $unwind: {
              path: '$createdBy',
              preserveNullAndEmptyArrays: true
            }
          },
          {
            $lookup: {
              from: 'ticketcomments',
              let: { commentIds: '$comments' },
              pipeline: [
                {
                  $match: {
                    $expr: {
                      $in: ['$_id', '$$commentIds']
                    },
                    is_deleted: false
                  }
                },
                {
                  $addFields: {
                    userId: '$user' // store original user ObjectId
                  }
                },
                {
                  $lookup: {
                    from: 'users',
                    localField: 'userId',
                    foreignField: '_id',
                    as: 'user'
                  }
                },
                {
                  $unwind: {
                    path: '$user',
                    preserveNullAndEmptyArrays: true
                  }
                },{
                  $lookup: {
                    from: 'roles',
                    localField: 'user.user_role',
                    foreignField: '_id',
                    as: 'user.user_role'
                  }
                },
                {
                  $unwind: {
                    path: '$user.user_role',
                    preserveNullAndEmptyArrays: true
                  }
                },
                {
                  $lookup: {
                    from: 'admins',
                    localField: 'userId',
                    foreignField: '_id',
                    as: 'admin'
                  }
                },
                {
                  $unwind: {
                    path: '$admin',
                    preserveNullAndEmptyArrays: true
                  }
                },
                {
                  $project : {
                    media : 1,
                    comment : 1 ,
                    is_deleted : 1, 
                    "createdAt": 1,
                    "updatedAt":1,
                    user : {
                      first_name : 1, 
                      last_name : 1,
                      profile_pic : 1 ,
                      gender : 1,
                      user_role : 1
                    },
                    admin : {
                            first_name : 1, 
                            last_name : 1,
                            profile_pic : 1 ,
                            gender : 1,
                            user_role : 1
                          },
                  }
                }
              ],
              as: 'comments'
            }
          }
        ])
        return apiResponse(res, false, [], '', SUCCESS.OK, 0, record,req);   

    }
    catch(error)
    {
      console.log(error)
        return apiResponse(res, true, [], ERROR_MSG['SYSTEM-ERROR'], SERVER_ERROR.internalServerError, 0, [])
    }
}

exports.fetchTicketList = async ( req , res ) => 
{
    try
    {
        const { limit=10 , page =1 , user_id  , first_name , last_name , createdAt , updatedAt , status , title} = req.body;
        const filteredQuery:any = {};
        user_id ? filteredQuery['createdBy'] = new mongoose.Schema.Types.ObjectId(user_id) : "";
        status ? filteredQuery['status'] = status : "";
        title ? filteredQuery['title'] = { $regex : new RegExp(title , 'i') } : "";
        if(createdAt && createdAt != "" && createdAt != null)
        {
          let startDate = new Date(createdAt);
          startDate.setUTCHours(0,0,0);

          let endDate = new Date(createdAt);
          endDate.setUTCHours(23,59,59);
         filteredQuery['createdAt'] =  
                    { $gte: startDate ,
                     $lte: endDate }
                
        }
         if(updatedAt && updatedAt != "" && updatedAt != null)
        {
           let startDate = new Date(createdAt);
          startDate.setUTCHours(0,0,0);

          let endDate = new Date(createdAt);
          endDate.setUTCHours(23,59,59);
         filteredQuery['updatedAt'] =  
                    { $gte: startDate ,
                     $lte: endDate }
        }
        let filter = {}
        first_name != "" && first_name ? filter['createdBy.first_name'] =  { $regex : new RegExp(first_name , 'i') }: "";
        last_name != "" && last_name ? filter['createdBy.last_name'] = { $regex : new RegExp(last_name , 'i') } : "";

        let skip = (page-1) * limit;
        console.log(filter , filteredQuery)
        const [records , count ] = await Promise.all([
            await Ticket.aggregate([
                {
                  $match: filteredQuery
                },
                { $sort : { createdAt : -1}},
                { $skip: skip },
                { $limit: limit },
                {
                  $lookup: {
                    from: 'users',
                    localField: 'createdBy',
                    foreignField: '_id',
                    as: 'createdBy'
                  }
                },
                {
                  $unwind: {
                    path: '$createdBy',
                    preserveNullAndEmptyArrays: true
                  }
                },
                {
                  $match : filter
                },
                {
                  $lookup: {
                    from: 'ticketcomments',
                    let: { commentIds: '$comments' },
                    pipeline: [
                      {
                        $match: {
                          $expr: {
                            $in: ['$_id', '$$commentIds']
                          },
                          is_deleted: false
                        }
                      },
                       {
                        $addFields: {
                          userId: '$user' // store original user ObjectId
                        }
                      },
                      {
                        $lookup: {
                          from: 'users',
                          localField: 'userId',
                          foreignField: '_id',
                          as: 'user'
                        }
                      },
                      {
                        $unwind: {
                          path: '$user',
                          preserveNullAndEmptyArrays: true
                        }
                      },
                      
                       {
                        $lookup: {
                          from: 'admins',
                          localField: 'userId',
                          foreignField: '_id',
                          as: 'admin'
                        }
                      },
                      {
                        $unwind: {
                          path: '$admin',
                          preserveNullAndEmptyArrays: true
                        }
                      },
                      {
                        $lookup: {
                          from: 'roles',
                          localField: 'user.user_role',
                          foreignField: '_id',
                          as: 'user.user_role'
                        }
                      },
                      {
                        $unwind: {
                          path: '$user.user_role',
                          preserveNullAndEmptyArrays: true
                        }
                      },
                      {
                        $project : {
                          media : 1,
                          comment : 1 ,
                          is_deleted : 1, 
                          "createdAt": 1,
                          "updatedAt":1,
                          user : {
                            first_name : 1, 
                            last_name : 1,
                            profile_pic : 1 ,
                            gender : 1,
                            user_role : 1
                          },
                          admin : {
                            first_name : 1, 
                            last_name : 1,
                            profile_pic : 1 ,
                            gender : 1,
                            user_role : 1
                          },

                        }
                      }
                    ],
                    as: 'comments'
                  }
                },
                {
                  $project : 
                  {
                    comments : 1,
                    createdBy : 
                    {
                      first_name : 1, 
                      last_name : 1,
                      profile_pic : 1 ,
                      gender : 1
                    },
                    "_id": 1,
                    "title": 1,
                    "description":1,
                    "media": 1,
                    "status": 1,
                    "is_completed": 1,
                    "is_deleted": 1,
                    "createdAt": 1,
                    "updatedAt": 1,
                  }
                }
              ]),
            await Ticket.countDocuments(filteredQuery)
        ]);
        return apiResponse(res, false, [], '', SUCCESS.OK, count, records,req);   
    }
    catch(error)
    {
      console.log(error)
        return apiResponse(res, true, [], ERROR_MSG['SYSTEM-ERROR'], SERVER_ERROR.internalServerError, 0, [])
    }
}