#!/usr/bin/python2
import logging
from argparse import ArgumentParser

from sleekxmpp.componentxmpp import ComponentXMPP
from sleekxmpp.xmlstream.xmlstream import XMLStream

from user import UserHandler
from config import filename, config
import daemon
from lockfile.pidlockfile import PIDLockFile

class ObjectComponent(ComponentXMPP):

    def __init__(self, jid, secret, server, port, root):
        ComponentXMPP.__init__(self, jid, secret, server, port)
        self.register_plugin('xep_0030')
        self.register_plugin("AliasPlugin", module = "plugin", pconfig = {'root': root})
        self.add_event_handler("session_start", self.start)
        self.add_event_handler("presence_probe", self.presence_probe)
        self.add_event_handler("message", self.message)
        self.add_event_handler("changed_subscription", self.presence_subscription)
        self.userHandler = UserHandler(root)

    def start(self, event):
        for user in self.userHandler.get_user_list():
            self.send_presence(pto = user)

    def disconnect(self, reconnect = False):
        for user in self.userHandler.get_user_list():
            self.send_presence(pto = user, ptype = "unavailable")
        XMLStream.disconnect(self, reconnect)
        logging.info('Component {} disconnected'.format(self.boundjid.bare))

    def message(self, msg):
        msg.reply("Thanks for sending\n{[body]}".format(msg)).send()

    def presence_subscription(self, subscription):
        if subscription["type"] == "subscribe":
            userJID = subscription["from"].full
            if not self.userHandler.registered(userJID):
                self.userHandler.register(userJID)
            subscription.reply().send()
            self.send_presence(pto = userJID)
            self.send_presence_subscription(pto = userJID, ptype = "subscribe")
        if subscription["type"] == "unsubscribe":
            userJID = subscription["from"].full
            if self.userHandler.registered(userJID):
                self.userHandler.unregister(userJID)

    def presence_probe(self, event):
        self.send_presence(pto = event["from"].full)


if __name__ == '__main__':
    commandline = ArgumentParser(description = 'Connect the alias \
                                component to a given server')
    commandline.add_argument('-p', '--port',
                             help = 'Port to connect to',
                             type = int)
    commandline.add_argument('-s', '--secret',
                             help = 'password')
    commandline.add_argument('-n', '--name',
                             help = 'Name the component will have')
    commandline.add_argument('-r', '--root',
                             help = 'Root directory of the user files')
    commandline.add_argument('-c', '--config',
                             help = 'Name of the config file to use')
    commandline.add_argument('-d', '--debug',
                             help = 'Set log level to DEBUG',
                             action = 'store_const',
                             const = logging.DEBUG,
                             default = logging.INFO)
    commandline.add_argument('-o', '--host',
                             help = 'Host to connect to')
    commandline.add_argument('-b', '--background',
                             help = 'run the server in the background',
                             action = 'store_true')

    args = commandline.parse_args()

    if args.config is None:
        logging.basicConfig(level = args.debug)
        config.name = args.name
        config.port = args.port
        config.secret = args.secret
        config.root = args.root
        config.host = args.host
        config.background = args.background
    else:
        filename = args.config
        logging.basicConfig(level = args.debug)
        config.read(filename)
        
with daemon.DaemonContext(detach_process = config.background,
                          pidfile = PIDLockFile('alias.pid'),
                          working_directory = '.'):
    component = ObjectComponent(config.name, config.secret,
                                config.host, config.port,
                                config.root)
    if component.connect():
        logging.info('Component {} connected'.format(component.boundjid))
        component.process(False)
    else :
        logging.error("Component {} couldn't connect".format(component.boundjid))