#!/usr/bin/python

import sys, os
if __name__ == '__main__':
    sys.path = ([os.path.dirname(os.path.dirname(os.path.dirname(
        os.path.realpath(__file__))))] + sys.path)
    
__requires__='Bazki'
import pkg_resources
pkg_resources.require('Bazki')

import unittest, warnings

from bazbase import db, testing, flavors, structure, get
from bazbase.conversion import to_python, render
import gameki

import pylons

class TestNames(unittest.TestCase):
    def setUp(self):
        gameki.custom.set_up()
        testing.set_up_for_tests()
        db.begin_transaction()
        try:
            structure.clear_database()
            structure.create_prop(u'name', u'string').set_default('')
            structure.create_prop(u'substitution', u'macro').set_default('')
            root = structure.create_root_element(u'Root')
            dude = root.create_child(u'Dude')
            dude.set_prop(u'name', "Dr. Alex ``Bulldozer'' Anderson, Esq.")
            dude.set_prop(u'gender', 'A')
            structure.flush_database_for_test()
        except:
            db.abort_transaction()
            raise
    def tearDown(self):
        db.abort_transaction()

    def test_standalone(self):
        dude = structure.get_element(u'Dude')
        dude.set_prop(u'comment', '<<first/>>')
        self.assertEqual('Alex', render(dude, u'comment'))
        dude.set_prop(u'comment', '<<full/>>')
        self.assertEqual(u'Dr. Alex \u201CBulldozer\u201D Anderson, Esq.',
                         render(dude, u'comment'))
        dude.set_prop(u'comment', '<<formal/>>')
        self.assertEqual('Dr. Anderson', render(dude, u'comment'))
        dude.set_prop(u'comment', '<<informal/>>')
        self.assertEqual('Alex', render(dude, u'comment'))
        dude.set_prop(u'comment', '<<they/>>')
        self.assertEqual('she/he', render(dude, u'comment'))
        dude.set_prop(u'comment', '<<Them/>>')
        self.assertEqual('Her/him', render(dude, u'comment'))

    def test_in_content(self):
        root = structure.get_element(u'Root')
        root.set_prop(u'comment', '<<Dude>><<first/>><</Dude>>')
        self.assertEqual('Alex', render(root, u'comment'))
        root.set_prop(u'comment', '<<Dude>><<full/>><</Dude>>')
        self.assertEqual(u'Dr. Alex \u201CBulldozer\u201D Anderson, Esq.',
                         render(root, u'comment'))
        root.set_prop(u'comment', '<<Dude>><<formal/>><</Dude>>')
        self.assertEqual('Dr. Anderson', render(root, u'comment'))
        root.set_prop(u'comment', '<<Dude>><<informal/>><</Dude>>')
        self.assertEqual('Alex', render(root, u'comment'))
        root.set_prop(u'comment', '<<Dude>><<they/>><</Dude>>')
        self.assertEqual('she/he', render(root, u'comment'))
        root.set_prop(u'comment', '<<Dude>><<Them/>><</Dude>>')
        self.assertEqual('Her/him', render(root, u'comment'))

    def test_texish(self):
        root = structure.get_element(u'Root')
        root.set_prop(u'comment', r'\Dude{\first}')
        self.assertEqual('Alex', render(root, u'comment'))
        root.set_prop(u'comment', r'\Dude{\full}')
        self.assertEqual(u'Dr. Alex \u201CBulldozer\u201D Anderson, Esq.',
                         render(root, u'comment'))
        root.set_prop(u'comment', r'\Dude{\formal}')
        self.assertEqual('Dr. Anderson', render(root, u'comment'))
        root.set_prop(u'comment', r'\Dude{\informal}')
        self.assertEqual('Alex', render(root, u'comment'))
        root.set_prop(u'comment', r'\Dude{\they}')
        self.assertEqual('she/he', render(root, u'comment'))
        root.set_prop(u'comment', r'\Dude{\Them}')
        self.assertEqual('Her/him', render(root, u'comment'))

    def test_gender(self):
        dude = structure.get_element(u'Dude')
        dude.set_prop(u'gender', 'M')
        dude.set_prop(u'comment', "My <<uncle/>>, my dad's <<sibling/>>, crashed <<their/>> car which <<they/>> bought <<themself/>> when a \mfn{Werewolf}{Mongoose}{Fish} cheated <<them/>>.")
        self.assertEqual(u"My uncle, my dad\u2019s brother, crashed his car which he bought himself when a Werewolf cheated him.", render(dude, u'comment'))
        dude.set_prop(u'gender', 'F')
        self.assertEqual(u"My aunt, my dad\u2019s sister, crashed her car which she bought herself when a Mongoose cheated her.", render(dude, u'comment'))
        dude.set_prop(u'gender', 'N')
        self.assertEqual(u"My aunt/uncle, my dad\u2019s sibling, crashed its car which it bought itself when a Fish cheated it.", render(dude, u'comment'))
        dude.set_prop(u'gender', '?')
        self.assertEqual(u"My aunt/uncle, my dad\u2019s sibling, crashed her/his car which she/he bought herself/himself when a Werewolf/Mongoose cheated her/him.", render(dude, u'comment'))
        dude.set_prop(u'gender', 'S')
        self.assertEqual(u"My aunt/uncle, my dad\u2019s sibling, crashed eir car which ey bought emself when a Werewolf/Mongoose cheated em.", render(dude, u'comment'))

    def test_labeledrefs(self):
        structure.create_prop(u'contacts', u'labeledrefs')
        root = structure.get_element(u'Root')
        dude = structure.get_element(u'Dude')
        dude.set_prop(u'contacts', "\Dude{Yourself: \Dude{}.}")

        self.assertEqual(u" * Dr. Alex \u201cBulldozer\u201d Anderson, Esq. (Dude)@</edit/Dude>: Yourself: Dr. Alex \u201cBulldozer\u201d Anderson, Esq..", render(dude, u'contacts'))

        root.set_prop(u'comment', """<<foreach leaf.contacts c,desc ifNone='* None.'>>  * **<<c.name/>>**: <<desc/>>
<</foreach>>""")
        self.assertEqual(u' * *Dr. Alex \u201cBulldozer\u201d Anderson, Esq.*: Yourself: Dr. Alex \u201cBulldozer\u201d Anderson, Esq..', render(dude, u'comment'))

    def test_identities(self):
        dude = structure.get_element(u'Dude')
        identity = dude.create_child(u'Identity')
        identity.set_prop(u'name', r'\1')
        identity.set_prop(u'gender', r'\2')
        structure.create_prop(u'persona', u'reference')
        dude.set_prop(u'persona', r'\Identity[Gigo][N]')
        dude.set_prop(u'comment', r'\first had a fight with \their persona, \persona{\name, when \they ate a \food}.')
        dude.set_prop(u'food', r'carrot')
        self.assertEqual(u'Alex had a fight with her/his persona, Gigo, when it ate a carrot.', render(dude, u'comment'))

    def test_identity_ownership(self):
        dude = structure.get_element(u'Dude')
        identity = dude.create_child(u'Identity')
        identity.set_prop(u'name', r'\1')
        identity.set_prop(u'gender',
                          r'<<if _2>>\2<<else/>><<owner.gender/>><</if>>')
        structure.create_prop(u'owned', u'boolean')
        identity.set_prop(u'owned', r'True')
        structure.create_prop(u'persona', u'reference')
        dude.set_prop(u'gender', r'F')
        dude.set_prop(u'persona', r'\Identity[Psyche]')
        dude.set_prop(u'comment', r'\first had a fight with \their persona, \persona{\name, when \they ate a \food}.')
        dude.set_prop(u'food', r'carrot')
        self.assertEqual(u'Alex had a fight with her persona, Psyche, when she ate a carrot.', render(dude, u'comment'))
        
