#Snowbrawl
from helpers import *
import time, threading, copy
import org.bukkit.inventory.ItemStack as ItemStack
import org.bukkit.Material as Material
import org.bukkit.potion.PotionEffect as PotionEffect
import org.bukkit.potion.PotionEffectType as PotionEffectType
from java.lang import Runnable
from java.util.UUID import fromString as juuid
from operator import __contains__
from traceback import format_exc as trace
import random
from synchronize import make_synchronized

#file names
file = "snowbrawl"

#permissions
list_perm = "utils.snowbrawl.list"
modify_perm = "utils.snowbrawl.modify"
teleport_perm = "utils.snowbrawl.tp"
create_perm = "utils.snowbrawl.create"
info_perm = "utils.snowbrawl.info"
join_perm = "utils.snowbrawl.join"
quit_perm = "utils.snowbrawl.quit"

#commands - tp command does not exist
list_command = "list"
del_command = "del"
set_command = "set"
name_command = "name"
pos_command = "pos"
create_command = "create"
info_command = "info"
modify_command = "modify"
modify_command_alias = "m"
quit_command = "quit"



class Arena(object):

    def __init__(self, name):
        self.queue = Queue()
        self.name = name
        self.refill = None
        self.player_limit = None
        self.start_time = None
        self.match_goal = None # amount of deaths or time until the match ends (depends on arena_type)
        self.arena_type = None # arena type (death or time)
        self.explosion_damage = None

        self.player_stats = {}
        self.players = Queue()
        self.spawn_location = []
        self.respawn_location = []
        self.sign_location = []
        self.sign_click = []

        self.corner1 = None # The corner1 given by the player (really bad for 3D position compare)
        self.corner2 = None # The corner2 given by the player (really bad for 3D position compare)
        self.tpp = None # The top, positive x, positive z corner
        self.bnn = None # The bottom, negative x, negative z corner

    #set corners of arena
    def set_corner(self, sender, type):
        loc = sender.getLocation()
        if type == "1":
            self.corner1 = Coords(loc)
        elif type == "2":
            self.corner2 = Coords(loc)
        msg(sender, "&a-&e Arena corner %s set" % type)
        self.update_corner_points()

    #Compares the corner1 and corner2 locations and figures out tpp and bnn so that we dont have to do it everytime we run in_arena()
    def update_corner_points(self):
        self.tpp = None
        self.bnn = None
        if self.corner1 == None or self.corner2 == None:
            return
        corn1 = self.corner1.get_location()
        corn2 = self.corner2.get_location()
        if not corn1.getWorld().getName() == corn2.getWorld().getName():
            return

        top = corn1.y if corn1.y > corn2.y else corn2.y
        bottom = corn1.y if corn1.y < corn2.y else corn2.y
        pos_x = corn1.x if corn1.x > corn2.x else corn2.x
        pos_z = corn1.z if corn1.z > corn2.z else corn2.z
        neg_x = corn1.x if corn1.x < corn2.x else corn2.x
        neg_z = corn1.z if corn1.z < corn2.z else corn2.z

        self.tpp = Coords(corn1.getWorld(), pos_x, top, pos_z, 0, 0)
        self.bnn = Coords(corn2.getWorld(), neg_x, bottom, neg_z, 0, 0)

    #add sign to sign list
    def add_sign(self, sender, name):
        mats = set()
        mats = None
        block = sender.getTargetBlock(mats, 3).getState()
        if isinstance(block, bukkit.block.Sign):
            self.sign_click.append(NamedCoords(name, Coords(block.getLocation())))
            msg(sender, "&a-&e Arena tp sign %s created and set" % name)

    #Delete a sign from the sign list
    def del_sign(self, sender, name):
        for sign in self.sign_click:
            if sign.get_name() == name:
                self.sign_click.remove(sign)
                msg(sender, "&a-&e Arena tp sign %s removed" % sign.get_name())
                return
        msg(sender, "&a-&e Arena tp sign with this name doesn't exist")

    #Adds a player to the queue if they aren't already there.
    def add_player(self, player):
        if not self.queue.contains(player):
            self.queue.put(player)
            self.start_match()
            return True
        return False

    #remove a player from the queue
    def remove_player(self, player):
        if self.queue.contains(player):
            self.queue.remove(player)
            return True
        return False

    #return true if loc is inside the arena boundries
    def in_arena(self, loc):
        if self.tpp == None or self.bnn == None:
            return False
        loc_tpp = self.tpp.get_location()
        loc_bnn = self.bnn.get_location()

        if loc.y > loc_tpp.y:
            return False
        if loc.y < loc_bnn.y:
            return False
        if loc.x > loc_tpp.x:
            return False
        if loc.x < loc_bnn.x:
            return False
        if loc.z > loc_tpp.z:
            return False
        if loc.z < loc_bnn.z:
            return False
        return True

    def get_respawn(self):
        id = random.randint(0, len(self.respawn_location) - 1)
        return self.respawn_location[id]


    def spawn_player(self, player):
        id = random.randint(0, len(self.spawn_location) - 1)
        loc = self.spawn_location[id].get_location().get_location()
        safetp(player, loc.getWorld(), loc.x, loc.y, loc.z, loc.yaw, loc.pitch)

    #Start match
    def start_match(self):
        if self.player_limit == None or self.match_goal == None or self.arena_type == None or len(self.spawn_location) == 0 or len(self.respawn_location) == 0 or len(self.sign_location) == 0:
            return
        if len(self.queue.read()) >= self.player_limit and len(self.players.read()) == 0:
            self.start_time = time.time()
            for i in range(self.player_limit):
                player = self.queue.get()
                self.players.put(player)
            for player in self.players.read():
                self.player_stats[player.getName() + "_deaths"] = 0
                self.spawn_player(player)
                msg(player, "&6The match has started!")

    def bubbleSort(self, alist):
        for passnum in range(len(alist)-1,0,-1):
            for i in range(passnum):
                if self.player_stats[alist[i].getName()+"_deaths"]>self.player_stats[alist[i+1].getName()+"_deaths"]:
                    temp = alist[i]
                    alist[i] = alist[i+1]
                    alist[i+1] = temp
        return alist

    @make_synchronized #Jython synchronized block
    def end_match(self): #End match, sort the players and print the 3 players with least amount of deaths

        sorted_list = self.bubbleSort(self.players.read())

        for player in self.players.read():
            if player.isOnline():
                loc = self.sign_location[0].get_location().get_location()
                safetp(player, loc.getWorld(), loc.x, loc.y, loc.z, loc.yaw, loc.pitch)
                msg(player, "&6================= Match over =================")
                msg(player, "&c&c")
                if not len(sorted_list) < 1:
                    msg(player, "&e1. %s (%s)" % (sorted_list[0].getName(), self.player_stats[sorted_list[0].getName()+"_deaths"]))
                if not len(sorted_list) < 2:
                    msg(player, "&e2. %s (%s)" % (sorted_list[1].getName(), self.player_stats[sorted_list[1].getName()+"_deaths"]))
                if not len(sorted_list) < 3:
                    msg(player, "&e3. %s (%s)" % (sorted_list[2].getName(), self.player_stats[sorted_list[2].getName()+"_deaths"]))
                msg(player, "&c&c")
                msg(player, "&e Your deaths:&6 %s" % str(self.player_stats[player.getName() + "_deaths"]))
                msg(player, "&c&c")
                msg(player, "&6==============================================")
        self.players.clear()
        self.player_stats = {}
        self.start_match()

    def check_deaths(self):
        if self.arena_type == "death":
            for player in self.players.read():
                if self.player_stats[player.getName() + "_deaths"] >= self.match_goal:
                    return True
        return False

    def is_running(self):
        if len(self.players.read()) == 0:
            return False
        return True

    def set_explosion_damage(self, dmg):
        self.explosion_damage = dmg

    def get_explosion_damage(self):
        if self.explosion_damage == None:
            return 1
        return self.explosion_damage

    def in_players(self, player):
        return self.players.contains(player)

    def set_player_limit(self, limit):
        self.player_limit = limit

    def set_end_goal(self, value):
        self.match_goal = value

    def set_type(self, type):
        self.arena_type = type

    def get_name(self):
        return self.name

    def set_refill(self, amount):
        self.refill = int(amount)

    def set_name(self, name):
        self.name = name

    def get_refill(self):
        if self.refill == None:
            return 16
        return self.refill

    def get_tp_signs(self):
        return self.sign_location

    def get_click_signs(self):
        return self.sign_click

    #Check if player is in the queue
    def in_queue(self,player):
        if self.queue.contains(player):
            return True
        return False

    #Returns queue contents in list. use "".join(queue) to get a string
    def get_queue_contents(self):
        return self.queue.read()
    #Returns queue object
    def get_queue(self):
        return self.queue

    #Returns list of location objects of type, type.
    def get_location(self, type):
        if type == "spawn":
            return self.spawn_location
        elif type == "respawn":
            return self.respawn_location
        elif type == "sign":
            return self.sign_location

    #Add a location to list of type location
    def add_location(self, name, location, type):
        named_loc = NamedCoords(name, Coords(location))
        if type == "spawn":
            self.spawn_location.append(named_loc)
        elif type == "respawn":
            self.respawn_location.append(named_loc)
        elif type == "sign":
            self.sign_location.append(named_loc)

    #Change location of location of type, type
    def change_location(self, name, location, type):
        if type == "spawn":
            for spawn in self.spawn_location:
                if spawn.get_name() == name:
                    spawn.get_location().set_location(location)
                    break
        elif type == "respawn":
            for respawn in self.respawn_location:
                if respawn.get_name() == name:
                    respawn.get_location().set_location(location)
                    break
        elif type == "sign":
            for sign in self.sign_location:
                if sign.get_name() == name:
                    sign.get_location().set_location(location)
                    break

    #Remove location out of location
    def delete_location(self, name, type):
        if type == "spawn":
            for spawn in self.spawn_location[:]:
                if spawn.get_name() == name:
                    self.spawn_location.remove(spawn)
                    break
        elif type == "respawn":
            for respawn in self.respawn_location[:]:
                if respawn.get_name() == name:
                    self.respawn_location.remove(respawn)
                    break
        elif type == "sign":
            for sign in self.sign_location[:]:
                if sign.get_name() == name:
                    self.sign_location.remove(sign)
                    break

    def get_data(self):
        spawns = []
        for spawn in self.spawn_location:
            spawns.append(spawn.get_data())
        respawns = []
        for respawn in self.respawn_location:
            respawns.append(respawn.get_data())
        signs = []
        for sign in self.sign_location:
            signs.append(sign.get_data())
        sign_clicks = []
        for click in self.sign_click:
            sign_clicks.append(click.get_data())
        corners = []
        corners.append(self.corner1.get_data() if not self.corner1 == None else None)
        corners.append(self.corner2.get_data() if not self.corner2 == None else None)
        corners.append(self.tpp.get_data() if not self.tpp == None else None)
        corners.append(self.bnn.get_data() if not self.bnn == None else None)
        data = {
        "spawns": spawns,
        "respawns": respawns,
        "signs": signs,
        "clicks": sign_clicks,
        "corners": corners,
        "explosion": self.explosion_damage,
        "players": self.player_limit,
        "refill": self.refill,
        "type": self.arena_type,
        "goal": self.match_goal,
        "name": self.name
        }
        return data

    def load(self, data):
        self.explosion_damage = None if str(data["explosion"]) == "None" else float(data["explosion"])
        self.player_limit = None if str(data["players"]) == "None" else int(data["players"])
        self.refill = None if str(data["refill"]) == "None" else int(data["refill"])
        self.arena_type = str(data["type"])
        self.match_goal = None if str(data["goal"]) == "None" else int(data["goal"])
        self.corner1 = Coords(None).load(data["corners"][0]) if not data["corners"][0] == None else None
        self.corner2 = Coords(None).load(data["corners"][1]) if not data["corners"][1] == None else None
        self.tpp = Coords(None).load(data["corners"][2]) if not data["corners"][2] == None else None
        self.bnn = Coords(None).load(data["corners"][3]) if not data["corners"][3] == None else None
        for subdata in data["spawns"]:
            self.spawn_location.append(NamedCoords(None, None).load(subdata))
        for subdata in data["respawns"]:
            self.respawn_location.append(NamedCoords(None, None).load(subdata))
        for subdata in data["signs"]:
            self.sign_location.append(NamedCoords(None, None).load(subdata))
        for subdata in data["clicks"]:
            self.sign_click.append(NamedCoords(None, None).load(subdata))
        self.name = data["name"]
        return self

