from axiom.store import Store
from axiom.item import Item
from axiom.attributes import bytes, boolean, reference
from axiom.errors import ItemNotFound
from axiom.upgrade import registerAttributeCopyingUpgrader

class User(Item):
    typeName = 'ares_user'
    schemaVersion = 2

    nickname = bytes()
    admin = boolean()
    active = boolean()

registerAttributeCopyingUpgrader(User, 1, 2)

class Admin(Item):
    typeName = 'ares_admin'
    schemaVersion = 1
    name = bytes()

class Group(Item):
    typeName = 'ares_group'
    schemaVersion = 1

    name = bytes()
    cloak = bytes()
    founder = bytes()

class _GroupMembership(Item):
    typeName = 'ares_group_membership'
    schemaVersion = 1

    user = reference(reftype=User)
    group = reference(reftype=Group)

class GroupData:
    # TODO: Add group representitive/founder
    authAdmins = []

    def __init__(self):
        self.store = Store('ares.axiom')

    def addAdmin(self, admin):
        admin = admin.lower()
        user = self.store.findOrCreate(User, nickname=admin)
        user.admin = True

    def getAdmin(self):
        return self.store.query(User, User.admin == True).getColumn('nickname')

    def deleteAdmin(self, admin):
        admin = admin.lower()
        self.store.query(User, User.nickname == admin).deleteFromStore()

    def removeMember(self, username):
        username = username.lower()
        try:
            user = self.store.findUnique(User, User.nickname == username)
        except ItemNotFound:
            return None

        self.store.query(_GroupMembership, _GroupMembership.user == user).deleteFromStore()
        user.deleteFromStore()

    def deleteGroup(self, group):
        groupName = group.lower()
        try:
            group = self.store.findUnique(Group, Group.name == groupName)
        except ItemNotFound:
            return None

        self.store.query(_GroupMembership, _GroupMembership.group == group).deleteFromStore()
        group.deleteFromStore()

    def unauthAdmin(self, nickname):
        nickname = nickname.lower()
        try:
            user = self.store.findUnique(User, User.nickname == nickname)
            return user is not None and user.admin
        except:
            return False

    def isAdmin(self, user):
        user = user.lower()
        if user == 'karnaugh': # An override for blank databases
            return True
        return user in self.authAdmins

    def unauthUser(self, nickname):
        # only returns true if a user is not active yet but does exist
        nickname = nickname.lower()
        try:
            user = self.store.findUnique(User, User.nickname == nickname)
            return not user.active
        except ItemNotFound:
            return None

    def authoriseUser(self, nickname):
        nickname = nickname.lower()
        try:
            user = self.store.findUnique(User, User.nickname == nickname)
            user.active = True
        except ItemNotFound:
            return

    def getMask(self, nickname):
        nickname = nickname.lower()
        try:
            user = self.store.findUnique(User, User.nickname == nickname)
        except ItemNotFound:
            return None

        # XXX: we should do something sane with multiple memberships
        for membership in self.store.query(_GroupMembership, _GroupMembership.user == user):
            if user.active:
                return membership.group.cloak
            else:
                # At this point, possibly message them again
                return None

        return None

    def getGroupAndMask(self, nickname):
        nickname = nickname.lower()
        try:
            user = self.store.findUnique(User, User.nickname == nickname)
            for membership in self.store.query(_GroupMembership, _GroupMembership.user == user):
                return membership.group.name, membership.group.cloak
        except:
            return None, None

    def getGroup(self, nickname):
        nickname = nickname.lower()
        try:
            user = self.store.findUnique(User, User.nickname == nickname)
        except ItemNotFound:
            return None

        # XXX: we should do something sane with multiple memberships
        for membership in self.store.query(_GroupMembership, _GroupMembership.user == user):
            return membership.group.name

        return None

    def showGroup(self, groupName):
        groupName = groupName.lower()

        try:
            group = self.store.findUnique(Group, Group.name == groupName)
        except ItemNotFound:
            return None
        out = ["Group %s" % group.name]
        #out = ["Group founder: %s" % self.
        out.append("Group Members:")
        for user in self.store.query(_GroupMembership, _GroupMembership.group == group).getColumn('user'):
            out.append(" * %s" % (user.nickname,))

        out.append("Host Mask: %s" % (group.cloak,))
        out.append("Group Founder: %s" % (group.founder,))

        return out

    def iterGroups(self):
        return [group.name for group in self.store.query(Group)]

    def isFounder(self, name):
        name = name.lower()
        try:
            group = self.store.query(Group, Group.founder == name).getColumn('name')
            return [i for i in group][0]
        except:
            return None

    def addGroup(self, groupName, mask, founder):
        groupName = groupName.lower()
        founder = founder.lower()
        group = self.store.findOrCreate(Group, name=groupName)
        group.cloak = mask
        group.founder = founder
        return True

    def modGroup(self, groupName, mask, founder):
        # Synonym for add really..
        groupName = groupName.lower()
        founder = founder.lower()
        try:
            group = self.store.findUnique(Group, Group.name == groupName)
            group.cloak = mask
            group.founder = founder
        except:
            return False

    def addMember(self, nickname, groupName):
        nickname = nickname.lower()
        groupName = groupName.lower()
        # Make sure they are not already in a group.

        user = self.store.findOrCreate(User, nickname=nickname)

        try:
            l =  self.store.query(_GroupMembership, _GroupMembership.user == user).getColumn('group')
            print repr(l)
            if l:
                print "Already in ", l.group.name
                return False
        except:
            print "Got exception"
            pass

        try:
            group = self.store.findUnique(Group, Group.name == groupName)
        except ItemNotFound:
            return False

        self.store.findOrCreate(_GroupMembership, user=user, group=group)
        return True