# copyright 2003-2013 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/>.

"""rest publishing functions

contains some functions and setup of docutils for cubicweb. Provides the

following ReST directives:

* `eid`, create link to entity in the repository by their eid

* `card`, create link to card entity in the repository by their wikiid

  (proposing to create it when the refered card doesn't exist yet)

* `winclude`, reference to a web documentation file (in wdoc/ directories)

* `sourcecode` (if pygments is installed), source code colorization

* `rql-table`, create a table from a RQL query

"""

import sys

from itertools import chain

from logging import getLogger

from os.path import join

from docutils import statemachine, nodes, utils, io

from docutils.core import Publisher

from docutils.parsers.rst import Parser, states, directives, Directive

from docutils.parsers.rst.roles import register_canonical_role, set_classes

from logilab.mtconverter import ESC_UCAR_TABLE, ESC_CAR_TABLE, xml_escape

from cubicweb import UnknownEid

from cubicweb.ext.html4zope import Writer

from cubicweb.web.views import vid_from_rset  # XXX better not to import c.w.views here...

# We provide our own parser as an attempt to get rid of

# state machine reinstanciation

import re

# compile states.Body patterns

for k, v in states.Body.patterns.items():

    if isinstance(v, str):

        states.Body.patterns[k] = re.compile(v)

# register ReStructured Text mimetype / extensions

import mimetypes

mimetypes.add_type('text/rest', '.rest')

mimetypes.add_type('text/rest', '.rst')

LOGGER = getLogger('cubicweb.rest')

def eid_reference_role(role, rawtext, text, lineno, inliner,

                       options={}, content=[]):

    try:

        try:

            eid_num, rest = text.split(u':', 1)

        except ValueError:

            eid_num, rest = text, '#'+text

        eid_num = int(eid_num)

        if eid_num < 0:

            raise ValueError

    except ValueError:

        msg = inliner.reporter.error(

            'EID number must be a positive number; "%s" is invalid.'

            % text, line=lineno)

        prb = inliner.problematic(rawtext, rawtext, msg)

        return [prb], [msg]

    # Base URL mainly used by inliner.pep_reference; so this is correct:

    context = inliner.document.settings.context

    try:

        refedentity = context._cw.entity_from_eid(eid_num)

    except UnknownEid:

        ref = '#'

        rest += u' ' + context._cw._('(UNEXISTANT EID)')

    else:

        ref = refedentity.absolute_url()

    set_classes(options)

    return [nodes.reference(rawtext, utils.unescape(rest), refuri=ref,

                            **options)], []

def rql_role(role, rawtext, text, lineno, inliner, options={}, content=[]):

    """``:rql:`<rql-expr>``` or ``:rql:`<rql-expr>:<vid>```

    Example: ``:rql:`Any X,Y WHERE X is CWUser, X login Y:table```

    Replace the directive with the output of applying the view to the resultset

    returned by the query.

    "X eid %(userid)s" can be used in the RQL query for this query will be

    executed with the argument {'userid': _cw.user.eid}.

    """

    _cw = inliner.document.settings.context._cw

    text = text.strip()

    if ':' in text:

        rql, vid = text.rsplit(u':', 1)

        rql = rql.strip()

    else:

        rql, vid = text, None

    _cw.ensure_ro_rql(rql)

    try:

        rset = _cw.execute(rql, {'userid': _cw.user.eid})

        if rset:

            if vid is None:

                vid = vid_from_rset(_cw, rset, _cw.vreg.schema)

        else:

            vid = 'noresult'

        view = _cw.vreg['views'].select(vid, _cw, rset=rset)

        content = view.render()

    except Exception as exc:

        content = 'an error occurred while interpreting this rql directive: %r' % exc

    set_classes(options)

    return [nodes.raw('', content, format='html')], []

