import unittest
import os
import warnings

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

def unikati(s):
    visited = {}
    res = []

    for name in s:
        if name not in visited:
            res.append(name)
            visited[name] = True

    return res

def skupnih(s, t):
    set_s = set()
    set_t = set()

    for name in s:
        set_s.add(name)

    for name in t:
        set_t.add(name)

    cnt = 0
    for name in set_s:
        if name in set_t:
            cnt += 1

    return cnt

def vseh(s, t):
    unique_elements = set()

    for name in s:
        unique_elements.add(name)

    for name in t:
        unique_elements.add(name)

    return len(unique_elements)

def preberi_datoteko(ime_dat, locilo):
    res_arr = []
    with open(ime_dat, "r") as f:
        for line in f:
            tmp_arr = line.split(locilo)
            res_arr.append(tmp_arr)

    return res_arr

def filtriran(s, stolpec, vrednost):
    res_arr = []
    for arr in s:
        if len(arr) > stolpec:
            if type(vrednost) == type(arr[stolpec]) and vrednost == arr[stolpec]:
                res_arr.append(arr)

    return res_arr
def izlusci(s, stolpec):
    res_arr = []
    for arr in s:
        if len(arr) > stolpec:
            res_arr.append(arr[stolpec])

    return res_arr

def predmeti(ime_dat, osebe):
    visited = set()
    arr = []
    with open(ime_dat, "r") as f:
        for line in f:
            a = line.split(",")
            if osebe == a[1]:
                if a[0] not in visited:
                    visited.add(a[0])
                    arr.append(a[0])

    return arr
def osebe(ime_dat, predmet):
    arr = []
    visited = set()
    with open(ime_dat, "r") as f:
        for line in f:
            a = line.split(",")
            if a[0] == predmet:
                if a[1] not in visited:
                    visited.add(a[1])
                    arr.append(a[1])

    return list(arr)

def podobnost_oseb(ime_dat, oseba1, oseba2):
    predmeti_1 = set()
    predmeti_2 = set()
    predmeti = set()
    with open(ime_dat, "r") as f:
        for line in f:
            a = line.split(",")
            if a[1] == oseba1:
                predmeti_1.add(a[0])
                predmeti.add(a[0])


            if a[1] == oseba2:
                predmeti_2.add(a[0])
                predmeti.add(a[0])

    zaednicki = 0
    for predmet in predmeti_1:
        if predmet in predmeti_2:
            zaednicki += 1

    return zaednicki / float(len(predmeti))
def podobnost_predmetov(ime_dat, predmet1, predmet2):
    p1 = set()
    p2 = set()
    p = set()

    with open(ime_dat, "r") as f:
        for line in f:
            a = line.split(",")
            if a[0] == predmet1:
                p1.add(a[1])
                p.add(a[1])

            if a[0] == predmet2:
                p2.add(a[1])
                p.add(a[1])

    zaednicki = 0
    for lice in p1:
        if lice in p2:
            zaednicki += 1

    return zaednicki / float(len(p))

class TestSeznami(NoWarning):
    def test_01_unikati(self):
        s = ["Ana", "Ana", "Berta", "Cilka", "Ana", "Berta", "Berta", "Berta", "Ema", "Dani", "Cilka"]
        t = s.copy()
        self.assertEqual(["Ana", "Berta", "Cilka", "Ema", "Dani"], unikati(s))
        self.assertEqual(t, s, "Pusti seznam, ki ga funkcija dobi kot argument, pri miru!")
        self.assertEqual([], unikati([]))
        self.assertEqual(["Ana"], unikati(["Ana"]))
        self.assertEqual([5, 8, 3], unikati([5, 8, 3]))
        self.assertEqual([5, 8, 3], unikati([5, 5, 5, 5, 8, 5, 8, 8, 8, 3, 3, 3, 5]))

    def test_02_skupnih(self):
        s = ["Ana", "Ana", "Berta", "Cilka", "Ana", "Berta", "Berta", "Berta", "Ema", "Dani", "Cilka"]
        sc = s.copy()
        t = ["Cilka", "Fanči", "Ana", "Ana", "Fanči", "Ana", "Cilka"]
        tc = t.copy()
        self.assertEqual(2, skupnih(s, t))
        self.assertEqual(2, skupnih(t, s))
        self.assertEqual(sc, s, "Pusti seznam, ki ga funkcija dobi kot argument, pri miru!")
        self.assertEqual(tc, t, "Pusti seznam, ki ga funkcija dobi kot argument, pri miru!")
        self.assertEqual(0, skupnih(s, ["Fanči", "Greta"]))
        self.assertEqual(1, skupnih(t, ["Fanči", "Greta"]))
        self.assertEqual(0, skupnih(s, []))
        self.assertEqual(0, skupnih([], []))

    def test_03_vseh(self):
        s = ["Ana", "Ana", "Berta", "Cilka", "Ana", "Berta", "Berta", "Berta", "Ema", "Dani", "Cilka"]
        sc = s.copy()
        t = ["Cilka", "Fanči", "Ana", "Ana", "Fanči", "Ana", "Cilka"]
        tc = t.copy()
        self.assertEqual(6, vseh(s, t))
        self.assertEqual(6, vseh(t, s))
        self.assertEqual(sc, s, "Pusti seznam, ki ga funkcija dobi kot argument, pri miru!")
        self.assertEqual(tc, t, "Pusti seznam, ki ga funkcija dobi kot argument, pri miru!")
        self.assertEqual(7, vseh(s, ["Fanči", "Greta"]))
        self.assertEqual(4, vseh(t, ["Fanči", "Greta"]))
        self.assertEqual(5, vseh(s, []))
        self.assertEqual(0, vseh([], []))


