# copyright 2010-2016 LOGILAB S.A. (Paris, FRANCE), all rights reserved.

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

#

# This file is part of CubicWeb.

#

# CubicWeb is free software: you can redistribute it and/or modify it under the

# terms of the GNU Lesser General Public License as published by the Free

# Software Foundation, either version 2.1 of the License, or (at your option)

# any later version.

#

# CubicWeb is distributed in the hope that it will be useful, but WITHOUT

# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS

# FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more

# details.

#

# You should have received a copy of the GNU Lesser General Public License along

# with CubicWeb.  If not, see <http://www.gnu.org/licenses/>.

"""some basic entity adapter implementations, for interfaces used in the

framework itself.

"""

from cubicweb import _

from hashlib import sha1

from itertools import chain

from rdflib import URIRef, Literal, namespace as rdflib_namespace

from logilab.mtconverter import TransformError

from logilab.common.decorators import cached, cachedproperty

from cubicweb import rdf

from cubicweb import (Unauthorized, ValidationError, ViolatedConstraint,

                      UniqueTogetherError)

from cubicweb.entity import EntityAdapter

from cubicweb.schema import constraint_name_for, VIRTUAL_RTYPES

from cubicweb.predicates import is_instance, relation_possible, match_exception

class EntityRDFAdapter(EntityAdapter):

    """EntityRDFAdapter is to be specialized for each entity that wants to

    be converted to RDF using the mechanism from cubicweb.rdf

    """

    __regid__ = "rdf"

    SKIP_RTYPES = VIRTUAL_RTYPES | set(['cwuri', 'is', 'is_instance_of'])

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

        super().__init__(_cw, **kwargs)

        self.entity.complete()

        self.used_namespaces = {}

    def _use_namespace(self, prefix, base_url=None):

        if prefix not in self.used_namespaces:

            if base_url is not None:

                if prefix in rdf.NAMESPACES:

                    raise KeyError('prefix redefinition not allowed: '

                                   f'"{prefix}" already exists as "{rdf.NAMESPACES[prefix]}"')

                ns = rdflib_namespace.Namespace(base_url)

            else:

                ns = rdf.NAMESPACES[prefix]

            self.used_namespaces[prefix] = ns

        elif base_url is not None:

            if self.used_namespaces[prefix] != rdflib_namespace.Namespace(base_url):

                raise ValueError('prefix redefinition not allowed: '

                                 f'"{prefix}" already exists as "{self.used_namespaces[prefix]}"')

        return self.used_namespaces[prefix]

    @cachedproperty

    def uri(self):

        return URIRef(self.entity.cwuri)

    def triples(self):

        """return sequence of 3-tuple of rdflib identifiers"""

        yield from self.cw_triples()

        yield from self.dc_triples()

    def cw_triples(self):

        RDF = self._use_namespace('rdf')

        CW = self._use_namespace('cubicweb')

        yield (self.uri, RDF.type, CW[self.entity.e_schema.type])

        for rschema, targettypes, role in self.entity.e_schema.relation_definitions('relation'):

            rtype = rschema.type

            if rtype in self.SKIP_RTYPES or rtype.endswith('_permission'):

                continue

            for targetype in targettypes:

                # if rschema is an attribute

                if targetype.final:

                    try:

                        value = self.entity.cw_attr_cache[rtype]

                    except KeyError:

                        continue

                    if value is not None:

                        yield (self.uri, CW[rtype], Literal(value))

                # else if rschema is a relation

                else:

                    for related in self.entity.related(rtype, role, entities=True, safe=True):

                        if role == 'subject':

                            yield (self.uri, CW[rtype], URIRef(related.cwuri))

                        else:

                            yield (URIRef(related.cwuri), CW[rtype], self.uri)

    def dc_triples(self):

        dc_entity = self.entity.cw_adapt_to('IDublinCore')

        DC = self._use_namespace('dc')

        yield (self.uri, DC.title, Literal(dc_entity.long_title()))  # or title() ?

        desc = dc_entity.description()

        if desc:

            yield (self.uri, DC.description, Literal(desc))

        creator = dc_entity.creator()  # use URI instead of Literal ?

        if creator:

            yield (self.uri, DC.creator, Literal(creator))

        yield (self.uri, DC.date, Literal(dc_entity.date()))

        yield (self.uri, DC.type, Literal(dc_entity.type()))

        yield (self.uri, DC.language, Literal(dc_entity.language()))

