"""abstract action classes for CubicWeb web client

:organization: Logilab
:copyright: 2001-2008 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
:contact: http://www.logilab.fr/ -- mailto:contact@logilab.fr
"""
__docformat__ = "restructuredtext en"

from cubicweb.common.appobject import AppRsetObject
from cubicweb.common.registerers import action_registerer
from cubicweb.common.selectors import add_etype_selector, \
     searchstate_selector, searchstate_accept_one_selector, \
     searchstate_accept_one_but_etype_selector
    
_ = unicode


class Action(AppRsetObject):
    """abstract action. Handle the .search_states attribute to match
    request search state. 
    """
    __registry__ = 'actions'
    __registerer__ = action_registerer
    __selectors__ = (searchstate_selector,)
    # by default actions don't appear in link search mode
    search_states = ('normal',) 
    property_defs = {
        'visible':  dict(type='Boolean', default=True,
                         help=_('display the action or not')),
        'order':    dict(type='Int', default=99,
                         help=_('display order of the action')),
        'category': dict(type='String', default='moreactions',
                         vocabulary=('mainactions', 'moreactions', 'addrelated',
                                     'useractions', 'siteactions', 'hidden'),
                         help=_('context where this component should be displayed')),
    }
    site_wide = True # don't want user to configuration actions eproperties
    category = 'moreactions'
    
    @classmethod
    def accept_rset(cls, req, rset, row, col):
        user = req.user
        action = cls.schema_action
        if row is None:
            score = 0
            need_local_check = [] 
            geteschema = cls.schema.eschema
            for etype in rset.column_types(0):
                accepted = cls.accept(user, etype)
                if not accepted:
                    return 0
                if action:
                    eschema = geteschema(etype)
                    if not user.matching_groups(eschema.get_groups(action)):
                        if eschema.has_local_role(action):
                            # have to ckeck local roles
                            need_local_check.append(eschema)
                            continue
                        else:
                            # even a local role won't be enough
                            return 0
                score += accepted
            if need_local_check:
                # check local role for entities of necessary types
                for i, row in enumerate(rset):
                    if not rset.description[i][0] in need_local_check:
                        continue
                    if not cls.has_permission(rset.get_entity(i, 0), action):
                        return 0
                    score += 1
            return score
        col = col or 0
        etype = rset.description[row][col]
        score = cls.accept(user, etype)
        if score and action:
            if not cls.has_permission(rset.get_entity(row, col), action):
                return 0
        return score
    
    @classmethod
    def has_permission(cls, entity, action):
        """defined in a separated method to ease overriding (see ModifyAction
        for instance)
        """
        return entity.has_perm(action)
    
    def url(self):
        """return the url associated with this action"""
        raise NotImplementedError
    
    def html_class(self):
        if self.req.selected(self.url()):
            return 'selected'
        if self.category:
            return 'box' + self.category.capitalize()

class UnregisteredAction(Action):
    """non registered action used to build boxes. Unless you set them
    explicitly, .vreg and .schema attributes at least are None.
    """
    category = None
    id = None
    
    def __init__(self, req, rset, title, path, **kwargs):
        Action.__init__(self, req, rset)
        self.title = req._(title)
        self._path = path
        self.__dict__.update(kwargs)
        
    def url(self):
        return self._path


class AddEntityAction(Action):
    """link to the entity creation form. Concrete class must set .etype and
    may override .vid
    """
    __selectors__ = (add_etype_selector, searchstate_selector)
    vid = 'creation'
    etype = None
    
    def url(self):
        return self.build_url(vid=self.vid, etype=self.etype)


class EntityAction(Action):
    """an action for an entity. By default entity actions are only
    displayable on single entity result if accept match.
    """
    __selectors__ = (searchstate_accept_one_selector,)
    schema_action = None
    condition = None
    
    @classmethod
    def accept(cls, user, etype):
        score = super(EntityAction, cls).accept(user, etype)
        if not score:
            return 0
        # check if this type of entity has the necessary relation
        if hasattr(cls, 'rtype') and not cls.relation_possible(etype):
            return 0
        return score

    
class LinkToEntityAction(EntityAction):
    """base class for actions consisting to create a new object
    with an initial relation set to an entity.
    Additionaly to EntityAction behaviour, this class is parametrized
    using .etype, .rtype and .target attributes to check if the
    action apply and if the logged user has access to it
    """
    etype = None
    rtype = None
    target = None
    category = 'addrelated'

    @classmethod
    def accept_rset(cls, req, rset, row, col):
        entity = rset.get_entity(row or 0, col or 0)
        # check if this type of entity has the necessary relation
        if hasattr(cls, 'rtype') and not cls.relation_possible(entity.e_schema):
            return 0
        score = cls.accept(req.user, entity.e_schema)
        if not score:
            return 0
        if not cls.check_perms(req, entity):
            return 0
        return score

    @classmethod
    def check_perms(cls, req, entity):
        if not cls.check_rtype_perm(req, entity):
            return False
        # XXX document this:
        # if user can create the relation, suppose it can create the entity
        # this is because we usually can't check "add" permission before the
        # entity has actually been created, and schema security should be
        # defined considering this
        #if not cls.check_etype_perm(req, entity):
        #    return False
        return True
        
    @classmethod
    def check_etype_perm(cls, req, entity):
        eschema = cls.schema.eschema(cls.etype)
        if not eschema.has_perm(req, 'add'):
            #print req.user.login, 'has no add perm on etype', cls.etype
            return False
        #print 'etype perm ok', cls
        return True

    @classmethod
    def check_rtype_perm(cls, req, entity):
        rschema = cls.schema.rschema(cls.rtype)
        # cls.target is telling us if we want to add the subject or object of
        # the relation
        if cls.target == 'subject':
            if not rschema.has_perm(req, 'add', toeid=entity.eid):
                #print req.user.login, 'has no add perm on subject rel', cls.rtype, 'with', entity
                return False
        elif not rschema.has_perm(req, 'add', fromeid=entity.eid):
            #print req.user.login, 'has no add perm on object rel', cls.rtype, 'with', entity
            return False
        #print 'rtype perm ok', cls
        return True
            
    def url(self):
        current_entity = self.rset.get_entity(self.row or 0, self.col or 0)
        linkto = '%s:%s:%s' % (self.rtype, current_entity.eid, self.target)
        return self.build_url(vid='creation', etype=self.etype,
                              __linkto=linkto,
                              __redirectpath=current_entity.rest_path(), # should not be url quoted!
                              __redirectvid=self.req.form.get('__redirectvid', ''))


class LinkToEntityAction2(LinkToEntityAction):
    """LinkToEntity action where the action is not usable on the same
    entity's type as the one refered by the .etype attribute
    """
    __selectors__ = (searchstate_accept_one_but_etype_selector,)