# -*- coding: utf-8 -*-

"""XXX rename, split, reorganize this

:license: GNU Lesser General Public License, v2.1 - http://www.gnu.org/licenses

"""

from logilab.common.testlib import unittest_main

from cubicweb.devtools.apptest import EnvBasedTC

from cubicweb import CW_SOFTWARE_ROOT as BASE, Binary

from cubicweb.selectors import (match_user_groups, implements,

                                specified_etype_implements, rql_condition,

                                traced_selection)

from cubicweb.web import NoSelectableObject

from cubicweb.web.action import Action

from cubicweb.web.views import (primary, baseviews, tableview, editforms,

                                calendar, management, embedding, actions,

                                startup, cwuser, schema, xbel, vcard, owl,

                                treeview, idownloadable, wdoc, debug,

                                cwproperties, workflow, xmlrss, csvexport)

from cubes.folder import views as folderviews

USERACTIONS = [('myprefs', actions.UserPreferencesAction),

               ('myinfos', actions.UserInfoAction),

               ('logout', actions.LogoutAction)]

SITEACTIONS = [('siteconfig', actions.SiteConfigurationAction),

               ('manage', actions.ManageAction),

               ('schema', schema.ViewSchemaAction),

               ('siteinfo', actions.SiteInfoAction),

               ]

class ViewSelectorTC(EnvBasedTC):

    def setup_database(self):

        self.add_entity('BlogEntry', title=u"une news !", content=u"cubicweb c'est beau")

        self.add_entity('Bookmark', title=u"un signet !", path=u"view?vid=index")

        self.add_entity('EmailAddress', address=u"devel@logilab.fr", alias=u'devel')

        self.add_entity('Tag', name=u'x')

    def pactions(self, req, rset):

        resdict = self.vreg['actions'].possible_actions(req, rset)

        for cat, actions in resdict.items():

            resdict[cat] = [(a.id, a.__class__) for a in actions]

        return resdict

