Module - DataManager

-- Constructor: _G.DataManager.createManager(player)
-- Nest functions: Manager.loadData(isEphemeral)

local module = {}
module.__index = module
local managerMethods = {}
managerMethods.__index = managerMethods

local Network = require(game.ReplicatedStorage.Network)
local Network2 = require(game.ReplicatedStorage.Network2)

local data_network = Network.new("data_network")
local bindable_data_network = Network2.new("data_network")

local Managers = {}
local starterData = function(shouldSave) local t = {}
    if shouldSave then
        t = {}
        local add_data = bindable_data_network:invoke("on_data_created")
        if add_data then
            for node,value in pairs(add_data) do
                t[node] = value
            end
        end
    else
        t = {}
        }
    end
    return t
end

_G.DataStorage = game:GetService('DataStoreService'):GetDataStore('[TEST]-18')

local function get_equipped_title(manager,team)
    for i,v in pairs(manager.Data.Saved.Inventory) do
        if v.Equipped and v.ClassName == 'Title' and v.Team == team then
            return v
        end
    end
end

local function load_data(userId,shouldSave)
    if shouldSave == false then
        return starterData(shouldSave)
    end
    local dataToLoad = _G.DataStorage:GetAsync(userId) or starterData(shouldSave)
    return dataToLoad
end

local function table_to_object(tbl,folder)
    for index,value in pairs(tbl) do
        local typeOf = typeof(value)
        if typeOf == 'table' then
            local instance_folder = Instance.new('Folder')
            instance_folder.Name = index
            instance_folder.Parent = folder
            table_to_object(value,instance_folder)
        else
            local value_object = Instance.new(_G.GeneralUtilities.getClassName(value))
            value_object.Value = value
            value_object.Name = index
            value_object.Changed:Connect(function(newValue)
                tbl[index] = newValue
            end)
            value_object.Parent = folder
        end
    end
end

function module.createManager(player)
    local userId = player.UserId
    local newManager = {UserId=userId;SavingAttempts=0;Data={Saved={};Ephemeral={}};IsSaving=false;Saved=Instance.new('BindableEvent')}
    Managers[player.UserId] = newManager
    print('Manager created for',player.Name)
    bindable_data_network:fire("on_manager_created",newManager)
    return setmetatable(newManager,module)
end

function module:LoadData(shouldSave)
    local dataKey = shouldSave and 'Saved' or 'Ephemeral'
    self.Data[dataKey] = load_data(self.UserId,shouldSave)

    bindable_data_network:connect_event("value_changed",function(name,newValue,manager)
        if name == 'Saved/Experience' then
            if newValue == 260* 1.5^(self.Data.Saved.Level) then
                self:LevelUp()
            end
        end
    end)
end
function module:SaveData(should_destroy)
    self.IsSaving = true
    self.SavingAttempts += 1
    local data_to_save = self.Data.Saved
    local success,error_code = pcall(_G.DataStorage:UpdateAsync(self.UserId,function(old)
            if old then
                if old.Level > data_to_save.Level then
                    return old
                end
            end
            return data_to_save
    end))
    if not success and self.SavingAttempts < 5 then
        if error_code == 502 then
            wait(1)
            self:SaveData(should_destroy)
            return
        elseif error_code == 304 then
            wait(6)
            self:SaveData(should_destroy)
            return
        end
        self:SaveData(should_destroy)
        return
    end
    self.Saved:Fire()
    if should_destroy then
        Managers[self.UserId] = nil
        self = nil
    end
end

function module:Change(settingPath,settingValue)
    local splitPath = string.split(settingPath,'/')
    local objectChanged
    local pathNode
    local pathNodeObject
    for i = 1,#splitPath-1 do
        if self.DataObject then
            local firstPath = true
            if splitPath[1] == 'Data' then firstPath = false end
            pathNodeObject = pathNodeObject ~= nil and pathNodeObject[splitPath[i]] or firstPath and self.DataObject:FindFirstChild(splitPath[i]) or self.DataObject
            pathNode = pathNode and pathNode[splitPath[i]] or self[splitPath[i]]
        else
            pathNode = pathNode and pathNode[splitPath[i]] or self[splitPath[i]]
        end
    end
    if typeof(settingValue) ~= 'table' and pathNodeObject then
        pathNodeObject[splitPath[#splitPath]].Value = settingValue
        return pathNodeObject[splitPath[#splitPath]].Value
    end
    pathNode[splitPath[#splitPath]] = settingValue
    data_network:fire(game.Players:GetPlayerByUserId(self.UserId),"value_changed",settingPath,settingValue,self)
    bindable_data_network:fire("value_changed",settingPath,settingValue,self)
    return pathNode[splitPath[#splitPath]]
end

function module:createDataFolder(folderParent,folderName)
    if self.DataObject then
        self.DataObject:Destroy()
    end
    self.DataObject = Instance.new('Folder')
    self.DataObject.Name = folderName
    self.DataObject.Parent = folderParent
    local function createFolder(key)
        local tableObjects = self.Data[key]
        local instanceFolder = Instance.new('Folder')
        instanceFolder.Name = key

        table_to_object(tableObjects,instanceFolder)
        instanceFolder.Parent = self.DataObject
    end
    createFolder('Saved')
    createFolder('Ephemeral')
end

function module:GetManagers()
    return Managers
end

function module:GetCurrentSkin(team)
    local currentSkin
    for node,value in pairs(self.Data.Saved.Inventory) do
        if value.ClassName == 'Skin' and value.Equipped and value.Team == team then
            value.Name = node
            currentSkin = value
        end
    end
    return currentSkin
end


function module:GetCurrentTitle()
    local currentTitle
    local success, msg = pcall(function()
        for node,value in pairs(self.Data.Saved.Inventory) do
            if value.ClassName == 'Title' and value.Equipped then
                value.Name = node
                currentTitle = value
            end
        end
    end)

    if not success then
        warn(msg)
        warn(debug.traceback())
    end

    return currentTitle
end

function module:LevelUp()
    local saved = self.Data.Saved
    saved.Level = saved.Level + 1
end

function module:AddTitle(titleName)
    local Player = game.Players:GetPlayerByUserId(self.UserId)
    self.Data.Saved.Inventory[titleName] = {Equipped=false; Equip = function()

            get_equipped_title(self,Player.Team.Name).Equipped = false
            self.Data.Saved.Inventory[titleName].Equipped = true
            _G.TitleEquipped:FireClient(Player,titleName)

        end
    }
end

return module