#coord = an instance of Coords class, adds a name to it.
class NamedCoords(object):

    def __init__(self, name, coord):
        self.name = name
        self.coord = coord

    def get_name(self):
        return self.name

    def get_location(self):
        return self.coord

    def get_data(self):
        coords = self.coord.get_location()
        data = {
        "x": coords.x,
        "y": coords.y,
        "z": coords.z,
        "yaw": coords.yaw,
        "pitch": coords.pitch,
        "world": coords.getWorld().getName(),
        "name": self.name
        }
        return data

    def load(self, data):
        self.name = str(data["name"])
        self.coord = Coords(None).load(data)
        return self

class Coords(object):

    def __init__(self, world = None, x = None, y = None, z = None, yaw = None, pitch = None):
        if world == None:
            self.world = None
            self.x = None
            self.y = None
            self.z = None
            self.yaw = None
            self.pitch = None
            return
        if not isinstance(world, Location):
            self.x = x
            self.y = y
            self.z = z
            self.yaw = yaw
            self.pitch = pitch
            self.world = world.getName()
        else:
            location = world
            self.x = location.x
            self.y = location.y
            self.z = location.z
            self.yaw = location.yaw
            self.pitch = location.pitch
            self.world = location.getWorld().getName()

    def get_location(self):
        return Location(server.getWorld(str(self.world)), float(self.x), float(self.y), float(self.z), int(self.yaw), int(self.pitch))

    def set_location(self, location):
        self.x = location.x
        self.y = location.y
        self.z = location.z
        self.yaw = location.yaw
        self.pitch = location.pitch
        self.world = location.getWorld().getName()

    def get_data(self):
        data = {
        "x": self.x,
        "y": self.y,
        "z": self.z,
        "yaw": self.yaw,
        "pitch": self.pitch,
        "world": self.world
        }
        return data

    def load(self, data):
        self.x = float(data["x"])
        self.y = float(data["y"])
        self.z = float(data["z"])
        self.yaw = int(data["yaw"])
        self.pitch = int(data["pitch"])
        self.world = str(data["world"])
        return self

