from program import *

import unittest
import ast
from xml.dom import minidom

povezave = [
    (11, 10, 13, 10),

    (2, 12, 8, 12),
    (6, 11, 6, 13),

    (0, 16, 10, 16),
    (3, 18, 3, 13),
    (7, 14, 3, 14),
    (9, 17, 9, 14),
    (13, 15, 8, 15),
    (12, 14, 12, 17),
    (13, 16, 21, 16),
    (14, 18, 14, 15),
    (13, 15, 13, 16),
    (16, 16, 16, 10),
    (16, 10, 21, 10),
    (14, 18, 10, 18),
    (11, 13, 11, 20),
    (15, 13, 22, 13),
    (17, 15, 17, 17),
    (18, 17, 18, 14),
    (19, 19, 22, 19),
    (20, 15, 20, 17),
    (21, 10, 21, 19),
]


class TestOneLineMixin:
    functions = {
        elm.name: elm
        for elm in ast.parse(open(__file__, "r", encoding="utf-8").read()).body
        if isinstance(elm, ast.FunctionDef)}

    def assert_is_one_line(self, func):
        body = self.functions[func.__code__.co_name].body
        self.assertEqual(len(body), 1, "\nFunkcija ni dolga le eno vrstico")
        self.assertIsInstance(body[0], ast.Return, "\nFunkcija naj bi vsebovala le return")

    def test_nedovoljene_funkcije(self):
        dovoljene_funkcije = {
            "pravilna", "pravilne", "urejena", "na_povezavi",
            "povezave_tocke", "secisce", "krizisca", "mozna_pot",
            "razdalja", "svg", "povezane", "dostopne", "pot"}
        for func in self.functions:
            self.assertIn(func, dovoljene_funkcije, f"\nFunkcija {func} ni dovoljena.")