def bookmark_role(role, rawtext, text, lineno, inliner, options={}, content=[]):

    """``:bookmark:`<bookmark-eid>``` or ``:bookmark:`<eid>:<vid>```

    Example: ``:bookmark:`1234:table```

    Replace the directive with the output of applying the view to the resultset

    returned by the query stored in the bookmark. By default, the view is the one

    stored in the bookmark, but it can be overridden by the directive as in the

    example above.

    "X eid %(userid)s" can be used in the RQL query stored in the Bookmark, for

    this query will be executed with the argument {'userid': _cw.user.eid}.

    """

    _cw = inliner.document.settings.context._cw

    text = text.strip()

    try:

        if ':' in text:

            eid, vid = text.rsplit(u':', 1)

            eid = int(eid)

        else:

            eid, vid = int(text), None

    except ValueError:

        msg = inliner.reporter.error(

            'EID number must be a positive number; "%s" is invalid.'

            % text, line=lineno)

        prb = inliner.problematic(rawtext, rawtext, msg)

        return [prb], [msg]

    try:

        bookmark = _cw.entity_from_eid(eid)

    except UnknownEid:

        msg = inliner.reporter.error('Unknown EID %s.' % text, line=lineno)

        prb = inliner.problematic(rawtext, rawtext, msg)

        return [prb], [msg]

    try:

        params = dict(_cw.url_parse_qsl(urlsplit(bookmark.path).query))

        rql = params['rql']

        if vid is None:

            vid = params.get('vid')

    except (ValueError, KeyError) as exc:

        msg = inliner.reporter.error('Could not parse bookmark path %s [%s].'

                                     % (bookmark.path, exc), line=lineno)

        prb = inliner.problematic(rawtext, rawtext, msg)

        return [prb], [msg]

    try:

        rset = _cw.execute(rql, {'userid': _cw.user.eid})

        if rset:

            if vid is None:

                vid = vid_from_rset(_cw, rset, _cw.vreg.schema)

        else:

            vid = 'noresult'

        view = _cw.vreg['views'].select(vid, _cw, rset=rset)

        content = view.render()

    except Exception as exc:

        content = 'An error occurred while interpreting directive bookmark: %r' % exc

    set_classes(options)

    return [nodes.raw('', content, format='html')], []

def winclude_directive(name, arguments, options, content, lineno,

                       content_offset, block_text, state, state_machine):

    """Include a reST file as part of the content of this reST file.

    same as standard include directive but using config.locate_doc_resource to

    get actual file to include.

    Most part of this implementation is copied from `include` directive defined

    in `docutils.parsers.rst.directives.misc`

    """

    context = state.document.settings.context

    cw = context._cw

    source = state_machine.input_lines.source(

        lineno - state_machine.input_offset - 1)

    #source_dir = os.path.dirname(os.path.abspath(source))

    fid = arguments[0]

    for lang in chain((cw.lang, cw.vreg.property_value('ui.language')),

                      cw.vreg.config.available_languages()):

        rid = '%s_%s.rst' % (fid, lang)

        resourcedir = cw.vreg.config.locate_doc_file(rid)

        if resourcedir:

            break

    else:

        severe = state_machine.reporter.severe(

              'Problems with "%s" directive path:\nno resource matching %s.'

              % (name, fid),

              nodes.literal_block(block_text, block_text), line=lineno)

        return [severe]

    path = join(resourcedir, rid)

    encoding = options.get('encoding', state.document.settings.input_encoding)

    try:

        state.document.settings.record_dependencies.add(path)

        include_file = io.FileInput(

            source_path=path, encoding=encoding,

            error_handler=state.document.settings.input_encoding_error_handler,

        )

    except IOError as error:

        severe = state_machine.reporter.severe(

              'Problems with "%s" directive path:\n%s: %s.'

              % (name, error.__class__.__name__, error),

              nodes.literal_block(block_text, block_text), line=lineno)

        return [severe]

    try:

        include_text = include_file.read()

    except UnicodeError as error:

        severe = state_machine.reporter.severe(

              'Problem with "%s" directive:\n%s: %s'

              % (name, error.__class__.__name__, error),

              nodes.literal_block(block_text, block_text), line=lineno)

        return [severe]

    if 'literal' in options:

        literal_block = nodes.literal_block(include_text, include_text,

                                            source=path)

        literal_block.line = 1

        return literal_block

    else:

        include_lines = statemachine.string2lines(include_text,

                                                  convert_whitespace=1)

        state_machine.insert_input(include_lines, path)

        return []

