# -------------------------------------------------------------------------
# 1. Készítse el az mpbe függvényt, amely az óra, perc, másodperc
#    alakban megadott időpont másodpercben kifejezett értékét adja!
#    A függvényt a megoldásba be kell építenie!
#    Függvény mpbe(o, p, mp:egész szám):egész szám
# -------------------------------------------------------------------------
def mpbe(o, p, mp):
    m = o * 3600 + p * 60 + mp
    return m


# visszaváltjuk a mp-ben meglévő időt óra.perc.mp formába egy lista segítségével
def vissza(mp):
    ora = mp // 3600
    mp = mp % 3600
    perc = mp // 60
    mp = mp % 60
    ido = [ora, perc, mp]
    return ido


# -------------------------------------------------------------------------
# 2. Olvassa be a hivas.txt állományban talált adatokat, s annak
#    felhasználásával oldja meg a következő feladatokat!
# -------------------------------------------------------------------------
print('2. feladat - adatok beolvasása')
fv = open('hivas.txt')
adatok = []
for sor in fv:
    sor = sor.strip().split()  # Pl.: sor=['7','57','36','7','59','59']
    sor2 = []
    # a stringként beolvasott adatok számokká alakítása
    for elem in sor:
        sor2.append(int(elem))  # Pl.: sor2=[7,57,36,7,59,59]
    k = mpbe(sor2[0], sor2[1], sor2[2])  # Pl. k=7*3600+57*60+36 = 28656
    v = mpbe(sor2[3], sor2[4], sor2[5])  # Pl. v=7*3600+59*60+59 = 28799
    ido_adatok = []
    ido_adatok.append(k)
    ido_adatok.append(v)  # Pl. ido_adatok=[28656,28799]
    adatok.append(ido_adatok)  # Pl. adatok=[[28656,28799],...]
    # lista a listában: MÁTRIX
fv.close()

# -------------------------------------------------------------------------
# 3. Készítsen statisztikát, amely megadja, hogy óránként hány hívás
#    futott be! A képernyőn soronként egy óra-darabszám párost jelenítsen
#    meg! Csak azok az órák jelenjenek meg, amelyben volt hívás!
# -------------------------------------------------------------------------
print('3.feladat - óránkénti hívások száma')

ora = [0] * 24  # 24 elemű lista, melyet pontosan az órák indexelnek majd
for elem in adatok:
    index = elem[0] // 3600  # első elem (0 index) mp-ben a hívás ideje
    ora[index] += 1  # //3600: egész osztás (div) --> óra az eredmény
    # ami pont indexeli az ora listát
    # számláljuk, hogy ez az óra előfordult (+1)
for óra in range(0, 24):
    if ora[óra] != 0:
        print('{} óra {} hívás'.format(óra, ora[óra]))

# -------------------------------------------------------------------------
# 4. Írja a képernyőre a leghosszabb hívásnak a sorszámát és másodpercben
#    kifejezett hosszát – attól függetlenül, hogy a hívó tudott-e beszélni
#    az ügyfélszolgálatossal vagy sem! Azonos híváshossz esetén elegendő
#    egyet megjelenítenie.
# -------------------------------------------------------------------------
print('4. feladat')

hívás_hosszak = []
for elem in adatok:
    hívás_hosszak.append(elem[1] - elem[0])  # vége-kezdés mp-ben

leghosszabb = max(hívás_hosszak)
sorszam = hívás_hosszak.index(leghosszabb) + 1  # leghosszabb sorszáma
print('A leghosszabb ideig vonalban levo hivo %d. sorban szerepel, a hivas hossza: %d masodperc.' % (
sorszam, leghosszabb))

# -------------------------------------------------------------------------
# 5. Olvasson be egy munkaidőn belüli időpontot, majd jelenítse meg a
#    képernyőn, hogy hányadik hívóval beszélt akkor az alkalmazott, és éppen
#    hányan vártak arra, hogy sorra kerüljenek! Ha nem volt hívó, akkor a
#    „Nem volt beszélő.” üzenetet jelenítse meg!
# -------------------------------------------------------------------------
print('5. feladat')