class Test06(unittest.TestCase):
    def test_01_pravilna(self):
        self.assertTrue(pravilna((10, 20, 10, 22)))
        self.assertTrue(pravilna((10, 22, 10, 20)))
        self.assertTrue(pravilna((13, 5, 18, 5)))
        self.assertTrue(pravilna((18, 5, 13, 5)))

        # Ni OK: spremenita se obe koordinati
        self.assertFalse(pravilna((10, 18, 12, 4)))
        self.assertFalse(pravilna((18, 10, 4, 12)))
        self.assertFalse(pravilna((10, 20, 10, 20)))

        # Ni OK: ne spremeni se nobena koordinata
        self.assertFalse(pravilna((10, 12, 10, 12)))

    def test_02_pravilne(self):
        self.assertTrue(pravilne(povezave))
        self.assertTrue(pravilne([(1, 5, 1, 8)]))
        self.assertTrue(pravilne([(1, 5, 2, 5)]))

        self.assertFalse(pravilne(povezave + [(10, 10, 10, 10)]))
        self.assertFalse(pravilne([(10, 10, 10, 10)] + povezave))
        self.assertFalse(pravilne(povezave + [(10, 18, 12, 4)]))
        self.assertFalse(pravilne([(10, 18, 12, 4)] + povezave))

    def test_03_urejena(self):
        self.assertEqual((10, 20, 10, 22), urejena((10, 20, 10, 22)))
        self.assertEqual((10, 20, 10, 22), urejena((10, 22, 10, 20)))
        self.assertEqual((13, 5, 18, 5), urejena((13, 5, 18, 5)))
        self.assertEqual((13, 5, 18, 5), urejena((18, 5, 13, 5)))

    def test_04_na_povezavi(self):
        self.assertTrue(na_povezavi(10, 20, (10, 20, 10, 22)))
        self.assertTrue(na_povezavi(10, 21, (10, 20, 10, 22)))
        self.assertTrue(na_povezavi(10, 22, (10, 20, 10, 22)))
        self.assertTrue(na_povezavi(10, 20, (10, 22, 10, 20)))
        self.assertTrue(na_povezavi(10, 21, (10, 22, 10, 20)))
        self.assertTrue(na_povezavi(10, 22, (10, 22, 10, 20)))
        self.assertFalse(na_povezavi(10, 23, (10, 22, 10, 20)))
        self.assertFalse(na_povezavi(10, 19, (10, 22, 10, 20)))
        self.assertFalse(na_povezavi(10, 23, (10, 20, 10, 22)))
        self.assertFalse(na_povezavi(10, 19, (10, 20, 10, 22)))
        self.assertFalse(na_povezavi(9, 21, (10, 20, 10, 22)))
        self.assertFalse(na_povezavi(9, 21, (10, 22, 10, 20)))
        self.assertFalse(na_povezavi(11, 21, (10, 20, 10, 22)))
        self.assertFalse(na_povezavi(11, 21, (10, 22, 10, 20)))

        self.assertTrue(na_povezavi( 20, 10, (20, 10, 22, 10)))
        self.assertTrue(na_povezavi( 21, 10, (20, 10, 22, 10)))
        self.assertTrue(na_povezavi( 22, 10, (20, 10, 22, 10)))
        self.assertTrue(na_povezavi( 20, 10, (22, 10, 20, 10)))
        self.assertTrue(na_povezavi( 21, 10, (22, 10, 20, 10)))
        self.assertTrue(na_povezavi( 22, 10, (22, 10, 20, 10)))
        self.assertFalse(na_povezavi(23, 10, (22, 10, 20, 10)))
        self.assertFalse(na_povezavi(19, 10, (22, 10, 20, 10)))
        self.assertFalse(na_povezavi(23, 10, (20, 10, 22, 10)))
        self.assertFalse(na_povezavi(19, 10, (20, 10, 22, 10)))
        self.assertFalse(na_povezavi(21,  9, (20, 10, 22, 10)))
        self.assertFalse(na_povezavi(21,  9, (22, 10, 20, 10)))
        self.assertFalse(na_povezavi(21, 11, (20, 10, 22, 10)))
        self.assertFalse(na_povezavi(21, 11, (22, 10, 20, 10)))

    def test_05_povezave_tocke(self):
        self.assertEqual({(3, 13, 3, 18)}, povezave_tocke(3, 15, povezave))
        self.assertEqual({(3, 13, 3, 18)}, povezave_tocke(3, 18, povezave))
        self.assertEqual({(3, 13, 3, 18)}, povezave_tocke(3, 13, povezave))

        self.assertEqual({(11, 13, 11, 20)}, povezave_tocke(11, 17, povezave))
        self.assertEqual({(11, 13, 11, 20)}, povezave_tocke(11, 13, povezave))
        self.assertEqual({(11, 13, 11, 20)}, povezave_tocke(11, 20, povezave))

        self.assertEqual({(6, 11, 6, 13), (2, 12, 8, 12)},
                         povezave_tocke(6, 12, povezave))
        self.assertEqual({(3, 14, 7, 14), (3, 13, 3, 18)},
                         povezave_tocke(3, 14, povezave))
        self.assertEqual({(13, 16, 21, 16), (13, 15, 13, 16)},
                         povezave_tocke(13, 16, povezave))

        self.assertEqual(set(), povezave_tocke(13, 17, povezave))

    def test_06_secisce(self):
        # Sekanje
        self.assertEqual((10, 22), secisce((10, 20, 10, 25), (8, 22, 18, 22)))
        self.assertEqual((10, 22), secisce((10, 25, 10, 22), (8, 22, 18, 22)))
        self.assertEqual((10, 22), secisce((10, 25, 10, 22), (18, 22, 8, 22)))
        self.assertEqual((10, 22), secisce((10, 20, 10, 25), (18, 22, 8, 22)))

        self.assertEqual((10, 22), secisce((8, 22, 18, 22), (10, 20, 10, 25)))
        self.assertEqual((10, 22), secisce((8, 22, 18, 22), (10, 25, 10, 22)))
        self.assertEqual((10, 22), secisce((18, 22, 8, 22), (10, 25, 10, 22)))
        self.assertEqual((10, 22), secisce((18, 22, 8, 22), (10, 20, 10, 25)))

        # Dotikanje
        self.assertEqual((10, 22), secisce((10, 20, 10, 25), (10, 22, 18, 22)))
        self.assertEqual((10, 22), secisce((10, 25, 10, 20), (10, 22, 18, 22)))
        self.assertEqual((10, 22), secisce((10, 25, 10, 20), (18, 22, 10, 22)))
        self.assertEqual((10, 22), secisce((10, 20, 10, 25), (18, 22, 10, 22)))

        # Dotikanje v točki
        self.assertEqual((10, 20), secisce((10, 20, 10, 25), (10, 20, 8, 20)))
        self.assertEqual((10, 20), secisce((10, 25, 10, 20), (10, 20, 8, 20)))
        self.assertEqual((10, 20), secisce((10, 25, 10, 20), (8, 20, 10, 20)))
        self.assertEqual((10, 20), secisce((10, 20, 10, 25), (8, 20, 10, 20)))

        # Sekanje
        self.assertEqual((22, 10), secisce((20, 10, 25, 10), (22,  8, 22, 18)))
        self.assertEqual((22, 10), secisce((25, 10, 22, 10), (22,  8, 22, 18)))
        self.assertEqual((22, 10), secisce((25, 10, 22, 10), (22, 18, 22,  8)))
        self.assertEqual((22, 10), secisce((20, 10, 25, 10), (22, 18, 22,  8)))
        self.assertEqual((22, 10), secisce((22,  8, 22, 18), (20, 10, 25, 10)))
        self.assertEqual((22, 10), secisce((22,  8, 22, 18), (25, 10, 22, 10)))
        self.assertEqual((22, 10), secisce((22, 18, 22,  8), (25, 10, 22, 10)))
        self.assertEqual((22, 10), secisce((22, 18, 22,  8), (20, 10, 25, 10)))

        # Dotikanje
        self.assertEqual((22, 10), secisce((20, 10, 25, 10), (22, 10, 22, 18)))
        self.assertEqual((22, 10), secisce((25, 10, 20, 10), (22, 10, 22, 18)))
        self.assertEqual((22, 10), secisce((25, 10, 20, 10), (22, 18, 22, 10)))
        self.assertEqual((22, 10), secisce((20, 10, 25, 10), (22, 18, 22, 10)))

        # Dotikanje v točki
        self.assertEqual((20, 10), secisce((20, 10, 25, 10), (20, 10, 20,  8)))
        self.assertEqual((20, 10), secisce((25, 10, 20, 10), (20, 10, 20,  8)))
        self.assertEqual((20, 10), secisce((25, 10, 20, 10), (20,  8, 20, 10)))
        self.assertEqual((20, 10), secisce((20, 10, 25, 10), (20,  8, 20, 10)))

        # Ni sekanja: vzporedni
        self.assertIsNone(secisce((10, 20, 10, 25), (8, 20, 8, 25)))
        self.assertIsNone(secisce((8, 20, 8, 25), (10, 20, 10, 25)))
        self.assertIsNone(secisce((8, 20, 18, 20), (1, 25, 0, 25)))

        # Ni sekanja: različni
        self.assertIsNone(secisce((10, 20, 10, 25), (12, 22, 15, 22)))

        krizisca = Test07.prava_krizisca
        for p1 in povezave:
            for p2 in povezave:
                if p1 != p2:
                    up1, up2 = urejena(p1), urejena(p2)
                    if (up1, up2) in krizisca:
                        self.assertEqual(krizisca[up1, up2], secisce(p1, p2),
                                         f"Napaka v klicu secisce({p1}, {p2})")
                    elif (up2, up1) in krizisca:
                        self.assertEqual(krizisca[up2, up1], secisce(p1, p2),
                                         f"Napaka v klicu secisce({p1}, {p2})")
                    else:
                        self.assertIsNone(secisce(p1, p2), f"Napaka v klicu secisce({p1}, {p2})")


