"""abstract controler classe for CubicWeb web client

:organization: Logilab

:copyright: 2001-2010 LOGILAB S.A. (Paris, FRANCE), license is LGPL v2.

:contact: http://www.logilab.fr/ -- mailto:contact@logilab.fr

:license: GNU Lesser General Public License, v2.1 - http://www.gnu.org/licenses

"""

__docformat__ = "restructuredtext en"

import datetime

from cubicweb import typed_eid

from cubicweb.selectors import yes, require_group_compat

from cubicweb.appobject import AppObject

from cubicweb.web import LOGGER, Redirect, RequestError

NAVIGATION_PARAMETERS = (('vid', '__redirectvid'),

                         ('rql', '__redirectrql'),

                         ('__redirectpath', '__redirectpath'),

                         ('__redirectparams', '__redirectparams'),

                         )

NAV_FORM_PARAMETERS = tuple(fp for ap, fp in NAVIGATION_PARAMETERS)

def redirect_params(form):

    """transform redirection parameters into navigation parameters

    """

    params = {}

    # extract navigation parameters from redirection parameters

    for navparam, redirectparam in NAVIGATION_PARAMETERS:

        if navparam == redirectparam:

            continue

        if redirectparam in form:

            params[navparam] = form[redirectparam]

    return params

def parse_relations_descr(rdescr):

    """parse a string describing some relations, in the form

    subjeids:rtype:objeids

    where subjeids and objeids are eids separeted by a underscore

    return an iterator on (subject eid, relation type, object eid) found

    """

    for rstr in rdescr:

        subjs, rtype, objs = rstr.split(':')

        for subj in subjs.split('_'):

            for obj in objs.split('_'):

                yield typed_eid(subj), rtype, typed_eid(obj)

def append_url_params(url, params):

    """append raw parameters to the url. Given parameters, if any, are expected

    to be already url-quoted.

    """

    if params:

        if not '?' in url:

            url += '?'

        else:

            url += '&'

        url += params

    return url

