documentation does not work. https://www.passportjs.org/tutorials/google/ about passport HOT 3 CLOSED

    // Define routes for initiating Google and Facebook authentication
    app.get(
        '/auth/google',
        passport.authenticate('google', {
        scope: ['profile', 'email'], // Define the required scopes
        })
    );
    
    app.get(
        '/auth/facebook',
        passport.authenticate('facebook', {
        scope: ['public_profile', 'email'], // Define the required scopes
        })
    );
    
    // Define the callback routes for Google and Facebook authentication
    app.get(
        '/auth/google/callback',
        passport.authenticate('google', { failureRedirect: '/Login-Page-Form' }),
        async(req, res) => {
        // Successful Google authentication
        const user = req.user
        await collection.insertOne(user);
        res.redirect('/LoggedInHomePage'); // Redirect to the profile page or any other page
        }
    );

    app.get(
        '/auth/facebook/callback',
        passport.authenticate('facebook', { failureRedirect: '/Login-Page-Form' }),
        async(req, res) => {
        // Successful Facebook authentication
        const user = req.user
        await collection.insertOne(user);
        res.redirect('/LoggedInHomePage'); // Redirect to the profile page or any other page
        }
    );

    app.use(session({
        secret: jwtSecret,
        resave: false,
        saveUninitialized: false
    }));

    // Function to determine the content type of the image
    function getImageContentType(imageData) {
        const type = imageType(Buffer.from(imageData));   // imageType library expects a buffer as its argument so imageData is converted to buffer before passing it to imageType
        if (type) {
            return `image/${type.ext}`;
        }
        // Default to PNG content type if not recognized
        return 'image/png';
    }

    const upload = multer({ storage: multer.memoryStorage() });
    // Handle image upload
    app.post('/upload', upload.single('image'), async(req, res) => {
        console.log('Post upload entry')
        if (!req.file) {
            console.log('No image uploaded')
            return res.status(400).send('No image uploaded');
        }
        console.log('Image file is found')
        const authHeader = req.headers.authorization
        const token = authHeader && authHeader.split(' ')[1]
        console.log('Entering check token')
        if (!token) {
            // No JWT provided
            console.log('Unauthorized')
            res.status(401).send('Unauthorized')
            return
        }
        let userEmail;
        console.log('After userEmail')
        try {
            // Verify JWT
            const decoded = jwt.verify(token, jwtSecret)
            userEmail = decoded.email
            console.log('Token verified')
        } 
        catch (error) {
            // Invalid JWT
            console.log('Forbidden')
            res.status(403).send('Forbidden')
        }

        // Serialize the imageBinary before storing it in the cache
        const imageBinarySerialized = imageBinary.buffer.toString('base64');
        imageCache.set(userEmail, imageBinarySerialized);  // responsible for storing the image data in an image cache, associating it with the user's email address
        console.log('Image uploaded');
        return res.status(200).send('Image upload successful');
    });
    app.use(express.static('public'));   
    
    app.get('/user/image', async (req, res) => {
        // Verify the user's token and extract their email
        console.log('Entered server side /user/image')
        const authHeader = req.headers.authorization;
        const token = authHeader && authHeader.split(' ')[1];
        if (!token) {
            return res.status(401).send('Unauthorized');
        }
    
        let userEmail;
        try {
            const decoded = jwt.verify(token, jwtSecret);
            userEmail = decoded.email;
            console.log('Token Verified')
        } 
        catch (error) {
            return res.status(403).send('Forbidden');
        }
    
        // When retrieving from the cache, deserialize the data
        const cachedImageSerialized = imageCache.get(userEmail);
        if (cachedImageSerialized) {
            try {
                console.log('Enter if cachedImage')
                const cachedImageBinary = new Binary(Buffer.from(cachedImageSerialized, 'base64'));
                const imageContentType = getImageContentType(cachedImageBinary);  
                res.setHeader('Content-Type', imageContentType);
                res.send(cachedImageBinary.buffer);  // you are sending the raw binary image data as the response body
            } 
            catch (error) {
                console.error('Error serving cached image:', error);
                res.status(500).send('Internal Server Error');
            }
        } 
        else {
            try {
                // Retrieve user's image data from the database
                const user = await collection.findOne({ email: userEmail });
                console.log('Retrieve user image data from the database')
                if (!user || !user.image) {
                    console.log('User or image data not found')
                    return res.status(404).send('User or image data not found');
                }
                const imageBinary = user.image
                // Serialize the imageBinary before storing it in the cache
                const imageBinarySerialized = imageBinary.buffer.toString('base64');
                imageCache.set(userEmail, imageBinarySerialized);
    
                // Serve the image
                try {
                    console.log('Serve the image');
                    const imageSerialized = imageCache.get(userEmail);  // if there is image in the cache it returns true
                    if (imageSerialized) {
                        const imageBinary = new Binary(Buffer.from(imageSerialized, 'base64'));
                        const imageContentType = getImageContentType(imageBinary);
                        res.setHeader('Content-Type', imageContentType);
                        res.send(imageBinary.buffer);
                    } 
                    else {
                        // This could happen if there was an issue with caching the image data
                        res.status(404).send('Image not found in cache');
                    }
                } 
                catch (error) {
                    console.error('Error serving retrieved image:', error);
                    res.status(500).send('Internal Server Error');
                }
            } 
            catch (error) {
                console.error('Error retrieving image from database:', error);
                res.status(500).send('Internal Server Error');
            }
        }
    });     

    app.put('/updateProfile', async(req, res) => {
        const authHeader = req.headers.authorization;
        const token = authHeader && authHeader.split(' ')[1];
        if (!token) {
            return res.status(401).send('Unauthorized');
        }
    
        let email;
        try {
            const decoded = jwt.verify(token, jwtSecret);
            email = decoded.email;
            console.log('Token Verified for updateProfile')
        } 
        catch (error) {
            return res.status(403).send('Forbidden');
        }

        const response = await collection.updateOne(
            { email: email },
            { $set: { fullname: req.body.name, dob: req.body.dob, school: req.body.school, college: req.body.college, university: req.body.uni, workplace: req.body.workplace } }
        );
        if (response.modifiedCount === 1) {
            console.log('Profile updated successfully');
            res.sendStatus(200);
        } else {
            console.log('Profile update failed');
            res.sendStatus(500); // Internal Server Error
        }
    })

    app.get('/userProfileData', async(req, res) => {
        const authHeader = req.headers.authorization;
        const token = authHeader && authHeader.split(' ')[1];
        if (!token) {
            return res.status(401).send('Unauthorized');
        }
    
        let email;
        try {
            const decoded = jwt.verify(token, jwtSecret);
            email = decoded.email;
            console.log('Token Verified for updateProfile')
            const user = await collection.findOne({ email: email });
            if (!user) {
                return res.status(404).send('User profile not found');
            }
            res.send(user)
        } 
        catch (error) {
            return res.status(403).send('Forbidden');
        }
    })

    app.get('/logout', (req, res) => {
        req.session.destroy((err) => {
            if (err) {
                console.log(err);
                res.status(500).send('Error occurred during logout');
            } 
            else {
                res.clearCookie('authToken');
                res.redirect('/')
            }
        });
    });


    // Verifies the JWT and authenticates the user
    app.get('/protected-route', (req, res) => {
        // Get JWT from Authorization header
        const authHeader = req.headers.authorization
        const token = authHeader && authHeader.split(' ')[1]
    
        if (!token) {
            // No JWT provided
            console.log('Unauthorized')
            res.status(401).send('Unauthorized')
            return
        }
        
        try {
            // Verify JWT
            const decoded = jwt.verify(token, jwtSecret)
            let email = decoded.email
            // Authentication successful
            res.status(200).send(email)
        } 
        catch (error) {
            // Invalid JWT
            console.log('Forbidden')
            res.status(403).send('Forbidden')
        }
    })        

    // Verify email route
    app.get('/verify', async (req, res) => {
        const verificationToken = req.query.token
        console.log('verificationToken = ',verificationToken)
        try {
            // Find the user in the database based on the verification token
            const user = await collection.findOne({ verificationToken })
            console.log('user = ', user)
    
        if (!user) {
            // User not found or already verified
            console.log('Invalid verification token')
            res.status(404).send('Invalid verification token')
            return
        }
        console.log('entered verify token email')
        // Update the user's status to "verified" in the database
        await collection.updateOne(
            { _id: user._id },
            { $set: { verified: true }, $unset:{ verificationToken: 1 } }
        )
        console.log('exit update email token to true')
        res.status(200).json({ message: 'Email verified successfully' });
        // Redirect the user to a success page or display a success message
        // res.redirect('/LoginPage')
        } 
        catch (error) {
            console.log(error.message)
            res.status(500).send('Error verifying email')
        }
    })  

    app.get('/verify-forgot-password-email', async (req, res) => {
        const verificationToken = req.query.resetToken;
        try {
            // Find the user in the database based on the verification token
            const user = await collection.findOne({ verificationToken: verificationToken });

            if (!user) {
                console.log('Invalid verification token from forgot password')
                // User not found or already verified
                return res.status(404).send('Invalid verification token');
            }
        
            console.log('entered verify token email for forgot password')
            // Update the user's status to "verified" in the database
            await collection.updateOne(
                { _id: user._id },
                { $set: { verified: true } }//resetToken: null, resetTokenExpiresAt: null
            );
            console.log('exit update email token to true for forgot password')
            res.status(200).json({ message: 'Email verified successfully for forgot password' });
        } 
        catch (error) {
          console.log(error);
          res.status(500).send('Error verifying email');
        }
    });

    // For the form inside About.js on the client side
    app.post('/submit-form', async (req, res) => {
        try {
            await collection.insertOne(req.body)
            res.status(200).send('Form data saved')  /* On the client-side, when making the Axios POST request 

    // Define the sendVerificationEmail function
    function sendVerificationEmail(email, verificationToken) {
        const mailOptions = {
        from: '[email protected]',
        to: email,
        subject: 'Account Verification',
        html: `<p>Hello,</p>
                <p>Thank you for registering. Please verify your email address by clicking the following link:</p>
                <a href="http://localhost:3000/verify?token=${verificationToken}">Verify Email</a>`,
        };
    
        transporter.sendMail(mailOptions, (error, info) => {
        if (error) {
            console.log(error);
            // Handle error while sending verification email
        } 
        else {
            console.log('Verification email sent - from nodemailer');
            // Handle successful sending of verification email
        }
        });
    }

    // For the form inside Register_Page.js on the client side
    app.post('/Register-Page-Form', async (req, res) => {
        const {text, email, password} = req.body
        try {
            let userExist = await collection.findOne({email})
            if(userExist){
                res.status(200).send({ message : 'This email already exists. Please Login'})
            }
            else{
                const hashedPassword = await bcrypt.hash(password, 10); 
                const verificationToken = generateVerificationToken();
                const user = {
                    username: text,
                    email: email,
                    password: hashedPassword,
                    verified: false,
                    verificationToken: verificationToken
                };
                await collection.insertOne(user)
                console.log('User in database')
                res.status(200).send({ message : 'User registered successfully. Please Login'})
                sendVerificationEmail(email, verificationToken);
            }
        } 
        catch (error) {
            console.log(error)
            res.status(500).send('Error saving form data')
        }
    })
    // Function to generate verification token
    function generateVerificationToken() {
        return crypto.randomBytes(20).toString('hex');
    }

    function forgotPasswordToken(email, resetToken){
        const mailOptions = {
            from: '[email protected]',
            to: email,
            subject: 'Account Verification',
            html: `<p>Hello,</p>
                    <p>Enter the new Password by clicking the following link:</p>
                    <a href="http://localhost:3000/verify-forgot-password-email?resetToken=${resetToken}">Verify Email</a>`,
            };
        
        transporter.sendMail(mailOptions, (error, info) => {
            if (error) {
                console.log(error);
                // Handle error while sending verification email
            } 
            else {
                console.log('Verification email sent- from nodemailer for forgot password');
                // Handle successful sending of verification email
            }
        });
    }

    app.post('/Forgot-Password', async(req, res) => {
        const {email} = req.body
        try{
            let userExist = await collection.findOne({email})
            if (!userExist) {
                console.log('Email not found in Forgot-Password snippet')
                // User with the provided email doesn't exist
                return res.status(404).send('User not found');
            }
            const resetToken = generateVerificationToken()
            console.log('Reset Token in Forgot-Password snippet = ', resetToken)
            // Save the reset token and its expiration in the user document in your database
            await collection.updateOne(
                { _id: userExist._id },
                {
                  $set: {
                    resetToken: resetToken,
                    resetTokenExpiresAt: Date.now() + 3600000,
                    verified: false,
                    verificationToken: resetToken
                  }
                }
            );
            console.log('In Forgot-Password successfully updated in Database')
            //console.log('resetTokenExpiresAt = ', resetTokenExpiresAt, 'Current Date = ', Date.now())
            forgotPasswordToken(email, resetToken)
            res.status(200).send({ email });
        }
        catch (error) {
            console.log(error)
            res.status(500).send('Error saving form data')
        }
    })

    app.post('/Forgot-Password-Form', async(req, res) => {
        const { resetToken, password, email } = req.body;
        try{
            const user = await collection.findOne({ verificationToken: resetToken });
            console.log('Hi i am Forgot-Password-Form')
            if (!user) {
                // User not found or the reset token is invalid
                console.log('User with the email not found in Forgot-Password-Form')
                return res.status(404).send('Invalid reset token');
            }
            console.log('User exists and Current Date = ', Date.now())
            // Check if the reset token has expired
            if (user.resetTokenExpiresAt < Date.now()) {
                // Reset token has expired
                console.log('Reset token has expired')
                return res.status(400).send('Reset token has expired');
            }
            console.log('Reset Token has not expired, Hurray !!!!!')
            const newPassword = await bcrypt.hash(password, 10); 
            console.log('Hashed Password done')
            await collection.updateOne(
                { _id: user._id },
                {
                  $set: {
                    password: newPassword,
                    resetToken: null,
                    verificationToken: null,
                    resetTokenExpiresAt: null
                  }
                }
            );
            console.log('Password reset successfully')
            // Redirect the user to the login page or send a success response
            res.sendStatus(200);
        }
        catch(error){
            console.log(error)
            res.status(500).send('Error Resetting Password')
        }
    })

    app.listen(5000, () => {
        console.log('App is running')
    })
} 
catch (error) {
    console.log(error)
}