controllers/RoundTwoController.js

const asyncHandler = require("express-async-handler");
const Room = require("../models/RoomModel");
const Question = require("../models/QuestionsModel");
const Leaderboard = require("../models/LeaderboardModel");
const Round = require("../models/RoundsModel");
const { getRoomLeaderBoardR1R2 } = require("../helpers/LeaderBoardPreFetch");
const Team = require("../models/TeamModel");
const User = require("../models/UserModel");
const PreviousRoomModel = require("../models/PreviousRoomModel");
const UserQuestionModel = require("../models/UserQuestionModel");


//Static variable
let count = 0;


//Random array retunrer
const randomUniqueArray = (n, array) => {
    var arr = [];
    while (arr.length < n) {
        var r = Math.floor(Math.random() * array.length) + 0;
        if (arr.indexOf(array[r]) === -1) arr.push(array[r]);
    }
    return arr;
}






//MULTI BIG FUNCTION :: INITIAL ASSIGNMENT
module.exports.roundTwoAssign = asyncHandler(async (req, res) => {
    try {
        let date = new Date();
        let roundNumber = 2;
        let round = await Round.findOne({ Round: 2 });
        if (!round.Enabled) {
            res.send("Round is disabled");
            return;
        }
        if (date >= round.StartTime && date <= round.EndTime) {
            //Router Should be open
            let leaderboardR1 = await getRoomLeaderBoardR1R2(req.team,  1)
            //here 1 represents round is 1
          //  console.log(leaderboardR1)
            if (checkTeamIdInTop5(leaderboardR1, req.team._id)) {
                //if team is in top 5 teams of Round 1
                //set leaderboard of team
                let board = await Leaderboard.findOne({ TeamID: req.team._id, Round: roundNumber });
                let board1 = await Leaderboard.findOne({ TeamID: req.team._id, Round: 1 });
                if (board === null) {
                    board = new Leaderboard({
                        TeamID: req.team._id,
                        TeamName: req.team.TeamName,
                        Points: board1.Points,
                        Questions: {
                            Solved: [],
                            Unsolved: []
                        },
                        Round: 2
                    });
                }
                else if (!board.Enabled) {
                    res.send("This round is no longer available");
                    return;
                }
                //ASSIGNING ROOMID
                let rooms = await Room.find({ Round: roundNumber });

                if (board.RoomID === undefined) {
                    board.RoomID = rooms[count]._id;
                    let team = await Team.findOne({ _id: req.team._id });
                    team.RoomID = rooms[count]._id;
                    let PreviousRoom = new PreviousRoomModel({
                        TeamID: req.team._id,
                        RoomID: rooms[count]._id,
                        Round: roundNumber
                    });
                    await all_member_room_assign(req.team, rooms[count]._id);
                    await PreviousRoom.save();
                    await team.save();
                    count++;
                }
                if (count === rooms.length) {
                    count = 0;
                }

                //ASSIGNING QUESTIONS 
                //ASSIGNING QUESTIONS 

                let temp = await Round.findOne({ Round: roundNumber });
                let roundQs = temp.Questions

                if (board.Questions.Unsolved.length === 0) {
                    let room = await Room.findOne({ _id: board.RoomID })
                    let questions = room.Questions;
                    board.Questions.Unsolved = randomUniqueArray(roundQs, questions);
                    
                    //ASSIGNING HINTADDRESS FROM 0 TO 12
                    arr = []
                    let countr = 1;
                    for (let i = 0; i < board.Questions.Unsolved.length; i++) {
                        var r = Math.floor(Math.random() * 8) + 1;
                        if (arr.indexOf(r) === -1) {
                            arr.push(r);
                            let question = await Question.findOne({ _id: board.Questions.Unsolved[i] });
                            let UserQuestion = await UserQuestionModel.findOne({ QuestionNumber: question.QuestionNumber, TeamID: req.team._id });
                       
                            if (UserQuestion === null) {
                               
                                UserQuestion = new UserQuestionModel({
                                    TeamID: req.team._id,
                                    QuestionID: question._id,
                                    QuestionNumber: question.QuestionNumber,
                                    Question: question.Question,
                                    Description: question.Description,
                                    Answer: question.Answer,
                                    Hint: question.Hint,
                                    HintAddress: r,
                                    Round: question.Round,
                                    Points: question.Points,
                                    RoomID: question.RoomID,
                                    num: countr++
                                })
                               // console.log(countr)
                                await UserQuestion.save();
                            }


                        }
                        else {
                       
                            i--;
                        }
                    }
                    await board.save();

                }







                //SENDING QUESTIONS AS RESPONSE

                let UnSqsnsID = board.Questions.Unsolved;
                let SqsnsID = board.Questions.Solved;
                let qsns = { Solved: [], Unsolved: [] }

                //for unsolved
                for (let i in UnSqsnsID) {

                    let question = await UserQuestionModel.findOne({ QuestionID: UnSqsnsID[i], TeamID: req.team._id })
                    if (question) {
                        let obj = {
                            QuestionNumber: question.QuestionNumber,
                            Question: question.Question,
                            Description: question.Description,
                            HintAddress: question.HintAddress,
                            Points: question.Points,
                            num: question.num
                        }
                        qsns.Unsolved.push(obj);
                    }
                }

                //for solved
                for (let i in SqsnsID) {

                    let question = await UserQuestionModel.findOne({ QuestionID: SqsnsID[i], TeamID: req.team._id })
                    if (question) {
                        let obj = {
                            QuestionNumber: question.QuestionNumber,
                            Question: question.Question,
                            Description: question.Description,
                            HintAddress: question.HintAddress,
                            Points: question.Points,
                            num: question.num
                        }
                        qsns.Solved.push(obj);
                    }
                }
                res.json({
                    Questions: qsns,
                    ServerTime: new Date(),
                    RoundEnd: round.EndTime,
                    status: true
                })
            }
            else {
                res.send("You are not qualified for this round");
            }

        }
        else {
            //router should be closed
            res.send("Round is closed");
        }























    }
    catch (error) {
        console.log(error)
        res.status(500).json({
            message: error.message
        })
    }
})


function checkTeamIdInTop5(leaderboard, teamId) {
    // Get the top 5 array elements
   // console.log(leaderboard);
    const top5 = leaderboard.slice(0, 8);
    // Check if the teamId exists in the top 5
    for (let i = 0; i < top5.length; i++) {
        if(top5[i].TeamID===undefined)
        {
            return false;

        }
        if (top5[i].TeamID.toString() == teamId.toString()) {
            return true;
        }
    }

    return false;
}

async function all_member_room_assign(team, RoomID) {
    let members = team.Members;
    for (let i in members) {
        let member = await User.findOne({ _id: members[i] });
        if (member) {
            member.RoomID = RoomID;
            await member.save();
        }
    }
}