--SETTINGS
DataVersion = 1
SaveSpeed = 6
--SETTINGS

local players = game.Players
local HttpService = game:GetService("HttpService")
print("Darkness PlayerDataScript launched!")

gamemain = workspace.GameMain
gamedata = gamemain.GameData
resources = game.ServerStorage.Resources
playerstats = gamemain.PlayerStats
playerstats:ClearAllChildren()

local debug_mode = game:findFirstChild("NetworkServer") == nil--) or true

local ds_dp = game:GetService("DataStoreService"):GetDataStore("DarknessProducts")
local LoadLibrary = game.ReplicatedStorage.LoadLibrary
local RbxUtility = LoadLibrary.RbxUtility


local Utils = require(RbxUtility)

_G["GameDatabase"] = {
    pinfo = {},
    action = {},
    ready = false,
}

_G["GameDatabase"].action["CanPlay"] = function(player_name)
    if _G["GameDatabase"].pinfo[player_name] == nil then return false end
    return _G["GameDatabase"].pinfo[player_name].ready and not _G["GameDatabase"].pinfo[player_name].afk
end

_G["GameDatabase"].action["SetData"] = function(player_name, data_name, value)
    pcall(function()
        _G["GameDatabase"].pinfo[player_name].stats[data_name] = value
        _G["GameDatabase"].pinfo[player_name].changed:Fire()
    end)
end

_G["GameDatabase"].action["UpdateData"] = function(player_name, data_name, value)
    pcall(function()
        _G["GameDatabase"].pinfo[player_name].stats[data_name] = _G["GameDatabase"].pinfo[player_name].stats[data_name] + value
        _G["GameDatabase"].pinfo[player_name].changed:Fire()
    end)
end

_G["GameDatabase"].action["GetData"] = function(player_name, data_name)
    if _G["GameDatabase"].pinfo[player_name] == nil then return 0 end
    return _G["GameDatabase"].pinfo[player_name].stats[data_name]
end

