import random
import pygame
import sas_pygame as sas

# Farbkonstanten wie im Java-Programm
HELLBRAUN = (255, 127, 36)
HELLBLAU  = (99, 184, 255)

GREEN   = (0, 200, 0)
RED     = (255, 0, 0)
BLUE    = (0, 0, 255)
YELLOW  = (255, 255, 0)
MAGENTA = (255, 0, 255)


class Spielfeld:
    def __init__(self):
        # Gehäuse
        self.gehaeuse = sas.Rectangle(0, 0, 270, 660, (139, 69, 19))

        # Eingabecodes, Ergebnisse, geheimer Code
        self.eingabeCode = [[None for _ in range(4)] for _ in range(12)]
        self.ergebnisse  = [[None for _ in range(4)] for _ in range(12)]
        self.code        = [None for _ in range(4)]

        # Eingabekreise
        for row in range(12):
            for col in range(4):
                self.eingabeCode[row][col] = sas.Circle(
                    110 + 50 * (col - 1),
                    610 - 50 * row,
                    20,
                    HELLBRAUN,
                )

        # Code-Kreise (oben)
        for j in range(4):
            self.code[j] = sas.Circle(
                110 + 50 * (j - 1),
                10,
                20,
                HELLBRAUN,
            )

        # Sichtblende über dem Code
        self.sichtblende = sas.Rectangle(0, 0, 270, 50, "red")
        self.sichtblende.set_hidden(False)

        # Ergebnis-Kreise (klein)
        for row in range(12):
            self.ergebnisse[row][0] = sas.Circle(10,  610 - 26 - 50 * (row - 1), 6, HELLBRAUN)
            self.ergebnisse[row][1] = sas.Circle(30,  610 - 26 - 50 * (row - 1), 6, HELLBRAUN)
            self.ergebnisse[row][2] = sas.Circle(10,  610 - 46 - 50 * (row - 1), 6, HELLBRAUN)
            self.ergebnisse[row][3] = sas.Circle(30,  610 - 46 - 50 * (row - 1), 6, HELLBRAUN)

        # Button „prüfen“ und aktuelle Reihen-Nummer
        self.pruefenbtn = sas.Button(90, 670, 90, 20, "prüfen", "green")
        self.reihenNr   = sas.Text(5, 665, "1", "black")
        self.reihenNr.setFont(30)

        # Status-Text
        self.status = sas.Text(5, 640, "", "white")
        self.status.setFont(18)

    # ---- Hilfsfunktionen ----

    def update_row_label(self, row_index: int):
        self.reihenNr.set_text(str(row_index + 1))

    def set_message(self, text: str):
        self.status.set_text(text)

    def gib_naechste_farbe(self, aktuelle_farbe):
        """entspricht gibNaechsteFarbe in Java"""
        farbe = GREEN
        if aktuelle_farbe == HELLBRAUN:
            farbe = GREEN
        elif aktuelle_farbe == GREEN:
            farbe = RED
        elif aktuelle_farbe == RED:
            farbe = BLUE
        elif aktuelle_farbe == BLUE:
            farbe = YELLOW
        elif aktuelle_farbe == YELLOW:
            farbe = HELLBLAU
        elif aktuelle_farbe == HELLBLAU:
            farbe = MAGENTA
        elif aktuelle_farbe == MAGENTA:
            farbe = GREEN
        return farbe

    def erzeuge_code(self):
        for i in range(4):
            zuf = random.randint(0, 5)
            if zuf == 0:
                farbe = GREEN
            elif zuf == 1:
                farbe = RED
            elif zuf == 2:
                farbe = BLUE
            elif zuf == 3:
                farbe = YELLOW
            elif zuf == 4:
                farbe = HELLBLAU
            else:
                farbe = MAGENTA
            self.code[i].set_color(farbe)

    def gib_anzahl_pos_und_farbe_richtig(self, row: int) -> int:
        anzahl = 0
        for i in range(4):
            if self.eingabeCode[row][i].color == self.code[i].color:
                anzahl += 1
        return anzahl

    def gib_farb_nr(self, farbe) -> int:
        if farbe == GREEN:
            return 0
        elif farbe == RED:
            return 1
        elif farbe == BLUE:
            return 2
        elif farbe == YELLOW:
            return 3
        elif farbe == HELLBLAU:
            return 4
        elif farbe == MAGENTA:
            return 5
        else:
            return -1

    def gib_anzahl_farbe_richtig(self, row: int) -> int:
        """richtige Farbe, aber falsche Position (weiß)"""
        anzahl = 0
        farbenCode = [0] * 6
        farbenEingabe = [0] * 6

        for i in range(4):
            if self.eingabeCode[row][i].color != self.code[i].color:
                nr_code = self.gib_farb_nr(self.code[i].color)
                if nr_code > -1:
                    farbenCode[nr_code] += 1

                nr_eing = self.gib_farb_nr(self.eingabeCode[row][i].color)
                if nr_eing > -1:
                    farbenEingabe[nr_eing] += 1

        for i in range(6):
            anzahl += min(farbenCode[i], farbenEingabe[i])
        return anzahl

    def zeige_ergebnis(self, row: int, schwarz: int, weiss: int):
        for i in range(schwarz):
            self.ergebnisse[row][i].set_color((0, 0, 0))
        for j in range(schwarz, schwarz + weiss):
            if j < 4:
                self.ergebnisse[row][j].set_color((255, 255, 255))

    def zeige_loesung(self):
        self.sichtblende.set_hidden(True)


class MastermindGame:
    def __init__(self):
        self.spielfeld = Spielfeld()
        self.current_row = 0
        self.game_over = False

        self.spielfeld.erzeuge_code()
        self.spielfeld.update_row_label(self.current_row)
        self.spielfeld.set_message("Farben wählen, dann 'prüfen' klicken.")

    def update(self, view):
        """Ein Logik-Schritt pro Frame – KEINE while-Schleife hier!"""


        # Wenn Spiel vorbei -> nichts interaktives mehr
        if self.game_over:
            return

        row = self.current_row

        # 1. Farbauswahl in aktueller Reihe per Mausklick
        for col in range(4):
            kreis = self.spielfeld.eingabeCode[row][col]
            if kreis.mouse_clicked():
                neue_farbe = self.spielfeld.gib_naechste_farbe(kreis.color)
                kreis.set_color(neue_farbe)

        # 2. Prüfen-Button
        if self.spielfeld.pruefenbtn.clicked():
            schwarz = self.spielfeld.gib_anzahl_pos_und_farbe_richtig(row)
            weiss   = self.spielfeld.gib_anzahl_farbe_richtig(row)
            self.spielfeld.zeige_ergebnis(row, schwarz, weiss)

            if schwarz == 4:
                # Code erraten
                self.game_over = True
                self.spielfeld.zeige_loesung()
                self.spielfeld.set_message("Aufgabe gelöst – Herzlichen Glückwunsch!")
            else:
                if row >= 11:
                    # keine Zeilen mehr
                    self.game_over = True
                    self.spielfeld.zeige_loesung()
                    self.spielfeld.set_message("Leider nicht gelöst.")
                else:
                    # nächste Reihe freigeben
                    self.current_row += 1
                    self.spielfeld.update_row_label(self.current_row)
                    self.spielfeld.set_message("Farben wählen, dann 'prüfen' klicken.")



def main():
    view = sas.createView(270, 700,"yellow","Mastermind")
    game = MastermindGame()
    while view.running:
        view.step()   # sammelt Events, klicks, Tasten usw.
        game.update(view)        
    pygame.quit()


main()