router.post("/", async (req, res) => {
	const { email, password } = req.body;

	try {
	if (!email) return res.status(400).json({ msg: "An email is required" });

	if (!password)
	return res.status(400).json({ msg: "A password is required" });

	const user = await User.findOne({ email }).select("_id password");

	if (!user) return res.status(400).json({ msg: "Invalid credentials" });

	const match = await bcrypt.compare(password, user.password);

	if (!match) return res.status(400).json({ msg: "Invalid credentials" });

	const accessToken = genAccessToken({ id: user._id });
	const refreshToken = genRefreshToken({ id: user._id });

	res.cookie("token", refreshToken, {
	expires: new Date(Date.now() + 604800),
	httpOnly: true,
	});

	res.json({ accessToken });
	} catch (err) {
	console.log(err.message);
	res.status(500).json({ msg: "Error logging in user" });
	}
});

const arithmeticProgression  = (n, lim) =>
  Array.from({ length: Math.ceil(lim / n) }, (_, i) => (i + 1) * n );
  
arithmeticProgression(5, 25); // [5, 10, 15, 20, 25]

const Discord = require('discord.js');
const client = new Discord.Client();
const token = 'YOUR_BOT_TOKEN';

// When the bot is ready, log a message to the console
client.on('ready', () => {
  console.log(`Logged in as ${client.user.tag}!`);
});

// When a user sends a message, check if they are authenticated
client.on('message', async (msg) => {
  if (!msg.author.bot && !msg.author.authenticated) {
    const filter = (m) => m.author.id === msg.author.id;
    const collector = msg.channel.createMessageCollector(filter, { time: 15000 });

    // Send an authentication message to the user
    msg.author.send('Please authenticate yourself by clicking this link: ' + generateAuthURL(msg.author.id));

    collector.on('collect', async (m) => {
      // Check if the message contains the authentication code
      if (m.content.startsWith('!auth ')) {
        const code = m.content.slice(6);
        const { access_token } = await getAccessToken(code);

        // Set the user's authenticated status and access token
        msg.author.authenticated = true;
        msg.author.access_token = access_token;
        collector.stop();
      }
    });

    collector.on('end', () => {
      if (!msg.author.authenticated) {
        msg.author.send('Authentication timed out.');
      }
    });
  }
});

// Generate an authentication URL for the user
function generateAuthURL(userId) {
  const redirectURI = encodeURIComponent('YOUR_REDIRECT_URL');
  const scopes = 'identify';
  const clientID = 'YOUR_CLIENT_ID';

  return `https://discord.com/api/oauth2/authorize?client_id=${clientID}&redirect_uri=${redirectURI}&response_type=code&scope=${scopes}&state=${userId}`;
}

// Exchange the authorization code for an access token
async function getAccessToken(code) {
  const redirectURI = encodeURIComponent('YOUR_REDIRECT_URL');
  const clientID = 'YOUR_CLIENT_ID';
  const clientSecret = 'YOUR_CLIENT_SECRET';

  const res = await fetch('https://discord.com/api/oauth2/token', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/x-www-form-urlencoded',
    },
    body: `grant_type=authorization_code&code=${code}&redirect_uri=${redirectURI}&client_id=${clientID}&client_secret=${clientSecret}`,
  });

  return await res.json();
}

client.login(token);

const getSearchTerm = delimiter => {
	let searchTerm = "";

	for (let i = 1; i < commands.length - 1; i++)
	searchTerm = searchTerm + commands[i] + delimiter;

	searchTerm += commands[commands.length - 1];

	return searchTerm;
	};

const binomialCoefficient = (n, k) => {
  if (Number.isNaN(n) || Number.isNaN(k)) return NaN;
  if (k < 0 || k > n) return 0;
  if (k === 0 || k === n) return 1;
  if (k === 1 || k === n - 1) return n;
  if (n - k < k) k = n - k;
  let res = n;
  for (let j = 2; j <= k; j++) res *= (n - j + 1) / j;
  return Math.round(res);
};

binomialCoefficient(8, 2); // 28

function printHeap(heap, index, level) {
    if (index >= heap.length) {
        return;
    }
    console.log("  ".repeat(level) + heap[index]);
    printHeap(heap, 2 * index + 1, level + 1);
    printHeap(heap, 2 * index + 2, level + 1);
}

//You can call this function by passing in the heap array and the index of the root node, which is typically 0, and level = 0.

let heap = [3, 8, 7, 15, 17, 30, 35, 2, 4, 5, 9];
printHeap(heap,0,0)