class Queue(object):

    def __init__(self):
        self.queue = []

    #Appends to queue
    def put(self,args):
        self.queue.append(args)

    #Returns the first item in the queue and removes it
    def get(self):
        if len(self.queue) > 0:
            return self.queue.pop(0)

        else:
            return False

    #Returns the queue's list object
    def read(self):
        return self.queue

    #Removes the value args from the queue
    def remove(self,args):
        self.queue.remove(args)

    #Check if queue contains player
    def contains(self, player):
        if player in self.queue:
            return True
        return False

    #Clear the queue
    def clear(self):
        self.queue = []

##############################################################################################
# Initialization
##############################################################################################

def save_snowbrawl():
    out = []
    for arena in arenas:
        out.append(arena.get_data())
    save_json_file(file, out)

def load_snowbrawl():
    out = []
    buffer = open_json_file(file, [])
    for data in buffer:
        out.append(Arena(None).load(data))
    return out

arenas = load_snowbrawl()

##############################################################################################
# Threads
##############################################################################################

class timings_runnable(Runnable):

    def __init__(self, arena):
        self.arena = arena

    def run(self):
        self.arena.end_match()

#timings thread to end arenas if their type is time
def timings():
    while True:
        for arena in arenas:
            if arena.is_running():
                if arena.arena_type == "time":
                    current_time = time.time()
                    start_time = arena.start_time
                    if arena.start_time + arena.match_goal < current_time:
                        timing = timings_runnable(arena)
                        server.getScheduler().runTask(server.getPluginManager().getPlugin("RedstonerUtils"), timing)

        time.sleep(0.1)


