from random import randint  # Kreves ikke i besvarelse

# Indikasjoner. Bruk skj?nn og helhetlig vurdering
# Der det st?r poeng inne i metoden
# inng?r de i tall ved metodesignatur/ klassedefinisjon
# (skal mao ikke legges til disse)

# 4a) 4 poeng DEF 
class Plagg:
    def __init__(self, farger):             # 2p
        self._farger = farger
        self._ant_antrekk = 0               # 1p av de 2

    def har_farge(self, farge):             # 1p
        return farge in self._farger

    def hent_ant_antrekk(self):
        return self._ant_antrekk

    def oppdater_ant_antrekk(self, endring):    # 1p
        self._ant_antrekk += endring



# 4b) 10p (2P DEF, 5P OO, 3P PRO)
class Kategori:
    def __init__(self, kategorinavn):       # 2p DEF 
        self._kategorinavn = kategorinavn
        self._plagg = []                    # NB tom liste

    def nytt_plagg(self, farger):           # 2p OO
        self._plagg.append(Plagg(farger))   # NB opprettelse Plagg 

    def finn_plagg_med_farge(self, farge):  # 4p (2p OO + 2p PRO)
        plagg_liste = []
        for plagg in self._plagg:
            if plagg.har_farge(farge):      # NB kall p? har_farge 2P OO
                plagg_liste.append(plagg)   # l?kke og liste-bygging 2P PRO
        return plagg_liste

    def trekk_tilfeldig_plagg(self, farge): # 2p (1P PROBL, 1P OO)
        plagg_liste = self.finn_plagg_med_farge(farge) # 1P OO
        if len(plagg_liste) == 0:
            return None
        trukket = randint(0, len(plagg_liste)-1)
        return plagg_liste[trukket]


# 4c) 7p
# 3p Def: Helhet klasse og metoder, setter inn anledning i liste
# 4p OO: Oppdaterer Plagg med metode, kaller har_farge
class Antrekk:                                  
    def __init__(self, anledning, plagg):
        self._plagg = plagg
        self._anledninger = [anledning]

        for et_plagg in self._plagg:
            et_plagg.oppdater_ant_antrekk(1)

    def hent_plaggene(self):
        return self._plagg

    def legg_til_anledning(self, anledning):
        self._anledninger.append(anledning)

    def passer_til(self, anledning):
        return anledning in self._anledninger

    def har_farge(self, farge):
        for plagg in self._plagg:
            if plagg.har_farge(farge):
                return True
        return False


# 4d) 7 p 
# 2P PRO for konstrukt?r m tom ordbok og liste
# 2P PRO for sjekk om Kategori finnes
# 1P OO for opprettelse ny Kategori
# 2P OO for kall p? nytt_plagg
class Garderobe:
    def __init__(self):
        self._kategorier = {}
        self._antrekk = []

    def nytt_plagg(self, kategorinavn, farger): 
        if kategorinavn not in self._kategorier:
            self._kategorier[kategorinavn] = Kategori(kategorinavn)
        self._kategorier[kategorinavn].nytt_plagg(farger)

# 4e) 9p

    # 2P OO, 2P PRO
    # Tom liste hvis ingen funn
    def finn_antrekk_til_anledning(self, anledning):
        passende_antrekk = []
        for antrekk in self._antrekk:
            if antrekk.passer_til(anledning):
                passende_antrekk.append(antrekk)
        return passende_antrekk

    # 2P OO, 3P PRO
    # None hvis ingen ? velge fra
    # Kall p? har_farge and passer_til er ogs? ok:
    def velg_f?rste_antrekk(self, anledning, farge):
        antrekk_liste = self.finn_antrekk_til_anledning(anledning)
        for antrekk in antrekk_liste:
            if antrekk.har_farge(farge):
                return antrekk
        return None 
    
# 4f) 10P

    # 3P OO Kategorinavn vs referanser, kaller trekk_tilfeldig p? objekt
    # 3P PRO: Oppslag, bygger liste, returnerer None om ikke plagg i alle kategorier
    def finn_plagg_til_antrekk(self, kategorinavn, farge): 
        plagg_liste = []
        for navn in kategorinavn:
            if navn not in self._kategorier:
                return None
            kategori = self._kategorier[navn]
            plagg = kategori.trekk_tilfeldig_plagg(farge)
            if plagg is None:
                return None
            plagg_liste.append(plagg)
        return plagg_liste


    # 2P OO for kall p? finn_plagg_til_antrekk og oppretter Antrekk
    # 2P PRO for resten inkl oppgitte returverdier
    def lag_nytt_antrekk(self, kategorinavn, farge, anledning): 
        plagg_liste = self.finn_plagg_til_antrekk(kategorinavn, farge) 
        if plagg_liste is None:
            return False 
        nytt = Antrekk(anledning, plagg_liste)
        self._antrekk.append(nytt)
        return True