class Test07(unittest.TestCase):
    prava_krizisca = {
         ((0, 16, 10, 16), (3, 13, 3, 18)): (3, 16),
         ((0, 16, 10, 16), (9, 14, 9, 17)): (9, 16),
         ((2, 12, 8, 12), (6, 11, 6, 13)): (6, 12),
         ((3, 13, 3, 18), (3, 14, 7, 14)): (3, 14),
         ((8, 15, 13, 15), (9, 14, 9, 17)): (9, 15),
         ((8, 15, 13, 15), (11, 13, 11, 20)): (11, 15),
         ((8, 15, 13, 15), (12, 14, 12, 17)): (12, 15),
         ((8, 15, 13, 15), (13, 15, 13, 16)): (13, 15),
         ((10, 18, 14, 18), (11, 13, 11, 20)): (11, 18),
         ((10, 18, 14, 18), (14, 15, 14, 18)): (14, 18),
         ((13, 15, 13, 16), (13, 16, 21, 16)): (13, 16),
         ((13, 16, 21, 16), (14, 15, 14, 18)): (14, 16),
         ((13, 16, 21, 16), (16, 10, 16, 16)): (16, 16),
         ((13, 16, 21, 16), (17, 15, 17, 17)): (17, 16),
         ((13, 16, 21, 16), (18, 14, 18, 17)): (18, 16),
         ((13, 16, 21, 16), (20, 15, 20, 17)): (20, 16),
         ((13, 16, 21, 16), (21, 10, 21, 19)): (21, 16),
         ((15, 13, 22, 13), (16, 10, 16, 16)): (16, 13),
         ((15, 13, 22, 13), (21, 10, 21, 19)): (21, 13),
         ((16, 10, 16, 16), (16, 10, 21, 10)): (16, 10),
         ((16, 10, 21, 10), (21, 10, 21, 19)): (21, 10),
         ((19, 19, 22, 19), (21, 10, 21, 19)): (21, 19)}

    def test_01_krizisca(self):
        self.assertEqual(self.prava_krizisca, krizisca(povezave))
        self.assertEqual(
            {((0, 16, 10, 16), (3, 13, 3, 18)): (3, 16),
             ((0, 16, 10, 16), (9, 14, 9, 17)): (9, 16),
             ((2, 12, 8, 12), (6, 11, 6, 13)): (6, 12),
             ((3, 13, 3, 18), (3, 14, 7, 14)): (3, 14),
             ((8, 15, 13, 15), (9, 14, 9, 17)): (9, 15)},
            krizisca(povezave[:8]))

    def test_02_mozna_pot(self):
        self.assertTrue(mozna_pot(
            [(14, 18, 10, 18),
             (14, 18, 14, 15),
             (13, 16, 21, 16),
             (13, 16, 13, 15),
             (8, 15, 13, 15),
             (9, 14, 9, 17),
             (10, 16, 0, 16),
             (9, 14, 9, 17),
             (8, 15, 13, 15),
             (13, 16, 13, 15)], self.prava_krizisca))

        self.assertFalse(mozna_pot(
            [(14, 18, 10, 18),
             (14, 18, 14, 15),
             (13, 16, 13, 15),
             (8, 15, 13, 15),
             (9, 14, 9, 17),
             (10, 16, 0, 16),
             (9, 14, 9, 17),
             (8, 15, 13, 15),
             (13, 16, 13, 15)], self.prava_krizisca))

        self.assertFalse(mozna_pot(
            [(14, 18, 10, 18),
             (14, 18, 14, 15),
             (13, 16, 21, 16),
             (13, 16, 13, 15),
             (8, 15, 14, 15),
             (9, 14, 9, 17),
             (10, 16, 0, 16),
             (9, 14, 9, 17),
             (8, 15, 13, 15),
             (13, 16, 13, 15)], self.prava_krizisca))

    def test_03_razdalja(self):
        self.assertEqual(
            14,
            razdalja([(14, 18, 10, 18),
             (14, 18, 14, 15),
             (13, 16, 21, 16),
             (13, 16, 13, 15),
             (8, 15, 13, 15),
             (9, 14, 9, 17),
             (10, 16, 0, 16),
             (9, 14, 9, 17),
             (8, 15, 13, 15),
             (13, 16, 13, 15)], self.prava_krizisca)
        )

