#All rights reserved by Nicolas Menet
#Before use please ask kindly

from enum import Enum

class Fachart(Enum):
  Nichts = 0
  Anwendung_der_MathematikA = 1
  Anwendung_der_MathematikC = 2
  InformatikA = 3
  InformatikC = 4
  PhysikA = 5
  PhysikC = 6
  ChemieA = 7
  ChemieC = 8
  BiologieA = 9
  BiologieC = 10
  EnglischB = 11
  FranzoesischB = 12
  DeutschB = 13
  LateinB = 14
  SpanischB = 15



class Schueler:

  def __init__(self, name, pkas: list, pkbs: list, pkcs: list):#Three object lists for the different PK(Fachart)
    self.name = name
    self.pksoptions = []
    self.pksoptions.append(pkas)
    self.pksoptions.append(pkbs)
    self.pksoptions.append(pkcs)
    self.pks = []
    self.pks.append(Fachart.Nichts)#PKA
    self.pks.append(Fachart.Nichts)#PKB
    self.pks.append(Fachart.Nichts)#PKC


class Fach:

  def __init__(self, fachart:Fachart, mindest_zahl:int, maximal_zahl:int):
    self.name = str(fachart.value)
    self.art = fachart
    self.mindest_zahl = mindest_zahl
    self.maximal_zahl = maximal_zahl
    self.zahl = 0

class Stundenplan:

  def get_Fach_by_Fachart(self,fachart):
    for fach in self.faecher:
      if fach.art == fachart:
          return fach
    raise 'Fach mit dieser Fachart existiert nicht'

  def __init__(self):
    self.faecher = []
    self.schueler = []
    self.problem_faecher_zuviel = []
    self.problem_faecher_zuwenig = []
    self.problem_schueler_zuviel = []


  def add_Fach(self, fachart:Fachart, mindest_zahl:int, maximal_zahl:int):
    self.faecher.append(Fach(fachart,mindest_zahl,maximal_zahl))

  def add_Schueler(self, name, pka: list, pkb: list, pkc: list):
    self.schueler.append(Schueler(name,pka,pkb,pkc))


  def fuege_schueler_fach_hinzu(self,schueler,fachart,pkabc):#pkabc: 0-> PKA, 1-> PKB, 2-> PKC
    for fach in self.faecher:


      if fach.art == fachart:
        pk_fach = fach
        if pk_fach.maximal_zahl > pk_fach.zahl:
          pk_fach.zahl += 1
          schueler.pks[pkabc] = fachart
          return True
        else:
          return False
    return False #Falls Fach schon entfernt wurde

  #PKA
  def schueler_umverteilen(self,schueler,methode,pkabc): #Methode 0:Unterfüllte 2. Wahl, Methode 1: 2. Wahl, Methode 2: Untefüllte 3. Wahl, Methode 3: 3. Wahl
      if methode == 0:
          for pfzw in self.problem_faecher_zuwenig:
              if schueler.pksoptions[pkabc][1] == pfzw:#Student, welcher im Überfüllten Fach ist, jedoch ein unterfülltes Fach auffüllen könnte (2. Wahl)
                    self.fuege_schueler_fach_hinzu(schueler,pfzw,pkabc)
                    return pfzw

      if methode == 1:
          if self.fuege_schueler_fach_hinzu(schueler,schueler.pksoptions[pkabc][1],pkabc):#Student, welcher im Überfüllten Fach ist, jedoch die 2. Wahl noch frei ist
              return schueler.pksoptions[pkabc][1]

      if methode == 2:
          for pfzw in self.problem_faecher_zuwenig:#Student, welcher im Überfüllten Fach ist und sein zweites Fach auch überfüllt ist, jedoch die 3. Wahl
              if schueler.pksoptions[pkabc][2] == pfzw:
                  self.fuege_schueler_fach_hinzu(schueler,pfzw,pkabc)
                  return pfzw
      if methode == 3:
          if self.fuege_schueler_fach_hinzu(schueler,schueler.pksoptions[pkabc][2],pkabc):
              return schueler.pksoptions[pkabc][2]

      return Fachart.Nichts

  def optimiere_pk(self,pkabc):
    #Optimiere PKA/PKB/PKC
    for schueler in self.schueler:
        if not self.fuege_schueler_fach_hinzu(schueler,schueler.pksoptions[pkabc][0],pkabc):
            self.problem_faecher_zuviel.append(schueler.pksoptions[pkabc][0])
            self.problem_schueler_zuviel.append(schueler)
    #Welche Fächer sind problematisch
    for fach in self.faecher:
        if fach.mindest_zahl > fach.zahl:
            self.problem_faecher_zuwenig.append(fach)

    #Fülle Fächer mit 1. Methode
    for schueler in self.problem_schueler_zuviel:
        fach = self.schueler_umverteilen(schueler,0,pkabc)
        if fach != Fachart.Nichts:
            fach = self.get_Fach_by_Fachart(fach)
            self.problem_schueler_zuviel.remove(schueler)
            if fach.mindest_zahl <= fach.zahl:
                self.problem_faecher_zuwenig.remove(fach)
    #Fülle Fächer mit 2. Methode
    for schueler in self.problem_schueler_zuviel:
        fach = self.schueler_umverteilen(schueler,1,pkabc)
        if fach != Fachart.Nichts:
            fach = self.get_Fach_by_Fachart(fach)
            self.problem_schueler_zuviel.remove(schueler)
            if fach.mindest_zahl <= fach.zahl:
                self.problem_faecher_zuwenig.remove(fach)
    #Fülle Fächer mit 3. Methode
    for schueler in self.problem_schueler_zuviel:
        fach = self.schueler_umverteilen(schueler,2,pkabc)
        if fach != Fachart.Nichts:
            fach = self.get_Fach_by_Fachart(fach)
            self.problem_schueler_zuviel.remove(schueler)
            if fach.mindest_zahl <= fach.zahl:
                self.problem_faecher_zuwenig.remove(fach)
    #Fülle Fächer mit 4. Methode
    for schueler in self.problem_schueler_zuviel:
        fach = self.schueler_umverteilen(schueler,3,pkabc)
        if fach != Fachart.Nichts:
            fach = self.get_Fach_by_Fachart(fach)
            self.problem_schueler_zuviel.remove(schueler)
            if fach.mindest_zahl <= fach.zahl:
                self.problem_faecher_zuwenig.remove(fach)

  def optimiere(self):
    #Probiere alle ins Lieblingsfach
    print([fach.name for fach in self.faecher])
    self.optimiere_pk(0)#PKA
    self.optimiere_pk(1)#PKB
    self.optimiere_pk(2)#PKC
    for fach in self.faecher:
      if fach.mindest_zahl > fach.zahl:
        self.faecher.remove(fach)
        print('Fachart ' + fach.name + '  kann nicht durchgeführt werden, leider haben sich zu wenige Schüler dafür angemeldet')
        #Entferne Schüler von Fächer -> Neu initialisierung
        for fach in self.faecher:
          fach.zahl = 0
        self.optimiere()#Neue Optimierung