print('Kérek egy időpontot: ')
ora = int(input('Óra: '))
perc = int(input('Perc: '))
mp = int(input('Másodperc: '))

keres = mpbe(ora, perc, mp)  # keresett időpont mp-be váltása

varakozok = 0  # várakozók száma
beszelo = 0  # beszélő sorszáma

for elem in adatok:
    if keres >= elem[0] and keres <= elem[1]:
        if beszelo == 0:
            beszelo = adatok.index(elem) + 1  # éppen beszélő sorszáma
        varakozok += 1  # mindenki várakozónak számít, aki a keresettel
        # azonos időpontban bent van a rendszerben
        # a beszélőt is beleértve, ezért majd -1

if beszelo != 0:  # van találat
    print('A várakozók száma: {}, a beszélő a(z) {}. hivo.'.format(varakozok - 1, beszelo))
else:
    print('Nem volt beszélő.')

# -------------------------------------------------------------------------
# 6. Írja a képernyőre, annak a hívónak az azonosítóját, akivel a
#    munkatárs utoljára beszélt! Írja ki a várakozás másodpercekben mért
#    hosszát is! (Ha nem kellett várnia, a várakozási idő 0.)
# -------------------------------------------------------------------------
print('6. feladat')

utolso = 0  # az utolsó hívó indexe lesz ebben
ora12 = mpbe(12, 0, 0)  # ügyfélfogadás vége 12 óra

# Sorban megyünk az adatokon előre:
for i in range(len(adatok)):
    # ha az aktuális hívó<12 és később fejezte be, mint az utolsónak feltételezett
    if adatok[i][0] < ora12 and adatok[i][1] > adatok[utolso][1]:
        # akkor ő az utolsó, és aki utolsónak feltételezett volt,
        # az lesz az előző
        elozo = utolso
        utolso = i

varakozas = adatok[elozo][1] - adatok[utolso][0]
print('Az utolsó telefonáló adatai a(z) {}. sorban vannak, {} masodpercig várt.'.format(utolso + 1, varakozas))

# -------------------------------------------------------------------------
# 7. Készítse el a sikeres.txt állományt, amely az ügyfélszolgálathoz
#    bekapcsolt hívások listáját tartalmazza! A fájl egyes soraiban a hívó
#    sorszáma, a beszélgetés kezdete (amikor az ügyfélszolgálatos fogadta a
#    hívást) és vége szerepeljen az alábbi mintának megfelelő formában!
#    Például a feladat elején olvasható példa bemenet esetén a fájl tartalma:
#       2 8 0 0 8 1 39
#       4 8 1 39 8 4 17
#       …
# -------------------------------------------------------------------------
print('7. feladat - sikeres.txt fájl írása')


def kiírás(index, előző):
    if adatok[előző][1] < ora8:
        kezdőidőpont_beszélő = vissza(ora8)
    else:
        kezdőidőpont_beszélő = vissza(adatok[előző][1])

    végeidőpont_beszélő = vissza(adatok[index][1])
    fájl_sor = ''
    fájl_sor = str(index + 1) + ' '
    for elem in kezdőidőpont_beszélő:
        fájl_sor += (str(elem) + ' ')
    for elem in végeidőpont_beszélő:
        fájl_sor += (str(elem) + ' ')
    fájl_sor += '\n'
    return fájl_sor


fv = open('sikeres.txt', 'w')

ora8 = mpbe(8, 0, 0)  # beszélgetés kezdése 8 óra

elozo = 0
beszelok = []  # ebbe gyűjtjük azok indexét, akikkel beszélt a központos

# Sorban megyünk az adatokon előre, a 0 indexű (előző) utánival kezdve:
for i in range(1, len(adatok)):
    # ha 12 előtti a hívás, de 8 utáni és a vége későbbi, mint az előzőé, akkor...
    if adatok[i][0] < ora12 and adatok[i][1] > ora8 and adatok[i][1] > adatok[elozo][1]:
        # ...ő beszélt a központossal
        fv.write(kiírás(i, elozo))

        beszelok.append(i)  # így eltároljuk
        elozo = i  # és ő lesz az előző, akihez majd a következőt hasonlítjuk

fv.close()