class Test08(unittest.TestCase, TestOneLineMixin):
    def test(self):
        self.assert_is_one_line(pravilna)
        self.assert_is_one_line(pravilne)
        self.assert_is_one_line(urejena)
        self.assert_is_one_line(povezave_tocke)

class Test09(unittest.TestCase, TestOneLineMixin):
    def test(self):
        self.assert_is_one_line(krizisca)
        self.assert_is_one_line(mozna_pot)
        self.assert_is_one_line(razdalja)

    def test_01_svg(self):
        for pov in [povezave[:8], povezave]:
            urejene = set(map(urejena, pov))

            svg(pov, "test.svg")
            dom = minidom.parse("test.svg")
            el_svg = dom.getElementsByTagName("svg")[0]

            viewport = el_svg.getAttribute("viewBox")
            mix, miy, wi, he = map(int, viewport.split())
            self.assertLessEqual(mix, min(x for x, _, _, _ in pov))
            self.assertLessEqual(miy, min(y for _, y, _, _ in pov))
            self.assertGreaterEqual(mix + wi, max(x for _, _, x, _ in pov))
            self.assertGreaterEqual(miy + he, max(y for _, _, _, y in pov))

            self.assertEqual(
                sorted(urejene),
                sorted({urejena(tuple(int(line.getAttribute(a)) for a in "x1 y1 x2 y2".split()))
                  for line in el_svg.getElementsByTagName("line")}))
            self.assertEqual(
                {p[:2] for p in pov} | {p[2:] for p in pov},
                { tuple(int(line.getAttribute(a)) for a in "cx cy".split())
                  for line in el_svg.getElementsByTagName("circle")})


