const express = require('express');
const bodyParser = require('body-parser');
const uuid = require('uuid');

// Define the states for the Raft node
const STATES = {
  FOLLOWER: 'FOLLOWER',
  CANDIDATE: 'CANDIDATE',
  LEADER: 'LEADER',
};

class RaftNode {
  constructor(port) {
    this.nodeId = uuid.v4();
    this.port = port;
    this.state = STATES.FOLLOWER;
    this.currentTerm = 0;
    this.votedFor = null;
    this.voteCount = 0;
    this.peers = [];
    this.app = express();
    this.app.use(bodyParser.json());

    // Define the /vote endpoint for receiving vote requests
    this.app.post('/vote', (req, res) => {
      const { term, candidateId } = req.body;

      // If the received term is greater than the current term, update the current term and reset the votedFor field
      if (term > this.currentTerm) {
        this.currentTerm = term;
        this.votedFor = null;
      }

      // If the node has not voted for any candidate in this term and the candidateId matches the received ID, grant the vote
      if (this.votedFor === null && candidateId === this.candidateId) {
        this.votedFor = candidateId;
        this.state = STATES.FOLLOWER;
        clearTimeout(this.candidateTimeout);
        this.setFollowerTimeout();
        res.status(200).json({ voteGranted: true });
      } else {
        // Otherwise, deny the vote
        res.status(200).json({ voteGranted: false });
      }
    });

    // Start the Express app
    this.app.listen(this.port, () => {
      console.log(`Raft Node ${this.nodeId} running on port ${this.port}`);
    });

    // Start the initial timer as a follower
    this.setFollowerTimeout();
  }

  // Register the peer nodes
  registerPeers(peers) {
    this.peers = peers;
  }

  // Set a random timeout to become a candidate
  setFollowerTimeout() {
    this.candidateTimeout = setTimeout(() => {
      this.state = STATES.CANDIDATE;
      this.currentTerm++;
      this.voteCount = 1;
      this.votedFor = this.nodeId;
      this.requestVotes();
    }, Math.floor(Math.random() * (3000 - 1500)) + 1500);
  }

  // Request votes from all other nodes
  async requestVotes() {
    const requestOptions = {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ term: this.currentTerm, candidateId: this.nodeId }),
    };

    const promises = this.peers.map(peer =>
      fetch(`http://${peer}/vote`, requestOptions)
        .then(response => response.json())
        .then(data => {
          if (data.voteGranted) {
            this.voteCount++;
          }
        })
        .catch(err => console.error(`Error requesting vote from ${peer}: ${err}`))
    );

    await Promise.all(promises);
    this.evaluateElection();
  }

  // Check if the node has received a majority of votes and become the leader
  evaluateElection() {
    if (this.state === STATES.CANDIDATE && this.voteCount > this.peers.length / 2) {
      this.state = STATES.LEADER;
      console.log(`Node ${this.nodeId} became the leader of term ${this.currentTerm}`);
    } else {
      this.setFollowerTimeout();
    }
  }
}

// Create an array of 5 nodes and register their peers
const nodes = [];
for (let i = 0; i < 5; i++) {
  const node = new RaftNode(3000 + i);
  nodes.push(node);
}
nodes.forEach(node => node.registerPeers(nodes.map(n => `localhost:${n.port}`)));
This code creates an array of 5 RaftNode instances with ports ranging from 3000 to 3004. Each node registers all other nodes as peers using the registerPeers method. When a node becomes a candidate, it sends a POST request to the /vote endpoint of all other nodes with its current term and ID. Each node checks if it has already voted in this term and if not, grants the vote to the candidate if its ID matches the received ID. If a candidate receives a majority of the votes, it becomes the leader and prints a message to the console. If a candidate does not receive a majority of the votes, it resets its follower timer and starts over as a follower