timingsThread = threading.Thread(target = timings)
timingsThread.daemon = True #Thread dies if main thread dies
timingsThread.start()





##############################################################################################
# Events
##############################################################################################

@hook.event("player.PlayerMoveEvent", "low")
def onMove(event):
    if event.getPlayer().getWorld().getName() != "minigames":
        return
    player = event.getPlayer()
    for arena in arenas:
        if arena.in_players(player):
            loc = player.getLocation()
            block = player.getWorld().getBlockAt(int(loc.x), int(loc.y) - 1, int(loc.z))
            if block != None:
                material = block.getType()
                if material == Material.SPONGE:
                    player.addPotionEffect(PotionEffect(PotionEffectType.JUMP, 60, 0))
                elif material == Material.GLASS or material == Material.STAINED_GLASS:
                    player.addPotionEffect(PotionEffect(PotionEffectType.SPEED, 60, 0))
                elif material == Material.OBSIDIAN:
                    player.addPotionEffect(PotionEffect(PotionEffectType.DAMAGE_RESISTANCE, 300, 0))
            break

@hook.event("entity.PlayerDeathEvent", "high")
def onDeath(event):
    if event.getEntity().getWorld().getName() != "minigames":
        return
    if not isinstance(event.getEntity(), bukkit.entity.Player):
        return
    for arena in arenas:
        if arena.in_players(event.getEntity()):
            arena.player_stats[event.getEntity().getName() + "_deaths"] += 1
            if arena.check_deaths():
                arena.end_match()
            break

