#!/usr/bin/env python

import random
from threading import Timer

import requests
from mumo_module import (commaSeperatedIntegers, MumoModule)


# noinspection PyPep8Naming
class autochannel(MumoModule):
    default_config = {'autochannel': (
        ('servers', commaSeperatedIntegers, []),
        ('spare_channel', int, 1),
        ('top_games_limit', int, 10),
        ('root_channel_name', str, "Random Channel"),
        ('check_timer_interval', int, 5)
    )
    }

    def __init__(self, name, manager, configuration=None):
        MumoModule.__init__(self, name, manager, configuration)
        self.murmur = manager.getMurmurModule()
        self.spare_channel = self.cfg().autochannel.spare_channel
        self.top_games_limit = self.cfg().autochannel.top_games_limit
        self.root_channel_name = self.cfg().autochannel.root_channel_name
        self.timer_interval = self.cfg().autochannel.check_timer_interval
        self.root = None
        self.servertimer = {}

        # Load steam top 100 last two weeks
        r = requests.get("http://steamspy.com/api.php?request=top100in2weeks")

        if r.status_code == 200:
            self.top_list = r.json()
            self.log().info("Loaded steam Top100")
        else:
            self.top_list = None

        # Load wordlist
        r = requests.get("https://raw.githubusercontent.com/dwyl/english-words/master/words.txt")

        if r.status_code == 200:
            self.wordlist = r.text.splitlines()
            self.log().info("Loaded {} words".format(len(self.wordlist)))
        else:
            self.wordlist = None

    def connected(self):
        self.log().debug("Register for Server callbacks")

        servers = self.cfg().autochannel.servers
        if not servers:
            servers = self.manager().SERVERS_ALL

        self.manager().subscribeMetaCallbacks(self, servers)

        for server in self.manager().getMeta().getBootedServers():
            self.init_channels(server)
            self.servertimer[server.id] = Timer(self.timer_interval, self.handle_timer, [server])
            self.servertimer[server.id].start()

    def handle_timer(self, server):
        self.check_channel(server)

        self.servertimer[server.id] = Timer(self.timer_interval, self.handle_timer, [server])
        self.servertimer[server.id].start()

    def disconnected(self):
        pass

    def init_channels(self, server):
        channels = server.getChannels()

        if not self.root:
            for cid, channel in channels.items():
                if channel.name == self.root_channel_name and channel.parent == 0:
                    self.root = channel

            if not self.root:
                new_root_cid = server.addChannel(self.root_channel_name, 0)
                self.root = server.getChannelState(new_root_cid)

        self.check_channel(server)

    @staticmethod
    def get_user_for_channel(cid, server):
        users = server.getUsers()
        users_in_channel = {}

        for uid, user in users.items():
            if user.channel == cid:
                users_in_channel[uid] = user

        return users_in_channel

    def check_channel(self, server):
        empty_channels = []
        channels = server.getChannels()

        for cid, channel in channels.items():
            if channel.parent == self.root.id and len(self.get_user_for_channel(cid, server)) == 0:
                empty_channels.append(cid)

        for cid in empty_channels[1:]:
            server.removeChannel(cid)

        if len(empty_channels) == 0:
            self.add_random_channel(server)

    def add_random_channel(self, server):
        word = self.wordlist[random.randint(0, len(self.wordlist))]

        while not word.isalnum():
            word = self.wordlist[random.randint(0, len(self.wordlist))]

        server.addChannel(word, self.root.id)

    #
    # --- Meta callback functions
    #

    def started(self, server, context=None):
        self.manager().subscribeServerCallbacks(self, [server.id])

        self.servertimer[server.id] = Timer(self.timer_interval, self.handle_timer, [server])
        self.servertimer[server.id].start()
        self.init_channels(server)

    def stopped(self, server, context=None):
        if server.id in self.servertimer:
            self.servertimer[server.id].stop()