# DuelArena will start automatically if at least 3 players
# opted in (!duel or !d) to the queue.
# DuelArena will be deactivated automatically if connected players
# exceed the player_limit (default 5), or if there are only 2 players left, or
# if too many players opted out.

import minqlx
import time

MIN_ACTIVE_PLAYERS = 3 # with <3 connected and subscribed players we deactive DuelArena
MAX_ACTIVE_PLAYERS = 5 # with >5 connected players we deactivate DuelArena

class duelarena(minqlx.Plugin):

    def __init__(self):

        self.add_hook("team_switch", self.handle_switch)
        self.add_hook("player_disconnect", self.handle_player_disco)
        self.add_hook("player_connect", self.handle_player_connect)
        #self.add_hook("game_start", self.handle_game_start)
        self.add_hook("game_countdown",self.handle_game_countdown)
        self.add_hook("round_end", self.handle_round_end)
        self.add_hook("game_end", self.handle_game_end)
        self.add_command(("duel", "d"), self.cmd_duel)
        self.add_command(("queue", "q"), self.cmd_printqueue)

        self.duelmode = False  #global gametype switch
        self.initduel = False  #initial player setup switch
        self.psub = []         #steam_ids of players subscribed to DuelArena
        self.queue = []        #queue for rotating players
        self.red_score = 0     #previous score to determine winner team
        self.blue_score = 0    #previous score to determine winner team
        self.player_red = 0    #force spec exception for this player
        self.player_blue = 0   #force spec exception for this player

    def handle_switch(self, player, old, new):
        # don't allow anyone to join manually when DuelArena is activ
        if self.game and new in ['red', 'blue'] and self.duelmode and self.game.state != "warmup":
            # except we auto join him
            if player == self.player_red or player == self.player_blue:
                return
            player.put("spectator")
            player.tell("^3Server is in DuelArena mode. You will automatically join. Type ^2!duel ^3or ^2!d ^3to enter or to leave the queue")

    @minqlx.delay(4)
    def handle_player_connect(self, player):

        playercount = self.connected_players()

        if playercount == 3 or playercount == 5 and not self.duelmode:
            self.center_print("^3Type ^2!d ^3for DuelArena!")
            self.msg("^3Type ^2!d ^3for DuelArena!")

        self.duelarena_switch()

        #dbg = "echo DUELARENA DBG: playercount {} duelmode: {} psub: {}"
        #minqlx.console_command(dbg.format(playercount, self.duelmode, len(self.psub)))

    def handle_player_disco(self, player, reason):

        playercount = self.connected_players() - 1

        if playercount == 3 or playercount == 5 and not self.duelmode:
            self.center_print("^3Type ^2!d ^3for DuelArena!")
            self.msg("^3Type ^2!d ^3for DuelArena!")

        self.duelarena_switch()

        if player.steam_id in self.psub:
            self.psub.remove(player.steam_id)

    @minqlx.delay(3)
    def handle_game_countdown(self):

        if self.duelmode:
            self.init_duel()

    def handle_game_end(self, *args, **kwargs):

        #put both players back to the queue, winner first position, loser last position
        if self.duelmode:

            teams = self.teams()

            if self.game.blue_score > self.blue_score:
                empty_team = "red"
                winner_team = "blue"
            elif self.game.red_score > self.red_score:
                empty_team = "blue"
                winner_team = "red"
            else: return

            for _p in teams[empty_team]:
                loser = _p

            self.queue.insert(0, loser.steam_id)

            for _p in teams[winner_team]:
                winner = _p

            self.queue.append(winner.steam_id)

    @minqlx.delay(1.5)
    def handle_round_end(self, round_number):

        # Not in CA? Do nothing
        if (self.game is None) or (self.game.type_short != "ca"): return

        # Last round? Do nothing
        if self.game.roundlimit in [self.game.blue_score, self.game.red_score]:
            return

        if self.initduel:
            self.init_duel()
            return

        if self.duelmode:

            if self.game.blue_score > self.blue_score: empty_team = "red"
            elif self.game.red_score > self.red_score: empty_team = "blue"
            else: return # Draw? Do nothing

            self.blue_score = self.game.blue_score
            self.red_score = self.game.red_score

            next_player = self.queue.pop()

            cancelduel = True

            teams =  self.teams()

            for _p in teams[empty_team]:
                loser = _p

            for _p in teams['spectator']:
                if _p.steam_id == next_player:
                    self.player_blue = _p
                    self.player_red = _p
                    _p.put(empty_team)
                    self.queue.insert(0, loser.steam_id)
                    loser.put("spectator")
                    cancelduel = False
                    self.center_print("{} ^2vs {}".format(teams["red"][-1].name, teams["blue"][-1].name))

            if cancelduel: self.duelmode = False #no specs found? Deactivate DuelArena

    def cmd_duel(self, player, msg, channel):

        if self.connected_players() > MAX_ACTIVE_PLAYERS:
            player.tell("^3!duel command not available with {} or more players connected".format(MAX_ACTIVE_PLAYERS+1))
            return

        if player.steam_id not in self.psub:
            if player.steam_id not in self.queue: self.queue.insert(0, player.steam_id)
            self.psub.append(player.steam_id)
            indicator = len(self.queue) - self.queue.index(player.steam_id)
            player.tell("^3You successfully opted in to the DuelArena queue. Type ^2!queue ^3or ^2!q ^3to get your queue position. Your position is ^2{}.".format(indicator))
            countdown = 3 - len(self.psub)
            if not self.duelmode and countdown > 0:
                self.msg("{} ^3entered the DuelArena queue. ^1{} ^3more players needed to start DuelArena. Type ^2!duel ^3or ^2!d ^3to enter DuelArena queue.".format(player.name, countdown))
            else: self.msg("{} ^3entered the DuelArena. Type ^2!duel ^3or ^2!d ^3to join DuelArena queue.".format(player.name))
        elif player.steam_id in self.psub:
            if player.steam_id in self.queue: self.queue.remove(player.steam_id)
            self.psub.remove(player.steam_id)
            self.msg("{} ^3left DuelArena.".format(player.name))

        self.printqueue()
        self.duelarena_switch()

    def cmd_printqueue(self, player, msg, channel):

        if self.connected_players() > MAX_ACTIVE_PLAYERS:
            player.tell("^3!queue command not available with {} or more players connected".format(MAX_ACTIVE_PLAYERS+1))
            return

        self.printqueue()

    def printqueue(self):

        qstring = "^3DuelArena queue: "

        for s_id in self.queue:
            p = self.player(s_id)
            indicator = len(self.queue) - self.queue.index(s_id)
            if indicator == 1: place = "1st"
            elif indicator == 2: place = "2nd"
            elif indicator == 3: place = "3rd"
            elif indicator == 4: place = "4th"
            elif indicator == 5: place = "5th"
            qstring = qstring + ("^3{}^7: ^2{} ".format(place, p.name))

        if qstring != "^3DuelArena queue: ":
            self.msg(qstring)
        else:
            self.msg("^3There's no one in the queue yet. Type ^2!d ^3or ^2!duel ^3to enter the queue.")

    def init_duel(self):

        self.checklists()

        for _p in self.psub:
            if _p not in self.queue:
                self.queue.insert(0, _p)

        teams =  self.teams()

        self.player_red = self.player(self.queue.pop())
        self.player_blue = self.player(self.queue.pop())
        self.player_red.put("red")
        self.player_blue.put("blue")

        # put all other players to spec
        for _p in teams['red'] + teams['blue']:
            if _p != self.player_red and _p != self.player_blue:
                _p.put("spectator")

        if self.game.blue_score: self.blue_score = self.game.blue_score
        else: self.blue_score = 0
        if self.game.red_score: self.red_score = self.game.red_score
        else: self.red_score = 0

        self.center_print("^3DuelArena initialized!")

        self.initduel = False

    def duelarena_switch(self):

        self.checklists()

        if self.duelmode:
            player_count = self.connected_players()
            if player_count > MAX_ACTIVE_PLAYERS or player_count < MIN_ACTIVE_PLAYERS or len(self.psub) < MIN_ACTIVE_PLAYERS:
                self.duelmode = False
                self.msg("^3DuelArena has been deactivated! You are free to join.")
        elif not self.duelmode:
            if len(self.psub) >= MIN_ACTIVE_PLAYERS and len(self.psub) <= MAX_ACTIVE_PLAYERS:
                self.duelmode = True
                self.msg("^3DuelArena activated!")
                self.center_print("^3DuelArena activated!")
                if self.game and self.game.state == "in_progress":
                    self.initduel = True
                    self.blue_score = self.game.blue_score
                    self.red_score = self.game.red_score

    def checklists(self):

        for sid in self.queue:
            if not self.player(sid): self.queue.remove(sid)

        for sid in self.psub:
            if not self.player(sid): self.psub.remove(sid)

        for p in self.players():
            if p.ping >= 990:
                if p.steam_id in self.queue: self.queue.remove(p.steam_id)
                if p.steam_id in self.psub: self.psub.remove(p.steam_id)

## Helper functions

    def connected_players(self):
        teams =  self.teams()
        players = int( len(teams["red"] + teams["blue"] + teams["spectator"] + teams["free"]) )
        return players