local runService = game:GetService("RunService")

local tel = game:GetService("TeleportService")

local mes = game:GetService("MessagingService")

local listTopic = "ServerList"

local requestServers = "RequestServers"

local codeMatch = "CheckCodeMatch"

local requestCode = "RequestCode"

local requestModify = "RequestModify"

local mapSkeldId = 5928953638

local queued = {

}

-- variables and tables

local serverCodes = {
    --["ABCDEF"] = "21i4b5i2tewtewr3u5bip34u2"
}

function addServer(message, updating)
    game.ReplicatedStorage.CreateServer:FireAllClients(message, nil, updating)

    print(4)
end -- adds a server to all clients

function addServerSingular(player, message, bundle, updating)
    print("sing")

    game.ReplicatedStorage.CreateServer:FireClient(player, message, bundle, updating)

    print("sing2")

    print(5)
end

 -- adds a server to a specific client

function addServerPersonal(message, updating)
    print("pers")

    local data = message.Data

    if updating then
        data = message.Data[4]
    end

    local clone = game.ReplicatedStorage.Servers["123456789-ABCDEF"]:Clone()

    clone.Parent = game.ReplicatedStorage.Servers.List

    clone.Name = data[2] .. "-" .. "ABCDEF"

    clone.HostUserId.Value = data[2]

    clone.Code.Value = data[4]

    clone.ReservedCode.Value = data[5][1]
end -- adds a server to the games own storage for debugging / etc

mes:SubscribeAsync(listTopic, function(message)
    print(message)

    local toDo = message.Data[1]

    print(2)

    print(toDo)

    local data = message.Data[4]

    if toDo == "Add" then
        print(3)

        addServer(message, message.Data[5])

        addServerPersonal(message, message.Data[5])
    else
        print(toDo)

        if data[1] == "Add" then
            print(4)

            addServer(message, message.Data[5])

            --addServerPersonal(message, message.Data[5])
        else
            print(data[1], "not")
        end
    end
end) -- adds a server when it is created to all clients

mes:SubscribeAsync(codeMatch, function(message)
    local data = message.Data

    if serverCodes[data[2]] and message[3] ~= game.JobId then
        mes:PublishAsync(data[1] .. codeMatch, true)
    else
        print(message[3], game.JobId)
    end
end) -- checks if the invite code for a server exists or not.

game.ReplicatedStorage.CreateServer.OnServerEvent:Connect(function(player)
    local code = ""

    local function settage(num)
        local codage = {}

        for i = 1, num do
            codage[#codage + 1] = string.char(math.random(65, 90))
        end

        local codaged = table.concat(codage, "")

        local event1

        local taken = false

        event1 = mes:SubscribeAsync(player.UserId .. codeMatch, function(message)
            if message.Data then
                taken = true

                event1:Disconnect()
            end
        end)

        mes:PublishAsync(codeMatch, {player.UserId, codaged, game.JobId})

        wait(1)

        if taken then
            return settage(num)
        else
            return codaged
        end
    end

    code = settage(6)

    print(code)

    local id

    if runService:IsStudio() then
        id = {"studioPlayer", player.UserId}
    else
        id = {tel:ReserveServer(mapSkeldId), player.UserId}
    end

    local data = {"Add", player.UserId, player.Name, code, id}

    serverCodes[code] = id[1]

    print(data[1])

    --lined because of private / public features (private is default, public comes after)

    --mes:PublishAsync(listTopic, data)

    print(1)

    game.ReplicatedStorage.TeleportCode.InititateJoin:Fire(player, id[1], code)
end) -- fires when the player creates a new server and creates the server. the creator of the server will auto join the server aswell.

game.Players.PlayerAdded:Connect(function(player)
    for i, v in pairs(game.ReplicatedStorage.Servers.List:GetChildren()) do
        local id = v.HostUserId.Value

        local name

        if not runService:IsStudio() then
            name = game.Players:GetNameFromUserIdAsync(id)
        else
            name = "StudioPlayer" .. -id
        end

        local data = {"Add", id, name, v.Code.Value, v.ReservedCode.Value}

        addServerSingular(player, data, true)
    end

    queued[player.UserId] = true

    local event

    local lastRecieverTime = 0

    event = mes:SubscribeAsync(player.UserId, function(message)
        local data = message.Data

        lastRecieverTime = -1

        if data[6] then
            addServerSingular(player, data, true)
        else
            addServerSingular(player, data)
        end

        print("data", data)

        lastRecieverTime = 0
    end)

    mes:PublishAsync(requestServers, player.UserId)

    repeat
        wait()

        if lastRecieverTime >= 0 then
            lastRecieverTime += 0.033333333333333333333333333333333333333333333333333333333333333333333333333333333
        end
    until lastRecieverTime >= 1

    event:Disconnect()

    queued[player.UserId] = nil

    --should receive all servers
end) -- will retrieve a list of every server to add to the player

mes:SubscribeAsync(requestServers, function(message)
    local data = message.Data

    if not game.Players:FindFirstChild(game.Players:GetNameFromUserIdAsync(data)) then
        for i, v in pairs(game.ReplicatedStorage.Servers.List:GetChildren()) do
            local info

            if not runService:IsStudio() then
                info = {"Add", v.HostUserId.Value, game.Players:GetNameFromUserIdAsync(v.HostUserId.Value), v.Code.Value, v.ReservedCode.Value}
            else
                info = {"Add", v.HostUserId.Value, "StudioPlayer" .. -v.HostUserId.Value, v.Code.Value, v.ReservedCode.Value}
            end

            mes:PublishAsync(data, info)
        end
    end
end) -- returns a list of all the game server's serves when requested to.



game.ReplicatedStorage.TeleportCode.OnServerEvent:Connect(function(player, key)
    tel:TeleportToPrivateServer(mapSkeldId, key, {player})
end) -- teleports the player to the server they join

game.ReplicatedStorage.TeleportCode.InititateJoin.Event:Connect(function(player, key, code)
    tel:TeleportToPrivateServer(mapSkeldId, key, {player}, nil, {
        ["Code"] = code,

        ["Key"] = key,

        ["UserId"] = player.UserId
    }, nil
    )

    print("host")

    --host
end) -- teleports the host to the server he creates.



mes:SubscribeAsync(requestCode, function(message)
    local data = message.Data

    local code = serverCodes[data[2]]

    print(22)

    print(code)

    if code then
        mes:PublishAsync(data[1] .. requestCode, code)

        print(33)
    end
end) -- tells the sender if the specified code for a server exists.

mes:SubscribeAsync(requestModify, function(message)
    print("server modify")

    local data = message.Data

    game.ReplicatedStorage.ServerModify:FireAllClients(data)
end) -- modifies all clients servers with allocated data.

function requestCodeAvailability(player, key)
    local event

    print(11)

    local datad

    event = mes:SubscribeAsync(player.UserId .. requestCode, function(message)
        local data = message.Data

        print(44)

        datad = data

        event:Disconnect()
    end)

    mes:PublishAsync(requestCode, {player.UserId, key})

    local timer = 0

    repeat
        wait(0.01)

        timer += 0.01
    until datad or timer >= 1

    if event.Connected then
        event:Disconnect()
    end

    print("ended")

    return datad
end -- sends a request to every server ingame to check if the specified code is available for a hosts server.

game.ReplicatedStorage.RequestCode.OnServerInvoke = requestCodeAvailability