winclude_directive.arguments = (1, 0, 1)

winclude_directive.options = {'literal': directives.flag,

                              'encoding': directives.encoding}

class RQLTableDirective(Directive):

    """rql-table directive

    Example:

        .. rql-table::

           :vid: mytable

           :headers: , , progress

           :colvids: 2=progress

            Any X,U,X WHERE X is Project, X url U

    All fields but the RQL string are optionnal. The ``:headers:`` option can

    contain empty column names.

    """

    required_arguments = 0

    optional_arguments = 0

    has_content= True

    final_argument_whitespace = True

    option_spec = {'vid': directives.unchanged,

                   'headers': directives.unchanged,

                   'colvids': directives.unchanged}

    def run(self):

        errid = "rql-table directive"

        self.assert_has_content()

        if self.arguments:

            raise self.warning('%s does not accept arguments' % errid)

        rql = ' '.join([l.strip() for l in self.content])

        _cw = self.state.document.settings.context._cw

        _cw.ensure_ro_rql(rql)

        try:

            rset = _cw.execute(rql)

        except Exception as exc:

            raise self.error("fail to execute RQL query in %s: %r" %

                             (errid, exc))

        if not rset:

            raise self.warning("empty result set")

        vid = self.options.get('vid', 'table')

        try:

            view = _cw.vreg['views'].select(vid, _cw, rset=rset)

        except Exception as exc:

            raise self.error("fail to select '%s' view in %s: %r" %

                             (vid, errid, exc))

        headers = None

        if 'headers' in self.options:

            headers = [h.strip() for h in self.options['headers'].split(',')]

            while headers.count(''):

                headers[headers.index('')] = None

            if len(headers) != len(rset[0]):

                raise self.error("the number of 'headers' does not match the "

                                 "number of columns in %s" % errid)

        cellvids = None

        if 'colvids' in self.options:

            cellvids = {}

            for f in self.options['colvids'].split(','):

                try:

                    idx, vid = f.strip().split('=')

                except ValueError:

                    raise self.error("malformatted 'colvids' option in %s" %

                                     errid)

                cellvids[int(idx.strip())] = vid.strip()

        try:

            content = view.render(headers=headers, cellvids=cellvids)

        except Exception as exc:

            raise self.error("Error rendering %s (%s)" % (errid, exc))

        return [nodes.raw('', content, format='html')]

try:

    from pygments import highlight

    from pygments.lexers import get_lexer_by_name

    from pygments.formatters.html import HtmlFormatter

except ImportError:

    pygments_directive = None

else:

    _PYGMENTS_FORMATTER = HtmlFormatter()

    def pygments_directive(name, arguments, options, content, lineno,

                           content_offset, block_text, state, state_machine):

        try:

            lexer = get_lexer_by_name(arguments[0])

        except ValueError:

            # no lexer found

            lexer = get_lexer_by_name('text')

        parsed = highlight(u'\n'.join(content), lexer, _PYGMENTS_FORMATTER)

        # don't fail if no context set on the sourcecode directive

        try:

            context = state.document.settings.context

            context._cw.add_css('pygments.css')

        except AttributeError:

            # used outside cubicweb XXX use hasattr instead

            pass

        return [nodes.raw('', parsed, format='html')]

    pygments_directive.arguments = (1, 0, 1)

    pygments_directive.content = 1

class CubicWebReSTParser(Parser):

    """The (customized) reStructuredText parser."""

    def __init__(self):

        self.initial_state = 'Body'

        self.state_classes = states.state_classes

        self.inliner = states.Inliner()

        self.statemachine = states.RSTStateMachine(

              state_classes=self.state_classes,

              initial_state=self.initial_state,

              debug=0)

    def parse(self, inputstring, document):

        """Parse `inputstring` and populate `document`, a document tree."""

        self.setup_parse(inputstring, document)

        inputlines = statemachine.string2lines(inputstring,

                                               convert_whitespace=1)

        self.statemachine.run(inputlines, document, inliner=self.inliner)