"""

Part of the bsie test suite.
A copy of the license is provided with the project.
Author: Matthias Baumgartner, 2022
"""
# imports
import unittest

# inner-module imports
from bsie.base import errors
from bsie.utils.filematcher import matcher

# objects to test
from bsie.utils.filematcher import parse


## code ##

class TestFileMatcherParser(unittest.TestCase):
    def test_empty(self):
        # no criterion
        self.assertEqual(parse(''), matcher.Any())

    def test_ruleone(self):
        # single criterion, single value
        self.assertEqual(parse('mime=text'), matcher.Mime('text'))
        self.assertEqual(parse('MIME=text'), matcher.Mime('text'))
        self.assertEqual(parse('MiMe=text'), matcher.Mime('text'))
        self.assertEqual(parse('MIME=TEXT'), matcher.Mime('TEXT'))
        self.assertEqual(parse('mime={text}'), matcher.Mime('text'))
        self.assertEqual(parse('mime=image/jpeg'), matcher.Mime('image/jpeg'))
        self.assertEqual(parse('mime="image/jpeg"'), matcher.Mime('image/jpeg'))
        self.assertEqual(parse('extension=pdf'), matcher.Extension('pdf'))
        self.assertEqual(parse('extension={pdf}'), matcher.Extension('pdf'))
        self.assertEqual(parse('extension="pdf"'), matcher.Extension('pdf'))
        self.assertEqual(parse('extension="foo,bar"'), matcher.Extension('foo,bar'))
        self.assertEqual(parse('extension="f{oo|ba}r"'), matcher.Extension('f{oo|ba}r'))
        self.assertEqual(parse('extension=""'), matcher.Extension(''))
        self.assertEqual(parse('extension="foo'), matcher.Extension('"foo'))
        self.assertRaises(errors.ParserError, parse, 'extension=foo=bar')
        self.assertRaises(errors.ParserError, parse, 'extension=')
        self.assertRaises(errors.ParserError, parse, 'extension={}')
        self.assertRaises(errors.ParserError, parse, 'extension={foo')

        # valueless
        self.assertEqual(parse('any'), matcher.Any())
        self.assertEqual(parse('nothing'), matcher.Nothing())
        self.assertEqual(parse('exists'), matcher.Exists())
        self.assertEqual(parse('any, nothing'), matcher.And(matcher.Any(), matcher.Nothing()))
        self.assertEqual(parse('any, nothing, exists'),
            matcher.And(matcher.Any(), matcher.Nothing(), matcher.Exists()))
        self.assertEqual(parse('any, extension=jpg'), matcher.And(matcher.Any(), matcher.Extension('jpg')))
        self.assertRaises(errors.ParserError, parse, 'mime')
        self.assertRaises(errors.ParserError, parse, 'extension')
        self.assertRaises(errors.ParserError, parse, 'exists=True')
        self.assertRaises(errors.ParserError, parse, 'exists=foo')
        self.assertEqual(parse('!any'), matcher.NOT(matcher.Any()))
        self.assertEqual(parse('!any, nothing'), matcher.And(matcher.NOT(matcher.Any()), matcher.Nothing()))
        self.assertEqual(parse('!any, extension=jpg'),
            matcher.And(matcher.NOT(matcher.Any()), matcher.Extension('jpg')))
        self.assertRaises(errors.ParserError, parse, '!mime')
        self.assertRaises(errors.ParserError, parse, '!extension')

    def test_rulefew(self):
        # single criterion, multiple values
        self.assertEqual(parse('extension={jpg, jpeg}'), matcher.Extension('jpg', 'jpeg'))
        self.assertEqual(parse('mime={image/jpeg, image/png}'),
            matcher.Mime('image/jpeg', 'image/png'))
        self.assertRaises(errors.ParserError, parse, 'mime=image/png, image/jpeg')
        self.assertRaises(errors.ParserError, parse, 'extension=jpg, jpeg')

    def test_rulesets_ruleone(self):
        # mutliple criteria, single value
        self.assertEqual(parse('mime=text, extension=t'),
            matcher.And(matcher.Mime('text'), matcher.Extension('t')))
        self.assertEqual(parse('mime=text/plain, extension=t'),
            matcher.And(matcher.Mime('text/plain'), matcher.Extension('t')))
        self.assertRaises(errors.ParserError, parse, 'mime=text/plain extension=t')
        self.assertRaises(errors.ParserError, parse, 'mime={image/jpeg, extension=jpg'),

    def test_rulesets_rulefew(self):
        # multiple criteria, multiple values
        self.assertEqual(parse('mime=image/jpeg, extension={jpg, jpeg}'),
            matcher.And(matcher.Mime('image/jpeg'), matcher.Extension('jpg', 'jpeg')))
        self.assertEqual(parse('mime={image/jpeg, image/tiff}, extension={jpg, jpeg}'),
            matcher.And(matcher.Mime('image/jpeg', 'image/tiff'), matcher.Extension('jpg', 'jpeg')))
        self.assertEqual(parse('mime={image/jpeg, image/tiff}, extension=jpg'),
            matcher.And(matcher.Mime('image/jpeg', 'image/tiff'), matcher.Extension('jpg')))
        self.assertRaises(errors.ParserError, parse, 'mime={image/jpeg, image/tiff, extension=jpg')
        self.assertRaises(errors.ParserError, parse, 'mime=image/jpeg, image/tiff, extension=jpg')
        self.assertRaises(errors.ParserError, parse, 'mime=image/jpeg, extension=jpg, ')

    def test_not(self):
        self.assertEqual(parse('extension!=jpg'), matcher.NOT(matcher.Extension('jpg')))
        self.assertEqual(parse('extension!={jpg, jpeg}'),
            matcher.NOT(matcher.Extension('jpg', 'jpeg')))
        self.assertEqual(parse('extension!=jpg, mime=image/jpeg'),
            matcher.And(matcher.NOT(matcher.Extension('jpg')), matcher.Mime('image/jpeg')))
        self.assertEqual(parse('extension!=jpg, mime!=image/jpeg'),
            matcher.And(matcher.NOT(matcher.Extension('jpg')), matcher.NOT(matcher.Mime('image/jpeg'))))
        self.assertEqual(parse('extension!=jpg | mime=image/jpeg'),
            matcher.Or(matcher.NOT(matcher.Extension('jpg')), matcher.Mime('image/jpeg')))
        self.assertEqual(parse('extension!=jpg | mime!=image/jpeg'),
            matcher.Or(matcher.NOT(matcher.Extension('jpg')), matcher.NOT(matcher.Mime('image/jpeg'))))

    def test_expr(self):
        # multiple rulesets
        self.assertEqual(parse('mime=image/jpeg | extension=jpg'),
            matcher.Or(matcher.Mime('image/jpeg'), matcher.Extension('jpg')))
        self.assertEqual(parse('mime=image/jpeg | extension={jpg, jpeg}'),
            matcher.Or(matcher.Mime('image/jpeg'), matcher.Extension('jpg', 'jpeg')))
        self.assertEqual(parse('mime={image/jpeg, image/png} | extension={jpg, jpeg}'),
            matcher.Or(matcher.Mime('image/jpeg', 'image/png'), matcher.Extension('jpg', 'jpeg')))
        self.assertEqual(parse('mime=image/jpeg , extension=jpg | extension=jpg'),
            matcher.Or(matcher.And(matcher.Mime('image/jpeg'), matcher.Extension('jpg')), matcher.Extension('jpg')))
        self.assertEqual(parse(
            'mime={jpeg, text}, extension={jpg,t} | extension={png,txt}, mime={png, tiff}'),
            matcher.Or(
                matcher.And(matcher.Mime('jpeg', 'text'), matcher.Extension('jpg', 't')),
                matcher.And(matcher.Extension('png', 'txt'), matcher.Mime('png', 'tiff'))))
        self.assertEqual(parse('mime=text | extension=jpg | extension=png | mime=png'),
            matcher.Or(matcher.Mime('text'), matcher.Extension('jpg'), matcher.Extension('png'), matcher.Mime('png')))
        self.assertRaises(errors.ParserError, parse, 'mime=text |')
        self.assertRaises(errors.ParserError, parse, '| mime=text')
        self.assertRaises(errors.ParserError, parse, 'extension=png | mime=text, ')

    def test_invalid(self):
        # Invalid parses
        self.assertRaises(errors.ParserError, parse, "extension=") # Empty value
        self.assertRaises(errors.ParserError, parse, "mime=foo,bar") # Escaping
        self.assertRaises(errors.ParserError, parse, "mime='foo,bar") # Quoting
        self.assertRaises(errors.ParserError, parse, "mime=\"foo,bar") # Quoting

        # Invalid input
        self.assertRaises(AttributeError, parse, None)
        self.assertRaises(AttributeError, parse, 123)
        self.assertRaises(AttributeError, parse, [123,321])


## main ##

if __name__ == '__main__':
    unittest.main()

## EOF ##