const { v4: uuidv4 } = require('uuid');
const asyncHandeler = require("express-async-handler");
const { response } = require("express");
const login = require("../middlewares/UserLoginMiddleware");
const path = require('path');
const User = require('../models/UserModel');
const Team = require('../models/TeamModel');
const { getRoomLeaderBoardR1R2, getRound4Leaderboard } = require('../helpers/LeaderBoardPreFetch');
const { distributeQs } = require('./QuestionController');
const { getRoundLeaderboard } = require('../helpers/LeaderBoardPreFetch');
const Leaderboard = require("../models/LeaderboardModel");
const CollaborativeLeaderboardModel = require("../models/CollaborativeLeaderboardModel");
const UserQuestionModel = require("../models/UserQuestionModel");
const Room = require("../models/RoomModel");

exports.get = asyncHandeler(async (req, res) => {
  //  console.log(await getRoomLeaderBoardR1(req.user.Team));
  res.send(await getRoomLeaderBoardR1(req.user.Team));
  return;
});











exports.post = asyncHandeler(async (req, res) => {
  //distribution of questions here
  //let data=await insertLogsToMongo();
  // await setQues()
  //setAllTLeaderBoardFalse();
  //start timer of setcollaborative timer
  let date = new Date();
  // await setQues();
  // scheduleCollaborativeRound(date);
   await setQues2();
  
  res.json(await getRound4Leaderboard());
});
async function createLeaderboardDocuments() {
  try {
    // Retrieve all teams from the Team collection
    const teams = await Team.find();

    // Iterate over each team and create a leaderboard document
    for (const team of teams) {
      // Check if a leaderboard document already exists for the team
      const existingLeaderboard = await Leaderboard.findOne({ TeamID: team._id });

      if (!existingLeaderboard) {
        // Create a new leaderboard document for the team
        const leaderboard = new Leaderboard({
          TeamID: team._id,
          TeamName: team.TeamName,
          Points: 0,
          Time: new Date(),
          RoomID: team.RoomID,
          Round: 0,
          Questions: { Solved: [], Unsolved: [] }
        });

        // Save the leaderboard document
        await leaderboard.save();
        console.log(`Created leaderboard document for team: ${team.TeamName}`);
      }
    }

    console.log("Leaderboard documents created for all teams.");
  } catch (error) {
    console.error("Error creating leaderboard documents:", error);
  }
}
async function checkTeamOK() {
  try {
    const teams = await Team.find();
    let count = 0;
    let teamcount = 0;
    let response = [];
    let team1 = [];
    for (const team of teams) {
      let flag = true;
      for (i in team.Members) {
        let user = await User.findOne({ _id: team.Members[i] });
        if (!user) {
          // console.log("Team " + team.TeamName + "has a member who is not a user")
          count++;
          response.push(team.Members[i]);
          if (flag) {
            let teamLeader = await User.findOne({ TeamID: team._id, Role: "Leader" });
            if (teamLeader) {
              console.log("Team Leader:" + teamLeader.Name);
            }

            team1.push(team.TeamName);
            teamcount++;
            flag = false;
          }
        }
      }
    }
    console.log("Total teams with missing registrations:" + teamcount)
    console.log("Total users with missing registrations:" + count);
    return team1;

  }
  catch (err) {
    console.log(err);
  }
}
const fs = require("fs");
const QuestionsModel = require('../models/QuestionsModel');
const { scheduleCollaborativeRound } = require('../timers/RoundThreeCollaborator');

