# Copyright (C) 2009  Lars Wirzenius <liw@liw.fi>
# 
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
# 
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
# 
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.


import os
import shutil
import tempfile
import unittest

import gtk

import dimbola


class AbswalkTests(unittest.TestCase):

    def setUp(self):
        self.root = tempfile.mkdtemp()
        self.dirname = tempfile.mkdtemp(dir=self.root)
        fd, self.filename = tempfile.mkstemp(dir=self.root)
        os.close(fd)
    
    def tearDown(self):
        shutil.rmtree(self.root)

    def test_returns_full_paths(self):
        results = list(dimbola.abswalk(self.root))
        self.assertEqual(results, 
                         [(self.root, [self.dirname], [self.filename]),
                          (self.dirname, [], [])])


class FilterAbswalkTests(unittest.TestCase):

    def setUp(self):
        self.root = tempfile.mkdtemp()
        self.dirname = tempfile.mkdtemp(dir=self.root)
        fd, self.filename = tempfile.mkstemp(dir=self.root)
        os.close(fd)
    
    def tearDown(self):
        shutil.rmtree(self.root)

    def test_returns_everything_if_is_ok_always_returns_true(self):
        results = list(dimbola.filterabswalk(lambda x: True, self.root))
        self.assertEqual(results, 
                         [(self.root, [self.dirname], [self.filename]),
                          (self.dirname, [], [])])

    def test_returns_nothing_if_is_ok_always_returns_false(self):
        results = list(dimbola.filterabswalk(lambda x: False, self.root))
        self.assertEqual(results, 
                         [(self.root, [self.dirname], []),
                          (self.dirname, [], [])])


class SafeCopyTests(unittest.TestCase):

    def setUp(self):
        self.root = tempfile.mkdtemp()
        
    def tearDown(self):
        shutil.rmtree(self.root)

    def make_file(self, contents):
        fd, name = tempfile.mkstemp(dir=self.root)
        os.write(fd, contents)
        os.close(fd)
        return name

    def cat(self, filename):
        return file(filename).read()

    def callback(self, *args):
        self.callback_args = args

    def test_copies_file_correctly(self):
        old = self.make_file('foobar')
        new = self.make_file('')
        os.remove(new)
        dimbola.safe_copy(old, new, self.callback)
        self.assertEqual(self.cat(new), 'foobar')
        self.assertEqual(self.callback_args, (old, new, len('foobar')))

    def test_fails_if_output_file_already_exists(self):
        name = self.make_file('foobar')
        self.assertRaises(Exception, dimbola.safe_copy, name, name, None)


class FilterCmdTests(unittest.TestCase):

    def test_raises_exception_for_nonexistent_command(self):
        self.assertRaises(Exception, dimbola.filter_cmd,
                          ['this-command-does-not-exist'], '')

    def test_raises_exception_for_failing_command(self):
        self.assertRaises(Exception, dimbola.filter_cmd, ['false'], '')

    def test_filters_cleanly_through_cat(self):
        self.assertEqual(dimbola.filter_cmd(['cat'], 'foo'), 'foo')

    def test_filters_a_lot_of_data_cleanly_through_cat(self):
        data = 'x' * (1024**2)
        self.assertEqual(dimbola.filter_cmd(['cat'], data), data)


class ImageDataToPixbufTests(unittest.TestCase):

    def test_makes_pixbuf_out_of_jpeg(self):
        jpeg = file('test-plugins/test.jpg').read()
        pixbuf = dimbola.image_data_to_pixbuf(jpeg)
        self.assert_(isinstance(pixbuf, gtk.gdk.Pixbuf))


class ScalePixbufTests(unittest.TestCase):

    def setUp(self):
        jpeg = file('test-plugins/test.jpg').read()
        self.pixbuf = dimbola.image_data_to_pixbuf(jpeg)
        self.small = dimbola.scale_pixbuf(self.pixbuf, 100, 100)

    def test_width_is_correct(self):
        self.assertEqual(self.small.get_width(), 100)
        
    def test_height_is_correct(self):
        w = self.pixbuf.get_width()
        h = self.pixbuf.get_height()
        sh = int(100 * float(h)/w)
        self.assertEqual(self.small.get_height(), sh)


class RotatePixbufTests(unittest.TestCase):

    def setUp(self):
        jpeg = file('test-plugins/test.jpg').read()
        self.pixbuf = dimbola.image_data_to_pixbuf(jpeg)

    def test_rotates_left_and_back_to_original(self):
        temp = dimbola.rotate_pixbuf(self.pixbuf, 180)
        temp2 = dimbola.rotate_pixbuf(temp, 180)
        self.assertEqual(self.pixbuf.get_pixels(), temp2.get_pixels())


