# 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 unittest

import dimbola


class GridDimensionsTests(unittest.TestCase):

    def setUp(self):
        self.model = dimbola.GridModel()
        self.model.scale_value = 10
        self.model.widget_width = 100
        self.model.widget_height = 100
        self.cell_dim = self.model.scale_value + self.model.padding
        self.per_row = self.model.widget_width / self.cell_dim

    def test_sets_padding_by_default(self):
        self.assert_(self.model.padding > 0)
        
    def test_computes_vertical_pixels_correctly_for_no_photos(self):
        self.assertEqual(self.model.vertical_pixels, 0)
        
    def test_computes_vertical_pixels_correctly_for_one_photo(self):
        self.model.photoids = [1]
        self.assertEqual(self.model.vertical_pixels, self.cell_dim)
        
    def test_computes_vertical_pixels_correctly_for_one_row(self):
        self.model.photoids = range(self.per_row)
        self.assertEqual(self.model.vertical_pixels, self.cell_dim)
        
    def test_computes_vertical_pixels_correctly_for_two_rows(self):
        self.model.photoids = range(1 + self.per_row)
        self.assertEqual(self.model.vertical_pixels, self.cell_dim * 2)

    def test_computes_vertical_pixels_correctly_for_lots_of_rows(self):
        self.model.photoids = range(self.per_row * 100**2)
        self.assertEqual(self.model.vertical_pixels, self.cell_dim * 100**2)


class GridModelTests(unittest.TestCase):

    def setUp(self):
        self.model = dimbola.GridModel()
    
    def fake_emit(self, *args):
        self.emit_args = args
        
    def test_has_empty_list_of_photoids_initially(self):
        self.assertEqual(self.model.photoids, [])

    def test_sets_photoids_correctly(self):
        self.model.photoids = [1, 2, 3]
        self.assertEqual(self.model.photoids, [1, 2, 3])
        
    def test_photoids_changed_emits_signals(self):
        self.model.emit = self.fake_emit
        self.model.photoids_changed()
        self.assertEqual(self.emit_args, ('photoids-changed',))

    def test_setting_photoids_emits_signal(self):
        self.model.emit = self.fake_emit
        self.model.photoids = [1]
        self.assertEqual(self.emit_args, ('photoids-changed',))
        
    def test_has_empty_list_of_selected_initially(self):
        self.assertEqual(self.model.selected, [])

    def test_selecting_unknown_photoids_raises_exception(self):
        self.assertRaises(AssertionError, self.model.set_selected, [1, 2, 3])

    def test_sets_selected_correctly(self):
        self.model.photoids = [1, 2, 3]
        self.model.selected = [1, 2, 3]
        self.assertEqual(self.model.selected, [1, 2, 3])
        
    def test_selection_changed_emits_signals(self):
        self.model.emit = self.fake_emit
        self.model.selection_changed()
        self.assertEqual(self.emit_args, ('selection-changed',))

    def test_setting_selection_emits_signal(self):
        self.model.emit = self.fake_emit
        self.model.photoids = [1, 2, 3]
        self.model.selected = [1]
        self.assertEqual(self.emit_args, ('selection-changed',))

    def test_setting_photoids_removes_selection(self):
        self.model.photoids = [1]
        self.model.selected = [1]
        self.model.photoids = [2]
        self.assertEqual(self.model.selected, [])

    def test_setting_photoids_clears_angles(self):
        self.model.photoids = [1]
        self.model.angles[1] = 180
        self.model.photoids = [1]
        self.assert_(1 not in self.model.angles)

    def test_setting_photoids_clears_thumbnails(self):
        self.model.photoids = [1]
        self.model.thumbnails[1] = 'mock thumbnail'
        self.model.photoids = [1]
        self.assert_(1 not in self.model.thumbnails)
        
    def test_sets_thumbnail(self):
        self.model.photoids = [1]
        self.model.set_thumbnail(1, 'mock thumbnail')
        self.assertEqual(self.model.thumbnails[1], 'mock thumbnail')
        
    def test_setting_thumbnail_for_nonexistent_photo_raises_exception(self):
        self.assertRaises(AssertionError, self.model.set_thumbnail, 1, '')
        
    def test_setting_thumbnail_emits_signal(self):
        self.model.emit = self.fake_emit
        self.model.photoids = [1]
        self.model.set_thumbnail(1, 'mock thumbnail')
        self.assertEqual(self.emit_args, ('photoids-changed',))
        
    def test_sets_angle(self):
        self.model.photoids = [1]
        self.model.set_angle(1, 90)
        self.assertEqual(self.model.angles[1], 90)
        
    def test_setting_angle_for_nonexistent_photo_raises_exception(self):
        self.assertRaises(AssertionError, self.model.set_angle, 1, 90)
        
    def test_setting_angle_emits_signal(self):
        self.model.emit = self.fake_emit
        self.model.photoids = [1]
        self.model.set_angle(1, 90)
        self.assertEqual(self.emit_args, ('photoids-changed',))


class ThumbnailPosTests(unittest.TestCase):

    def setUp(self):
        self.model = dimbola.GridModel()
        self.model.photoids = range(10)
        self.model.widget_width = 100
        self.model.padding = 10
        self.model.scale_value = 20
        self.cell_dim = self.model.padding + self.model.scale_value
        self.per_row = self.model.widget_width / self.cell_dim

    def test_computes_xy_of_zeroth_photo_correctly(self):
        self.assertEqual(self.model.thumbnail_pos(0), (0, 0))

    def test_computes_xy_of_last_photo_on_first_row_correctly(self):
        self.assertEqual(self.model.thumbnail_pos(self.per_row - 1), 
                         ((self.per_row - 1) * self.cell_dim, 0))

    def test_computes_xy_of_first_photo_on_second_row_correctly(self):
        self.assertEqual(self.model.thumbnail_pos(self.per_row), 
                         (0, self.cell_dim))

    def test_computes_xy_of_last_photo_row_correctly(self):
        i = len(self.model.photoids) - 1
        row = i / self.per_row
        col = i % self.per_row
        self.assertEqual(self.model.thumbnail_pos(i), 
                         (col * self.cell_dim, row * self.cell_dim))


class GridModelSelectionTests(unittest.TestCase):

    def setUp(self):
        self.model = dimbola.GridModel()
        self.model.photoids = [1, 2, 3]

    def test_select_next_selects_first_photo_if_nothing_selected(self):
        self.model.select_next()
        self.assertEqual(self.model.selected, [1])

    def test_select_next_selects_next_photo_if_something_is_selected(self):
        self.model.selected = [1, 2]
        self.model.select_next()
        self.assertEqual(self.model.selected, [2])

    def test_select_previous_selects_first_photo_if_nothing_selected(self):
        self.model.select_previous()
        self.assertEqual(self.model.selected, [1])

    def test_select_previous_selects_previous_if_something_is_selected(self):
        self.model.selected = [2, 3]
        self.model.select_previous()
        self.assertEqual(self.model.selected, [1])