@hook.event("player.PlayerRespawnEvent", "high")
def onRespawn(event):
    if event.getPlayer().getWorld().getName() != "minigames":
        return
    player = event.getPlayer()
    for arena in arenas:
        if arena.in_players(player):
            event.setRespawnLocation(arena.get_respawn().get_location().get_location())
            break

@hook.event("entity.ProjectileHitEvent", "high")
def onHit(event):
    if event.getEntity().getWorld().getName() != "minigames":
        return
    if event.getEntity().getName() != "Snowball":
        return
    location = event.getEntity().getLocation()
    for arena in arenas:
        if arena.in_arena(location):
            event.getEntity().getWorld().createExplosion(location.x, location.y, location.z, float(arena.get_explosion_damage()), False, False)
            break

@hook.event("player.PlayerInteractEvent", "high")
def onClick(event):
    if event.getPlayer().getWorld().getName() != "minigames":
        return
    if str(event.getAction()) != "RIGHT_CLICK_BLOCK":
        return
    block = event.getClickedBlock().getState()
    if event.getClickedBlock().getType() == Material.SNOW_BLOCK:
        for arena in arenas:
            if arena.in_players(event.getPlayer()):
                inv = event.getPlayer().getInventory()
                inv.remove(Material.SNOW_BALL)
                inv.setItemInHand(ItemStack(Material.SNOW_BALL, arena.get_refill()))
                event.getPlayer().updateInventory()
                break

    elif isinstance(block, bukkit.block.Sign):
        line = str(block.getLine(1))
        if not event.getPlayer().hasPermission(join_perm):
            msg(event.getPlayer(), "&a-&e You don't have permission to join snowbrawl matches")
            return
        #go through arenas, if name matches line then add player to it
        for arena in arenas:
            if line == arena.get_name():
                for sign in arena.get_click_signs():
                    sign_loc = sign.get_location().get_location()
                    loc = block.getLocation()
                    if sign_loc.getWorld().getName() == loc.getWorld().getName() and sign_loc.x == loc.x and sign_loc.y == loc.y and sign_loc.z == loc.z:
                        if arena.add_player(event.getPlayer()):
                            msg(event.getPlayer(),"&a- &eYou have been added to the queue")
                        else:
                            msg(event.getPlayer(),"&a- &eYou are already in the queue")
                        break
        return