class DndTagidsTests(unittest.TestCase):

    def setUp(self):
        self.tagids = [1, 2, 3]
        
    def test_round_trip_works(self):
        encoded = dimbola.encode_dnd_tagids(self.tagids)
        decoded = dimbola.decode_dnd_tagids(encoded)
        self.assertEqual(self.tagids, decoded)


class TreeBuilderTests(unittest.TestCase):

    def setUp(self):
        self.tb = dimbola.TreeBuilder()
    
    def test_returns_empty_tree_by_default(self):
        self.tb.done()
        self.assertEqual(self.tb.tree, [])
        
    def test_returns_single_node_when_only_one_item(self):
        self.tb.add('node', 'data', 'sortkey', None)
        self.tb.done()
        self.assertEqual(self.tb.tree, [('node', 'data', [])])
        
    def test_returns_two_root_nodes_when_no_children(self):
        self.tb.add('node1', 'data1', None, None)
        self.tb.add('node2', 'data2', None, None)
        self.tb.done()
        self.assertEqual(self.tb.tree, 
                         [('node1', 'data1', []),
                          ('node2', 'data2', [])])
        
    def test_returns_children_nodes_when_there_is_one(self):
        self.tb.add('child', 'data3', None, 'node1')
        self.tb.add('node1', 'data1', None, None)
        self.tb.add('node2', 'data2', None, None)
        self.tb.done()
        self.assertEqual(self.tb.tree, 
                         [('node1', 'data1', [('child', 'data3', [])]),
                          ('node2', 'data2', [])])

    def test_sorts_children_with_same_parent(self):
        self.tb.add('parent', 'data', None, None)
        self.tb.add('foo', 'data1', 'key2', 'parent')
        self.tb.add('bar', 'data2', 'key1', 'parent')
        self.tb.done()
        self.assertEqual(self.tb.tree,
                         [('parent', 'data',
                            [('bar', 'data2', []),
                             ('foo', 'data1', [])])])

    def test_sorts_roots(self):
        self.tb.add('foo', 'data1', 'key2', None)
        self.tb.add('bar', 'data2', 'key1', None)
        self.tb.done()
        self.assertEqual(self.tb.tree,
                         [('bar', 'data2', []),
                          ('foo', 'data1', [])])


