routes/profileUpdate.js

const express = require('express');
const multer = require('multer');
const firebase = require("../utils/firebase")
var imageUrl = ""
const os = require('os');
const path = require('path');
const fs = require('fs');
const router = express.Router();
const User = require('../Database/models/user');
const { successResponse, failedResponse } = require("../utils/responseModel");
const mongoose = require('mongoose'); // Import Mongoose Types


const storage = multer.diskStorage({
    destination: (req, file, cb) => {
        const uploadDir = path.join(os.tmpdir(), 'uploads'); // Use a temporary directory
        fs.mkdirSync(uploadDir, { recursive: true }); // Create the directory if it doesn't exist
        cb(null, uploadDir);
    },
    filename: (req, file, cb) => {
        cb(null, file.originalname);
    },
});

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

//Update profile and watch
router.post('/', upload.single('file'), async (req, res) => {
    try {
        console.log("File:", req.file); // Check the uploaded file
        console.log("Body:", req.body); // Check other form data
        let imageUrl = '';
        // Find the user by userId
        const user = await User.findOne({ unique_id: req.body.userId });

        if (!user) {
            return res.status(404).send({ message: 'User not found!' });
        }

        // Handle file upload to Firebase Storage
        if (req.file || req.body.file) {
            const filePath = req.file.path; // Path to the uploaded file
            const imageName = req.file.filename; // Name of the uploaded file

            // Upload the file to Firebase Storage
            await firebase.uploadFile(filePath, "profile/" + imageName);
            await firebase.generateSignedUrl("profile/" + imageName)
                .then(url => {
                    imageUrl = url;
                })
                .catch(e => {
                    console.log(e);
                });

            // Update profilePic only if imageUrl is not empty
            if (imageUrl) {
                user.profilePic = imageUrl;
            }
        }

        // Update other user details
        if (req.body.username) user.username = req.body.username;
        if (req.body.dateOfBirth) user.dateOfBirth = req.body.dateOfBirth;
        if (req.body.mobileNumber) user.mobileNumber = req.body.mobileNumber;
        if (req.body.email) user.email = req.body.email;

        // Save the updated user data
        const savedData = await user.save();
        console.log('Profile updated successfully', savedData);
        res.status(200).send({ message: 'Profile updated!', data: savedData });
    } catch (error) {
        console.error('Error updating profile:', error);
        res.status(400).send({ message: 'Error updating profile', error });
    }
});

// Replace the "// Adress section" comment and subsequent code with:

// Address Section
const validateAddress = (address) => {
    const requiredFields = ['name', 'mobileNumber', 'pinCode', 'address', 'area'];
    const missingFields = requiredFields.filter(field => !address[field]);

    if (missingFields.length > 0) {
        throw new Error(`Missing required fields: ${missingFields.join(', ')}`);
    }
};

const asyncHandler = fn => (req, res, next) =>
    Promise.resolve(fn(req, res, next)).catch(next);

// Create new address
router.post("/address", asyncHandler(async (req, res) => {
    try {
        const { userId } = req.body;
        if (!userId) {
            return res.status(400).json({
                status: false,
                message: "User ID is required",
                data: null
            });
        }

        validateAddress(req.body);

        const addressData = {
            name: req.body.name,
            mobileNumber: req.body.mobileNumber,
            pinCode: req.body.pinCode,
            address: req.body.address,
            area: req.body.area,
            landMark: req.body.landMark || '',
            alterMobileNumber: req.body.alterMobileNumber || ''
        };

        const updatedUser = await User.findOneAndUpdate(
            { unique_id: userId },
            { $push: { addresses: addressData } },
            { new: true }
        );

        if (!updatedUser) {
            return res.status(404).json({
                status: false,
                message: "User not found",
                data: null
            });
        }

        const newAddress = updatedUser.addresses[updatedUser.addresses.length - 1];

        return res.status(200).json({
            status: true,
            message: "Address added successfully",
            data: newAddress
        });
    } catch (error) {
        return res.status(400).json({
            status: false,
            message: error.message,
            data: null
        });
    }
}));

// Get all addresses
router.get("/address/:userId", asyncHandler(async (req, res) => {
    try {
        const { userId } = req.params;
        const user = await User.findOne({ unique_id: userId }).select('addresses');

        if (!user) {
            return res.status(404).json({
                status: false,
                message: "User not found",
                data: null
            });
        }

        return res.status(200).json({
            status: true,
            message: "Addresses retrieved successfully",
            data: user.addresses || []
        });
    } catch (error) {
        return res.status(400).json({
            status: false,
            message: error.message,
            data: null
        });
    }
}));

// Update address
router.put("/address", asyncHandler(async (req, res) => {
    try {
        const { userId, addressId } = req.body;
        if (!userId || !addressId) {
            return res.status(400).json({
                status: false,
                message: "User ID and Address ID are required",
                data: null
            });
        }

        validateAddress(req.body);

        const updateFields = {};
        ['name', 'mobileNumber', 'pinCode', 'address', 'area', 'landMark', 'alterMobileNumber']
            .forEach(field => {
                if (req.body[field] !== undefined) {
                    updateFields[`addresses.$.${field}`] = req.body[field];
                }
            });

        const updatedUser = await User.findOneAndUpdate(
            {
                unique_id: userId,
                "addresses._id": addressId
            },
            { $set: updateFields },
            { new: true }
        );

        if (!updatedUser) {
            return res.status(404).json({
                status: false,
                message: "Address not found",
                data: null
            });
        }

        const updatedAddress = updatedUser.addresses.find(
            addr => addr._id.toString() === addressId
        );

        return res.status(200).json({
            status: true,
            message: "Address updated successfully",
            data: updatedAddress
        });
    } catch (error) {
        return res.status(400).json({
            status: false,
            message: error.message,
            data: null
        });
    }
}));

// Delete address
router.delete("/address", asyncHandler(async (req, res) => {
    try {
        const { userId, addressId } = req.body;
        if (!userId || !addressId) {
            return res.status(400).json({
                status: false,
                message: "User ID and Address ID are required",
                data: null
            });
        }

        const updatedUser = await User.findOneAndUpdate(
            { unique_id: userId },
            { $pull: { addresses: { _id: addressId } } },
            { new: true }
        );

        if (!updatedUser) {
            return res.status(404).json({
                status: false,
                message: "Address not found",
                data: null
            });
        }

        return res.status(200).json({
            status: true,
            message: "Address deleted successfully",
            data: null
        });
    } catch (error) {
        return res.status(400).json({
            status: false,
            message: error.message,
            data: null
        });
    }
}));

module.exports = router;