class TestProduction(unittest.TestCase):
    def setUp(self):
        testing.set_up_for_tests()
        db.begin_transaction()
        try:
            structure.clear_database()
            structure.create_prop(u'name', u'string').set_default('')
            structure.create_prop(u'topleft', u'string').set_default('')
            structure.create_prop(u'topright', u'string').set_default('')
            structure.create_prop(u'bottomleft', u'string').set_default('')
            structure.create_prop(u'bottomright', u'string').set_default('')
            structure.create_prop(u'badgecolor', u'string').set_default('')
            structure.create_prop(u'product', u'text').set_default('')
            root = structure.create_root_element(u'Root')
            root.set_prop(u'name', 'Bob')
            root.set_prop(u'topleft', 'TL')
            root.set_prop(u'topright', 'TR')
            root.set_prop(u'bottomleft', 'BL')
            root.set_prop(u'bottomright', 'BR')
            root.set_prop(u'product', 'Whatever')
            structure.flush_database_for_test()
        except:
            db.abort_transaction()
            raise
    def tearDown(self):
        db.abort_transaction()

    def test_badge(self):
        root = structure.get_element(u'Root')
        root.set_prop(u'badgecolor', 'white')        
        root.set_prop(u'comment', '''<<badge leaf color=leaf.badgecolor>>
  == <<leaf.name />> ==
<</badge>>''')
        self.assertIn('<div class="badge', render(root, u'comment', 'html'))

    def test_sheet(self):
        root = structure.get_element(u'Root')
        root.set_prop(u'comment', '''<<sheet leaf>>
* Foo
* Bar
<</sheet>>''')
        self.assertIn('\\end{itemize}\n\n\n\n\\end{sheet}',
                      render(root, u'comment', 'tex'))

    def test_printing(self):
        root = structure.get_element(u'Root')
        root.set_prop(u'comment', '''<<foreach Root r>>
  <<cache r.name />>
<</foreach>>''')
        render(root, u'comment', 'html')

