from twisted.internet.ssl import DefaultOpenSSLContextFactory
import json

from modules import alias
from modules.chankeep import nukeNetwork
from twisted.internet import reactor
from core.bot import IRCBot, IRCBotFactory
import main
from utils.logging.log import *
from utils.get import getRelay

class Network:
    def __init__(self, net, host, port, security, auth):
        self.net = net
        self.host = host
        self.port = port
        self.security = security
        self.auth = auth

        self.last = 1
        self.relays = {}
        self.aliases = {}

    def add_relay(self, num=None):
        if not num:
            num = self.last
            self.last += 1
        elif num == self.last:
            self.last += 1
        registered = False
        if self.net in main.irc.keys():
            if "register" in main.irc[self.net].keys():
                if not main.irc[self.net]["register"]:
                    registered = True
                    # Don't need to register if it's been disabled in definitions,
                    #  so we'll pretend we already did

        self.relays[num] = {
            "enabled": main.config["ConnectOnCreate"],
            "net": self.net,
            "id": num,
            "registered": registered
        }
        password = alias.generate_password()
        if not num in main.alias.keys():
            main.alias[num] = alias.generate_alias()
            main.saveConf("alias")
        self.aliases[num] = {"password": password}
        #if main.config["ConnectOnCreate"]: -- Done in provision
        #    self.start_bot(num)
        return num, main.alias[num]["nick"]

    def killAliases(self, aliasList):
        for i in aliasList:
            name = self.net+str(i)
            if name in main.ReactorPool.keys():
                if name in main.FactoryPool.keys():
                    main.FactoryPool[name].stopTrying()
                main.ReactorPool[name].disconnect()
                if name in main.IRCPool.keys():
                    del main.IRCPool[name]
                del main.ReactorPool[name]
                del main.FactoryPool[name]

    def delete_relay(self, id):
        del self.relays[id]
        del self.aliases[id]
        #del main.alias[id] - Aliases are global per num, so don't delete them!
        self.killAliases([id])

    def seppuku(self):
        # Removes all bots in preperation for deletion
        self.killAliases(self.relays.keys())
        nukeNetwork(self.net)

    def start_bot(self, num):
        # a single name is given to relays in the backend
        # e.g. freenode1 for the first relay on freenode network
        keyFN = main.certPath+main.config["Key"]
        certFN = main.certPath+main.config["Certificate"]
        contextFactory = DefaultOpenSSLContextFactory(keyFN.encode("utf-8", "replace"), certFN.encode("utf-8", "replace"))
        bot = IRCBotFactory(self.net, num)
        #host, port = self.relays[num]["host"], self.relays[num]["port"]
        host, port = getRelay(num)
        rct = reactor.connectSSL(host, port, bot, contextFactory)
        name = self.net + str(num)
        main.ReactorPool[name] = rct
        main.FactoryPool[name] = bot

        log("Started bot on relay %s on %s" % (num, self.host))

    def start_bots(self):
        for num in self.relays.keys():
            if self.relays[num]["enabled"]:
                self.start_bot(num)