@hook.event("player.PlayerQuitEvent", "normal")
def on_quit(event):
    #remove the player from the queue
    player = event.getPlayer().getName()
    for arena in arenas:
        if arena.in_queue(player):
            arena.remove_player(player)



##############################################################################################
# Command handling
##############################################################################################


def create_arena(sender, args):
    if len(args) == 0:
        msg(sender, "&c/sb %s <name>" % create_command)
        return
    arena = Arena(args[0])
    arenas.append(arena)
    msg(sender, "&a-&e Arena %s created" % args[0])

def list_arenas(sender):
    if len(arenas) == 0:
        msg(sender, "&a-&e There are currently no arenas")
        return
    for arena in arenas:
        msg(sender, "&a-&e %s" % arena.get_name())

def arena_info(sender, args):
    if len(args) == 0:
        msg(sender, "&a-&e /sb info <name>")
        return
    if len(arenas) == 0:
        msg(sender, "&a-&e There are currently no arenas")
        return
    for arena in arenas:
        if arena.get_name() == args[0]:
            msg(sender, "&a-&e %s" % arena.get_name())
            #msg(sender, "&ePlayers:&6 " + "&e,&6 ".join(arena.get_queue_contents()))
            spawn_list = []
            for spawn in arena.get_location("spawn"):
                spawn_list.append(spawn.get_name())
            msg(sender, "&eSpawns:&6 " + "&e,&6 ".join(spawn_list))
            respawn_list = []
            for respawn in arena.get_location("respawn"):
                respawn_list.append(respawn.get_name())
            msg(sender, "&eRespawns:&6 " + "&e,&6 ".join(respawn_list))
            sign_list = []
            for sign in arena.get_location("sign"):
                sign_list.append(sign.get_name())
            msg(sender, "&eSigns:&6 " + "&e,&6 ".join(sign_list))
            break

def quit_match(sender):
    for arena in arenas:
        if arena.in_queue(sender):
            arena.remove_player(sender)
            msg(sender, "&a-&e Quit arena")
            return
    msg(sender, "&a-&e You're not in a queue")

def print_help(sender):
    msg(sender, "&a-&e Alias: &6/sb")
    if sender.hasPermission(teleport_perm):
        msg(sender, "&a-&e /sb <name>     Teleport to an arena")
    if sender.hasPermission(quit_perm):
        msg(sender, "&a-&e /sb %s   Quit a queue" % quit_command)
    if sender.hasPermission(list_perm):
        msg(sender, "&a-&e /sb %s   List all existing arenas" % list_command)
    if sender.hasPermission(create_perm):
        msg(sender, "&a-&e /sb %s   Create an arena" % create_command)
    if sender.hasPermission(info_perm):
        msg(sender, "&a-&e /sb %s   Show info about an arena" % info_command)
    if sender.hasPermission(modify_perm):
        msg(sender, "&a-&e /sb %s   Deletes an arena" % del_command)
        msg(sender, "&a-&e /sb %s   Sets a teleport for an arena to a sign" % set_command)
        msg(sender, "&a-&e /sb %s   Renames an arena" % name_command)
        msg(sender, "&a-&e /sb %s   Sets the locations for an arena" % pos_command)
        msg(sender, "&a-&e /sb %s   Modifies the arena" % modify_command)
        msg(sender, "&a-&e Modify Aliases: &6/sbm&e,&6 /sb %s" % modify_command_alias)