class TestGetUrls(unittest.TestCase):
    def setUp(self):
        gameki.custom.set_up()
        testing.set_up_for_tests()
        self.getter = gameki.Getter()
        self.prod_getter = gameki.ProdGetter("/prod")
        db.begin_transaction()
        try:
            structure.clear_database()
            structure.create_prop(u'name', u'string').set_default('')
            structure.create_prop(u'topleft', u'string').set_default('')
            structure.create_prop(u'topright', u'string').set_default('')
            structure.create_prop(u'bottomleft', u'string').set_default('')
            structure.create_prop(u'bottomright', u'string').set_default('')
            structure.create_prop(u'badgecolor', u'string').set_default('')
            structure.create_prop(u'username', u'string').set_default('')
            structure.create_prop(u'product', u'text').set_default('')
            root = structure.create_root_element(u'Root')
            root.set_prop(u'name', 'Bob')
            root.set_prop(u'topleft', 'TL')
            root.set_prop(u'topright', 'TR')
            root.set_prop(u'bottomleft', 'BL')
            root.set_prop(u'bottomright', 'BR')
            root.set_prop(u'product', 'Whatever')
            # Since we're mucking with usernames, we need EDITOR_ANCESTOR
            # to exist.
            root.create_child(u'GM')
            structure.flush_database_for_test()
        except:
            db.abort_transaction()
            raise
    def tearDown(self):
        db.abort_transaction()
        from bazki import getting
        del getting.registered_getters[:]

    def test_owned_get_urls(self):
        root = structure.get_element(u'Root')
        fred = root.create_child(u'Fred')
        fred.set_prop(u'username', 'fred')
        george = root.create_child(u'George')
        george.set_prop(u'username', 'george')
        root.set_prop(u'comment', '''[[get:Root]]

<<let owner=Fred>>[[get:Root]]<</let>>

<<let owner=George>>[[get:Root]]<</let>>''')
        render(root, u'comment', 'html')
        self.assertIn('/_/Bob', render(root, u'comment', 'html'))
        self.assertIn('/fred/Bob', render(root, u'comment', 'html'))
        self.assertIn('/george/Bob', render(root, u'comment', 'html'))

    def test_arg_references(self):
        structure.create_prop(u'fish', u'references')
        root = structure.get_element(u'Root')
        page = root.create_child(u'Page')
        page.set_prop(u'name', r'Page: \1')
        root.set_prop(u'fish', '[[Page/Tree]]')
        self.assertEqual([flavors.Reference(page, [u'Tree'], root)],
                         to_python(root, u'fish'))
        root.set_prop(u'comment',
                      '<<foreach Root.fish f>><<f.name/>><</foreach>>')
        self.assertEqual(u'Page: Tree', render(root, u'comment'))
        self.assertEqual(u' * Page: Tree@</prod/193cfc9b/_/+Page/Tree>',
                         render(root, u'fish'))

    def test_arg_references2(self):
        structure.create_prop(u'fish', u'references')
        root = structure.get_element(u'Root')
        page = root.create_child(u'Page')
        page.set_prop(u'name', 'Page: <<1/>>')
        page.set_prop(u'dream', 'Name: <<leaf.name/>>')
        page.set_prop(u'substitution', '<<link Page "/" _1 />>')
        root.set_prop(u'fish', '\Page[Tree], \Page[PB&J]')
        self.assertEqual([flavors.Reference(page, [u'Tree'], root),
                          flavors.Reference(page, [u'PB&J'], root)],
                         to_python(root, u'fish'))
        root.set_prop(u'comment', '<<foreach Root.fish f>><<f.name/>><</foreach>>')
        self.assertEqual(u'Page: TreePage: PB&J', render(root, u'comment'))
        self.assertEqual(u' * Page: Tree@</prod/193cfc9b/_/+Page/Tree>\n * Page: PB&J@</prod/193cfc9b/_/+Page/PB%26J>',
                         render(root, u'fish'))

        self.assertEqual(ur'''\begin{itemize}
\item \href{/prod/193cfc9b/\_/+Page/Tree}{Page: Tree}
\item \href{/prod/193cfc9b/\_/+Page/PB\%26J}{Page: PB\&J}
\end{itemize}
''',
                         render(root, u'fish', 'tex'))
        self.assertEqual(ur'''Page: TreePage: PB\&J''',
                         render(root, u'comment', 'tex'))

        self.assertEqual('Page: Wish',
                         get.full_render(u'name', 'txt', page, u'name',
                                         {'let': {u'1': u'Wish'}}))
        self.assertEqual('Name: Page: Wish',
                         get.full_render(u'dream', 'txt', page, u'dream',
                                         {'let': {u'1': u'Wish'}}))

    def test_multi_arg_references(self):
        structure.create_prop(u'fish', u'references')
        root = structure.get_element(u'Root')
        page = root.create_child(u'Page')
        page.set_prop(u'name', 'Page: <<1/>>, not <<2/>>')
        page.set_prop(u'dream', 'Name: <<leaf.name/>>')
        page.set_prop(u'substitution', '<<link Page "/" _1 "/" _2 />>')
        root.set_prop(u'fish', '\Page[Tree][Grass], \Page[PB&J][Ham]')
        self.assertEqual([flavors.Reference(page, [u'Tree', u'Grass'], root),
                          flavors.Reference(page, [u'PB&J', u'Ham'], root)],
                         to_python(root, u'fish'))
        root.set_prop(u'comment',
                      '<<foreach Root.fish f>><<f.name/>><</foreach>>')
        self.assertEqual(u'Page: Tree, not GrassPage: PB&J, not Ham',
                         render(root, u'comment'))
        self.assertEqual(u' * Page: Tree, not Grass@</prod/193cfc9b/_/+Page/Tree/Grass>\n * Page: PB&J, not Ham@</prod/193cfc9b/_/+Page/PB%26J/Ham>',
                         render(root, u'fish'))