class CWUserRDFAdapter(EntityRDFAdapter):

    __select__ = is_instance("CWUser")

    def triples(self):

        yield from super().triples()

        yield from self.foaf_triples()

    def foaf_triples(self):

        RDF = self._use_namespace('rdf')

        FOAF = self._use_namespace('foaf')

        yield (self.uri, RDF.type, FOAF.Person)

        if self.entity.surname:

            yield (self.uri, FOAF.familyName, Literal(self.entity.surname))

        if self.entity.firstname:

            yield (self.uri, FOAF.givenName, Literal(self.entity.firstname))

        emailaddr = self.entity.cw_adapt_to("IEmailable").get_email()

        if emailaddr:

            email_digest = sha1(emailaddr.encode("utf-8")).hexdigest()

            yield (self.uri, FOAF.mbox_sha1sum, Literal(email_digest))

class IDublinCoreAdapter(EntityAdapter):

    __regid__ = 'IDublinCore'

    __select__ = is_instance('Any')

    def title(self):

        """Return a suitable *unicode* title for entity"""

        entity = self.entity

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

            if rschema.meta:

                continue

            value = entity.cw_attr_value(rschema.type)

            if value is not None:

                # make the value printable (dates, floats, bytes, etc.)

                return entity.printable_value(

                    rschema.type, value, attrschema.type, format='text/plain')

        return u'%s #%s' % (self.type(), entity.eid)

    def long_title(self):

        """Return a more detailled title for entity"""

        # go through entity.dc_title for bw compat purpose: if entity define dc_title but not

        # dc_long_title, we still want it to be considered.

        return self.entity.dc_title()

    def description(self, format='text/plain'):

        """Return a suitable description for entity"""

        if 'description' in self.entity.e_schema.subjrels:

            return self.entity.printable_value('description', format=format)

        return u''

    def authors(self):  # XXX is this part of DC ?

        """Return a suitable description for the author(s) of the entity"""

        try:

            return u', '.join(u.name() for u in self.entity.owned_by)

        except Unauthorized:

            return u''

    def creator(self):

        """Return a suitable description for the creator of the entity"""

        if self.entity.creator:

            return self.entity.creator.name()

        return u''

    def date(self, date_format=None):  # XXX default to ISO 8601 ?

        """Return latest modification date of entity"""

        return self._cw.format_date(self.entity.modification_date,

                                    date_format=date_format)

    def type(self, form=''):

        """Return the display name for the type of entity (translated)"""

        return self.entity.e_schema.display_name(self._cw, form)

    def language(self):

        """Return language used by this entity (translated)"""

        eschema = self.entity.e_schema

        # check if entities has internationalizable attributes

        # XXX one is enough or check if all String attributes are internationalizable?

        for rschema, attrschema in eschema.attribute_definitions():

            if getattr(rschema.rdef(eschema, attrschema), 'internationalizable', False):

                return self._cw._(self._cw.user.property_value('ui.language'))

        return self._cw._(self._cw.vreg.property_value('ui.language'))

class IEmailableAdapter(EntityAdapter):

    __regid__ = 'IEmailable'

    __select__ = relation_possible('primary_email') | relation_possible('use_email')

    def get_email(self):

        if getattr(self.entity, 'primary_email', None):

            return self.entity.primary_email[0].address

        if getattr(self.entity, 'use_email', None):

            return self.entity.use_email[0].address

        return None

    def allowed_massmail_keys(self):

        """returns a set of allowed email substitution keys

        The default is to return the entity's attribute list but you might

        override this method to allow extra keys.  For instance, a Person

        class might want to return a `companyname` key.

        """

        return set(rschema.type

                   for rschema, attrtype in self.entity.e_schema.attribute_definitions()

                   if attrtype.type not in ('Password', 'Bytes'))

    def as_email_context(self):

        """returns the dictionary as used by the sendmail controller to

        build email bodies.

        NOTE: the dictionary keys should match the list returned by the

        `allowed_massmail_keys` method.

        """

        return dict((attr, getattr(self.entity, attr))

                    for attr in self.allowed_massmail_keys())

