#!/usr/bin/env python

import random
from threading import Timer

import requests
from mumo_module import (commaSeperatedIntegers, MumoModule)
from tools.Utils import find_channel_with_name, get_empty_channels


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),
        ('game_channels_permament', str, "")
    )
    }

    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):
        self.root = find_channel_with_name(self.root_channel_name, server, 0)

        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)

    def check_channel(self, server):
        empty_channels = get_empty_channels(server, self.root.id)

        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()