class Controller(AppObject):

    """a controller is responsible to make necessary stuff to publish

    a request. There is usually at least one standard "view" controller

    and another linked by forms to edit objects ("edit").

    """

    __registry__ = 'controllers'

    __select__ = yes()

    registered = require_group_compat(AppObject.registered)

    def __init__(self, *args, **kwargs):

        self.appli = kwargs.pop('appli', None)

        super(Controller, self).__init__(*args, **kwargs)

        # attributes use to control after edition redirection

        self._after_deletion_path = None

        self._edited_entity = None

    def publish(self, rset=None):

        """publish the current request, with an option input rql string

        (already processed if necessary)

        """

        raise NotImplementedError

    # generic methods useful for concret implementations ######################

    def process_rql(self, rql):

        """execute rql if specified"""

        # XXX assigning to self really necessary?

        self.rset = None

        if rql:

            self.ensure_ro_rql(rql)

            if not isinstance(rql, unicode):

                rql = unicode(rql, self.req.encoding)

            pp = self.vreg['components'].select_object('magicsearch', self.req)

            if pp is not None:

                self.rset = pp.process_query(rql, self.req)

        return self.rset

    def check_expected_params(self, params):

        """check that the given list of parameters are specified in the form

        dictionary

        """

        missing = []

        for param in params:

            if not self.req.form.get(param):

                missing.append(param)

        if missing:

            raise RequestError('missing required parameter(s): %s'

                               % ','.join(missing))

    def notify_edited(self, entity):

        """called by edit_entity() to notify which entity is edited"""

        # NOTE: we can't use entity.rest_path() at this point because

        #       rest_path() could rely on schema constraints (such as a required

        #       relation) that might not be satisfied yet (in case of creations)

        if not self._edited_entity:

            self._edited_entity = entity

    def delete_entities(self, eidtypes):

        """delete entities from the repository"""

        redirect_info = set()

        eidtypes = tuple(eidtypes)

        for eid, etype in eidtypes:

            entity = self.req.entity_from_eid(eid, etype)

            path, params = entity.after_deletion_path()

            redirect_info.add( (path, tuple(params.iteritems())) )

            entity.delete()

        if len(redirect_info) > 1:

            # In the face of ambiguity, refuse the temptation to guess.

            self._after_deletion_path = 'view', ()

        else:

            self._after_deletion_path = iter(redirect_info).next()

        if len(eidtypes) > 1:

            self.req.set_message(self.req._('entities deleted'))

        else:

            self.req.set_message(self.req._('entity deleted'))

    def delete_relations(self, rdefs):

        """delete relations from the repository"""

        # FIXME convert to using the syntax subject:relation:eids

        execute = self.req.execute

        for subj, rtype, obj in rdefs:

            rql = 'DELETE X %s Y where X eid %%(x)s, Y eid %%(y)s' % rtype

            execute(rql, {'x': subj, 'y': obj}, ('x', 'y'))

        self.req.set_message(self.req._('relations deleted'))

    def insert_relations(self, rdefs):

        """insert relations into the repository"""

        execute = self.req.execute

        for subj, rtype, obj in rdefs:

            rql = 'SET X %s Y where X eid %%(x)s, Y eid %%(y)s' % rtype

            execute(rql, {'x': subj, 'y': obj}, ('x', 'y'))

    def reset(self):

        """reset form parameters and redirect to a view determinated by given

        parameters

        """

        newparams = {}

        # sets message if needed

        if self.req.message:

            newparams['__message'] = self.req.message

        if self.req.form.has_key('__action_apply'):

            self._return_to_edition_view(newparams)

        if self.req.form.has_key('__action_cancel'):

            self._return_to_lastpage(newparams)

        else:

            self._return_to_original_view(newparams)

    def _return_to_original_view(self, newparams):

        """validate-button case"""

        # transforms __redirect[*] parameters into regular form parameters

        newparams.update(redirect_params(self.req.form))

        # find out if we have some explicit `rql` needs

        rql = newparams.pop('rql', None)

        # if rql is needed (explicit __redirectrql or multiple deletions for

        # instance), we have to use the old `view?rql=...` form

        if rql:

            path = 'view'

            newparams['rql'] = rql

        elif '__redirectpath' in self.req.form:

            # if redirect path was explicitly specified in the form, use it

            path = self.req.form['__redirectpath']

            if self._edited_entity and path != self._edited_entity.rest_path():

                # XXX may be here on modification? if yes the message should be

                # modified where __createdpath is detected (cw.web.request)

                newparams['__createdpath'] = self._edited_entity.rest_path()

        elif self._after_deletion_path:

            # else it should have been set during form processing

            path, params = self._after_deletion_path

            params = dict(params) # params given as tuple

            params.update(newparams)

            newparams = params

        elif self._edited_entity:

            path = self._edited_entity.rest_path()

        else:

            path = 'view'

        url = self.build_url(path, **newparams)

        url = append_url_params(url, self.req.form.get('__redirectparams'))

        raise Redirect(url)

    def _return_to_edition_view(self, newparams):

        """apply-button case"""

        form = self.req.form

        if self._edited_entity:

            path = self._edited_entity.rest_path()

            newparams.pop('rql', None)

        # else, fallback on the old `view?rql=...` url form

        elif 'rql' in self.req.form:

            path = 'view'

            newparams['rql'] = form['rql']

        else:

            self.warning("the edited data seems inconsistent")

            path = 'view'

        # pick up the correction edition view

        if form.get('__form_id'):

            newparams['vid'] = form['__form_id']

        # re-insert copy redirection parameters

        for redirectparam in NAV_FORM_PARAMETERS:

            if redirectparam in form:

                newparams[redirectparam] = form[redirectparam]

        raise Redirect(self.build_url(path, **newparams))

    def _return_to_lastpage(self, newparams):

        """cancel-button case: in this case we are always expecting to go back

        where we came from, and this is not easy. Currently we suppose that

        __redirectpath is specifying that place if found, else we look in the

        request breadcrumbs for the last visited page.

        """

        if '__redirectpath' in self.req.form:

            # if redirect path was explicitly specified in the form, use it

            path = self.req.form['__redirectpath']

            url = self.build_url(path, **newparams)

            url = append_url_params(url, self.req.form.get('__redirectparams'))

        else:

            url = self.req.last_visited_page()

        raise Redirect(url)

from cubicweb import set_log_methods

set_log_methods(Controller, LOGGER)