# standard imports
import os
import stat
import tempfile
import unittest

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


## code ##

class FakeMatcher(matcher.Matcher):
    def __call__(self, *args, **kwargs):
        pass

class FakeCriterion(matcher.Criterion):
    def __call__(self, *args, **kwargs):
        pass

class FakeAggregate(matcher.Aggregate):
    def __call__(self, *args, **kwargs):
        pass

class TestMatcher(unittest.TestCase):
    def setUp(self):
        # paths
        self.image = os.path.join(os.path.dirname(__file__), 'testimage.jpg')
        self.text= os.path.join(os.path.dirname(__file__), 'textfile.t')
        self.empty = os.path.join(os.path.dirname(__file__), 'empty')
        self.missing = os.path.join(os.path.dirname(__file__), 'missing.jpg')

    def test_matcher_skeleton(self):
        # node: iteration and length
        self.assertSetEqual(set(iter(FakeMatcher(1,2,3))), {1,2,3})
        self.assertSetEqual(set(iter(FakeMatcher([1,2,3]))), {1,2,3})
        self.assertEqual(len(FakeMatcher([1,2,3])), 3)
        self.assertEqual(len(FakeMatcher(1,2,3)), 3)
        self.assertEqual(len(FakeMatcher()), 0)
        self.assertIn(1, FakeMatcher(1,2,3))
        self.assertIn(3, FakeMatcher([1,2,3]))
        self.assertNotIn(0, FakeMatcher(1,2,3))
        self.assertNotIn(4, FakeMatcher([1,2,3]))
        # node: comparison
        self.assertEqual(FakeMatcher([1,2,3]), FakeMatcher([1,2,3]))
        self.assertEqual(FakeMatcher(1,2,3), FakeMatcher(1,2,3))
        self.assertEqual(FakeMatcher(1,2,3), FakeMatcher([1,2,3]))
        self.assertEqual(FakeMatcher(1,2,3), FakeMatcher((1,2,3)))
        self.assertNotEqual(FakeMatcher(1,2,3), FakeMatcher(1,2,4))
        self.assertNotEqual(FakeMatcher(1,2,3), FakeMatcher(1,2,3,4))
        self.assertNotEqual(FakeMatcher(1,2,3), FakeMatcher(1,2))
        self.assertEqual(hash(FakeMatcher([1,2,3])), hash(FakeMatcher([1,2,3])))
        self.assertEqual(hash(FakeMatcher(1,2,3)), hash(FakeMatcher(1,2,3)))
        self.assertEqual(hash(FakeMatcher(1,2,3)), hash(FakeMatcher([1,2,3])))
        self.assertEqual(hash(FakeMatcher(1,2,3)), hash(FakeMatcher((1,2,3))))
        # node: representation
        self.assertEqual(repr(FakeMatcher(1,2,3)), 'FakeMatcher({1, 2, 3})')

        # criterion
        self.assertEqual(repr(FakeCriterion(1,2,3)), 'FakeCriterion({1, 2, 3})')
        self.assertEqual(hash(FakeCriterion(1,2,3)), hash(FakeCriterion(1,2,3)))
        self.assertEqual(FakeCriterion(1,2,3), FakeCriterion([1,2,3]))
        self.assertNotEqual(FakeCriterion(1,2,3), FakeCriterion(1,2))
        self.assertNotEqual(FakeCriterion(1,2,3), FakeMatcher(1,2,3))
        self.assertSetEqual(FakeCriterion(1,2,3).accepted(), {1,2,3})

        # aggregate
        self.assertEqual(repr(FakeAggregate(1,2,3)), 'FakeAggregate({1, 2, 3})')
        self.assertNotEqual(FakeAggregate(1,2,3), FakeMatcher(1,2,3))

    def test_any(self):
        self.assertTrue(matcher.Any()(self.image))
        self.assertTrue(matcher.Any()(self.text))
        self.assertTrue(matcher.Any()(self.missing))
        self.assertTrue(matcher.Any()(self.empty))

    def test_nothing(self):
        self.assertFalse(matcher.Nothing()(self.image))
        self.assertFalse(matcher.Nothing()(self.text))
        self.assertFalse(matcher.Nothing()(self.missing))
        self.assertFalse(matcher.Nothing()(self.empty))

    def test_exists(self):
        self.assertTrue(matcher.Exists()(self.image))
        self.assertTrue(matcher.Exists()(self.text))
        self.assertTrue(matcher.Exists()(self.empty))
        self.assertFalse(matcher.Exists()(self.missing))

    def test_isfile(self):
        self.assertTrue(matcher.IsFile()(self.image))
        self.assertTrue(matcher.IsFile()(self.text))
        self.assertFalse(matcher.IsFile()(self.missing))
        self.assertFalse(matcher.IsFile()(os.path.dirname(self.image)))

    def test_isdir(self):
        self.assertTrue(matcher.IsDir()(os.path.dirname(self.image)))
        self.assertFalse(matcher.IsDir()(self.image))
        self.assertFalse(matcher.IsDir()(self.text))
        self.assertFalse(matcher.IsDir()(self.missing))

    def test_islink(self):
        self.assertFalse(matcher.IsLink()(os.path.dirname(self.image)))
        self.assertFalse(matcher.IsLink()(self.image))
        self.assertFalse(matcher.IsLink()(self.text))
        _, temp = tempfile.mkstemp(prefix='bsie-test-')
        templink = temp + '-link'
        os.symlink(temp, templink)
        self.assertTrue(matcher.IsLink()(templink))
        os.unlink(templink)
        os.unlink(temp)

    def test_isabs(self):
        self.assertTrue(matcher.IsAbs()(os.path.abspath(self.image)))
        self.assertTrue(matcher.IsAbs()(os.path.abspath(self.text)))
        self.assertFalse(matcher.IsAbs()(os.path.relpath(self.text, os.path.dirname(self.text))))

    def test_isrel(self):
        self.assertFalse(matcher.IsRel()(os.path.abspath(self.image)))
        self.assertFalse(matcher.IsRel()(os.path.abspath(self.text)))
        self.assertTrue(matcher.IsRel()(os.path.relpath(self.text, os.path.dirname(self.text))))
        self.assertTrue(matcher.IsRel()(os.path.basename(self.text)))

    def test_ismount(self):
        self.assertFalse(matcher.IsMount()(self.image))
        self.assertFalse(matcher.IsMount()(self.text))
        self.assertFalse(matcher.IsMount()(self.missing))
        # there's no reasonable way to test a positive case

    def test_isempty(self):
        self.assertTrue(matcher.IsEmpty()(self.empty))
        self.assertFalse(matcher.IsEmpty()(self.image))
        self.assertFalse(matcher.IsEmpty()(self.text))
        self.assertFalse(matcher.IsEmpty()(self.missing))

    def test_isreadable(self):
        self.assertTrue(matcher.IsReadable()(self.empty))
        self.assertTrue(matcher.IsReadable()(self.image))
        self.assertFalse(matcher.IsReadable()(self.missing))
        _, temp = tempfile.mkstemp(prefix='bsie-test-')
        os.chmod(temp, 0)
        self.assertFalse(matcher.IsReadable()(temp))
        os.unlink(temp)

    def test_iswritable(self):
        self.assertTrue(matcher.IsWritable()(self.empty))
        self.assertTrue(matcher.IsWritable()(self.image))
        self.assertFalse(matcher.IsWritable()(self.missing))
        _, temp = tempfile.mkstemp(prefix='bsie-test-')
        os.chmod(temp, 0)
        self.assertFalse(matcher.IsWritable()(temp))
        os.unlink(temp)

    def test_isexecutable(self):
        self.assertFalse(matcher.IsExecutable()(self.empty))
        self.assertFalse(matcher.IsExecutable()(self.image))
        self.assertFalse(matcher.IsExecutable()(self.missing))
        _, temp = tempfile.mkstemp(prefix='bsie-test-')
        os.chmod(temp, stat.S_IEXEC)
        self.assertTrue(matcher.IsExecutable()(temp))
        os.unlink(temp)

    def test_extension(self):
        self.assertTrue(matcher.Extension('jpg')(self.image))
        self.assertTrue(matcher.Extension('jpg', 'png')(self.image))
        self.assertTrue(matcher.Extension('jpg', 't')(self.text))
        self.assertTrue(matcher.Extension('jpg', 'png', 't')(self.missing))
        self.assertTrue(matcher.Extension('')(self.empty))

        self.assertFalse(matcher.Extension()(self.image))
        self.assertFalse(matcher.Extension('jpeg')(self.image))
        self.assertFalse(matcher.Extension('.t')(self.text))
        self.assertFalse(matcher.Extension('png', 't')(self.missing))
        self.assertFalse(matcher.Extension('tiff')(self.empty))

    def test_mime(self):
        self.assertTrue(matcher.Mime('image/jpeg')(self.image))
        self.assertTrue(matcher.Mime('image/tiff', 'image/jpeg')(self.image))
        self.assertTrue(matcher.Mime('text/plain', 'image/jpeg')(self.text))
        self.assertTrue(matcher.Mime('inode/x-empty')(self.empty))

        self.assertFalse(matcher.Mime()(self.image))
        self.assertFalse(matcher.Mime('image')(self.image))
        self.assertFalse(matcher.Mime('image/tiff', 'image/png')(self.image))
        self.assertFalse(matcher.Mime('')(self.text))
        self.assertFalse(matcher.Mime('text')(self.text))
        self.assertFalse(matcher.Mime('tiff')(self.empty))
        self.assertFalse(matcher.Mime()(self.empty))
        self.assertFalse(matcher.Mime('')(self.empty))
        self.assertFalse(matcher.Mime()(self.missing))
        self.assertFalse(matcher.Mime('')(self.missing))
        self.assertFalse(matcher.Mime('inode/x-empty')(self.missing))

    def test_not(self):
        self.assertFalse(matcher.NOT(matcher.Mime('image/jpeg'))(self.image))
        self.assertTrue(matcher.NOT(matcher.Mime('text/plain'))(self.image))

    def test_and(self):
        self.assertTrue(matcher.And(matcher.Mime('image/jpeg'), matcher.Extension('jpg'))(self.image))
        self.assertTrue(matcher.And(matcher.Mime('image/jpeg'), matcher.Extension('jpg', 'tiff'))(self.image))
        self.assertTrue(matcher.And(matcher.Mime('text/plain'), matcher.Extension('t', 'tiff'))(self.text))

        self.assertFalse(matcher.And(matcher.Mime('image/jpeg'), matcher.Extension('tiff'))(self.image))
        self.assertFalse(matcher.And(matcher.Mime('text/plain'), matcher.Extension('jpg'))(self.image))
        self.assertFalse(matcher.And(matcher.Mime('inode/x-empty'), matcher.Extension('jpg'))(self.missing))
        self.assertFalse(matcher.And(matcher.Mime('image/jpeg'), matcher.Extension('jpg', 't'))(self.text))

    def test_or(self):
        self.assertTrue(matcher.Or(matcher.Mime('image/jpeg'))(self.image))
        self.assertFalse(matcher.Or(matcher.Mime('text/plain'))(self.image))

        self.assertTrue(matcher.Or(matcher.Mime('image/jpeg'), matcher.Extension('jpg'))(self.image))
        self.assertTrue(matcher.Or(matcher.Mime('image/jpeg'), matcher.Extension('t'))(self.image))
        self.assertTrue(matcher.Or(matcher.Mime('text/plain'), matcher.Extension('jpg', 'tiff'))(self.image))
        self.assertTrue(matcher.Or(matcher.Mime('text/plain'), matcher.Extension('tiff'))(self.text))
        self.assertTrue(matcher.Or(matcher.Mime('image/jpeg'), matcher.Extension('jpg'))(self.missing))

        self.assertFalse(matcher.Or(matcher.Mime('text/plain'), matcher.Extension('tiff'))(self.image))
        self.assertFalse(matcher.Or(matcher.Mime('inode/x-empty'), matcher.Extension('jpg', 'tiff'))(self.text))


## main ##

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

## EOF ##