stpln = Stundenplan()

stpln.add_Fach(Fachart.Anwendung_der_MathematikA,10,20)
stpln.add_Fach(Fachart.Anwendung_der_MathematikC,10,20)
stpln.add_Fach(Fachart.InformatikA,10,20)
stpln.add_Fach(Fachart.InformatikC,10,20)
stpln.add_Fach(Fachart.PhysikA,10,20)
stpln.add_Fach(Fachart.PhysikC,10,20)
stpln.add_Fach(Fachart.ChemieA,10,20)
stpln.add_Fach(Fachart.ChemieC,10,20)
stpln.add_Fach(Fachart.BiologieA,10,20)
stpln.add_Fach(Fachart.BiologieC,10,20)
stpln.add_Fach(Fachart.EnglischB,10,20)
stpln.add_Fach(Fachart.FranzoesischB,10,20)
stpln.add_Fach(Fachart.DeutschB,10,20)
stpln.add_Fach(Fachart.LateinB,10,20)
stpln.add_Fach(Fachart.SpanischB,10,20)

stpln.add_Schueler('Nicolas Menet',[Fachart.Anwendung_der_MathematikA,Fachart.InformatikA,Fachart.PhysikA],[Fachart.DeutschB,Fachart.EnglischB,Fachart.LateinB],[Fachart.Anwendung_der_MathematikC,Fachart.BiologieC,Fachart.ChemieC])




stpln.optimiere()