class Test10(unittest.TestCase):
    def test_01_povezane(self):
        self.assertEqual(
            {(0, 16, 10, 16): {(3, 13, 3, 18),
                               (9, 14, 9, 17)},
             (2, 12, 8, 12): {(6, 11, 6, 13)},
             (3, 13, 3, 18): {(0, 16, 10, 16),
                              (3, 14, 7, 14)},
             (3, 14, 7, 14): {(3, 13, 3, 18)},
             (6, 11, 6, 13): {(2, 12, 8, 12)},
             (8, 15, 13, 15): {(9, 14, 9, 17),
                               (11, 13, 11, 20),
                               (12, 14, 12, 17),
                               (13, 15, 13, 16)},
             (9, 14, 9, 17): {(0, 16, 10, 16),
                              (8, 15, 13, 15)},
             (10, 18, 14, 18): {(14, 15, 14, 18),
                                (11, 13, 11, 20)},
             (11, 13, 11, 20): {(8, 15, 13, 15),
                                (10, 18, 14, 18)},
             (12, 14, 12, 17): {(8, 15, 13, 15)},
             (13, 15, 13, 16): {(8, 15, 13, 15),
                                (13, 16, 21, 16)},
             (13, 16, 21, 16): {(13, 15, 13, 16),
                                (14, 15, 14, 18),
                                (16, 10, 16, 16),
                                (17, 15, 17, 17),
                                (18, 14, 18, 17),
                                (20, 15, 20, 17),
                                (21, 10, 21, 19)},
             (14, 15, 14, 18): {(10, 18, 14, 18),
                                (13, 16, 21, 16)},
             (15, 13, 22, 13): {(16, 10, 16, 16),
                                (21, 10, 21, 19)},
             (16, 10, 16, 16): {(13, 16, 21, 16),
                                (15, 13, 22, 13),
                                (16, 10, 21, 10)},
             (16, 10, 21, 10): {(16, 10, 16, 16),
                                (21, 10, 21, 19)},
             (17, 15, 17, 17): {(13, 16, 21, 16)},
             (18, 14, 18, 17): {(13, 16, 21, 16)},
             (19, 19, 22, 19): {(21, 10, 21, 19)},
             (20, 15, 20, 17): {(13, 16, 21, 16)},
             (21, 10, 21, 19): {(13, 16, 21, 16),
                                (15, 13, 22, 13),
                                (16, 10, 21, 10),
                                (19, 19, 22, 19)}},
            povezane(Test07.prava_krizisca))

    def test_02_dostopne(self):
        obmocje1 =  {
            (0, 16, 10, 16),
            (3, 13, 3, 18),
            (3, 14, 7, 14),
            (8, 15, 13, 15),
            (9, 14, 9, 17),
            (10, 18, 14, 18),
            (11, 13, 11, 20),
            (12, 14, 12, 17),
            (13, 15, 13, 16),
            (13, 16, 21, 16),
            (14, 15, 14, 18),
            (15, 13, 22, 13),
            (16, 10, 16, 16),
            (16, 10, 21, 10),
            (17, 15, 17, 17),
            (18, 14, 18, 17),
            (19, 19, 22, 19),
            (20, 15, 20, 17),
            (21, 10, 21, 19)}

        obmocje2 = {(6, 11, 6, 13), (2, 12, 8, 12)}
        obmocje3 = {(11, 10, 13, 10)}

        self.assertEqual(obmocje1, dostopne((0, 16, 10, 16), Test07.prava_krizisca))
        self.assertEqual(obmocje1, dostopne((20, 15, 20, 17), Test07.prava_krizisca))
        self.assertEqual(obmocje1, dostopne((20, 17, 20, 15), Test07.prava_krizisca))

        self.assertEqual(obmocje2, dostopne((2, 12, 8, 12), Test07.prava_krizisca))
        self.assertEqual(obmocje2, dostopne((8, 12, 2, 12), Test07.prava_krizisca))
        self.assertEqual(obmocje2, dostopne((6, 13, 6, 11), Test07.prava_krizisca))
        self.assertEqual(obmocje2, dostopne((6, 11, 6, 13), Test07.prava_krizisca))

        self.assertEqual(obmocje3, dostopne((11, 10, 13, 10), Test07.prava_krizisca))
        self.assertEqual(obmocje3, dostopne((13, 10, 11, 10), Test07.prava_krizisca))

    def test_03_pot(self):
        for sx, sy, ex, ey in [(11, 19, 17, 10),
                               (17, 10, 11, 19),
                               (1, 16, 22, 13)]:
            najdena = pot(sx, sy, ex, ey, Test07.prava_krizisca)
            rez = '\n'.join(map(str, najdena))
            napaka = f"Napaka pri iskanju poti od ({sx}, {sy}) do ({ex}, {ey}):\n{rez}"
            self.assertTrue(mozna_pot(najdena, Test07.prava_krizisca), napaka)
            self.assertTrue(na_povezavi(sx, sy, najdena[0]), napaka)
            self.assertTrue(na_povezavi(ex, ey, najdena[-1]), napaka)

        # Ni poti - območji sta nepovezani
        self.assertIsNone(pot(11, 19, 13, 10, Test07.prava_krizisca))

        # Na prvi točki ni povezave
        self.assertIsNone(pot(8, 18, 8, 16, Test07.prava_krizisca))
        # Na drugi točki ni povezave
        self.assertIsNone(pot(8, 16, 8, 18, Test07.prava_krizisca))


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