def set_location(sender, args):
    if len(args) < 3:
        msg(sender, "&c/sb pos <arena name> respawn/spawn/sign set/add/del <name>")
        msg(sender, "&c/sb pos <arena name> bounds corner1/corner2")
        return
    if "bounds" not in args:
        if len(args) < 4:
            msg(sender, "&c/sb pos <arena name> respawn/spawn/sign set/add/del <name>")
            msg(sender, "&c/sb pos <arena name> bounds corner1/corner2")
            return
    if len(arenas) == 0:
        msg(sender, "&a-&e There are currently no arenas")
        return
    for arena in arenas:
        if arena.get_name() == args[0]:
            if args[1] == "respawn":
                set_location_of_type(sender, args[2:], "respawn", arena)
            elif args[1] == "spawn":
                set_location_of_type(sender, args[2:], "spawn", arena)
            elif args[1] == "sign":
                set_location_of_type(sender, args[2:], "sign", arena)
            elif args[1] == "bounds":
                set_location_of_type(sender, args[2:], "bounds", arena)
            break

def set_location_of_type(sender, args, type, arena):
    if len(args) == 0:
        msg(sender, "&c/sb pos <arena name> respawn/spawn/sign set/add/del <name>")
        msg(sender, "&c/sb pos <arena name> bounds corner1/corner2")
        return
    location = sender.getLocation()
    if args[0] == "set":
        arena.change_location(args[1], location, type)
        msg(sender, "&a-&e Location of name %s and type %s changed to your current location" % (args[1], type))
    elif args[0] == "add":
        arena.add_location(args[1], location, type)
        msg(sender, "&a-&e Location of name %s and type %s created at your current location" % (args[1], type))
    elif args[0] == "del":
        arena.delete_location(args[1], type)
        msg(sender, "&a-&e Location of name %s deleted" % args[1])
    elif args[0] == "corner1":
        arena.set_corner(sender, "1")
    elif args[0] == "corner2":
        arena.set_corner(sender, "2")

def rename_arena(sender, args):
    if len(args) < 2:
        msg(sender, "&c/sb name <name> <new name>")
        return
    for arena in arenas:
        if arena.get_name() == args[0]:
            arena.set_name(args[1])
            msg(sender, "&a-&e Arena %s renamed to %s" % (args[0], args[1]))
            return
    msg(sender, "&a-&e Arena with this name doesn't exist")

def delete_arena(sender, args):
    if len(args) == 0:
        msg(sender, "&c/sb del <name>")
        return
    for arena in arenas:
        if arena.get_name() == args[0]:
            arenas.remove(arena)
            msg(sender, "&a-&e Arena %s deleted" % arena.get_name())
            return
    msg(sender, "&a-&e Arena with this name doesn't exist")

def teleport_to_arena(sender, name, id):
    try:
        int(id)
    except ValueError:
        msg(sender, "&c/sb <name> <id of teleport>")
        return
    for arena in arenas:
        if arena.get_name() == name:
            i = 0
            if int(id) > len(arena.get_tp_signs()):
                msg(sender, "&cGiven tp id is out of range")
                return
            for sign in arena.get_tp_signs():
                i += 1
                if i == int(id):
                    loc = sign.get_location().get_location()
                    safetp(sender, loc.getWorld(), loc.x, loc.y, loc.z, loc.yaw, loc.pitch)
                    break
            msg(sender, "&a-&e Teleporting to arena %s" % name)
            return
    msg(sender, "&a-&e Arena with this name doesn't exist")

