# copyright 2010-2011 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/>.

"""datafeed parser for xml generated by cubicweb

Example of mapping for CWEntityXMLParser::

  {u'CWUser': {                                        # EntityType

      (u'in_group', u'subject', u'link'): [            # (rtype, role, action)

          (u'CWGroup', {u'linkattr': u'name'})],       #   -> rules = [(EntityType, options), ...]

      (u'tags', u'object', u'link-or-create'): [       # (...)

          (u'Tag', {u'linkattr': u'name'})],           #   -> ...

      (u'use_email', u'subject', u'copy'): [           # (...)

          (u'EmailAddress', {})]                       #   -> ...

      }

   }

"""

import os.path as osp

from datetime import datetime, timedelta

from urllib import urlencode

from cgi import parse_qs # in urlparse with python >= 2.6

from logilab.common.date import todate, totime

from logilab.common.textutils import splitstrip, text_to_dict

from yams.constraints import BASE_CONVERTERS

from yams.schema import role_name as rn

from cubicweb.server.sources import datafeed

# XXX see cubicweb.cwvreg.YAMS_TO_PY

# XXX see cubicweb.web.views.xmlrss.SERIALIZERS

DEFAULT_CONVERTERS = BASE_CONVERTERS.copy()

DEFAULT_CONVERTERS['String'] = unicode

DEFAULT_CONVERTERS['Password'] = lambda x: x.encode('utf8')

def convert_date(ustr):

    return todate(datetime.strptime(ustr, '%Y-%m-%d'))

DEFAULT_CONVERTERS['Date'] = convert_date

def convert_datetime(ustr):

    if '.' in ustr: # assume %Y-%m-%d %H:%M:%S.mmmmmm

        ustr = ustr.split('.',1)[0]

    return datetime.strptime(ustr, '%Y-%m-%d %H:%M:%S')

DEFAULT_CONVERTERS['Datetime'] = convert_datetime

def convert_time(ustr):

    return totime(datetime.strptime(ustr, '%H:%M:%S'))

DEFAULT_CONVERTERS['Time'] = convert_time

def convert_interval(ustr):

    return time(seconds=int(ustr))

DEFAULT_CONVERTERS['Interval'] = convert_interval

def extract_typed_attrs(eschema, stringdict, converters=DEFAULT_CONVERTERS):

    typeddict = {}

    for rschema in eschema.subject_relations():

        if rschema.final and rschema in stringdict:

            if rschema == 'eid':

                continue

            attrtype = eschema.destination(rschema)

            typeddict[rschema.type] = converters[attrtype](stringdict[rschema])

    return typeddict

