# Den foreløpig endelige versjonen av programmet som modellerer en vei
# med hus som eies av personer. Husene kjedes sammen til ei lenkeliste
# (gate/vei) ved hjelp av de klassen Lenkeliste. Denne bruker igjen nodeobjekter for å 
# å lage lenkelista
# Denne versjonen skrevet 25. april 2023, michael@uio.no

class Node :
    def __init__(self, nytt) :
        self._innhold = nytt
        self._neste = None

    def settNeste (self, ny) :
        self._neste = ny

    def neste (self) :
        return self._neste

    def hentData (self) :
        return self._innhold

class Lenkeliste :   
    def __init__(self) :
        self._lliste = None
        self._ANTALL = 0
        

    def push(self, innhold):
        ny = Node(innhold)
        ny.settNeste(self._lliste)
        self._lliste = ny
        self._ANTALL += 1

    def pop(self):
        ut = self._lliste.hentData()
        self._lliste = self._lliste.neste()
        self._ANTALL -= 1
        return ut

    def ikkeTom(self):
        return self._lliste is not None
        # alternativt: return Lenkeliste.ANTALL == 0

    def finn(self, innh):
        node = self._lliste
        funnet = False
        returverdi = None
        while  node != None and not funnet:
            if node.hentData() == innh: # det vi leter etter
                # Her må brukeren av klassen selv presisere == ved å definere __eq__
                funnet = True # løkka vil terminere
                returverdi = node.hentData()
            else:
                node = node.neste()
                # hvis vi leter etter noe som ikke finnes, blir denne None tilslutt og løkka terminerer
        return returverdi
    
    def lag_innholdsliste(self):
        # returnerer ei liste (list) av nodenes innhold
        # Hvis vi skal bruke pop() til å hente ut data, må vi ta vare på lista og antall noder
        listekopi = self._lliste
        ant = self._ANTALL # fordi pop() minker antallet
        returliste = []
        while self.ikkeTom():
            returliste.append(self.pop())
        self._ANTALL = ant
        self._lliste = listekopi # gjenoppretter lista
        return returliste
    
    def skriv_ut_hele_lista(self):
        for elem in self.lag_innholdsliste():
            print(elem)
       
class Hus:
    def __init__(self, farge, refTilEier):
        self._farge = farge
        self._eier = refTilEier # Nå kan vi sette eier når husobjektet lages
        self.neste = None 

    def sett_eier(self, hvem):
        self._eier = hvem

    def hent_eier(self):
        return self._eier

    def mal(self, farge):
        self._farge = farge

    def hent_farge(self):
        return self._farge
    
    def __str__(self):
        return "Et hus med fargen " + self.hent_farge() + " som eies av " + self.hent_eier().hent_navn()
    
    def __eq__(self, andre):
        # En magisk metode som bestemmer om self == andre (to husobjekter)
        # Vi legger til grunn at en person kun kan eie ett hus med en bestemt farge,
        # m.a.o. er to hus like hvis de har samme farge og eier med samme navn:
        samme_eier = ( self._eier.hent_navn() == andre.hent_eier().hent_navn() )
        samme_farge = ( self.hent_farge() == andre.hent_farge() )
        # høyresiden i tilordningene er logiske uttrykk som får verdi True eller False
        # En slik logisk (boolsk) verdi kan tilordnes en variabel, akkurat som andre verdier
        # ()-ene ytterst er ikke nødvendige, men skrevet inn for tydelighet
        return samme_eier and samme_farge
        # det siste er det samme som:
        # if samme_eier and samme_farge:
        #    return True
        # else:
        #    return False

class Person:
    def __init__(self, navn):
        self._navn = navn

    def hent_navn(self):
        return self._navn
    
    def __str__(self):
        return self._navn
    
gate = Lenkeliste()

ola = Person("Ola")
olas_hus = Hus("blå", ola)
gate.push(olas_hus)

karis_hus = Hus("rød", Person("Kari"))
gate.push(karis_hus)

farge = "gul"
gate.push(Hus(farge, Person("Ita")))

def nytt_hus_med_eier(eiernavn, husfarge):
# eiernavn er navn på huseier/person (str)
# husfarge er fargen til det nye huset (str)
# Nå kan vi gjøre alt i ett uttrykk:
    return Hus(husfarge, Person(eiernavn))


gate.push(nytt_hus_med_eier("Ulv", "grått"))
gate.push(nytt_hus_med_eier("Ada", "oransje"))
gate.push(nytt_hus_med_eier("Gard", "akvamarin"))
gate.push(Hus("grønn", Person("Ane")))

for hus in gate.lag_innholdsliste():
    print(hus.hent_eier().hent_navn(), "eier et hus med farge", hus.hent_farge())  

for hus in gate.lag_innholdsliste():
    print(hus.hent_eier(), "eier huset", hus)

gate.skriv_ut_hele_lista()

# Koda i/etter forlesningen 25. april:
# Definere __str__ i Hus og Person
# Skrive en metode i Lenkeliste som skriver ut hele lista
# Definere __eq__ slik at vi kan bruke finn-metoden i Lenkeliste til å finne Hus

ethus = Hus("gul", Person("Ulv"))
print(gate.finn(ethus))
ethus = Hus("grått", Person("Ulv"))
print(gate.finn(ethus))