class Ido:
    def __init__(self, ora, perc):
        osszperc = ora * 60 + perc
        self.ora = osszperc // 60
        self.perc = osszperc % 60

    def percbe(self) -> int:
        return self.ora * 60 + self.perc

    def __str__(self):
        return str(self.ora) + ':' + str(self.perc)

    def __add__(self, other):
        return Ido(0, self.percbe() + other.percbe())

    def __sub__(self, other):
        return Ido(0, abs(self.percbe() - other.percbe()))


class Fajl:
    def __init__(self, fnev):
        self.fnev = fnev

    def beolvas(self):
        """fajl adatainak beolvasasa"""
        f = open(self.fnev)
        adatok = {}  # dict, amelynek kulcsa az azonosito és értékei az áthaladasokat tartalmazo lista
        ssz = 1  # azonos idok miatt el kell tarolni a belepes sorszamat
        for sor in f.readlines():
            ora, perc, az, irany = sor.split()
            adatok[az] = adatok.get(az, [])
            adatok[az].append([ssz, Ido(int(ora), int(perc)), irany])
            ssz += 1
        f.close()
        return adatok

    def kiir(self, adatok):
        """fajlba iras"""
        f = open(self.fnev, 'w')
        print(adatok, end='', file=f)
        f.close()


class Szemely:

    def __init__(self, azon):
        fajl = Fajl('ajto.txt')
        adatok = fajl.beolvas()  # dict, amelynek kulcsa az azonosito és értékei az áthaladasokat tartalmazo lista
        self.azon = azon  # szemely azonositoja
        self.athaladas = adatok[self.azon]  # osszes athaladasa az ajton

    def athaladas_kap(self, adat):
        """athaladasok atadasa"""
        self.athaladas = adat
        return self.athaladas

    def athaladas_db(self) -> int:
        """az ajton torteno athaladasok szama"""
        return len(self.athaladas)

    def bent_maradt(self) -> bool:
        """bent maradt-e a tarsalgoban"""
        return [False, True][len(self.athaladas) % 2 == 1]

    def beido(self) -> Ido:
        """a tarsalgoba lepes ideje"""
        return self.athaladas[0][1]

    def besorszam(self) -> int:
        """a tarsalgoba lepes sorszama"""
        return self.athaladas[0][0]

    def kiido(self) -> Ido:
        """az utolso ki ideje"""
        # ha bent maradt akkor az utolso elotti ideje
        return [self.athaladas[-1][1], self.athaladas[-2][1]][self.bent_maradt()]

    def kisorszam(self) -> int:
        """a tarsalgoba lepes sorszama"""
        # ha bent maradt akkor az utolso elotti sorszama
        return [self.athaladas[-1][0], self.athaladas[-2][0]][self.bent_maradt()]

    def idok_kiir(self) -> str:
        """a benttartozkodasi idok formazott kiirasa"""
        sz = ''
        i = 0
        for ssz, ido, irany in self.athaladas:
            sz += str(ido.ora) + ':' + str(ido.perc)
            sz += ['-', '\n'][i % 2 == 1]  # anikir kimegy, sortores
            i += 1
        return sz

    def bent_db(self) -> int:
        """a tarsalgoban tartozkodas szama"""
        return int(len(self.athaladas) / 2 + 0.5)  # lehet, hogy nem jott ki

    def bent_ido(self) -> int:
        """tarsalgoban toltott ido"""
        at = self.athaladas
        if self.bent_maradt():
            at.append([Ido(15, 0), 'ki'])
        be, ki = Ido(0, 0), Ido(0, 0)
        for ssz, ido, irany in at:
            if irany == 'be':
                be += ido
            else:
                ki += ido
        return (ki - be).percbe()

    def vege_kiir(self) -> str:
        """a tarsalgobaan eltoltott ido kiirasa"""
        sz = 'A(z) ' + self.azon + '. személy összesen ' + str(self.bent_db()) + ' alkalommal volt a társalgóban, '
        sz += 'ahol összesen ' + str(self.bent_ido()) + ' percet töltött és a mefigyelés végén '
        sz += ['nem volt a társalgóban.', 'a társalgóban volt.'][self.bent_maradt()]
        return sz


class Ajto:
    """az ajto osztalya"""
    def __init__(self):
        fajl = Fajl('ajto.txt')
        adatok = fajl.beolvas()
        szemelyek = []
        for azon in adatok:
            szemely = Szemely(azon)
            szemely.athaladas_kap(adatok[azon])
            szemelyek.append(szemely)
        self.szemelyek = szemelyek

    def elso(self):
        """elso szemely azonositoja, aki belepett a tarsalgoba"""
        elsoszemely = [szemely for szemely in self.szemelyek if
                       szemely.besorszam() == min(szemely.besorszam() for szemely in self.szemelyek)]
        return elsoszemely[0].azon

    def utolso(self):
        """utolso szemely azonositoja, aki kilepett a tarsalgobol"""
        elsoszemely = [szemely for szemely in self.szemelyek if
                       szemely.kisorszam() == max(szemely.kisorszam() for szemely in self.szemelyek)]
        return elsoszemely[0].azon

    def athaladasok_szama(self) -> list:
        """athaladasok szama azonosito szerint"""
        return [(szemely.azon, szemely.athaladas_db()) for szemely in self.szemelyek]

    def athaladasok_szama_kiir(self) -> str:
        """athaladasok szama azonosito szerint kiir"""
        sz = ''
        for azon, db in sorted(self.athaladasok_szama(), key=lambda x: int(x[0])):
            sz += azon + ' ' + str(db) + '\n'
        return sz

    def bentmaradtak(self) -> list:
        """azok a szemelyek, akik bent maradtak"""
        return [szemely for szemely in self.szemelyek if szemely.bent_maradt()]

    def bentmaradtak_azon_kiir(self) -> str:
        """azok a szemelyek azonositoja, akik bent maradtak"""
        sz = ''
        for szemely in sorted(self.bentmaradtak(), key=lambda x: int(x.azon)):
            sz += szemely.azon + ' '
        return sz

    def legtobben_egyidoben(self) -> Ido:
        """a legtobben bentlevok ideje"""
        bent = 0
        maxbent = 0
        ido = Ido(0, 0)
        athaladasok = []  # kigyujtjuk a athaladasokat
        for szemely in self.szemelyek:
            athaladasok.extend(szemely.athaladas)
        for athalad in sorted(athaladasok):  # sorbarendezve a sorszam szerint
            if athalad[2] == 'be':
                bent += 1
            else:
                bent -= 1
            if bent > maxbent:
                maxbent = bent
                ido = athalad[1]
        return ido


# 2. feladat
ajto = Ajto()
print("2. feladat")
print("Az első belépő:", ajto.elso())
print("Az utolsó kilépő:", ajto.utolso())

# 3. feladat
print("3. feladat: fájlbaírása az áthaladások számának")
fajl = Fajl('athaladasOOP.txt')
fajl.kiir(ajto.athaladasok_szama_kiir())

# 4. feladat
print("4. feladat\nA végén a társalgóban voltak:", ajto.bentmaradtak_azon_kiir())

# 5. feladat
print("5. feladat\nPéldául ", ajto.legtobben_egyidoben(), "-kor voltak a legtöbben a társalgóban.", sep='')

# 6. feladat
id = input("6. feladat\nAdjon meg egy azonosítót: ")
szemely = Szemely(id)
print("7. feladat\n", szemely.idok_kiir(), sep='')

# 8. feladat
print("8. feladat")
print(szemely.vege_kiir())