class DcrawTypeCacheTests(unittest.TestCase):

    def setUp(self):
        self.dtc = dimbola.DcrawTypeCache()
        self.dtc.get_mime_type = self.fake_get_mime_type
        self.dtc.get_dcraw = self.fake_get_dcraw
        self.fake_get_mime_type_called = False
        self.fake_get_dcraw_called = False

    def fake_get_mime_type(self, filename):
        self.fake_get_mime_type_called = True
        return 'mime/type'

    def fake_get_dcraw(self, filename):
        self.fake_get_dcraw_called = True
        return 'desc'

    def fake_get_dcraw_fail(self, filename):
        self.fake_get_dcraw_called = True
        return None
        
    def test_lists_nothing_by_default(self):
        self.assertEqual(self.dtc.formats, [])
        
    def test_adding_format_lists_it(self):
        self.dtc.add_format('name', 'mime/type', 'ext')
        self.assertEqual(self.dtc.formats, 
                         [{ 'name': 'name', 
                            'mime_types': ['mime/type'],
                            'extensions': ['ext', 'EXT'],
                         }])
  
    def test_adding_format_with_same_name_does_not_add_it(self):
        self.dtc.add_format('name', 'mime/type', 'ext')
        self.dtc.add_format('name', 'mime/type', 'ext')
        self.assertEqual(len(self.dtc.formats), 1)
  
    def test_adding_with_same_name_new_mime_type_modifies_existing(self):
        self.dtc.add_format('name', 'mime/type', 'ext')
        self.dtc.add_format('name', 'mime/type2', 'ext2')
        self.assertEqual(self.dtc.formats, 
                         [{ 'name': 'name', 
                            'mime_types': ['mime/type', 'mime/type2'],
                            'extensions': ['ext', 'EXT', 'ext2', 'EXT2'],
                         }])
  
    def test_adding_with_diff_name_same_mime_type_modifies_existing(self):
        self.dtc.add_format('name', 'mime/type', 'ext')
        self.dtc.add_format('name2', 'mime/type', 'ext2')
        self.assertEqual(self.dtc.formats, 
                         [{ 'name': 'name', 
                            'mime_types': ['mime/type'],
                            'extensions': ['ext', 'EXT', 'ext2', 'EXT2'],
                         }])
  
    def test_adding_with_same_extension_modifies_existing(self):
        self.dtc.add_format('name', 'mime/type', 'ext')
        self.dtc.add_format('name2', 'mime/type2', 'ext')
        self.assertEqual(self.dtc.formats, 
                         [{ 'name': 'name', 
                            'mime_types': ['mime/type', 'mime/type2'],
                            'extensions': ['ext', 'EXT'],
                         }])

    def test_known_extension_is_known(self):
        self.dtc.add_format('name', 'mime/type', 'ext')
        self.assert_(self.dtc.extension_is_known('ext'))

    def test_unknown_extension_is_unknown(self):
        self.dtc.add_format('name', 'mime/type', 'ext')
        self.assertFalse(self.dtc.extension_is_known('ext2'))

    def test_known_mime_type_is_known(self):
        self.dtc.add_format('name', 'mime/type', 'ext')
        self.assert_(self.dtc.mime_type_is_known('mime/type'))

    def test_unknown_mime_type_is_unknown(self):
        self.dtc.add_format('name', 'mime/type', 'ext')
        self.assertFalse(self.dtc.extension_is_known('mime/type2'))

    def test_recognizes_jpeg_mime_type(self):
        dtc = dimbola.DcrawTypeCache()
        self.assertEqual(dtc.get_mime_type('test-plugins/test.jpg'),
                         'image/jpeg')

    def test_recognizes_raw_file_type(self):
        dtc = dimbola.DcrawTypeCache()
        self.assertEqual(dtc.get_dcraw('test-plugins/test.cr2'),
                         'Canon EOS 5D')

    def test_dcraw_returns_None_for_unknown_filetype(self):
        dtc = dimbola.DcrawTypeCache()
        self.assertEqual(dtc.get_dcraw('README'), None)
  
    def test_recognizes_existing_format_based_on_mime_type(self):
        self.dtc.add_from_file('filename.ext')
        self.fake_get_mime_type_called = False
        self.fake_get_dcraw_called = False
        self.dtc.add_from_file('filename.ext2')
        self.assertFalse(self.fake_get_dcraw_called)
        self.assert_(self.fake_get_mime_type_called)
  
    def test_recognizes_existing_format_based_on_extension(self):
        self.dtc.add_from_file('filename.ext')
        self.fake_get_mime_type_called = False
        self.fake_get_dcraw_called = False
        self.dtc.add_from_file('filename.ext')
        self.assertFalse(self.fake_get_mime_type_called)
        self.assertFalse(self.fake_get_dcraw_called)

    def test_does_not_add_unrecognized_format(self):
        self.dtc.get_dcraw = self.fake_get_dcraw_fail
        self.dtc.add_from_file('filename.ext')
        self.assertEqual(self.dtc.formats, [])
  
    def test_adds_format_from_file_with_dcraw(self):
        self.dtc.add_from_file('filename.ext')
        self.assertEqual(self.dtc.formats, 
                         [{ 'name': 'ext', 
                            'mime_types': ['mime/type'],
                            'extensions': ['ext', 'EXT'],
                         }])

    def test_does_not_test_twice_for_unknown_type_with_same_ext(self):
        self.dtc.get_dcraw = self.fake_get_dcraw_fail
        self.dtc.add_from_file('filename.ext')
        self.fake_get_mime_type_called = False
        self.fake_get_dcraw_called = False
        self.dtc.add_from_file('filename.ext')
        self.assertFalse(self.fake_get_mime_type_called)
        self.assertFalse(self.fake_get_dcraw_called)

    def test_does_not_test_twice_for_unknown_type_with_same_mime(self):
        self.dtc.get_dcraw = self.fake_get_dcraw_fail
        self.dtc.add_from_file('filename.ext')
        self.fake_get_mime_type_called = False
        self.fake_get_dcraw_called = False
        self.dtc.add_from_file('filename.ext2')
        self.assertFalse(self.fake_get_dcraw_called)

    def test_supported_returns_false_for_unsupported_file(self):
        self.dtc.get_dcraw = self.fake_get_dcraw_fail
        self.assertFalse(self.dtc.supported('filename.ext'))

    def test_supported_returns_true_for_unsupported_file(self):
        self.assert_(self.dtc.supported('filename.ext'))