# -*- coding: utf8 -*-
#
# libcaca            Colour ASCII Art library
#                    Python language bindings
# Copyright (c) 2012 Alex Foulon <alxf@lavabit.com>
#                    All Rights Reserved
#
# This program is free software. It comes without any warranty, to
# the extent permitted by applicable law. You can redistribute it
# and/or modify it under the terms of the Do What the Fuck You Want
# to Public License, Version 2, as published by Sam Hocevar. See
# http://www.wtfpl.net/ for more details.
#

""" Libcaca canvas test suite """

import unittest

from caca.canvas import Canvas, CanvasError

class CanvasTestCase(unittest.TestCase):
    """ Class to test canvas functions.
    """
    def test_create(self):
        """ module canvas: Canvas.__init__()
        """
        self.assertTrue(isinstance(Canvas(), Canvas))
        self.assertTrue(isinstance(Canvas(10, 10), Canvas))
        self.assertRaises(CanvasError, Canvas, "a", 12)
        self.assertRaises(CanvasError, Canvas, 12, "a")

    def test_get_width(self):
        """ module canvas: Canvas.get_width()
        """
        cv = Canvas(5, 10)
        self.assertEqual(5, cv.get_width())

    def test_get_height(self):
        """ module canvas: Canvas.get_width()
        """
        cv = Canvas(5, 10)
        self.assertEqual(10, cv.get_height())

    def test_set_size(self):
        """ module canvas: Canvas.set_size()
        """
        cv = Canvas(0, 0)
        cv.set_size(1234, 1001)

        self.assertEqual((1234, 1001), (cv.get_width(), cv.get_height()))
        self.assertRaises(CanvasError, cv.set_size, "a", 12)
        self.assertRaises(CanvasError, cv.set_size, 12, "a")

    def test_get_char(self):
        """ module canvas: Canvas.get_char()
        """
        cv = Canvas(1, 1)
        self.assertEqual(" ", cv.get_char(0, 0))

    def test_put_char(self):
        """ module canvas: Canvas.put_char()
        """
        cv = Canvas(10, 1)
        self.assertEqual(1, cv.put_char(0, 0, "z"))
        self.assertEqual(1, cv.put_char(1, 0, "é"))
        self.assertEqual("z", cv.get_char(0, 0))
        self.assertEqual("é", cv.get_char(1, 0))
        self.assertRaises(CanvasError, cv.put_char, "a", 1, 2)
        self.assertRaises(CanvasError, cv.put_char, "a", 1, "b")

    def test_put_str(self):
        """ module canvas: Canvas.put_str()
        """
        cv = Canvas(10, 1)
        self.assertEqual(10, cv.put_str(0, 0, "teststring"))
        liststring = []
        for i in range(0, 10):
            liststring.append(cv.get_char(i, 0))

        self.assertEqual("teststring", "".join(liststring))
        self.assertRaises(CanvasError, cv.put_str, 0, 0, 111)
        self.assertRaises(CanvasError, cv.put_str, 0, "z", "abc")

    def test_printf(self):
        """ module canvas: Canvas.printf()
        """
        word1, word2 = "test", "string"
        cv = Canvas(10, 1)
        self.assertEqual(10, cv.printf(0, 0, "%s%s", word1, word2))
        liststring = []
        for i in range(0, 10):
            liststring.append(cv.get_char(i, 0))
        self.assertEqual("teststring", "".join(liststring))
        self.assertRaises(CanvasError, cv.printf, 0, 0, 111)
        self.assertRaises(CanvasError, cv.printf, 0, "z", "abc %s", "def")

    def test_wherex(self):
        """ module canvas: Canvas.wherex()
        """
        cv = Canvas(10, 10)
        self.assertEqual(0, cv.wherex())

    def test_wherey(self):
        """ module canvas: Canvas.wherey()
        """
        cv = Canvas(10, 10)
        self.assertEqual(0, cv.wherey())

    def test_gotoxy(self):
        """ module canvas: Canvas.gotoxy()
        """
        cv = Canvas(10, 10)
        cv.gotoxy(5, 5)
        self.assertEqual((5, 5), (cv.wherex(), cv.wherey()))
        self.assertRaises(CanvasError, cv.gotoxy, "a", 9)
        self.assertRaises(CanvasError, cv.gotoxy, 9, "a")

    def test_clear(self):
        """ module canvas: Canvas.clear()
        """
        cv = Canvas(5, 1)
        cv.put_str(0, 0, "test!")
        cv.clear()
        data = cv.export_to_memory("utf8").strip('\n')
        self.assertEqual("     ", data)

    def test_get_handle_x(self):
        """ module canvas: Canvas.get_handle_x()
        """
        cv = Canvas()
        self.assertEqual(0, cv.get_handle_x())

    def test_get_handle_y(self):
        """ module canvas: Canvas.get_handle_y()
        """
        cv = Canvas()
        self.assertEqual(0, cv.get_handle_y())

    def test_set_handle(self):
        """ module canvas: Canvas.set_handle()
        """
        cv = Canvas(10, 5)
        self.assertEqual(0, cv.set_handle(3, 3))
        self.assertEqual((3, 3), (cv.get_handle_x(), cv.get_handle_y()))
        self.assertRaises(CanvasError, cv.set_handle, "a", 1)
        self.assertRaises(CanvasError, cv.set_handle, 1, "a")

    def test_blit(self):
        """ module canvas: Canvas.blit()
        """
        cv1 = Canvas(10, 1)
        cv2 = Canvas(10, 1)
        cv2.put_str(0, 0, "teststring")
        self.assertEqual(0, cv1.blit(0, 0, cv2))
        self.assertEqual("teststring", cv1.export_to_memory("utf8").strip('\n'))
        self.assertRaises(CanvasError, cv1.blit, 0, 0, "abc")
        self.assertRaises(CanvasError, cv1.blit, "a", 0, cv2)

    def test_blit_mask(self):
        """ module canvas: Canvas.blit() (with mask)
        """
        cv1 = Canvas(10, 1)
        cv2 = Canvas(10, 1)
        mask = Canvas(10, 1)
        badm = Canvas()
        cv2.put_str(0, 0, "teststring")
        mask.put_str(0, 0, "####")
        self.assertEqual(0, cv1.blit(0, 0, cv2, mask))
        self.assertEqual("test      ", cv1.export_to_memory("utf8").strip("\n"))
        self.assertRaises(CanvasError, cv1.blit, 0, 0, cv2, badm)

    def test_set_boundaries(self):
        """ module canvas: Canvas.set_boundaries()
        """
        cv = Canvas()
        self.assertEqual(0, cv.set_boundaries(0, 0, 10, 10))
        self.assertEqual((10, 10), (cv.get_width(), cv.get_height()))
        self.assertEqual(0, cv.set_boundaries(0, 0, 5, 5))
        self.assertEqual((5, 5), (cv.get_width(), cv.get_height()))
        self.assertRaises(CanvasError, cv.set_boundaries, "a", 0, 10, 10)
        self.assertRaises(CanvasError, cv.set_boundaries, 0, 0, "abc", 10)

    def test_enable_dirty_rect(self):
        """ module canvas: Canvas.enable_dirty_rect()
        """
        cv = Canvas()
        self.assertRaises(CanvasError, cv.enable_dirty_rect)
        cv.disable_dirty_rect()
        self.assertEqual(0, cv.enable_dirty_rect())

    def test_add_dirty_rect(self):
        """ module canvas: Canvas.add_dirty_rect()
        """
        cv = Canvas(10, 10)
        self.assertEqual(0, cv.add_dirty_rect(4, 4, 2, 2))
        self.assertRaises(CanvasError, cv.add_dirty_rect, 11, 11, 20, 20)

    def test_remove_dirty_rect(self):
        """ module canvas: Canvas.remove_dirty_rect()
        """
        cv = Canvas(10, 10)
        cv.add_dirty_rect(4, 4, 2, 2)
        self.assertEqual(0, cv.remove_dirty_rect(4, 4, 2, 2))
        self.assertRaises(CanvasError, cv.remove_dirty_rect, 11, 11, 20, 20)

    def test_draw_line(self):
        """ module canvas: Canvas.draw_line()
        """
        cv = Canvas(10, 1)
        cv.draw_line(0, 0, 10, 1, "#")
        self.assertEqual("#" * 10, cv.export_to_memory("utf8").strip('\n'))
        self.assertRaises(CanvasError, cv.draw_line, 0, 0, 10, 1, 7)
        self.assertRaises(CanvasError, cv.draw_line, 0, "a", 10, 1, "#")

    def test_draw_thin_line(self):
        """ module canvas: Canvas.draw_thin_line()
        """
        cv = Canvas(10, 1)
        cv.draw_thin_line(0, 0, 10, 1)
        self.assertEqual("-" * 10, cv.export_to_memory("utf8").strip('\n'))
        self.assertRaises(CanvasError, cv.draw_thin_line, 0, "a", 10, 1)

    def test_draw_polyline(self):
        """ module canvas: Canvas.draw_polyline()
        """
        cv = Canvas(10, 10)
        self.assertEqual(0, cv.draw_polyline([(0, 0), (2, 2), (5, 2), (0, 0)],
                                              '#'))
        self.assertRaises(CanvasError, cv.draw_polyline, [], '#')
        self.assertRaises(CanvasError, cv.draw_polyline, [0, 1, 2, 4], '#')

    def test_draw_thin_polyline(self):
        """ module canvas: Canvas.draw_thin_polyline()
        """
        cv = Canvas(10, 10)
        self.assertEqual(0, cv.draw_thin_polyline([(0, 0), (2, 2),
                                                   (5, 2), (0, 0)]))
        self.assertRaises(CanvasError, cv.draw_thin_polyline, [])
        self.assertRaises(CanvasError, cv.draw_thin_polyline, [0, 1, 2, 4])

    def test_draw_circle(self):
        """ module canvas: Canvas.draw_circle()
        """
        cv = Canvas(10, 10)
        self.assertEqual(0, cv.draw_circle(5, 5, 3, '#'))
        self.assertRaises(CanvasError, cv.draw_circle, 0, 0, '#', '#')
        self.assertRaises(CanvasError, cv.draw_circle, 0, 0, 3, 0)

    def test_draw_ellipse(self):
        """ module canvas: Canvas.draw_ellipse()
        """
        cv = Canvas(10, 10)
        self.assertEqual(0, cv.draw_ellipse(5, 5, 3, 4, '#'))
        self.assertRaises(CanvasError, cv.draw_ellipse, 0, 0, 3, '#', '#')
        self.assertRaises(CanvasError, cv.draw_ellipse, 0, 0, 3, 5, 0)

    def test_draw_thin_ellipse(self):
        """ module canvas: Canvas.draw_thin_ellipse()
        """
        cv = Canvas(10, 10)
        self.assertEqual(0, cv.draw_thin_ellipse(5, 5, 3, 4))
        self.assertRaises(CanvasError, cv.draw_thin_ellipse, 0, 0, 3, '#')

    def test_fill_ellipse(self):
        """ module canvas: Canvas.fill_ellipse()
        """
        cv = Canvas(10, 10)
        self.assertEqual(0, cv.fill_ellipse(5, 5, 3, 3, '#'))
        self.assertRaises(CanvasError, cv.fill_ellipse, 0, 0, 3, '#', '#')
        self.assertRaises(CanvasError, cv.fill_ellipse, 0, 0, 3, 3, 0)

    def test_draw_box(self):
        """ module canvas: Canvas.draw_box()
        """
        cv = Canvas(10, 10)
        self.assertEqual(0, cv.draw_box(0, 0, 2, 2, '#'))
        self.assertRaises(CanvasError, cv.draw_box, 0, 0, 2, '#', '#')
        self.assertRaises(CanvasError, cv.draw_box, 0, 0, 2, 2, 0)

    def test_draw_thin_box(self):
        """ module canvas: Canvas.draw_thin_box()
        """
        cv = Canvas(10, 10)
        self.assertEqual(0, cv.draw_thin_box(0, 0, 2, 2))
        self.assertRaises(CanvasError, cv.draw_thin_box, 0, 0, 2, '#')

    def test_draw_cp437_box(self):
        """ module canvas: Canvas.draw_cp437_box()
        """
        cv = Canvas(10, 10)
        self.assertEqual(0, cv.draw_cp437_box(0, 0, 2, 2))
        self.assertRaises(CanvasError, cv.draw_cp437_box, 0, 0, 2, '#')

    def test_fill_box(self):
        """ module canvas: Canvas.fill_box()
        """
        cv = Canvas(10, 10)
        self.assertEqual(0, cv.fill_box(0, 0, 2, 2, '#'))
        self.assertRaises(CanvasError, cv.fill_box, 0, 0, 2, '#', '#')
        self.assertRaises(CanvasError, cv.fill_box, 0, 0, 2, 2, 0)

    def test_draw_triangle(self):
        """ module canvas: Canvas.draw_triangle()
        """
        cv = Canvas(10, 10)
        self.assertEqual(0, cv.draw_triangle(0, 0, 2, 2, 4, 0, '#'))
        self.assertRaises(CanvasError, cv.draw_triangle,
                          0, 0, 2, 2, 4, '#', '#')
        self.assertRaises(CanvasError, cv.draw_triangle,
                          0, 0, 2, 2, 4, 0, 0)

    def test_draw_thin_triangle(self):
        """ module canvas: Canvas.draw_thin_triangle()
        """
        cv = Canvas(10, 10)
        self.assertEqual(0, cv.draw_thin_triangle(0, 0, 2, 2, 4, 0))
        self.assertRaises(CanvasError, cv.draw_thin_triangle,
                          0, 0, 2, 2, 4, '#')

    def test_fill_triangle(self):
        """ module canvas: Canvas.fill_triangle()
        """
        cv = Canvas(10, 10)
        self.assertEqual(0, cv.fill_triangle(0, 0, 2, 2, 4, 0, '#'))
        self.assertRaises(CanvasError, cv.fill_triangle,
                          0, 0, 2, 2, 4, '#', '#')
        self.assertRaises(CanvasError, cv.fill_triangle,
                          0, 0, 2, 2, 4, 0, 0)