"""Set of HTML generic base views:

* noresult, final

* primary, sidebox

* secondary, oneline, incontext, outofcontext, text

* list

* xml, rss

:organization: Logilab

:copyright: 2001-2009 LOGILAB S.A. (Paris, FRANCE), all rights reserved.

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

"""

__docformat__ = "restructuredtext en"

from warnings import warn

from time import timezone

from rql import nodes

from logilab.common.decorators import cached

from logilab.mtconverter import TransformError, html_escape, xml_escape

from cubicweb import Unauthorized, NoSelectableObject, typed_eid

from cubicweb.common.selectors import (yes, nonempty_rset, accept,

                                       one_line_rset, match_search_state, 

                                       match_form_params, accept_rset)

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

                                   ajax_replace_url, rql_for_eid, simple_sgml_tag)

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)

    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, format='text/html'):

        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, format=format))

                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

        # XXX move render_entity implementation here

        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 valign="top">')

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

        self.render_entity_attributes(entity, siderelations)

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

        self.content_navigation_components('navcontenttop')

        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'</tr>')

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

        self.content_navigation_components('navcontentbottom')

    def content_navigation_components(self, context):

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

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

                                                self.req, self.rset, row=self.row,

                                                view=self, context=context):

            try:

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

            except NotImplementedError:

                warn('component %s doesnt implement cell_call, please update'

                     % comp.__class__, DeprecationWarning)

                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'):

            sideboxes = [(label, rset) for label, rset in self.get_side_boxes_defs(entity)

                         if rset]

            if sideboxes:

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

                for label, rset in sideboxes:

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

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

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

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

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

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

        elif siderelations:

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

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

            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>')

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

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

        boxes = list(self.vreg.possible_vobjects('boxes', self.req, self.rset,

                                                 row=self.row, view=self,

                                                 context='incontext'))

        if boxes:

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

            for box in boxes:

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

                try:

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

                except NotImplementedError:

                    # much probably a context insensitive box, which only implements

                    # .call() and not cell_call()

                    box.dispatch(w=self.w)

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

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

    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'