from atop.store import Store
from atop.credup import StoreRealm, AnonymousUser, Avatar
from atop.powerup import IPowerStation,Powerup

from twisted.application import service
from twisted.cred import credentials, portal, checkers
from twisted.python import reflect
from twisted.internet import defer

import types


class NullRealm:
    __implements__ = portal.IRealm

    def requestAvatar(self, avatarId, mind, *interfaces):
        raise NotImplementedError("Realm not yet initialized.")


class StorageService(service.Service):


    def __init__(self, db, fs, guarded=False):
        self.setName(reflect.qual(self.__class__))
        self._storeParams = (db, fs)
        self._pups = []
        self.guarded = guarded
        if self.guarded:
            self.portal = portal.Portal(NullRealm())

    def addPowerups(self, pups):
        if type(pups) not in (types.TupleType, types.ListType):
            pups = [pups]
        self._pups.extend(pups)

    def storeInit(self):
        pass

    def portalInit(self):
        self.portal.registerChecker(checkers.AllowAnonymousAccess(), credentials.IAnonymous)
        self.portal.registerChecker(checkers.ICredentialsChecker(self.store))

    def startService(self):
        service.Service.startService(self)
        self.store = Store(*self._storeParams)
        self.store.service = self
        ps = IPowerStation(self.store)

        def _():
            self.storeInit()
            if self.guarded:
                # install the realm
                ps.installPowerup(StoreRealm)

                # create checker & domain
                checker = checkers.ICredentialsChecker(self.store)
                checker.addDomain("myDefaultDomain")

                realm = portal.IRealm(self.store)
                self.portal.realm = realm
                self.portalInit()

            for pup in self._pups:
                ps.installPowerup(pup)

            svc = service.IService(self.store, default=None)
            if svc is not None:
                return svc.startService()

        return self.store.transact(_)


    def _closeLater(self, result):
        d = defer.Deferred()
        from twisted.internet import reactor
        reactor.callLater(0, self._reallyClose, d, result)
        return d

    def _reallyClose(self, d, result):
        self.store.close()
        d.callback(result)

    def stopService(self):
        service.Service.stopService(self)
        def _():
            svc = service.IService(self.store, default=None)
            if svc is not None:
                return svc.stopService()
            return defer.succeed(None)
        return self.store.transact(_).addCallback(self._closeLater)