async function insertLogsToMongo() {
  try {
    const logData = fs.readFileSync("logs.txt", "utf8");
    let insert = false;
    const logEntries = logData.split("\n");

    let finalData = [];
    let tempObj = {};

    for (const row of logEntries) {
      //   console.log(row);
      if (row.includes("{")) {

        insert = true;
      } else if (row.includes("}")) {
        insert = false;
        finalData.push(tempObj);
        tempObj = {};
      }

      const rowData = row.split(": ");

      if (insert) {
        if (
          rowData[0].includes("Name") ||
          rowData[0].includes("Email") ||
          rowData[0].includes("RollNumber") ||
          rowData[0].includes("PhoneNumber") ||
          rowData[0].includes("TeamID") ||
          rowData[0].includes("Branch") ||
          rowData[0].includes("Year") ||
          rowData[0].includes("DiscordID") ||
          rowData[0].includes("Password") ||
          rowData[0].includes("Role") ||
          rowData[0].includes("Timestamp") ||
          rowData[0].includes("_id")
        ) {
          tempObj[rowData[0]] = rowData[1];
        }
      }
    }
    let response = [];
    let users = await checkTeamOK();
    users = extractIdsFromArray(users)
    let data = await convertDataArray(cleanData(finalData));

    for (let i in users) {
      let team = users[i].toString();
      //  console.log(team);
      let flag = false;
      for (let j in data) {
        if (data[j] !== undefined) {
          //console.log(data[j].TeamID);
          if (data[j]._id === team) {
            // console.log("found"+data[j].TeamID);
            response.push(data[j]);
            flag = true;

          }
        }

      }
      if (!flag) {
        console.log("Team not found:" + team);
      }
    }
    console.log(response.length);
    for (k in response) {
      await registerUser(response[k]);
    }
    return response;


  } catch (err) {
    console.error("Error parsing data:", err);
  }
}
function cleanData(dataArray) {
  const cleanedData = [];

  dataArray.forEach((item) => {
    const cleanedItem = {};
    for (const key in item) {
      let value = item[key];
      value = value.trim().replace(/^'new ObjectId\("(.*)"\)'$|^'(.*)',$/, '$1$2'); // Remove single quotes and optional trailing comma
      cleanedItem[key.trim()] = value;
    }
    cleanedData.push(cleanedItem);
  });

  return cleanedData;
}
function convertDataArray(dataArray) {
  const convertedArray = dataArray.map((item) => {
    let response = {};
    let goodObj = true;
    if (item.Name) {
      response.Name = item.Name.trim()
    }
    else
      goodObj = false;
    if (item.Email) { response.Email = item.Email.trim() }
    else
      goodObj = false;

    if (item.RollNumber)
      response.RollNumber = item.RollNumber.replace(',', '').trim()
    else
      goodObj = false;
    if (item.PhoneNumber)
      response.PhoneNumber = item.PhoneNumber.trim()
    else
      goodObj = false;
    if (item.TeamID)
      response.TeamID = item.TeamID.replace('new ObjectId("', '').replace('"),', '').trim()
    else
      goodObj = false;
    if (item.Branch)
      response.Branch = item.Branch.trim()
    else
      goodObj = false;
    if (item.Year)
      response.Year = item.Year.trim()
    else
      goodObj = false;
    if (item.DiscordID)
      response.DiscordID = item.DiscordID.trim()
    else
      goodObj = false;
    if (item.Password)
      response.Password = item.Password.trim()
    else
      goodObj = false;
    if (item.Role)
      response.Role = item.Role.trim()
    else
      goodObj = false;
    if (item.Timestamp)
      response.Timestamp = item.Timestamp.replace(',', '').trim()
    else
      goodObj = false;
    if (item._id)
      response._id = item._id.replace('new ObjectId("', '').replace('"),', '').trim()
    else
      goodObj = false;
    if (goodObj)
      return response;

  });
  for (i in convertedArray) {
    if (convertedArray[i] === undefined) {
      convertedArray.splice(i, 1);
    }
  }
  return convertedArray;
}
function extractIdsFromArray(dataArray) {
  const idArray = dataArray.map((item) => item.toString());
  return idArray;
}
async function registerUser(user) {
  let team = await Team.findOne({ _id: user.TeamID });
  let usern = new User({
    Name: user.Name,
    Email: user.Email,
    Password: team.Password,
    RollNumber: user.RollNumber,
    PhoneNumber: user.PhoneNumber,
    Branch: user.Branch,
    Year: user.Year,
    DiscordID: user.DiscordID,
    Role: "Member",
    TeamID: team._id
  });
  try {
    await usern.save();
    usern = await User.findOne({ Email: user.Email });
    let index = team.Members.indexOf(user._id);
    team.Members.splice(index, 1);
    team.Members.push(usern._id);
    //remove old user id

    await team.save();
    console.log("User saved:" + usern.Name);
  }
  catch (err) {
    console.log(err);

  }
  console.log(team);
}
async function setQues() {
  try {
    let ques = await QuestionsModel.find({ Round: 3 })
    for (i in ques) {
      let q = ques[i]
      q.assigned = true;
      console.log(q)
      await q.save()
    }
  }
  catch (err) {
    console.log(err)
  }
  //set assigned false to all round 2 questions

}

async function setAllTLeaderBoardFalse() {
  let leaderboard = await Leaderboard.find({ Round: 2 });
  for (i in leaderboard) {
    let board = leaderboard[i];
    board.Enabled = false;
    await board.save();
  }
}
async function setQues2() {
  let board = await Leaderboard.find({ Round: 4 });
  
  for (let i in board) {
    
    let questions=board[i].Questions.Unsolved;
    let count=1;
    for(let j in questions){
      let q=questions[j];
      let ques=await QuestionsModel.findOne({_id:q});
      let t1q=new UserQuestionModel({
        QuestionID:ques._id,
        QuestionNumber:ques.QuestionNumber,
        Question:ques.Question,
        Description:ques.Description,
        HintAddress:count,
        Answer:ques.Answer,
        Points:ques.Points,
        Round:ques.Round,
        TeamID:board[i].TeamID,
        Hint:ques.Hint,
        num:count
    })

      await t1q.save();
  }
}
}
async function setTopUser()
{
  let room=await Room.findOne({Round:3});
  let TopTeam=new CollaborativeLeaderboardModel({
      TeamID1:"5f9f1f1b1c9d440000b0b0a1",
      TeamID2:"5f9f1f1b1c9d440000b0b0a2",
      Questions:{
          Solved:[],
          Unsolved:[]
      },
      Points:241543903,
      TeamName:"david",
      Round:3,
      RoomID:room._id

  })
  TopTeam.save();
}