local ReplicatedStorage = game.ReplicatedStorage
local ServerScripts = game.ServerScriptService
local ServerStorage = game.ServerStorage
local Players = game.Players
local Events = ReplicatedStorage.RemoteEvents
local GameStartEvent = Events.GameStartEvent
local RoundEndEvent = Events.RoundEndEvent
local RoundInformation = require(ServerScripts.Directories.RoundInformation)
local PlayerManager = require(ServerScripts.Utilities.PlayerManager)
local LavaHandler = require(script.LavaHandler)
local GameInfo = require(ServerScripts.Directories.GameInformation)
local RoundLengthVal = ReplicatedStorage.GameInformation.RoundLength
local IntermissionLengthVal = ReplicatedStorage.GameInformation.IntermissionLength

local currentMap = workspace.CurrentMap
local Lobby = workspace.Lobby
local LobbySpawns = Lobby.LobbySpawns:GetChildren()

local currentPlayers = {}
local tagger = nil
local roundEnded = false
local connection
local RoundManager = {}
local currMap = nil


local function clean()
    if tagger then
        tagger:Clean()
    end
    tagger = nil
    for i, player in pairs(Players:GetChildren()) do
        local character = workspace:FindFirstChild(player.Name)
        local prompt = character:FindFirstChild("HumanoidRootPart"):FindFirstChild("TagPrompt")
        if prompt then
            prompt.Enabled = false
        end
        if character then
            task.delay(2, function()
                local randSpawn = LobbySpawns[math.random(1, #LobbySpawns)]
                character.HumanoidRootPart.CFrame = randSpawn.CFrame * CFrame.new(0, 4, 0)
            end)
        end
        player.Character:SetAttribute("InRound", false)
        task.wait(0.5)
    end
    for name, person in pairs(currentPlayers) do
        local survivalNum = 0
        if person.Survived then
            survivalNum += GameInfo.SurvivalCoins
        end
        if person.Player ~= nil then
            local level = PlayerManager:GetLevel(person.Player)
            if level ~= nil then
                PlayerManager:AddMoney(person.Player, survivalNum + GameInfo.ParticipationCoins)
                PlayerManager:AddXP(person.Player, (200 * level) ^ 1.25)
                RoundEndEvent:FireClient(person.Player, person.Survived, survivalNum, GameInfo.ParticipationCoins)
            end
        end
    end

    if connection then
        connection:Disconnect()
    end
    task.delay(3, function()
        if not currMap then
            currMap:Destroy()
            currMap = nil
        end
    end)
end

local function EndRound()
    roundEnded = true
    for i, player in pairs(Players:GetChildren()) do
        GameStartEvent:FireClient(player)
    end
    task.wait(3)
    clean()
end

local function spawnMap()
    local Maps = ServerStorage.Maps:GetChildren()
    local map = Maps[math.random(1, #Maps)]:Clone()
    map.Parent = currentMap
    if map:IsA("Model") then
        map:PivotTo(Lobby.PrimaryPart.CFrame * CFrame.new(map:GetExtentsSize().X + 125, 676, map:GetExtentsSize().Y + 125))
    elseif map:IsA("Part") then
        map.CFrame = Lobby.PrimaryPart.CFrame * CFrame.new(map.Size.X + 125, 676, map.Size.Y + 125)
    end


    return map
end

local function getTagger()
    local plrs = game.Players:GetPlayers()
    if plrs ~= 0 then
        return plrs[math.random(1, #plrs)]
    else
        return nil
    end
end

local function getSurvivorCount()
    local count = 0
    for _, data in pairs(currentPlayers) do
        if data.Survived then
            count += 1
        end
    end
    return count
end

local function spawnPlayer(map)
    for i, player in pairs(Players:GetChildren()) do
        player.RespawnLocation = LobbySpawns[math.random(1, #LobbySpawns)]
        local character = workspace:FindFirstChild(player.Name)
        if not character then return end
        currMap = map
        local spawns = map:WaitForChild("Spawns"):GetChildren()
        local spawn

        local hrp = character:WaitForChild("HumanoidRootPart")
        local TagPrompt = hrp:WaitForChild("TagPrompt")

        TagPrompt.Triggered:Once(function()
            if roundEnded then return end
            local currPlr = Players:GetPlayerFromCharacter(character)
            currentPlayers[currPlr.Name] = {Player = player, Survived = false}
            local num = getSurvivorCount()
            if num == 1 then
                EndRound()
            end
        end)

        character.Humanoid.Died:Once(function()
            if roundEnded then return end
            local currPlr = Players:GetPlayerFromCharacter(character)
            currentPlayers[currPlr.Name] = {Player = player, Survived = false}
            local num = getSurvivorCount()
            if num == 1 then
                EndRound()
            end
        end)

        character:SetAttribute("InRound", true)
        if tagger.Person ~= player then
            currentPlayers[player.Name] = {Player = player, Survived = true}
            repeat spawn = spawns[math.random(1, #spawns)]
            until spawn.Name ~= "LavaSpawnLocation"
        else
            currentPlayers[player.Name] = {Player = player, Survived = true, Tagger = player}
            for i, v in pairs(spawns) do
                if v.Name == "LavaSpawnLocation" then
                    spawn = v
                    break
                end
            end
        end

        character:PivotTo(spawn.CFrame * CFrame.new(0, 2, 0))
    end
end

function RoundManager:Init()
    RoundLengthVal.Value = RoundInformation.RoundLength
    IntermissionLengthVal.Value = RoundInformation.IntermissionLength
    task.spawn(function()
        while true do
            task.wait(0.25)
            if #game.Players:GetPlayers() ~= 0 then
                roundEnded = false
                RoundLengthVal.Value = -1
                for i = RoundInformation.IntermissionLength, 1, -1 do
                    IntermissionLengthVal.Value = i
                    task.wait(1)
                end

                local map = spawnMap()
                local taggerPerson = getTagger()
                for i, player in pairs(Players:GetChildren()) do
                    GameStartEvent:FireClient(player, taggerPerson)
                end

                task.wait(3.5)
                tagger = LavaHandler.New(taggerPerson)
                spawnPlayer(map)
                connection = game.Players.PlayerRemoving:Connect(function(player)
                    for i, person in pairs(currentPlayers) do
                        if person.Tagger == player then
                            EndRound()
                            break
                        end
                    end
                    currentPlayers[player.Name] = nil
                    local num = getSurvivorCount()
                    if num == 1 then
                        EndRound()
                    end
                end)
                IntermissionLengthVal.Value = -1
                for i = RoundInformation.RoundLength, 1, -1 do
                    if roundEnded then
                        break
                    end
                    RoundLengthVal.Value = i
                    task.wait(1)
                end
                if not roundEnded then
                    EndRound()
                end
            end
        end
    end)

end

return RoundManager