import re

from cubicweb.devtools.testlib import CubicWebTC
from cubicweb.web.views import actions

from cubes.comment import views

class CommentTC(CubicWebTC):
    """Comment"""
    def test_schema(self):
        self.assertEquals(self.schema['comments'].rdef('Comment', 'BlogEntry').composite,
                          'object')

    def setup_database(self):
        super(CommentTC, self).setup_database()
        self.b = self.execute('INSERT BlogEntry X: X title "yo", X content "qu\'il est beau"').get_entity(0, 0)
        self.c = self.execute('INSERT Comment X: X content "bouh!", X comments B WHERE B is BlogEntry')
        self.create_user('user')

    def test_possible_views(self):
        # comment primary view priority
        req = self.request()
        rset = req.execute('Comment X')
        self.assertIsInstance(self.vreg['views'].select('primary', req, rset=rset),
                             views.CommentPrimaryView)
        self.assertIsInstance(self.vreg['views'].select('tree', req, rset=rset),
                             views.CommentThreadView)

    def test_possible_actions(self):
        req = self.request()
        rset = req.execute('Any X WHERE X is BlogEntry')
        actions = self.pactions(req, rset)
        self.failUnless(('reply_comment', views.AddCommentAction) in actions)
        self.failIf(('edit_comment', views.EditCommentAction) in actions)
        rset = req.execute('Any X WHERE X is Comment')
        actions = self.pactions(req, rset)
        self.failUnless(('reply_comment', views.ReplyCommentAction) in actions)
        self.failUnless(('edit_comment', views.EditCommentAction) in actions)
        cnx = self.login('user')
        req = self.request()
        rset = req.execute('Any X WHERE X is Comment')
        actions = self.pactions(req, rset)
        self.failUnless(('reply_comment', views.ReplyCommentAction) in actions)
        self.failIf(('edit_comment', views.EditCommentAction) in actions)
        rset = self.execute('INSERT Comment X: X content "ho bah non!", X comments B WHERE B is Comment')
        cnx.commit()
        actions = self.pactions(req, rset)
        self.failUnless(('reply_comment', views.ReplyCommentAction) in actions)
        self.failUnless(('edit_comment', views.EditCommentAction) in actions)
        cnx.rollback()
        cnx = self.login('anon')
        req = self.request()
        rset = req.execute('Any X WHERE X is Comment')
        self.failUnlessEqual(self.pactions(req, rset), [])
        cnx.rollback()

    def test_nonregr_possible_actions(self):
        req = self.request()
        rset = req.execute('Any B WHERE B is BlogEntry')
        beid = rset[0][0]
        self.execute('INSERT Comment X: X content "Yooo !", X comments B WHERE B eid %s' % beid)
        # now two comments are commenting this blog
        rset = req.execute('Any C WHERE C comments X, X eid %s' % beid)
        self.assertEquals(len(rset), 2)
        self.failUnless(self.vreg['actions'].select('reply_comment', req, rset=rset, row=0))
        self.failUnless(self.vreg['actions'].select('reply_comment', req, rset=rset, row=1))

    def test_add_related_actions(self):
        req = self.request()
        rset = req.execute('Any X WHERE X is Comment')
        self.failUnlessEqual(self.pactions_by_cats(req, rset), [])
        cnx = self.login('user')
        rset = req.execute('Any X WHERE X is Comment')
        self.failUnlessEqual(self.pactions_by_cats(req, rset), [])
        cnx.rollback()
        cnx = self.login('anon')
        rset = req.execute('Any X WHERE X is Comment')
        self.failUnlessEqual(self.pactions_by_cats(req, rset), [])
        cnx.rollback()

    def test_path(self):
        teid = self.execute('BlogEntry X')[0][0]
        eid1 = self.execute('INSERT Comment X: X content "oijzr", X comments Y WHERE Y is BlogEntry')[0][0]
        eid2 = self.execute('INSERT Comment X: X content "duh?", X comments Y WHERE Y eid %s'%eid1)[0][0]
        comment1 = self.entity('Any X WHERE X eid %(x)s', {'x':eid1}, 'x')
        self.assertEquals(comment1.path(), [teid, eid1])
        self.assertEquals(comment1.root().eid, teid)
        comment2 = self.entity('Any X WHERE X eid %(x)s', {'x':eid2}, 'x')
        self.assertEquals(comment2.path(), [teid, eid1, eid2])
        self.assertEquals(comment2.root().eid, teid)

    def test_comments_ascending_order(self):
        teid = self.execute('BlogEntry X')[0][0]
        c1 = self.entity('INSERT Comment X: X content "one", X comments Y WHERE Y eid %s'%teid)
        eid1 = c1.eid
        c11 = self.execute('INSERT Comment X: X content "one-one", X comments Y WHERE Y eid %s'%eid1)
        c12 = self.execute('INSERT Comment X: X content "one-two", X comments Y WHERE Y eid %s'%eid1)
        c2 = self.entity('INSERT Comment X: X content "two", X comments Y WHERE Y eid %s'%teid)
        eid2 = c2.eid
        c21= self.execute('INSERT Comment X: X content "two-one", X comments Y WHERE Y eid %s'%eid2)
        c22= self.execute('INSERT Comment X: X content "two-two", X comments Y WHERE Y eid %s'%eid2)
        self.commit()
        rql = u'Any C,CD,CC,CCF,U,UL,US,UF ORDERBY CD WHERE C is Comment, '\
              'C comments X, C creation_date CD, C content CC, C content_format CCF, ' \
              'C created_by U?, U login UL, U firstname UF, U surname US, X eid %(x)s'
        all_comments = self.execute(rql, {'x': teid})
        self.assertEquals([c.eid for c in all_comments.entities()], [self.c[0][0], eid1, eid2])
        self.assertEquals([c.eid for c in c1.children()], [c11[0][0], c12[0][0]])

    def test_fullthreadtext_views(self):
        c = self.entity('Comment X')
        c2eid = self.execute('INSERT Comment X: X content %(text)s, X content_format "text/html", '
                              'X comments %(x)s',
                            {'x': c.eid, 'text': u"""
some long <b>HTML</b> text which <em>should not</em> fit on 80 characters, so i'll add some extra xxxxxxx.
Yeah !"""})[0][0]
        self.commit()
        c2rset= self.execute('Any X WHERE X eid %(x)s', {'x': c2eid}, 'x')
        v = self.vreg['views'].select('fullthreadtext', self.request(),
                                      rset=c2rset, row=0)
        content = v.render(row=0)
        # remove date
        content = re.sub('..../../.. ..:..', '', content)
        self.assertTextEquals(content,
                          """\
> On  - admin wrote :
> bouh!

some long **HTML** text which _should not_ fit on 80 characters, so i'll add
some extra xxxxxxx. Yeah !


i18n_by_author_field: admin
url: http://testing.fr/cubicweb/blogentry/%s""" % self.b.eid)
        # fullthreadtext_descending view
        self.assertTextEquals(re.sub('..../../.. ..:..', '', c.view('fullthreadtext_descending')),
                              '''On  - admin wrote :
bouh!
> On  - admin wrote :
> some long **HTML** text which _should not_ fit on 80 characters, so i\'ll add
> some extra xxxxxxx. Yeah !

''')

class CommentJsonControllerExtensionsTC(CubicWebTC):

    def setup_database(self):
        self.john = self.create_user(u'John')

    def test_add_and_edit_comment(self):
        # add comment
        self.remote_call('add_comment', self.john.eid, u'yo', u'text/plain')
        comment = self.entity('Any C,CT,F WHERE C content CT, C content_format F, '
                              'C comments P, P eid %s' % self.john.eid)
        self.assertEquals(comment.content, u'yo')
        self.assertEquals(comment.content_format, u'text/plain')
        # edit comment
        self.remote_call('edit_comment', comment.eid, u'yipee', u'text/plain')
        comment2 = self.entity('Any C,CT,F WHERE C content CT, C content_format F, '
                               'C comments P, P eid %s' % self.john.eid)
        self.assertEquals(comment.eid, comment2.eid)
        self.assertEquals(comment2.content, u'yipee')
        self.assertEquals(comment2.content_format, u'text/plain')


if __name__ == '__main__':
    from logilab.common.testlib import unittest_main
    unittest_main()