DanceController

--//Services//--

local Players = game:GetService("Players")

--//--//--//--//--

local DanceController = {Catalog = {}}
DanceController.__index = DanceController

function DanceController.new(Player : Player)
    local self = setmetatable({}, DanceController)
    self.Player = Player
    self.Animator = nil
    self.PlayingDance = nil
    self.SynchronizedTo = nil
    self.Connections = {}
    self.SynchronizedPlayers = {}

    Player.CharacterAdded:Connect(function(Character)
        self:setEvents(Character)
    end)

    Player.CharacterRemoving:Connect(function()
        for _, Controller in pairs(self.SynchronizedPlayers) do
            Controller:stopPlayingDance()
        end
    end)

    local OnPlayerRemoving;
    OnPlayerRemoving = Players.PlayerRemoving:Connect(function(Player)
        if not (Player == self.Player) then return end;
        OnPlayerRemoving:Disconnect()

        for _, Controller in pairs(self.SynchronizedPlayers) do
            Controller:unsync()
        end

        self = nil
    end)

    DanceController.Catalog[self.Player] = self
    return self
end

function DanceController:setEvents(Character)
    for _, Connection in pairs(self.Connections) do
        Connection:Disconnect()
    end
    table.clear(self.Connections)

    self.Animator = Character:WaitForChild("Humanoid"):WaitForChild("Animator")

    table.insert(self.Connections, self.Animator.AnimationPlayed:Connect(function(LTrack : AnimationTrack)
        if not LTrack:GetAttribute("CanSync") then return end;

        for _, Controller in pairs(self.SynchronizedPlayers) do
            if not Controller.Animator then return end;

            Controller:stopPlayingDance()

            local Track : AnimationTrack = Controller.Animator:LoadAnimation(LTrack.Animation)
            Controller.PlayingDance = Track
            Track:SetAttribute("CanSync", true)
            Track:Play()

            local OnTrackStopped;
            OnTrackStopped = LTrack.Stopped:Connect(function()
                OnTrackStopped:Disconnect()

                if Controller.PlayingDance == Track then
                    Controller:stopPlayingDance()

                else
                    Track:Stop()
                    Track:Destroy()
                end
            end)
        end
    end))
end

function DanceController:playDance(Animation)
    self:stopPlayingDance()

    local Track = self.Animator:LoadAnimation(Animation)
    Track:SetAttribute("CanSync", true)
    Track:Play()

    self.PlayingDance = Track
end

function DanceController:stopPlayingDance()
    if not self.PlayingDance then return end;
    self.PlayingDance:Stop()
    self.PlayingDance:Destroy()
    self.PlayingDance = nil
end

function DanceController:sync(Player)
    if Player == self.Player then return end;
    local Leader = DanceController.getLeaderFromPlayer(Player)
    local Controller = DanceController.getDanceControllerFromPlayer(Player)

    if not Controller or Controller.SynchronizedPlayers[self.Player] or Leader == self or Controller.SynchronizedTo == self.Player then return end;

    self:stopPlayingDance()
    if self.SynchronizedTo then self:unsync() end;
    self.Player:SetAttribute("Synchronized", true)
    self.SynchronizedTo = Player

    Controller.SynchronizedPlayers[self.Player] = self

    if Leader.PlayingDance then Leader.PlayingDance:Stop() Leader.PlayingDance:Play() end;

    return true
end

function DanceController:unsync()
    if not self.SynchronizedTo then return end;
    local Controller = DanceController.getDanceControllerFromPlayer(self.SynchronizedTo)
    Controller.SynchronizedPlayers[self.Player] = nil
    self.SynchronizedTo = nil

    self.Player:SetAttribute("Synchronized", nil)
    self:stopPlayingDance()
end

function DanceController.getDanceControllerFromPlayer(Player : Player)
    return DanceController.Catalog[Player]
end

function DanceController.getLeaderFromPlayer(Player : Player)
    local Controller = DanceController.getDanceControllerFromPlayer(Player)
    if not Controller.SynchronizedTo then return Controller end

    return DanceController.getLeaderFromPlayer(Controller.SynchronizedTo)
end

return DanceController