class TestProcesiranjeSeznamov(NoWarning):
    def test_01_preberi_datoteko(self):
        self.assertEqual([['Cube', '5031', '159', 'Janez', '2017\n'],
                          ['Stevens', '3819', '1284', 'Ana', '2012\n'],
                          ['Focus', '3823', '1921', 'Benjamin', '2019\n']],
                         preberi_datoteko("kolesa.txt", "-"))
        self.assertEqual([['slika', 'Berta', '31\n'],
                          ['slika', 'Ana', '33\n'],
                          ['slika', 'Berta', '35\n'],
                          ['slika', 'Fanči', '37\n'],
                          ['slika', 'Ana', '40\n']],
                         preberi_datoteko("zapisnik.txt", ",")[:5])

    def test_02_filter(self):
        s = [["Ana", 5, 9, "Berta"],
             ["Cilka", 5, 12, "Berta"],
             ["Ana", 5, 9, "Cilka"],
             ["Berta", 5, 1, "Ana"]]
        self.assertEqual(
            [["Ana", 5, 9, "Berta"],
             ["Ana", 5, 9, "Cilka"]], filtriran(s, 0, "Ana")
        )
        self.assertEqual(
            [["Ana", 5, 9, "Cilka"],
             ["Ana", 5, 9, "Berta"]], filtriran(s[::-1], 0, "Ana")
        )
        self.assertEqual(s, filtriran(s, 1, 5))
        self.assertEqual([], filtriran(s, 0, "Dani"))
        self.assertEqual([["Ana", 5, 9, "Cilka"]], filtriran(s, 3, "Cilka"))

    def test_03_izlusci(self):
        s = [["Ana", 5, 9, "Berta"],
             ["Cilka", 5, 12, "Berta"],
             ["Ana", 5, 9, "Cilka"],
             ["Berta", 5, 1, "Ana"]]
        self.assertEqual(["Ana", "Cilka", "Ana", "Berta"], izlusci(s, 0))
        self.assertEqual([5, 5, 5, 5], izlusci(s, 1))
        self.assertEqual([9, 12, 9, 1], izlusci(s, 2))


class TestDrazba(NoWarning):
    def test_01_predmeti(self):
        self.assertEqual(['slika', 'Meldrumove vaze'], predmeti("zapisnik.txt", "Ana"))
        self.assertEqual(['slika', 'skodelice', 'kip', 'čajnik'], predmeti("zapisnik.txt", "Berta"))
        self.assertEqual(['Meldrumove vaze', 'kip', 'srebrn jedilni servis'], predmeti("zapisnik.txt", "Cilka"))
        self.assertEqual([], predmeti("zapisnik.txt", "Benjamin"))

        try:
            os.rename("zapisnik.txt", "zapisnik-2.txt")
            self.assertEqual(['slika', 'Meldrumove vaze'], predmeti("zapisnik-2.txt", "Ana"))
        finally:
            os.rename("zapisnik-2.txt", "zapisnik.txt")

    def test_02_osebe(self):
        self.assertEqual(['Cilka', 'Ema', 'Berta', 'Dani', 'Greta'], osebe("zapisnik.txt", "kip"))
        self.assertEqual(['Fanči', 'Helga'], osebe("zapisnik.txt", "perzijska preproga"))
        self.assertEqual([], osebe("zapisnik.txt", "stol brez noge"))

    def test_03_podobnost_oseb(self):
        self.assertAlmostEqual(0.2, podobnost_oseb("zapisnik.txt", "Ana", "Berta"))
        self.assertAlmostEqual(0.5, podobnost_oseb("zapisnik.txt", "Cilka", "Ema"))
        self.assertAlmostEqual(0.25, podobnost_oseb("zapisnik.txt", "Ana", "Cilka"))
        self.assertAlmostEqual(1 / 6, podobnost_oseb("zapisnik.txt", "Berta", "Cilka"))
        self.assertAlmostEqual(1, podobnost_oseb("zapisnik.txt", "Berta", "Berta"))

    def test_04_podobnost_predmetov(self):
        self.assertAlmostEqual(0.4, podobnost_predmetov("zapisnik.txt", "kip", "skodelice"))
        self.assertAlmostEqual(1 / 7, podobnost_predmetov("zapisnik.txt", "kip", "slika"))
        self.assertAlmostEqual(0, podobnost_predmetov("zapisnik.txt", "kip", "perzijska preproga"))
        self.assertAlmostEqual(1, podobnost_predmetov("zapisnik.txt", "kip", "kip"))


# class TestPriporocila(NoWarning):
#     def test_01_priporoci_predmet(self):
#         self.assertEqual("srebrn jedilni servis", priporoci_predmet("zapisnik.txt", "kip"))
#         self.assertEqual("Meldrumove vaze", priporoci_predmet("zapisnik.txt", "slika"))
#
#     def test_02_priporoci_prijatelja(self):
#         self.assertEqual("Fanči", priporoci_prijatelja("zapisnik.txt", "Ana"))
#         self.assertEqual("Dani", priporoci_prijatelja("zapisnik.txt", "Berta"))
#

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