module("game_manager", package.seeall)

player_plugin = {
    properties = {
        team = state_variables.state_string()
    },

    init = function(self)
        self.team = '' -- empty until set
    end,

    activate = function(self)
        get_singleton():pick_team(self)

        self:connect("pre_deactivate", function(self)
            get_singleton():leave_team(self)
        end)

        self:respawn()
    end,

    client_activate = function(self)
        self:connect("client_respawn", function(self)
            get_singleton():place_player(self)
        end)
    end
}

function setup(plugins)
    plugins = plugins or {}

    entity_classes.reg(
        plugins.bake(
            entity.logent,
            table.mergedicts(
                {
                    _class     = "game_manager",
                    properties = {
                        team_data = state_variables.state_json(),
                        victory_sound = state_variables.state_string()
                    },

                    activate = function(self)
                        self:add_tag("game_manager")
                        self.teams = {}
                        self.victory_sound = ""
                    end,

                    get_players = function(self)
                        local players = {}
                        for i, team in pairs(table.values(self.teams)) do
                            table.mergearrays(players, team.player_list)
                        end
                        return players
                    end,

                    start_game = function(self)
                        local players = self:get_players()

                        -- clear teams
                        for i, team in pairs(table.values(self.teams)) do
                            team.score = 0
                            team.player_list = {}
                        end

                        -- place players randomly
                        while #players > 0 do
                            local player = table.pop(players, math.floor(math.random() * #players))[1]
                            self:pick_team(player, false) -- pick teams with no syncing until the end
                        end

                        self:sync_team_data()

                        for i, player in pairs(self:get_players()) do
                            player:respawn()
                        end

                        self:emit("start_game")
                        self.game_running = true
                    end,

                    end_game = function(self)
                        self.game_running = false
                        -- usually you want to connect something here to run
                        -- self.start_game, but see intermission plugin
                        self:emit("end_game")
                    end,

                    register_teams = function(self, data)
                        for i, team in pairs(data) do
                            self.teams[team._name] = {
                                _name = team._name,
                                player_list = {},
                                player_setup = team.setup,
                                score = 0,
                                flag_model_name = team.flag_model_name or '',
                                kwargs = team.kwargs or {}
                            }
                        end

                        self:emit('post_register_teams')
                        self:start_game()
                    end,

                    sync_team_data = function(self)
                        -- we are called during deactivation process, as players leave
                        if not self.deactivated then
                            self.team_data = self.teams
                        end
                        self:emit("team_data_modified")
                    end,

                    pick_team = function(self, player, sync)
                        sync = sync or true
                        local smallest = ""
                        for name, team in pairs(self.teams) do
                            if smallest == "" or #team.player_list < #self.teams[smallest].player_list then
                                smallest = name
                            end
                        end
                        self.set_player_team(player, smallest, sync)
                    end,

                    set_player_team = function(self, player, team, sync)
                        if player.team then
                            self:leave_team(player, sync)
                        end

                        player.team = team
                        team = self.teams[team]
                        table.insert(team.player_list, player)
                        team:player_setup(player)
                        player:respawn()

                        if sync then
                            self:sync_team_data()
                        end
                    end,

                    leave_team = function(self, player, sync)
                        sync = sync or true

                        local player_list = self.teams[player.team].player_list
                        local index = table.find(player_list, player)
                        if index and index >= 0 then
                            table.pop(player_list, index)
                            if sync then
                                self:sync_team_data()
                            end
                        end
                    end,

                    place_player = function(self, player)
                        local start_tag = "start_" .. player.team
                        local possibles = entity_store.get_all_bytag(start_tag)
                        if possibles and #possibles > 0 then
                            local start = possibles[math.floor(math.random() * #possibles)]
                            if start then
                                start:place_entity(player)
                                return nil
                            end
                        end
                        logging.log(logging.WARNING, "player start not found (\"%(1)s\"), placing player elsewhere .." % { start_tag })
                        player.position = { 512, 512, 571 }
                    end,

                    adjust_score = function(self, team_name, diff)
                        self.teams[team_name].score = self.teams[team_name].score + diff
                        self:sync_team_data()
                    end,

                    get_scoreboard_text = function()
                        local data = {}
                        for team_name, team in pairs(self.team_data) do
                            table.insert(data, { -1, " << " .. team_name .. " >> " .. team.score .. " points" })
                            for idx, player in pairs(team.player_list) do
                                table.insert(data, { player.uid, player._name .. " -" })
                            end
                        end
                        return data
                    end,

                    client_activate = function(self)
                        self:connect(state_variables.get_onmodify_prefix() .. "team_data", function(self, value)
                            if self.team_data and value and entity_store.get_plyent() then
                                local player_team = entity_store.get_plyent().team
                                if value[player_team].score > self.team_data[player_team].score and
                                   self.victory_sound and
                                   self.victory_sound ~= "" then sound.play(self.victory_sound)
                                end
                            end
                        end)
                    end,

                    set_localanim = function(self) end -- just so it can fake being animated by actions
                },
                plugins
            )
        )
    )

    if SERVER then
        entity_store.new("game_manager")
    end
end

function get_singleton()
    if not singleton then
        singleton = entity_store.get_all_byclass("game_manager")[1]
    end
    return singleton
end

function get_scoreboard_text()
    return get_singleton().get_scoreboard_text()
end