class TestMacros(unittest.TestCase):
    def setUp(self):
        gameki.custom.set_up()
        testing.set_up_for_tests()
        self.getter = gameki.Getter()
        self.prod_getter = gameki.ProdGetter("/prod")
        db.begin_transaction()
        try:
            structure.clear_database()
            structure.create_prop(u'product', u'text').set_default('')
            root = structure.create_root_element(u'Root')
            root.set_prop(u'product', 'Whatever')
            structure.flush_database_for_test()
        except:
            db.abort_transaction()
            raise
    def tearDown(self):
        db.abort_transaction()
        from bazki import getting
        del getting.registered_getters[:]

    def test_quotes(self):
        root = structure.get_element(u'Root')
        root.set_prop(u'product', r'''\cenquote{Foo}{Bar}
\bigquote{Baz}{Quux}

Text''')
        self.assertEquals(u'<center><i>Foo</i></center><p class="right"><i>Bar</i></p>\n\n\n<p class="noindent"><i>Baz</i></p>\n\n<p class="right"><i>Quux</i></p>\n\n<p>Text</p>', render(root, u'product', 'html'))
        self.assertEquals(ur'''\begin{thincenter}
{\em Foo}
\end{thincenter}\begin{thinright}
{\em Bar}
\end{thinright} 

\noindent{}{\em Baz}

\begin{thinright}
{\em Quux}
\end{thinright}

Text''', render(root, u'product', 'tex'))

    def test_sign(self):
        root = structure.get_element(u'Root')
        root.set_prop(u'desc', 'Desc')
        root.set_prop(u'topleft', 'A')
        root.set_prop(u'topright', 'B')
        root.set_prop(u'bottomleft', 'C')
        root.set_prop(u'bottomright', 'D')
        root.set_prop(u'key', 'key')
        root.set_prop(u'blurb', 'blurb')
        root.set_prop(u'something', '''<<sign leaf "Name" size="Big">>
  <<owner.desc />>

  To flip over, find <<owner.key/>>.

  <<flip/>>

  <<owner.desc />>

  To go on this Quest, find ""<<owner.key/>>".
<</sign>>''')
        root.set_prop(u'product', '''<<cache leaf.something owner=Root/>>''')

        self.assertEquals(u'''\\headfoot{A}{B}{C}{D}\\Sign[\\Big]{Name}{}{   Desc

  To flip over, find key.



}{Name}{

Desc

  To go on this Quest, find \u201c\u201ckey\u201d.

}{blurb}''', render(root, u'product', 'tex'))

if __name__ == "__main__":
    warnings.simplefilter("error")
    warnings.filterwarnings('ignore', "cgi.parse_qsl is deprecated")
    unittest.main()