import unittest
import os
import zipfile
import time

class TestKrogi(unittest.TestCase):
    krogi = ((13, 20, 2), (9, 16, 4), (17, 16, 2), (15, 14, 2), (6, 11, 3),
             (2, 10, 2), (11, 8, 2), (16, 8, 3), (6, 3, 3), (12, 3, 2),
             (18, 5, 2))

    @classmethod
    def setUpClass(cls):
        base, ext = os.path.splitext(os.path.basename(__file__))
        zf = zipfile.ZipFile(__file__ + ".zip", "a", zipfile.ZIP_DEFLATED)
        zf.write(__file__, "{}.{}{}".format(base, int(time.time()), ext))
        zf.close()
        cls.maxDiff = None

    def preveri_seznam(self, s, n, mi, ma, kaj):
        self.assertIsInstance(s, list, "Funkcija mora vrniti seznam")
        self.assertEqual(len(s), n, "Napačna dolžina seznama")
        self.assertTrue(all(mi <= r <= ma for r in s),
                        "{} morajo biti med {} in {}".format(kaj, mi, ma))
        if n:
            self.assertGreater(len(set(s)), n // 2,
                               "Sumljivo veliko enakih števil...")

    def test_6_radiji(self):
        kaj = "Vsa števila"
        self.preveri_seznam(radiji(3, 100, 1000), 3, 100, 1000, kaj)
        self.preveri_seznam(radiji(3, 10, 100), 3, 10, 100, kaj)
        self.preveri_seznam(radiji(1, 100, 1000), 1, 100, 1000, kaj)
        self.preveri_seznam(radiji(0, 100, 1000), 0, 100, 1000, kaj)
        self.preveri_seznam(radiji(20, 100, 1000), 20, 100, 1000, kaj)

    def test_6_krogi(self):
        k = krogi(5, 1000, 600, 10, 50)
        self.preveri_seznam([x[0] - x[2] for x in k], 5, 0, 1000,
                            "Vse skrajne leve točke krogov")
        self.preveri_seznam([x[0] + x[2] for x in k], 5, 0, 1000,
                            "Vse skrajne desne točke krogov")
        self.preveri_seznam([x[1] - x[2] for x in k], 5, 0, 600,
                            "Vse skrajne spodnje točke krogov")
        self.preveri_seznam([x[1] + x[2] for x in k], 5, 0, 600,
                            "Vse skrajne zgornje točke krogov")
        self.preveri_seznam([x[2] for x in k], 5, 10, 50,
                            "Vsi polmeri krogov")

    def test_6_ploscina(self):
        a, b, c, d, e, f, g, h, i, j, k = self.krogi
        self.assertAlmostEqual(ploscina([a, b, c]), pi * 24)
        self.assertAlmostEqual(ploscina([a]), pi * 4)
        self.assertAlmostEqual(ploscina([]), 0)

    def test_7_se_sekata(self):
        a, b, c, d, e, f, g, h, i, j, k = self.krogi
        self.assertTrue(se_sekata(a, b))
        self.assertTrue(se_sekata(b, e))
        self.assertTrue(se_sekata(e, f))
        self.assertTrue(se_sekata(c, d))
        self.assertTrue(se_sekata(g, h))
        self.assertTrue(se_sekata(h, k))

        self.assertFalse(se_sekata(a, c))
        self.assertFalse(se_sekata(a, e))
        self.assertFalse(se_sekata(g, e))
        self.assertFalse(se_sekata(h, d))
        self.assertFalse(se_sekata(i, j))

    def test_7_seka(self):
        a, b, c, d, e, f, g, h, i, j, k = self.krogi
        self.assertTrue(seka(a, [b, g, i]))
        self.assertTrue(seka(a, [g, b, i]))
        self.assertTrue(seka(a, [g, i, b]))
        self.assertTrue(seka(a, [g, i, a]))

        self.assertTrue(seka(b, [a, g, i, e]))
        self.assertTrue(seka(b, [g, a, e, i]))
        self.assertTrue(seka(b, [g, i, b]))

        self.assertFalse(seka(b, []))
        self.assertFalse(seka(b, [d, f]))
        self.assertFalse(seka(b, [j, i]))

    def test_8_seka_n(self):
        a, b, c, d, e, f, g, h, i, j, k = self.krogi
        self.assertEquals(seka_n(a, [b, g, i]), [0])
        self.assertEquals(seka_n(a, [g, b, i]), [1])
        self.assertEquals(seka_n(a, [g, i, b]), [2])
        self.assertEquals(seka_n(a, [g, i, a]), [2])
        self.assertEquals(seka_n(a, [g, b, i, a]), [1, 3])

        self.assertEquals(seka_n(b, [a, g, i, e]), [0, 3])
        self.assertEquals(seka_n(b, [g, a, e, i]), [1, 2])
        self.assertEquals(seka_n(b, [g, i, b]), [2])

        self.assertEquals(seka_n(b, []), [])
        self.assertEquals(seka_n(b, [d, f]), [])
        self.assertEquals(seka_n(b, [j, i]), [])

        self.assertEquals(seka_n(b, [b, b]), [0, 1])
        self.assertEquals(seka_n(b, [b, b, a, i, b]), [0, 1, 2, 4])

    def test_9_sosedi(self):
        a, b, c, d, e, f, g, h, i, j, k = self.krogi
        self.assertDictEqual(
            sosedi(self.krogi),
            {a: {b},
             b: {a, e},
             c: {d},
             d: {c},
             e: {f, b},
             f: {e},
             g: {h},
             h: {g, k},
             i: set(),
             j: set(),
             k: {h},
            })

        self.assertDictEqual(sosedi([a, e, g, k]),
                             {a: set(), e: set(), g: set(), k: set()})

        self.assertDictEqual(sosedi([a, e]), {a: set(), e: set()})
        self.assertDictEqual(sosedi([a]), {a: set()})
        self.assertDictEqual(sosedi([]), {})

        self.assertDictEqual(sosedi([a, e, b]), {a: {b}, e: {b}, b: {a, e}})

    def test_9_sosedi_n(self):
        a, b, c, d, e, f, g, h, i, j, k = self.krogi
        self.assertDictEqual(
            sosedi_n(self.krogi),
            {0: {1},
             1: {0, 4},
             2: {3},
             3: {2},
             4: {5, 1},
             5: {4},
             6: {7},
             7: {6, 10},
             8: set(),
             9: set(),
             10: {7},
            })

        self.assertDictEqual(sosedi_n([a, e, g, k]),
                             {0: set(), 1: set(), 2: set(), 3: set()})

        self.assertDictEqual(sosedi_n([a, e]), {0: set(), 1: set()})
        self.assertDictEqual(sosedi_n([a]), {0: set()})
        self.assertDictEqual(sosedi_n([]), {})

        self.assertDictEqual(sosedi_n([a, e, b]), {0: {2}, 1: {2}, 2: {0, 1}})

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