class VRegistryTC(ViewSelectorTC):

    """test the view selector"""

    def _test_registered(self, registry, content):

        try:

            expected = getattr(self, 'all_%s' % registry)

        except AttributeError:

            return

        if registry == 'hooks':

            self.assertEquals(len(content), expected, content)

            return

        try:

            self.assertSetEqual(content.keys(), expected)

        except:

            print registry, sorted(expected), sorted(content.keys())

            print 'no more', [v for v in expected if not v in content.keys()]

            print 'missing', [v for v in content.keys() if not v in expected]

            raise

    def setUp(self):

        super(VRegistryTC, self).setUp()

        assert self.vreg['views']['propertiesform']

    def test_possible_views_none_rset(self):

        req = self.request()

        self.assertListEqual(self.pviews(req, None),

                             [('changelog', wdoc.ChangeLogView),

                              ('debug', debug.DebugView),

                              ('index', startup.IndexView),

                              ('info', management.ProcessInformationView),

                              ('manage', startup.ManageView),

                              ('owl', owl.OWLView),

                              ('propertiesform', cwproperties.CWPropertiesForm),

                              ('registry', startup.RegistryView),

                              ('schema', schema.SchemaView),

                              ('systempropertiesform', cwproperties.SystemCWPropertiesForm),

                              ('tree', folderviews.FolderTreeView),

                              ])

    def test_possible_views_noresult(self):

        rset, req = self.env.get_rset_and_req('Any X WHERE X eid 999999')

        self.assertListEqual(self.pviews(req, rset),

                             [])

    def test_possible_views_one_egroup(self):

        rset, req = self.env.get_rset_and_req('CWGroup X WHERE X name "managers"')

        self.assertListEqual(self.pviews(req, rset),

                             [('adaptedlist', baseviews.AdaptedListView),

                              ('csvexport', csvexport.CSVRsetView),

                              ('ecsvexport', csvexport.CSVEntityView),

                              ('editable-table', tableview.EditableTableView),

                              ('filetree', treeview.FileTreeView),

                              ('list', baseviews.ListView),

                              ('oneline', baseviews.OneLineView),

                              ('owlabox', owl.OWLABOXView),

                              ('primary', primary.PrimaryView),

                              ('rsetxml', xmlrss.XMLRsetView),

                              ('rss', xmlrss.RSSView),

                              ('secondary', baseviews.SecondaryView),

                              ('security', management.SecurityManagementView),

                              ('table', tableview.TableView),

                              ('text', baseviews.TextView),

                              ('treeview', treeview.TreeView),

                              ('xbel', xbel.XbelView),

                              ('xml', xmlrss.XMLView),

                              ])

    def test_possible_views_multiple_egroups(self):

        rset, req = self.env.get_rset_and_req('CWGroup X')

        self.assertListEqual(self.pviews(req, rset),

                             [('adaptedlist', baseviews.AdaptedListView),

                              ('csvexport', csvexport.CSVRsetView),

                              ('ecsvexport', csvexport.CSVEntityView),

                              ('editable-table', tableview.EditableTableView),

                              ('filetree', treeview.FileTreeView),

                              ('list', baseviews.ListView),

                              ('oneline', baseviews.OneLineView),

                              ('owlabox', owl.OWLABOXView),

                              ('primary', primary.PrimaryView),

                              ('rsetxml', xmlrss.XMLRsetView),

                              ('rss', xmlrss.RSSView),

                              ('secondary', baseviews.SecondaryView),

                              ('security', management.SecurityManagementView),

                              ('table', tableview.TableView),

                              ('text', baseviews.TextView),

                              ('treeview', treeview.TreeView),

                              ('xbel', xbel.XbelView),

                              ('xml', xmlrss.XMLView),

                              ])

    def test_propertiesform_admin(self):

        assert self.vreg['views']['propertiesform']

        rset1, req1 = self.env.get_rset_and_req('CWUser X WHERE X login "admin"')

        rset2, req2 = self.env.get_rset_and_req('CWUser X WHERE X login "anon"')

        self.failUnless(self.vreg['views'].select('propertiesform', req1, rset=None))

        self.failUnless(self.vreg['views'].select('propertiesform', req1, rset=rset1))

        self.failUnless(self.vreg['views'].select('propertiesform', req2, rset=rset2))

    def test_propertiesform_anon(self):

        self.login('anon')

        rset1, req1 = self.env.get_rset_and_req('CWUser X WHERE X login "admin"')

        rset2, req2 = self.env.get_rset_and_req('CWUser X WHERE X login "anon"')

        self.assertRaises(NoSelectableObject, self.vreg['views'].select, 'propertiesform', req1, rset=None)

        self.assertRaises(NoSelectableObject, self.vreg['views'].select, 'propertiesform', req1, rset=rset1)

        self.assertRaises(NoSelectableObject, self.vreg['views'].select, 'propertiesform', req1, rset=rset2)

    def test_propertiesform_jdoe(self):

        self.create_user('jdoe')

        self.login('jdoe')

        rset1, req1 = self.env.get_rset_and_req('CWUser X WHERE X login "admin"')

        rset2, req2 = self.env.get_rset_and_req('CWUser X WHERE X login "jdoe"')

        self.failUnless(self.vreg['views'].select('propertiesform', req1, rset=None))

        self.assertRaises(NoSelectableObject, self.vreg['views'].select, 'propertiesform', req1, rset=rset1)

        self.failUnless(self.vreg['views'].select('propertiesform', req2, rset=rset2))

    def test_possible_views_multiple_different_types(self):

        rset, req = self.env.get_rset_and_req('Any X')

        self.assertListEqual(self.pviews(req, rset),

                             [('csvexport', csvexport.CSVRsetView),

                              ('ecsvexport', csvexport.CSVEntityView),

                              ('editable-table', tableview.EditableTableView),

                              ('filetree', treeview.FileTreeView),

                              ('list', baseviews.ListView),

                              ('oneline', baseviews.OneLineView),

                              ('owlabox', owl.OWLABOXView),

                              ('primary', primary.PrimaryView),

                              ('rsetxml', xmlrss.XMLRsetView),

                              ('rss', xmlrss.RSSView),

                              ('secondary', baseviews.SecondaryView),

                              ('security', management.SecurityManagementView),

                              ('table', tableview.TableView),

                              ('text', baseviews.TextView),

                              ('treeview', treeview.TreeView),

                              ('xbel', xbel.XbelView),

                              ('xml', xmlrss.XMLView),

                              ])

    def test_possible_views_any_rset(self):

        rset, req = self.env.get_rset_and_req('Any N, X WHERE X in_group Y, Y name N')

        self.assertListEqual(self.pviews(req, rset),

                             [('csvexport', csvexport.CSVRsetView),

                              ('editable-table', tableview.EditableTableView),

                              ('rsetxml', xmlrss.XMLRsetView),

                              ('table', tableview.TableView),

                              ])

    def test_possible_views_multiple_eusers(self):

        rset, req = self.env.get_rset_and_req('CWUser X')

        self.assertListEqual(self.pviews(req, rset),

                             [('adaptedlist', baseviews.AdaptedListView),

                              ('csvexport', csvexport.CSVRsetView),

                              ('ecsvexport', csvexport.CSVEntityView),

                              ('editable-table', tableview.EditableTableView),

                              ('filetree', treeview.FileTreeView),

                              ('foaf', cwuser.FoafView),

                              ('list', baseviews.ListView),

                              ('oneline', baseviews.OneLineView),

                              ('owlabox', owl.OWLABOXView),

                              ('primary', primary.PrimaryView),

                              ('rsetxml', xmlrss.XMLRsetView),

                              ('rss', xmlrss.RSSView),

                              ('secondary', baseviews.SecondaryView),

                              ('security', management.SecurityManagementView),

                              ('table', tableview.TableView),

                              ('text', baseviews.TextView),

                              ('treeview', treeview.TreeView),

                              ('vcard', vcard.VCardCWUserView),

                              ('wfhistory', workflow.WFHistoryView),

                              ('xbel', xbel.XbelView),

                              ('xml', xmlrss.XMLView),

                              ])

    def test_possible_actions_none_rset(self):

        req = self.request()

        self.assertDictEqual(self.pactions(req, None),

                             {'useractions': USERACTIONS,

                              'siteactions': SITEACTIONS,

                              })

    def test_possible_actions_no_entity(self):

        rset, req = self.env.get_rset_and_req('Any X WHERE X eid 999999')

        self.assertDictEqual(self.pactions(req, rset),

                             {'useractions': USERACTIONS,

                              'siteactions': SITEACTIONS,

                              })

    def test_possible_actions_same_type_entities(self):

        rset, req = self.env.get_rset_and_req('CWGroup X')

        self.assertDictEqual(self.pactions(req, rset),

                             {'useractions': USERACTIONS,

                              'siteactions': SITEACTIONS,

                              'mainactions': [('muledit', actions.MultipleEditAction)],

                              'moreactions': [('delete', actions.DeleteAction),

                                              ('addentity', actions.AddNewAction)],

                              })

    def test_possible_actions_different_types_entities(self):

        rset, req = self.env.get_rset_and_req('Any X')

        self.assertDictEqual(self.pactions(req, rset),

                             {'useractions': USERACTIONS,

                              'siteactions': SITEACTIONS,

                              'moreactions': [('delete', actions.DeleteAction)],

                              })

    def test_possible_actions_final_entities(self):

        rset, req = self.env.get_rset_and_req('Any N, X WHERE X in_group Y, Y name N')

        self.assertDictEqual(self.pactions(req, rset),

                             {'useractions': USERACTIONS,

                              'siteactions': SITEACTIONS})

    def test_possible_actions_eetype_cwuser_entity(self):

        rset, req = self.env.get_rset_and_req('CWEType X WHERE X name "CWUser"')

        self.assertDictEqual(self.pactions(req, rset),

                             {'useractions': USERACTIONS,

                              'siteactions': SITEACTIONS,

                              'mainactions': [('edit', actions.ModifyAction)],

                              'moreactions': [('managepermission', actions.ManagePermissionsAction),

                                              ('addrelated', actions.AddRelatedActions),

                                              ('delete', actions.DeleteAction),

                                              ('copy', actions.CopyAction),

                                              ],

                              })

    def test_select_creation_form(self):

        rset = None

        req = self.request()

        # creation form

        req.form['etype'] = 'CWGroup'

        self.assertIsInstance(self.vreg['views'].select('creation', req, rset=rset),

                              editforms.CreationFormView)

        del req.form['etype']

        # custom creation form

        class CWUserCreationForm(editforms.CreationFormView):

            __select__ = specified_etype_implements('CWUser')

        self.vreg._loadedmods[__name__] = {}

        self.vreg.register_appobject_class(CWUserCreationForm)

        req.form['etype'] = 'CWUser'

        self.assertIsInstance(self.vreg['views'].select('creation', req, rset=rset),

                              CWUserCreationForm)

    def test_select_view(self):

        # no entity

        rset = None

        req = self.request()

        self.assertIsInstance(self.vreg['views'].select('index', req, rset=rset),

                             startup.IndexView)

        self.failUnlessRaises(NoSelectableObject,

                             self.vreg['views'].select, 'primary', req, rset=rset)

        self.failUnlessRaises(NoSelectableObject,

                             self.vreg['views'].select, 'table', req, rset=rset)

        # no entity

        rset, req = self.env.get_rset_and_req('Any X WHERE X eid 999999')

        self.failUnlessRaises(NoSelectableObject,

                              self.vreg['views'].select, 'index', req, rset=rset)

        self.failUnlessRaises(NoSelectableObject,

                              self.vreg['views'].select, 'creation', req, rset=rset)

        self.failUnlessRaises(NoSelectableObject,

                              self.vreg['views'].select, 'primary', req, rset=rset)

        self.failUnlessRaises(NoSelectableObject,

                             self.vreg['views'].select, 'table', req, rset=rset)

        # one entity

        rset, req = self.env.get_rset_and_req('CWGroup X WHERE X name "managers"')

        self.assertIsInstance(self.vreg['views'].select('primary', req, rset=rset),

                             primary.PrimaryView)

        self.assertIsInstance(self.vreg['views'].select('list', req, rset=rset),

                             baseviews.ListView)

        self.assertIsInstance(self.vreg['views'].select('edition', req, rset=rset),

                             editforms.EditionFormView)

        self.assertIsInstance(self.vreg['views'].select('table', req, rset=rset),

                             tableview.TableView)

        self.failUnlessRaises(NoSelectableObject,

                              self.vreg['views'].select, 'creation', req, rset=rset)

        self.failUnlessRaises(NoSelectableObject,

                              self.vreg['views'].select, 'index', req, rset=rset)

        # list of entities of the same type

        rset, req = self.env.get_rset_and_req('CWGroup X')

        self.assertIsInstance(self.vreg['views'].select('primary', req, rset=rset),

                             primary.PrimaryView)

        self.assertIsInstance(self.vreg['views'].select('list', req, rset=rset),

                             baseviews.ListView)

        self.assertIsInstance(self.vreg['views'].select('table', req, rset=rset),

                             tableview.TableView)

        self.failUnlessRaises(NoSelectableObject,

                              self.vreg['views'].select, 'creation', req, rset=rset)

        # list of entities of different types

        rset, req = self.env.get_rset_and_req('Any X')

        self.assertIsInstance(self.vreg['views'].select('primary', req, rset=rset),

                                  primary.PrimaryView)

        self.assertIsInstance(self.vreg['views'].select('list', req, rset=rset),

                                  baseviews.ListView)

        self.assertIsInstance(self.vreg['views'].select('table', req, rset=rset),