Router

var express = require('express');
var router = express.Router();
const multer = require('multer');
const fs = require('fs')
const path = require('path');
const userDataModel = require('../collection/user')
const userDetailModel = require('../collection/userDetail')

const storage = multer.diskStorage({
  destination: (req, file, cb) => {
    cb(null, 'uploads/');
  },
  filename: (req, file, cb) => {
    cb(null, `${Date.now()}_${file.originalname}`); 
  },
});

const fileFilter = (req, file, cb) => {
  const allowedMimes = ['application/pdf'];
  if (allowedMimes.includes(file.mimetype)) {
    cb(null, true);
  } else {
    cb(new Error('Invalid file type. Only PDF files are allowed.'));
  }
};

const upload = multer({
  storage: storage,
  limits: {
    fileSize: 50 * 1024 * 1024,
  },
  fileFilter: fileFilter,
});


const userRegister = async (req, res,next) => {

  try {

    const registerUser = new userDataModel({
      email: req.body.email,
      password: req.body.password,
    })

    const saveUser = await registerUser.save();

    const userid = saveUser._id;

    const userDetail = new userDetailModel({
      user_id: userid,
      name: req.body.name,
      phone: req.body.phone,
      country: req.body.country,
      additional_info: req.body.additional_info,
      file: req.file.filename,
    })

    const saveUserDetail = await userDetail.save();

    res.status(200).json({
      status:"Success",
      saveUser,
      saveUserDetail,
    })

    
  } catch (error) {
    fs.unlinkSync(req.file.path);
    if (error.name === 'ValidationError') {
      fs.unlinkSync(req.file.path);
      const validationErrors = {};
      for (const key in error.errors) {
        validationErrors[key] = error.errors[key].message;
      }
      return res.status(400).json({ errors: validationErrors });
    }
    console.error(error);
    res.status(500).send('Internal Server Error'); 
  }

}

const userList = async (req, res,next) => {

  try {

      const query = {};
      if (req.query.email) {
        query.email = { $regex: new RegExp(req.query.email, 'i') };
      }
      if (req.query.name) {
        query.name = { $regex: new RegExp(req.query.name, 'i') };
      }
      if (req.query.phone) {
        query.phone = req.query.phone;
      }
      if (req.query.country) {
        query.country = { $regex: new RegExp(req.query.country, 'i') };
      }

        const page = parseInt(req.query.page) || 1;
        const pageSize = parseInt(req.query.pageSize) || 5;

        
        const userDetails = await userDetailModel.aggregate([
          {
            $match: query,
          },
          {
            $lookup: {
              from: 'users',
              localField: 'user_id',
              foreignField: '_id',
              as: 'user',
            },
          },
          // {
          //   $unwind: '$user',
          // },
          {
            $skip: (page - 1) * pageSize,
          },
          {
            $limit: pageSize,
          },
        ]);

        res.json(userDetails);
      
  } catch (error) {
      res.status(500).send('Internal Server Error');
  }

}

const updateUser = async (req, res, next) => {
  try {
    const userId = req.params.id;

    const existingUserDetail = await userDetailModel.findOne({ user_id: userId });

    if (existingUserDetail && existingUserDetail.file) {
      const filePath = path.join('uploads/', existingUserDetail.file);
      fs.unlinkSync(filePath);
    }

    const updateUserData = await userDataModel.findByIdAndUpdate(
      userId,
      {
        email: req.body.email,
        password: req.body.password,
      },
      { new: true }
    );

    if(updateUserData === null){
      res.status(200).json({
        status: 'User Not Found',
      });
    }

    const updateUserDetail = await userDetailModel.findOneAndUpdate(
      { user_id: userId },
      {
        name: req.body.name,
        phone: req.body.phone,
        country: req.body.country,
        additional_info: req.body.additional_info,
        file: req.file.filename,
      },
      { new: true }
    );

    res.status(200).json({
      status: 'Success',
      updateUserData,
      updateUserDetail,
    });
  } catch (error) {
    fs.unlinkSync(req.file.path);
    if (error.name === 'ValidationError') {
      fs.unlinkSync(req.file.path);
      const validationErrors = {};
      for (const key in error.errors) {
        validationErrors[key] = error.errors[key].message;
      }
      return res.status(400).json({ errors: validationErrors });
    }
    console.error(error);
    res.status(500).send('Internal Server Error');
  }
};

const deleteUser = async (req, res, next) => {
  try {

    const userId = req.params.id;

    const deleteUser = await userDataModel.findByIdAndDelete(userId);

    if (!deleteUser) {
      return res.status(404).json({ status: 'Error', message: 'User not found' });
    }

    const deleteUserDetail = await userDetailModel.findOneAndDelete({ user_id: userId });

    if (deleteUserDetail.file) {
      const filePath = path.join('uploads/', deleteUserDetail.file);
      fs.unlinkSync(filePath);
    }

    res.status(200).json({
      status: 'Success',
      message: 'User deleted successfully',
    });
    
  } catch (error) {
    if (error.name === 'ValidationError') {
      const validationErrors = {};
      for (const key in error.errors) {
        validationErrors[key] = error.errors[key].message;
      }
      return res.status(400).json({ errors: validationErrors });
    }
    console.error(error);
    res.status(500).send('Internal Server Error');
  }
};

router.post("/addUser",upload.single('file'), userRegister);
router.get("/userList", userList);
router.put('/updateUser/:id', upload.single('file'), updateUser);
router.delete('/deleteUser/:id', deleteUser);


module.exports = router;