"""Set of HTML generic base views:

* noresult, final

* primary, sidebox

* secondary, oneline, incontext, outofcontext, text

* list

* xml, rss

: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 time import timezone

from rql import nodes

from logilab.common.decorators import cached

from logilab.mtconverter import html_escape, TransformError

from cubicweb import Unauthorized, NoSelectableObject, typed_eid

from cubicweb.common.selectors import (yes_selector, anyrset_selector, accept_selector,

                                    onelinerset_selector, searchstate_selector, 

                                    req_form_params_selector, accept_rset_selector)

from cubicweb.common.uilib import (cut, printable_value,  UnicodeCSVWriter,

                                ajax_replace_url, rql_for_eid)

from cubicweb.common.view import EntityView, AnyRsetView, EmptyRsetView

from cubicweb.web.httpcache import MaxAgeHTTPCacheManager

from cubicweb.web.views import vid_from_rset, linksearch_select_url, linksearch_match

_ = unicode

class NullView(AnyRsetView):

    """default view when no result has been found"""

    id = 'null'

    __select__ = classmethod(yes_selector)

    def call(self, **kwargs):

        pass

    cell_call = call

class NoResultView(EmptyRsetView):

    """default view when no result has been found"""

    id = 'noresult'

    def call(self, **kwargs):

        self.w(u'<div class="searchMessage"><strong>%s</strong></div>\n'

               % self.req._('No result matching query'))

class FinalView(AnyRsetView):

    """display values without any transformation (i.e. get a number for

    entities) 

    """

    id = 'final'

    def cell_call(self, row, col, props=None, displaytime=False):

        etype = self.rset.description[row][col]

        value = self.rset.rows[row][col]

        if etype == 'String':

            entity, rtype = self.rset.related_entity(row, col)

            if entity is not None:

                # yes !

                self.w(entity.printable_value(rtype, value))

                return

        if etype in ('Time', 'Interval'):

            _ = self.req._

            # value is DateTimeDelta but we have no idea about what is the 

            # reference date here, so we can only approximate years and months

            if value.days > 730: # 2 years

                self.w(_('%d years') % (value.days // 365))

            elif value.days > 60: # 2 months

                self.w(_('%d months') % (value.days // 30))

            elif value.days > 14: # 2 weeks

                self.w(_('%d weeks') % (value.days // 7))

            elif value.days > 2:

                self.w(_('%s days') % int(value.days))

            elif value.hours > 2:

                self.w(_('%s hours') % int(value.hours))

            elif value.minutes >= 2:

                self.w(_('%s minutes') % int(value.minutes))

            else:

                self.w(_('%s seconds') % int(value.seconds))

            return

        self.wdata(printable_value(self.req, etype, value, props, displaytime=displaytime))

class EditableFinalView(FinalView):

    """same as FinalView but enables inplace-edition when possible"""

    id = 'editable-final'

    def cell_call(self, row, col, props=None, displaytime=False):

        etype = self.rset.description[row][col]

        value = self.rset.rows[row][col]

        entity, rtype = self.rset.related_entity(row, col)

        if entity is not None:

            self.w(entity.view('reledit', rtype=rtype))

        else:

            super(EditableFinalView, self).cell_call(row, col, props, displaytime)

PRIMARY_SKIP_RELS = set(['is', 'is_instance_of', 'identity',

                         'owned_by', 'created_by', 

                         'in_state', 'wf_info_for', 'require_permission',

                         'from_entity', 'to_entity',

                         'see_also'])

class PrimaryView(EntityView):

    """the full view of an non final entity"""

    id = 'primary'

    title = _('primary')

    show_attr_label = True

    show_rel_label = True

    skip_none = True

    skip_attrs = ('eid', 'creation_date', 'modification_date')

    skip_rels = ()

    main_related_section = True

    def html_headers(self):

        """return a list of html headers (eg something to be inserted between

        <head> and </head> of the returned page

        by default primary views are indexed

        """

        return []

    def cell_call(self, row, col):        

        self.row = row

        self.render_entity(self.complete_entity(row, col))

    def render_entity(self, entity):

        """return html to display the given entity"""

        siderelations = []

        self.render_entity_title(entity)

        self.render_entity_metadata(entity)

        # entity's attributes and relations, excluding meta data

        # if the entity isn't meta itself

        self.w(u'<table border="0" width="100%">')

        self.w(u'<tr>')

        self.w(u'<td style="width:75%" valign="top">')

        self.w(u'<div class="mainInfo">')

        self.render_entity_attributes(entity, siderelations)

        self.w(u'</div>')

        self.w(u'<div class="navcontenttop">')

        for comp in self.vreg.possible_vobjects('contentnavigation',

                                                self.req, self.rset,

                                                view=self, context='navcontenttop'):

            comp.dispatch(w=self.w, view=self)

        self.w(u'</div>')

        if self.main_related_section:

            self.render_entity_relations(entity, siderelations)

        self.w(u'</td>')

        # side boxes

        self.w(u'<td valign="top">')

        self.render_side_related(entity, siderelations)

        self.w(u'</td>')

        self.w(u'<td valign="top">')

        self.w(u'</td>')        

        self.w(u'</tr>')

        self.w(u'</table>')        

        self.w(u'<div class="navcontentbottom">')

        for comp in self.vreg.possible_vobjects('contentnavigation',

                                                self.req, self.rset,

                                                view=self, context='navcontentbottom'):

            comp.dispatch(w=self.w, view=self)

        self.w(u'</div>')

    def iter_attributes(self, entity):

        for rschema, targetschema in entity.e_schema.attribute_definitions():

            attr = rschema.type

            if attr in self.skip_attrs:

               continue

            yield rschema, targetschema

    def iter_relations(self, entity):

        skip = set(self.skip_rels)

        skip.update(PRIMARY_SKIP_RELS)

        for rschema, targetschemas, x in entity.e_schema.relation_definitions():

            if rschema.type in skip:

                continue

            yield rschema, targetschemas, x

    def render_entity_title(self, entity):

        title = self.content_title(entity) # deprecate content_title?

        if title:

            self.w(u'<h1><span class="etype">%s</span> %s</h1>'

                   % (entity.dc_type().capitalize(), title))

    def content_title(self, entity):

        """default implementation return an empty string"""

        return u''

    def render_entity_metadata(self, entity):

        entity.view('metadata', w=self.w)

        summary = self.summary(entity) # deprecate summary?

        if summary:

            self.w(u'<div class="summary">%s</div>' % summary)

    def summary(self, entity):

        """default implementation return an empty string"""

        return u''

    def render_entity_attributes(self, entity, siderelations):

        for rschema, targetschema in self.iter_attributes(entity):

            attr = rschema.type

            if targetschema.type in ('Password', 'Bytes'):

                continue

            try:

                wdg = entity.get_widget(attr)

            except Exception, ex:

                value = entity.printable_value(attr, entity[attr], targetschema.type)

            else:

                value = wdg.render(entity)

            if self.skip_none and (value is None or value == ''):

                continue

            if rschema.meta:

                continue

            self._render_related_entities(entity, rschema, value)

    def render_entity_relations(self, entity, siderelations):

        if hasattr(self, 'get_side_boxes_defs'):

            return

        eschema = entity.e_schema

        maxrelated = self.req.property_value('navigation.related-limit')

        for rschema, targetschemas, x in self.iter_relations(entity):

            try:

                related = entity.related(rschema.type, x, limit=maxrelated+1)

            except Unauthorized:

                continue

            if not related:

                continue

            if self.is_side_related(rschema, eschema):

                siderelations.append((rschema, related, x))

                continue

            self._render_related_entities(entity, rschema, related, x)

    def render_side_related(self, entity, siderelations):

        """display side related relations:

        non-meta in a first step, meta in a second step

        """

        if hasattr(self, 'get_side_boxes_defs'):

            for label, rset in self.get_side_boxes_defs(entity):

                if rset:

                    self.w(u'<div class="sideRelated">')

                    self.wview('sidebox', rset, title=label)

                    self.w(u'</div>')

        elif siderelations:

            self.w(u'<div class="sideRelated">')

            for relatedinfos in siderelations:

                # if not relatedinfos[0].meta:

                #    continue

                self._render_related_entities(entity, *relatedinfos)

            self.w(u'</div>')

        for box in self.vreg.possible_vobjects('boxes', self.req, entity.rset,

                                               col=entity.col, row=entity.row,

                                               view=self, context='incontext'):

            try:

                box.dispatch(w=self.w, col=entity.col, row=entity.row)

            except NotImplementedError:

                # much probably a context insensitive box, which only implements

                # .call() and not cell_call()

                box.dispatch(w=self.w)

    def is_side_related(self, rschema, eschema):

        return rschema.meta and \

               not rschema.schema_relation() == eschema.schema_entity()

    def _render_related_entities(self, entity, rschema, related,

                                 role='subject'):

        if rschema.is_final():

            value = related

            show_label = self.show_attr_label

        else:

            if not related:

                return

            show_label = self.show_rel_label

            # if not too many entities, show them all in a list

            maxrelated = self.req.property_value('navigation.related-limit')

            if related.rowcount <= maxrelated:

                if related.rowcount == 1:

                    value = self.view('incontext', related, row=0)

                elif 1 < related.rowcount <= 5:

                    value = self.view('csv', related)

                else:

                    value = '<div>' + self.view('simplelist', related) + '</div>'

            # else show links to display related entities

            else:

                rql = related.printable_rql()

                related.limit(maxrelated)

                value = '<div>' + self.view('simplelist', related)

                value += '[<a href="%s">%s</a>]' % (self.build_url(rql=rql),

                                                    self.req._('see them all'))

                value +=  '</div>'

        label = display_name(self.req, rschema.type, role)

        self.field(label, value, show_label=show_label, w=self.w, tr=False)

class SideBoxView(EntityView):

    """side box usually displaying some related entities in a primary view"""

    id = 'sidebox'

    def call(self, boxclass='sideBox', title=u''):

        """display a list of entities by calling their <item_vid> view

        """

        if title:

            self.w(u'<div class="sideBoxTitle"><span>%s</span></div>' % title)

        self.w(u'<div class="%s"><div class="sideBoxBody">' % boxclass)

        # if not too much entities, show them all in a list

        maxrelated = self.req.property_value('navigation.related-limit')

        if self.rset.rowcount <= maxrelated:

            if len(self.rset) == 1:

                self.wview('incontext', self.rset, row=0)

            elif 1 < len(self.rset) < 5:

                self.wview('csv', self.rset)

            else:

                self.wview('simplelist', self.rset)

        # else show links to display related entities

        else:

            self.rset.limit(maxrelated)

            rql = self.rset.printable_rql(encoded=False)

            self.wview('simplelist', self.rset)

            self.w(u'[<a href="%s">%s</a>]' % (self.build_url(rql=rql),

                                               self.req._('see them all')))

        self.w(u'</div>\n</div>\n')

class SecondaryView(EntityView):

    id = 'secondary'

    title = _('secondary')

    def cell_call(self, row, col):

        """the secondary view for an entity

        secondary = icon + view(oneline)

        """

        entity = self.entity(row, col)

        self.w(u' ')

        self.wview('oneline', self.rset, row=row, col=col)

class OneLineView(EntityView):

    id = 'oneline'

    title = _('oneline') 

    def cell_call(self, row, col):

        """the one line view for an entity: linked text view

        """

        entity = self.entity(row, col)

        self.w(u'<a href="%s">' % html_escape(entity.absolute_url()))

        self.w(html_escape(self.view('text', self.rset, row=row, col=col)))

        self.w(u'</a>')

class TextView(EntityView):

    """the simplest text view for an entity

    """

    id = 'text'

    title = _('text')

    accepts = 'Any',

    def call(self, **kwargs):

        """the view is called for an entire result set, by default loop

        other rows of the result set and call the same view on the

        particular row

        Views applicable on None result sets have to override this method

        """

        rset = self.rset

        if rset is None:

            raise NotImplementedError, self

        for i in xrange(len(rset)):

            self.wview(self.id, rset, row=i, **kwargs)

            if len(rset) > 1:

                self.w(u"\n")

    def cell_call(self, row, col=0, **kwargs):

        entity = self.entity(row, col)

        self.w(cut(entity.dc_title(),

                   self.req.property_value('navigation.short-line-size')))

class MetaDataView(EntityView):