def modify_arena(sender, args):
    if len(args) < 3:
        msg(sender, "&c/sb modify <arena name> limit/mode/players/explosion/refill <amount/mode (death/time)>")
        return
    for arena in arenas:
        if arena.get_name() == args[0]:
            if args[1] == "limit":
                try:
                    int(args[2])
                except ValueError:
                    msg(sender, "&cLast parameter has to be a number")
                    return
                arena.set_end_goal(int(args[2]))
                msg(sender, "&a-&e Set time/death limit to:&6 %s" % int(args[2]))
            elif args[1] == "mode":
                if args[2] == "time" or args[2] == "death":
                    arena.set_type(args[2])
                    msg(sender, "&a-&e Set mode to:&6 %s" % args[2])
                else:
                    msg(sender, "&cInvalid mode (time, death)")
            elif args[1] == "players":
                try:
                    int(args[2])
                except ValueError:
                    msg(sender, "&cLast parameter has to be a number")
                    return
                arena.set_player_limit(int(args[2]))
                msg(sender, "&a-&e Set player limit to:&6 %s" % int(args[2]))
            elif args[1] == "explosion":
                try:
                    float(args[2])
                except ValueError:
                    msg(sender, "&cLast parameter has to be a number")
                    return
                arena.set_explosion_damage(float(args[2]))
                msg(sender, "&a-&e Set explosion power to:&6 %s" % float(args[2]))
            elif args[1] == "refill":
                try:
                    int(args[2])
                except ValueError:
                    msg(sender, "&cLast parameter has to be a number")
                    return
                arena.set_refill(int(args[2]))
                msg(sender, "&a-&e Set snowball refill to:&6 %s" % int(args[2]))
            return
    msg(sender, "&a-&e Arena with this name doesn't exist")

def set_arena_sign(sender, args):
    if len(args) < 3:
        msg(sender, "&c/sb set <arena name> add/del <name>")
        return
    for arena in arenas:
        if arena.get_name() == args[0]:
            if args[1] == "add":
                arena.add_sign(sender, args[2])
            elif args[1] == "del":
                arena.del_sign(sender, args[2])

@hook.command("snowbrawl")
def on_snowbrawl_command(sender, command, label, args):
    if len(args) == 0:
        #print help
        plugin_header(sender, "Snowbrawl")
        print_help(sender)
        return True
    elif args[0] == list_command:
        if sender.hasPermission(list_perm):
            #print the list of arenas
            list_arenas(sender)
        else:
            noperm(sender)
        return True
    elif args[0] == del_command:
        if sender.hasPermission(modify_perm):
            #delete an arena
            delete_arena(sender, args[1:])
            save_snowbrawl()
        else:
            noperm(sender)
        return True
    elif args[0] == info_command:
        if sender.hasPermission(info_perm):
            #print info about an arena
            arena_info(sender, args[1:])
        else:
            noperm(sender)
        return True
    elif args[0] == create_command:
        if sender.hasPermission(create_perm):
            #create an arena
            create_arena(sender, args[1:])
            save_snowbrawl()
        else:
            noperm(sender)
        return True
    elif args[0] == pos_command:
        if sender.hasPermission(modify_perm):
            #set arena spawn/respawn/sign tp locations
            set_location(sender, args[1:])
            save_snowbrawl()
        else:
            noperm(sender)
        return True
    elif args[0] == name_command:
        if sender.hasPermission(modify_perm):
            #rename an arena
            rename_arena(sender, args[1:])
            save_snowbrawl()
        else:
            noperm(sender)
        return True
    elif args[0] == set_command:
        if sender.hasPermission(modify_perm):
            #set an arena tp sign
            set_arena_sign(sender, args[1:])
            save_snowbrawl()
        else:
            noperm(sender)
        return True
    elif args[0] == modify_command or args[0] == modify_command_alias:
        if sender.hasPermission(modify_perm):
            #modify the arena
            modify_arena(sender, args[1:])
            save_snowbrawl()
        else:
            noperm(sender)
        return True
    elif args[0] == quit_command:
        if sender.hasPermission(quit_perm):
            #quit match
            quit_match(sender)
        else:
            noperm(sender)
        return True
    else:
        if sender.hasPermission(teleport_perm):
            #try to tp to an arena
            if len(args) > 1:
                teleport_to_arena(sender, args[0], args[1])
            else:
                teleport_to_arena(sender, args[0], 1)
        else:
            noperm(sender)
    return True