class INotifiableAdapter(EntityAdapter):

    __regid__ = 'INotifiable'

    __select__ = is_instance('Any')

    def notification_references(self, view):

        """used to control References field of email send on notification

        for this entity. `view` is the notification view.

        Should return a list of eids which can be used to generate message

        identifiers of previously sent email(s)

        """

        itree = self.entity.cw_adapt_to('ITree')

        if itree is not None:

            return itree.path()[:-1]

        if view.msgid_timestamp:

            return (self.entity.eid,)

        return ()

class IFTIndexableAdapter(EntityAdapter):

    """standard adapter to handle fulltext indexing

    .. automethod:: cubicweb.entities.adapters.IFTIndexableAdapter.fti_containers

    .. automethod:: cubicweb.entities.adapters.IFTIndexableAdapter.get_words

    """

    __regid__ = 'IFTIndexable'

    __select__ = is_instance('Any')

    def fti_containers(self, _done=None):

        """return the list of entities to index when handling ``self.entity``

        The actual list of entities depends on ``fulltext_container`` usage

        in the datamodel definition

        """

        if _done is None:

            _done = set()

        entity = self.entity

        _done.add(entity.eid)

        containers = tuple(entity.e_schema.fulltext_containers())

        if containers:

            for rschema, role in containers:

                if role == 'object':

                    targets = getattr(entity, rschema.type)

                else:

                    targets = getattr(entity, 'reverse_%s' % rschema)

                for target in targets:

                    if target.eid in _done:

                        continue

                    for container in target.cw_adapt_to('IFTIndexable').fti_containers(_done):

                        yield container

        else:

            yield entity

    # weight in ABCD

    entity_weight = 1.0

    attr_weight = {}

    def get_words(self):

        """used by the full text indexer to get words to index

        this method should only be used on the repository side since it depends

        on the logilab.database package

        :rtype: list

        :return: the list of indexable word of this entity

        """

        from logilab.database.fti import tokenize

        # take care to cases where we're modyfying the schema

        entity = self.entity

        pending = self._cw.transaction_data.setdefault('pendingrdefs', set())

        words = {}

        for rschema in entity.e_schema.indexable_attributes():

            if (entity.e_schema, rschema) in pending:

                continue

            weight = self.attr_weight.get(rschema, 'C')

            try:

                value = entity.printable_value(rschema, format=u'text/plain')

            except TransformError:

                continue

            except Exception:

                self.exception("can't add value of %s to text index for entity %s",

                               rschema, entity.eid)

                continue

            if value:

                words.setdefault(weight, []).extend(tokenize(value))

        for rschema, role in entity.e_schema.fulltext_relations():

            if role == 'subject':

                for entity_ in getattr(entity, rschema.type):

                    merge_weight_dict(words, entity_.cw_adapt_to('IFTIndexable').get_words())

            else:  # if role == 'object':

                for entity_ in getattr(entity, 'reverse_%s' % rschema.type):

                    merge_weight_dict(words, entity_.cw_adapt_to('IFTIndexable').get_words())

        return words

def merge_weight_dict(maindict, newdict):

    for weight, words in newdict.items():

        maindict.setdefault(weight, []).extend(words)

class IDownloadableAdapter(EntityAdapter):

    """interface for downloadable entities"""

    __regid__ = 'IDownloadable'

    __abstract__ = True

    def download_url(self, **kwargs):  # XXX not really part of this interface

        """return a URL to download entity's content

        It should be a unicode object containing url-encoded ASCII.

        """

        raise NotImplementedError

    def download_content_type(self):

        """return MIME type (unicode) of the downloadable content"""

        raise NotImplementedError

    def download_encoding(self):

        """return encoding (unicode) of the downloadable content"""

        raise NotImplementedError

    def download_file_name(self):

        """return file name (unicode) of the downloadable content"""

        raise NotImplementedError

    def download_data(self):

        """return actual data (bytes) of the downloadable content"""

        raise NotImplementedError

# XXX should propose to use two different relations for children/parent

class ITreeAdapter(EntityAdapter):

    """This adapter provides a tree interface.

    It has to be overriden to be configured using the tree_relation,

    child_role and parent_role class attributes to benefit from this default

    implementation.

    This class provides the following methods:

    .. automethod: iterparents

    .. automethod: iterchildren

    .. automethod: prefixiter

    .. automethod: is_leaf

    .. automethod: is_root

    .. automethod: root

    .. automethod: parent

    .. automethod: children

    .. automethod: different_type_children

    .. automethod: same_type_children