const LeaderboardModel = require('../models/LeaderboardModel');
const RoomModel = require('../models/RoomModel');
const RoundsModel = require('../models/RoundsModel');
const PreviousRoomModel = require('../models/PreviousRoomModel');
const CollaborativeLeaderboardModel = require('../models/CollaborativeLeaderboardModel');
let getLeaderBoardR1 = [];

module.exports.getRoomLeaderBoardR1R2 = async function getRoomLeaderBoardR1R2(team,round) {
    try {
        let PreviousRoom = await PreviousRoomModel.findOne({ TeamID: team._id, Round: round});
        console.log(PreviousRoom);
        let roomLeaderBoard = await LeaderboardModel.find({ RoomID: PreviousRoom.RoomID, Round: round});
        if (roomLeaderBoard.length === 0) {
            return "No teams in the room";
        } else {
            getLeaderBoardR1 = roomLeaderBoard;
            getLeaderBoardR1 = await Promise.all(getLeaderBoardR1.map(async (team) => {
                return await unsetTeams(team,round);
            }));
            
          
            getLeaderBoardR1.sort((a, b) => {
                if (a.Points === b.Points) {
                    return a.Time - b.Time;
                } else {
                    return b.Points - a.Points;
                }
            });

            return getLeaderBoardR1;
        }
    } catch (error) {
        console.log(error);
        return false;
    }
};
module.exports.getRoundLeaderboard=async function getRoundLeaderboard(round)
{
    try{
        let leaderboard=[];
        let rooms= await RoomModel.find({Round:round});
       
        for(let i=0;i<rooms.length;i++)
        {
            let roomLeaderBoard = await LeaderboardModel.find({ RoomID: rooms[i]._id, Round: round});
           
            if (roomLeaderBoard.length === 0) {
                console.log("No teams in the room")
            } else {
                roomLeaderBoard.sort((a, b) => {
                    if (a.Points === b.Points) {
                        return a.Time - b.Time;
                    } else {
                        return b.Points - a.Points;
                    }
                });
                leaderboard.push(roomLeaderBoard);
                leaderboard[i] = await Promise.all(leaderboard[i].map(async (team) => {
                    return await unsetTeams(team,round);
                }));
            }
        }
        return leaderboard;
    }
        catch(error){
            console.log(error);
            return false;
        }
}
module.exports.getRound3Leaderboard=async function getRound3Leaderboard()
{
    round=3;
    try{
        let leaderboard=[];
        let roomLeaderBoard= await CollaborativeLeaderboardModel.find({Round:3});
        roomLeaderBoard.sort((a, b) => {
            if (a.Points === b.Points) {
                return a.Time - b.Time;
            } else {
                return b.Points - a.Points;
            }
        });
        leaderboard=roomLeaderBoard;
        leaderboard = await Promise.all(leaderboard.map(async (team) => {
            return await unsetTeams(team, round);
        }));
        return leaderboard;
    }
        catch(error){
            console.log(error);
            return false;
        }
}
module.exports.getRound4Leaderboard=async function getRound4Leaderboard()
{
    round=4;
    try{
        let leaderboard=[];
        let roomLeaderBoard= await LeaderboardModel.find({Round:4});
        roomLeaderBoard.sort((a, b) => {
            if (a.Points === b.Points) {
                return a.Time - b.Time;
            } else {
                return b.Points - a.Points;
            }
        });
        leaderboard=roomLeaderBoard;
        leaderboard = await Promise.all(leaderboard.map(async (team) => {
            return await unsetTeams(team, round);
        }));
        return leaderboard;
    }
        catch(error){
            console.log(error);
            return false;
        }
}
module.exports.getFinalLeaderboard=async function getFinalLeaderboard()
{
    round = 0;
    try {
        let leaderboard = [];
        let roomLeaderBoard = await LeaderboardModel.find({ Round: 0 });
        roomLeaderBoard.sort((a, b) => {
            if (a.Points === b.Points) {
                return a.Time - b.Time;
            } else {
                return b.Points - a.Points;
            }
        });
        leaderboard = roomLeaderBoard;
        leaderboard = await Promise.all(leaderboard.map(async (team) => {
            return await unsetTeams(team, round);
        }));
        return leaderboard;
    }
    catch (error) {
        console.log(error);
        return false;
    }
}

async function unsetTeams(team,round) {
    const unsetTeam = { ...team._doc }; 
    unsetTeam._id = undefined;
    unsetTeam.__v = undefined;
    //unsetTeam.TeamID = undefined;
    unsetTeam.RoomID = undefined;
    unsetTeam.Round = undefined;
    unsetTeam.Questions = undefined;
    unsetTeam.Time = undefined;
    if(round!==0)
    unsetTeam.TotalTime = await calculateTime(team.Time, round);
    else
    unsetTeam.TotalTime = "00H 00M 00S";
    return unsetTeam;
}

async function calculateTime(time, round) {
    const Round = await RoundsModel.findOne({Round:round});
    const RoundStartTime = new Date(Round.StartTime);
    const TeamTime = new Date(time);
    const TotalTime = TeamTime - RoundStartTime;
    return convertSecondsToDHMS(Math.floor(TotalTime / 1000));
}

function convertSecondsToDHMS(seconds) {
    const days = Math.floor(seconds / (24 * 60 * 60));
    const hours = Math.floor((seconds % (24 * 60 * 60)) / (60 * 60));
    const minutes = Math.floor((seconds % (60 * 60)) / 60);
    const remainingSeconds = seconds % 60;

    const formatNumber = (number) => {
        return number.toString().padStart(2, '0');
    };

    let result = '';
    if (days > 0) {
        result += `${formatNumber(days)}D `;
    }
    if (hours > 0) {
        result += `${formatNumber(hours)}H `;
    }
    else if(days!==0 && hours===0)
    {
        result += `${formatNumber(hours)}H `;
    }
    result += `${formatNumber(minutes)}M ${formatNumber(remainingSeconds)}S`;

    return result.trim();
}