import os
import random
import warnings
import unittest


A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, R, S, T, U, V = "ABCDEFGHIJKLMNOPRSTUV"

zemljevid = {
    (A, B): "gravel trava",
    (A, V): "pešci lonci",
    (B, C): "bolt lonci",
    (B, V): "",
    (C, R): "stopnice pešci lonci",
    (D, F): "stopnice pešci",
    (D, R): "pešci",
    (E, I): "trava lonci",
    (F, G): "trava črepinje",
    (G, H): "črepinje pešci",
    (G, I): "avtocesta",
    (H, J): "robnik bolt",
    (I, M): "avtocesta",
    (I, P): "gravel",
    (I, R): "stopnice robnik",
    (J, K): "",
    (J, L): "gravel bolt",
    (K, M): "stopnice bolt",
    (L, M): "robnik pešci",
    (M, N): "rodeo",
    (N, P): "gravel",
    (O, P): "gravel",
    (P, S): "",
    (R, U): "trava pešci",
    (R, V): "pešci lonci",
    (S, T): "robnik trava",
    (T, U): "gravel trava",
    (U, V): "robnik lonci trava"
}

zemljevid = {k: set(v.split()) for k, v in zemljevid.items()}
zemljevid.update({k[::-1]: v for k, v in zemljevid.items()})

class Test(unittest.TestCase):
    def setUp(self):
        warnings.simplefilter("ignore", ResourceWarning)

    def test_06_a_skupna_krizisca(self):
        self.assertEqual(3, skupna_krizisca("ABCDCAB", "DAEBA"))
        self.assertEqual(0, skupna_krizisca("ABCDCAB", ""))
        self.assertEqual(0, skupna_krizisca("PETER", "NOVAK"))
        self.assertEqual(1, skupna_krizisca("PETER", "JESENKO"))

    def test_06_b_skupni_odseki(self):
        self.assertEqual(0, skupni_odseki("ABCDCAB", "DAEBA"))
        self.assertEqual(1, skupni_odseki("ABCDCAB", "DABAB"))
        self.assertEqual(4, skupni_odseki("ABCDCAB", "DABCABCD"))

    zemljevid_txt = ("PeF-EF: robnik, bolt\n"
                     "PeF-FRI: robnik, avtocesta\n"
                     "FRI-BF: \n"
                     "BF-FE: robnik, trava, pešci\n")

    zemljevid_slo = {('BF', 'FE'): {'pešci', 'robnik', 'trava'},
                     ('FRI', 'BF'): set(),
                     ('PeF', 'EF'): {'bolt', 'robnik'},
                     ('PeF', 'FRI'): {'avtocesta', 'robnik'}}

    def test_07_a_preberi_zemljevid(self):
        with open("zemljevid.txt", "wt", encoding="utf-8") as f:
            f.write(self.zemljevid_txt)
        self.assertEqual(self.zemljevid_slo, preberi_zemljevid("zemljevid.txt"))

    def test_07_a_zapiši_zemljevid(self):
        fn = f"zem{random.randint(1000, 9999)}.txt"
        zapisi_zemljevid(fn, self.zemljevid_slo)
        with open(fn, encoding="utf-8") as f:
            self.assertEqual(self.zemljevid_slo, preberi_zemljevid(fn))
        os.remove(fn)

    def test_08_skupni_odsek(self):
        #                                      vvvvv
        self.assertEqual(5, skupni_odsek("ABCDEFGHIJKLMNOP",
                                         "BCDEMFGHIJXOAEFD"))
        #                                  vv  vvvvv   vvv
        self.assertEqual(5, skupni_odsek("ABCDEFGHIJKLMNOP",
                                         "XBDEMFGHIJXOANOP"))
        #                                  vv  vv vv   vvv
        self.assertEqual(3, skupni_odsek("ABCDEFGLIJKLMNOP",
                                         "XBDEMFGHIJXOANOP"))
        #                                 vvvv vv vv   vvv
        self.assertEqual(4, skupni_odsek("ABCDEFGLIJKLMNOP",
                                         "ABCDMFGHIJXOANOP"))
        #                                 vv v vv vv   vvv
        self.assertEqual(3, skupni_odsek("ABXDEFGLIJKLMNOPABC",
                                         "ABCDMFGHIJXOANOP"))
        #                                 vv v vv vv   vvv
        self.assertEqual(3, skupni_odsek("ABXDEFGLIJKLMNOP",
                                         "ABCDMFGHIJXOANOPABC"))
        #
        self.assertEqual(0, skupni_odsek("ABXDEFGLIJKLMNOP",
                                         ""))
        #
        self.assertEqual(0, skupni_odsek("ABCDEFGHI",
                                         "XABCDEFGHIJK"))
        #                                 v
        self.assertEqual(1, skupni_odsek("ABXDEFGLIJKLMNOP",
                                         "AFHDJEX"))
        #                                   v
        self.assertEqual(1, skupni_odsek("ABXDEFGLIJKLMNOP",
                                         "LAXYJEX"))
        #                                       v
        self.assertEqual(1, skupni_odsek("ABRDEFXLIJKLMNOP",
                                         "LAXDJEX"))
        #                                       v
        self.assertEqual(1, skupni_odsek("ABRDEFX",
                                         "LAXDJEXLIJKLMNOP"))

    def test_09_uporabne_vescine(self):
        self.assertEqual(set(), uporabne_vescine("V", zemljevid))
        self.assertEqual({'trava', 'lonci', 'robnik'}, uporabne_vescine("U", zemljevid))
        self.assertEqual({'trava', 'lonci', 'robnik', "gravel"}, uporabne_vescine("T", zemljevid))
        self.assertEqual({'trava', 'lonci', 'robnik', "gravel"}, uporabne_vescine("P", zemljevid))
        self.assertEqual({'trava', 'lonci', 'robnik', "pešci"}, uporabne_vescine("R", zemljevid))
        self.assertEqual({'trava', 'lonci', 'robnik', "gravel", "avtocesta", "rodeo", "pešci", "stopnice"}, uporabne_vescine("I", zemljevid))

    def test_10_dolzina_poti(self):
        self.assertEqual(0, dolzina_poti("C", "C", zemljevid))
        self.assertEqual(1, dolzina_poti("C", "R", zemljevid))
        self.assertEqual(1, dolzina_poti("D", "R", zemljevid))
        self.assertEqual(2, dolzina_poti("D", "U", zemljevid))
        self.assertEqual(4, dolzina_poti("F", "U", zemljevid))
        self.assertEqual(2, dolzina_poti("C", "U", zemljevid))
        self.assertEqual(3, dolzina_poti("I", "T", zemljevid))
        self.assertIsNone(dolzina_poti("B", "A", zemljevid))
        self.assertIsNone(dolzina_poti("C", "I", zemljevid))


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