def rtype_role_rql(rtype, role):

    if role == 'object':

        return 'Y %s X WHERE X eid %%(x)s' % rtype

    else:

        return 'X %s Y WHERE X eid %%(x)s' % rtype

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

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

        self._parsed_urls = {}

        self._processed_entities = set()

    # mapping handling #########################################################

    def add_schema_config(self, schemacfg, checkonly=False):

        """added CWSourceSchemaConfig, modify mapping accordingly"""

        _ = self._cw._

        try:

            rtype = schemacfg.schema.rtype.name

        except AttributeError:

            msg = _("entity and relation types can't be mapped, only attributes "

                    "or relations")

            raise ValidationError(schemacfg.eid, {rn('cw_for_schema', 'subject'): msg})

        if schemacfg.options:

            options = text_to_dict(schemacfg.options)

        else:

            options = {}

        try:

            role = options.pop('role')

            if role not in ('subject', 'object'):

                raise KeyError

        except KeyError:

            msg = _('"role=subject" or "role=object" must be specified in options')

            raise ValidationError(schemacfg.eid, {rn('options', 'subject'): msg})

        try:

            action = options.pop('action')

        except KeyError:

            msg = _('"action" must be specified in options; allowed values are '

                    '%s') % ', '.join(self.action_methods)

            raise ValidationError(schemacfg.eid, {rn('options', 'subject'): msg})

        if not checkonly:

            if role == 'subject':

                etype = schemacfg.schema.stype.name

                ttype = schemacfg.schema.otype.name

            else:

                etype = schemacfg.schema.otype.name

                ttype = schemacfg.schema.stype.name

            etyperules = self.source.mapping.setdefault(etype, {})

            etyperules.setdefault((rtype, role, action), []).append(

                (ttype, options) )

            self.source.mapping_idx[schemacfg.eid] = (

                etype, rtype, role, action, ttype)

    def del_schema_config(self, schemacfg, checkonly=False):

        """deleted CWSourceSchemaConfig, modify mapping accordingly"""

        etype, rtype, role, action, ttype = self.source.mapping_idx[schemacfg.eid]

        rules = self.source.mapping[etype][(rtype, role, action)]

        rules = [x for x in rules if not x[0] == ttype]

        if not rules:

            del self.source.mapping[etype][(rtype, role, action)]

    # import handling ##########################################################

    def process(self, url, raise_on_error=False, partialcommit=True):

        """IDataFeedParser main entry point"""

        super(CWEntityXMLParser, self).process(self.complete_url(url),

                                               raise_on_error, partialcommit)

    def process_item(self, item, rels):

        entity = self.extid2entity(str(item.pop('cwuri')),  item.pop('cwtype'),

                                   cwsource=item.pop('cwsource'), item=item)

        if entity is None:

            return None

        if entity.eid in self._processed_entities:

            return entity

        self._processed_entities.add(entity.eid)

        if not (self.created_during_pull(entity) or self.updated_during_pull(entity)):

            self.notify_updated(entity)

            item.pop('eid')

            # XXX check modification date

            attrs = extract_typed_attrs(entity.e_schema, item)

            entity.set_attributes(**attrs)

        for (rtype, role, action), rules in self.source.mapping.get(entity.__regid__, {}).iteritems():

            try:

                related_items = rels[role][rtype]

            except KeyError:

                self.source.error('relation %s-%s not found in xml export of %s',

                                  rtype, role, entity.__regid__)

                continue

            try:

        return entity

    def before_entity_copy(self, entity, sourceparams):

        """IDataFeedParser callback"""

        attrs = extract_typed_attrs(entity.e_schema, sourceparams['item'])

        entity.cw_edited.update(attrs)

        """append to the url's query string information about relation that should

        be included in the resulting xml, according to source mapping.

        If etype is not specified, try to guess it using the last path part of

        the url.

        """

        try:

            url, qs = url.split('?', 1)

        except ValueError:

            qs = ''

        if etype is None:

            try:

                etype = url.rsplit('/', 1)[1]

            except ValueError:

                return url

            try:

                etype = self._cw.vreg.case_insensitive_etypes[etype]

            except KeyError:

                return url

        params = parse_qs(qs)

        if not 'vid' in params:

            params['vid'] = ['xml']

        return url + '?' + self._cw.build_url_params(**params)

        try:

            return self._parsed_urls[(item['cwuri'], add_relations)]

        except KeyError:

            item_rels = list(self.parse(itemurl))

            assert len(item_rels) == 1, 'url %s expected to bring back one '\

                   'and only one entity, got %s' % (itemurl, len(item_rels))

            self._parsed_urls[(item['cwuri'], add_relations)] = item_rels[0]

            return item_rels[0]

            if len(ttypes) > 1:

                typerestr = ', Y is IN(%s)' % ','.join(ttypes)

            else:

                typerestr = ', Y is %s' % ','.join(ttypes)

        assert eids

        eidstr = ','.join(str(eid) for eid in eids)

        self._cw.execute('DELETE %s, NOT Y eid IN (%s)' % (rqlbase, eidstr),

            rql = 'SET %s, Y eid IN (%s), NOT Y %s X' % (rqlbase, eidstr, rtype)

        else:

            rql = 'SET %s, Y eid IN (%s), NOT X %s Y' % (rqlbase, eidstr, rtype)