_G["GameDatabase"].action["AddBought"] = function(player_name, bought_name)
    if _G["GameDatabase"].pinfo[player_name] == nil then return false end
    local ch = _G["GameDatabase"].pinfo[player_name].stats.bought
    for i = 1, #ch do
        if ch[i] == bought_name then
            return
        end
    end
    _G["GameDatabase"].pinfo[player_name].stats.bought[#ch + 1] = bought_name
    _G["GameDatabase"].pinfo[player_name].changed:Fire()
end

_G["GameDatabase"].action["CheckBought"] = function(player_name, bought_name)
    if _G["GameDatabase"].pinfo[player_name] == nil then return false end
    local ch = _G["GameDatabase"].pinfo[player_name].stats.bought
    for i = 1, #ch do
        if ch[i] == bought_name then
            return true
        end
    end
    return false
end

_G["GameDatabase"].action["UseBought"] = function(player_name, bought_name)
    if _G["GameDatabase"].pinfo[player_name] == nil then return false end
    local ch = _G["GameDatabase"].pinfo[player_name].stats.bought
    local result = {}
    local used = false
    for i = 1, #ch do
        if ch[i] == bought_name and not used then
            used = true
        else
            result[#result + 1] = ch[i]
        end
    end
    _G["GameDatabase"].pinfo[player_name].stats.bought = result
    _G["GameDatabase"].pinfo[player_name].changed:Fire()
    return used
end

_G["GameDatabase"].action["GetWait"] = function(player_name)
    if _G["GameDatabase"].pinfo[player_name] == nil then return 0 end
    return _G["GameDatabase"].pinfo[player_name].play_wait
end

_G["GameDatabase"].action["AddWait"] = function(player_name)
    if _G["GameDatabase"].pinfo[player_name] == nil then return end
    _G["GameDatabase"].pinfo[player_name].play_wait = _G["GameDatabase"].pinfo[player_name].play_wait + 1
end

_G["GameDatabase"].action["ClearWait"] = function(player_name)
    if _G["GameDatabase"].pinfo[player_name] == nil then return end
    _G["GameDatabase"].pinfo[player_name].play_wait = 0
end

_G["GameDatabase"].action["TempBeast"] = function(player_name)
    if _G["GameDatabase"].pinfo[player_name] == nil then return false end
    return _G["GameDatabase"].pinfo[player_name].temp_beast
end

local GamePassService = game:GetService('MarketplaceService')
function CheckGamePass(plr, gamepass_id)
    return GamePassService:UserOwnsGamePassAsync(plr.UserId, gamepass_id)
end

function PlayerAdded(newPlayer)
    print("Loading",newPlayer)
    local pname = newPlayer.Name
    local pid = newPlayer.userId
    _G["GameDatabase"].pinfo[pname] = {
        player = newPlayer,
        changed = Instance.new("BindableEvent"),
        stats = {
            points = 0,
            survivor_wins = 0,
            beast_wins = 0,
            games_played = 0,
            bought = {},
            version = DataVersion
        },
        play_wait = 0,
        ready = false,
        afk = false,
        temp_beast = false,
    }

    newPlayer.CharacterAdded:connect(function()
        pcall(function()
            wait()
            local tt = Instance.new("Tool")
            tt.Parent = newPlayer.Backpack
            wait(0.1)
            tt.Parent = nil
        end)
        wait()
        pcall(function()
            if _G["GameDatabase"].pinfo[pname].ready then
                local g = resources.MenuGui:clone()
                pcall(function()
                    if gamedata.GameRunning.Value then
                        g.MainFrame.GuiWall1.desc.Text = ""
                        g.MainFrame.GuiWall2.desc.Text = ""
                    else
                        g.MainFrame.GuiWall1.desc.Text = "GAME END"
                        g.MainFrame.GuiWall2.desc.Text = "NEXT ROUND WILL BEGIN SHORTLY"
                    end
                end)
                g.Parent = newPlayer.PlayerGui
            else
                local g = resources.IntroGui:clone()
                g.Parent = newPlayer.PlayerGui
            end
        end)
    end)

    if ds_dp:GetAsync("TempBeast" .. pid) == true then
        _G["GameDatabase"].pinfo[pname].temp_beast = true
    end
    ds_dp:OnUpdate("TempBeast" .. pid, function(val)
        if val == true then
            _G["GameDatabase"].pinfo[pname].temp_beast = true
            _G["GameDatabase"].pinfo[pname].changed:Fire()
        else
            _G["GameDatabase"].pinfo[pname].temp_beast = false
            _G["GameDatabase"].pinfo[pname].changed:Fire()
        end
    end)

    local last_save = 0
    local save_issued = false
    coroutine.resume(coroutine.create(function()
        while newPlayer.Parent == players do
            wait(0.05)
            if save_issued then
                while (tick() - last_save) <= 60 / SaveSpeed do
                    wait(0.05)
                end
                if _G["GameDatabase"].pinfo[pname] ~= nil and newPlayer.Parent == players then
                    ds_dp:SetAsync("DATA" .. pid, HttpService:EncodeJSON(_G["GameDatabase"].pinfo[pname].stats))
                end
            end
        end
    end))

    local function SavePlayerData()
        if debug_mode then return end
        save_issued = true
        --newPlayer:SaveString("GameData", Utils.EncodeJSON(_G["GameDatabase"].pinfo[pname].stats))
    end


    local dat_ver, get_dat
    if not debug_mode then
        get_dat = ds_dp:GetAsync("DATA" .. pid) --newPlayer:LoadString("GameData")
        if type(get_dat) ~= "string" then
            newPlayer:WaitForDataReady()
            local old_dat = newPlayer:LoadString("GameData")
            if old_dat ~= nil then
                if DataVersion == 1 then
                    get_dat = old_dat
                    dat_ver = 1
                end
            end
        else
            pcall(function()
                local test = HttpService:DecodeJSON(get_dat)
                dat_ver = test.version
            end)
        end
    end
    if not debug_mode and dat_ver == DataVersion then
        pcall(function()
            local test = HttpService:DecodeJSON(get_dat)
            if type(test) == "table" then
                if type(test["points"]) == "number" and type(test["survivor_wins"]) == "number" and type(test["beast_wins"]) == "number" and type(test["games_played"]) == "number" and type(test["bought"]) == "table" then
                    _G["GameDatabase"].pinfo[pname].stats.points = test.points
                    _G["GameDatabase"].pinfo[pname].stats.survivor_wins = test.survivor_wins
                    _G["GameDatabase"].pinfo[pname].stats.beast_wins = test.beast_wins
                    _G["GameDatabase"].pinfo[pname].stats.games_played = test.games_played
                    _G["GameDatabase"].pinfo[pname].stats.bought = test.bought
                end
            end
        end)
    end
    SavePlayerData()

    local ldc = newPlayer:findFirstChild("leaderstats")
    if ldc then ldc:remove() end

    local leaderboard = Instance.new("IntValue")
    leaderboard.Name = "leaderstats"

    local point_val = Instance.new("IntValue")
    point_val.Name = "Points"
    point_val.Parent = leaderboard

    local function UpdatePoints()
        point_val.Value = _G["GameDatabase"].pinfo[pname].stats.points
    end
    UpdatePoints()
    _G["GameDatabase"].pinfo[pname].changed.Event:connect(UpdatePoints)

    leaderboard.Parent = newPlayer
    local stats_val = Instance.new("StringValue")
    stats_val.Name = pname
    local function UpdatePStats()
        stats_val.Value = HttpService:EncodeJSON(_G["GameDatabase"].pinfo[pname].stats)
    end
    UpdatePStats()
    _G["GameDatabase"].pinfo[pname].changed.Event:connect(UpdatePStats)
    _G["GameDatabase"].pinfo[pname].changed.Event:connect(SavePlayerData)
    stats_val.Parent = playerstats

    --GAME PASSES---------------------------------------------------------------------------
    if game:findFirstChild("NetworkServer") ~= nil then
        if CheckGamePass(newPlayer, 11127214) then --Darkness 2 VIP
            _G["GameDatabase"].action["AddBought"](pname, "PassVIP")
        end
        if CheckGamePass(newPlayer, 11126779) then --Darkness 2 Two more bullets
            _G["GameDatabase"].action["AddBought"](pname, "PassTwoMore")
        end
        if CheckGamePass(newPlayer, 146152895) then --Darkness 2 Juggernaut x3
            _G["GameDatabase"].action["AddBought"](pname, "PassJuggernaut")
        end
        if CheckGamePass(newPlayer, 11127288) then --Darkness 2 nickname monitor
            _G["GameDatabase"].action["AddBought"](pname, "PassNicknames")
        end
        if CheckGamePass(newPlayer, 11127315) then --Darkness 2 x10 chance beast
            _G["GameDatabase"].action["AddBought"](pname, "Pass10Beast")
        end
        if CheckGamePass(newPlayer, 11127342) then --Darkness 2 x10 chance beast
            _G["GameDatabase"].action["AddBought"](pname, "PassX2Points")
        end
    end
    --GAME PASSES
end

local pids = {11127214, 11126779, 146152895, 11127288, 11127315, 11127342}
local pnms = {"PassVIP", "PassTwoMore", "PassJuggernaut", "PassNicknames", "Pass10Beast", "PassX2Points"}
local MarketplaceService = game:GetService("MarketplaceService")
MarketplaceService.PromptPurchaseFinished:connect(function(player, assetId, isPurchased)
    if isPurchased then
        for i = 1, #pids do
            if pids[i] == assetId then
                _G["GameDatabase"].action["AddBought"](player.Name, pnms[i])
                break
            end
        end
    end
end)

local MarketplaceService = Game:GetService("MarketplaceService")

MarketplaceService.ProcessReceipt = function(receiptInfo)
    local plr_id = receiptInfo.PlayerId
    local prod_id = receiptInfo.ProductId

    if prod_id .. "" == 19179198 .. "" then
        ds_dp:SetAsync("TempBeast" .. plr_id, true)
    end

    return Enum.ProductPurchaseDecision.PurchaseGranted
end

game.Players.PlayerRemoving:connect(function(player)
    local pname = player.Name
    local pid = player.userId
    if _G["GameDatabase"].pinfo[pname] ~= nil then
        ds_dp:SetAsync("DATA" .. pid, HttpService:EncodeJSON(_G["GameDatabase"].pinfo[pname].stats))
        _G["GameDatabase"].pinfo[pname] = nil
    end
    local stc = playerstats:findFirstChild(pname)
    if stc ~= nil then
        stc:remove()
    end
end)

_G["GameDatabase"].ready = true

game.Players.PlayerAdded:connect(PlayerAdded)
local pl = game.Players:GetPlayers()
for i = 1, #pl do
    PlayerAdded(pl[i])
end