class Szin:
    """A szinek osztálya"""
    def __init__(self, r, g, b):
        self.R = r
        self.G = g
        self.B = b
        self.RGBosszeg = self.R + self.G + self.B

    def __str__(self):
        return '(' + str(self.R) + ',' + str(self.G)+ ',' +  str(self.B) + ')'

    def vilagos_szin(self):
        return self.R + self.G + self.B > 600


class Pont:
    """pontok osztálya. Egy pontnak van sor- és oszlopszáma és szine"""
    def __init__(self, sor=0, oszlop=0, szin=None):
        self.sor = sor
        self.oszlop = oszlop
        self.szin = szin

    def __str__(self):
        return 'RGB' + str(self.szin)

    def vilagos_pont(self):
        return self.szin.vilagos_szin()


class Kep:
    """A képet megvakósító osztály"""
    def __init__(self, pontok=None):
        if pontok is None:
            pontok = []
        self.pontok = pontok

    def kep_egy_pontja(self, sor, oszlop):
        for pont in self.pontok:
            if pont.sor == sor and pont.oszlop == oszlop:
                return Pont(sor, oszlop, pont.szin)

    def vilagos_pontok_szama(self) -> int:
        return sum(1 for pont in self.pontok if pont.vilagos_pont())

    def sotet(self) -> int:
        """a legkisebb RGB összeg a kép szinei között"""
        return min(pont.szin.RGBosszeg for pont in self.pontok)

    def legsotetebb_szinek(self) -> list:
        """a képen szereplő legsötétebb szinek"""
        s = self.sotet()
        return [pont for pont in self.pontok if pont.szin.RGBosszeg == s]


    def legsotetebb_szinek_kiir(self) -> str:
        sz = ''
        for pont in self.legsotetebb_szinek():
            sz += str(pont)+'\n'
        return sz

    def sordb(self) -> int:
        """kép sorainak száma"""
        return sum(1 for pont in self.pontok if pont.sor == sor)
        # return 360

    # def hatar(self, sor, elteres):
    #     """5. feladat.  egy adott sorban van-e olyan hely a képen,
    #     ahol az egymás melletti képpontok kék színösszetevőinek eltérése meghalad egy adott értéket """
    #     van = False
    #     for i in range(1, 640):
    #         if abs(self.kep_egy_pontja(sor, i + 1).szin.B - self.kep_egy_pontja(sor, i).szin.B) > elteres:
    #             van = True
    #             break
    #     return van

    def hatar(self, sor, elteres):
        sor_pontjai = [pont for pont in self.pontok if pont.sor == sor]

        for i in range(len(sor_pontjai)-1):
            if sor_pontjai[i + 1].szin.B - sor_pontjai[i].szin.B > elteres:
                return True
        return False



    def felho_elso_sora(self):
        """felhő szélső sorait adja"""
        for i in range(1, self.sordb()):
            if self.hatar(i, 10):
                return i
        return None

    def felho_szelei(self):
        """felhő szélső sorait adja"""
        felhosorok = []
        for i in range(1, self.sordb()):
            if self.hatar(i, 10):
                felhosorok.append(i)
        return min(felhosorok), max(felhosorok)


class Fajl:
    """Fajlmuveletek osztalya"""

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

    def beolvas(self):
        """fajl adatainak beolvasasa"""
        pontok = []
        with open(self.fnev, encoding='utf-8') as f:
            s = 1
            for sor in f.readlines():
                i = 0
                r, g, b = None, None, None
                for sz in sor.split():

                    if i % 3 == 0:
                        r = int(sz)
                    elif i % 3 == 1:
                        g = int(sz)
                    else:
                        b = int(sz)
                        szin = Szin(r, g, b)
                        pontok.append(Pont(s, i // 3 + 1, szin))
                    i += 1
                s += 1
        return pontok

    def kiir(self, adatok):
        """fajlba iras"""
        with open(self.fnev, 'w', encoding='utf-8') as f:
            print(adatok, end='', file=f)


# 1. feladat
fajl = Fajl('kep.txt')
kep = Kep(fajl.beolvas())

# 2. feladat
print("2. feladat:\nKérem egy képpont adatait!")
sor = int(input("Sor: "))
oszlop = int(input("Oszlop: "))
print("A képpont szine", kep.kep_egy_pontja(sor, oszlop))

# 3. feladat
print("3. feladat:\nA világos képpontok száma:", kep.vilagos_pontok_szama())

# 4. feladat
print("4. feladat\nA legsötétebb RGB összege", kep.sotet())
print(f"A legsötétebb pixelek színe:\n{kep.legsotetebb_szinek_kiir()}")

# 6. feladat
print(f"6.feladat\nA felhő legfelső sora: {kep.felho_szelei()[0]}\nA felhő legalsó sora: {kep.felho_szelei()[1]}")