import math
import random
import pygame
import sas_pygame as sas

# -------------------------------------------------
# Konfiguration / Dateinamen
# -------------------------------------------------
WIDTH  = 600
HEIGHT = 400

BG_IMG    = "aquarium.png"   # Hintergrundbild
FISH_IMG  = "fisch.png"      # Fisch
SHARK_IMG = "hai.png"        # Hai
FOOD_IMG  = "plankton.png"   # Plankton

PLANKTON_SPEED = -1.5          # Geschwindigkeit Plankton (links → rechts)
BG_SPEED       = 0.5          # Scrollgeschwindigkeit Hintergrund


# -------------------------------------------------
# Fisch – bewegt sich immer in seiner Richtung,
# Richtung wird nur per Mausklick geändert,
# an den Rändern reflektiert er.
# -------------------------------------------------
class Fisch:
    def __init__(self, x, y):
        # feste Logik-Abmessungen wie im Java-Programm
        self.w = 80
        self.h = 50
        # Picture links oben anlegen
        self.fisch = sas.Picture(x - self.w // 2, y - self.h // 2,
                               self.w, self.h, FISH_IMG)

        self.speed = 2.0
        # Start: nach rechts schwimmen
        self.vx = self.speed
        self.vy = 0.0

        # nur horizontales Spiegeln, damit der Fisch
        # nie auf dem Kopf steht
        self.flip_h = False


    def bewege(self):
        self.fisch.move(self.speed)
        self.wendeAmRand(self.speed)

    def dreheNach(self, pX, pY):
        alteRichtung = self.fisch.getDirection()
        neueRichtung = sas.Tools.getDirection(self.fisch.getCenterX(), self.fisch.getCenterY(), pX, pY)
        self.fisch.turnTo(neueRichtung)
        self.ausrichten(alteRichtung, neueRichtung)
  
    def  wendeAmRand(self, pD):
        self.richtung = self.fisch.getDirection()
        if self.fisch.getShapeX() < 0  or  self.fisch.getShapeX()+self.fisch.getShapeWidth()>WIDTH:
            self.fisch.turnTo(360 - self.richtung)
            self.fisch.move(3)
            self.ausrichten(self.richtung, self.fisch.getDirection())
        else:
            if self.fisch.getShapeY() < 40 or self.fisch.getShapeY() + self.fisch.getShapeHeight() > HEIGHT:
                self.fisch.turnTo(180-self.richtung)
                self.fisch.move(3)
                self.fisch.move(2*pD);
                self.ausrichten(self.richtung, self.fisch.getDirection())

    def ausrichten(self, pAlteRichtung, pNeueRichtung):
        if pAlteRichtung <= 180 and pNeueRichtung >= 180:        
            self.fisch.turn(270 - pNeueRichtung)
            self.fisch.flipVertical()
            self.fisch.turn(pNeueRichtung - 270)
        elif pAlteRichtung >= 180 and pNeueRichtung <= 180: 
            self.fisch.turn(90 - pNeueRichtung)
            self.fisch.flipVertical()
            self.fisch.turn(pNeueRichtung - 90)

    def getGrafik(self):
        return self.fisch
# -------------------------------------------------
# Hai – doppelt so groß, schwimmt dauerhaft von
# rechts nach links und erscheint wieder rechts.
# -------------------------------------------------
class Hai:
    def __init__(self, x, y):
        # doppelt so groß
        self.w = 280
        self.h = 140
        self.hai = sas.Picture(x - self.w // 2, y - self.h // 2,
                               self.w, self.h, SHARK_IMG)
        self.hai.flipHorizontal()
        # Hai soll von rechts nach links schwimmen
        self.vx = -1.0

    def reset(self):
        hai.moveTo(WIDTH, 200)

    def bewege(self):
        self.hai.move(self.vx, 0)
        cx = self.hai.get_center_x()
        cy = self.hai.get_center_y()
        if self.hai.getShapeX() + self.hai.getShapeWidth() < 0:
            self.zurueck()

    def zurueck(self):
        yPos = sas.Tools.randomNumber(50,200)
        self.hai.moveTo(WIDTH, yPos)

    def frisst(self, fisch):
        return self.hai.intersects(fisch.getGrafik());

class Plankton:

    def __init__(self, pX,  pY, pBild):
        self.plankton = pBild
        self.plankton.moveTo(pX, pY);

    def bewege(self, pDistanz):
        self.plankton.move(pDistanz)  # pDistanz ist dx (bei dir negativ -> nach links)
        if self.plankton.getShapeX() < -20:
            self.plankton.moveTo(WIDTH, sas.Tools.randomNumber(60, HEIGHT-30))
    
    def entferne(self):
       self.plankton.setHidden(True)

    def wirdGefressen(self, pFisch):
      return pFisch.contains(self.plankton);


# -------------------------------------------------
# Plankton – bewegt sich von links nach rechts,
# ist von Anfang an vorhanden.
# -------------------------------------------------
class Futter:
    def __init__(self, pAnzahl):
        self.anzahl = pAnzahl
        self.maxZahl = pAnzahl
        self.futter = []
        for i in range(self.anzahl):
            x = sas.Tools.randomNumber(30, WIDTH - 30)
            y = sas.Tools.randomNumber(60, HEIGHT - 30)
            planktonBild = sas.Picture(x, y, 20, 10,FOOD_IMG)
            self.futter.append(Plankton(x, y, planktonBild))
       
    def reset(self):
        self.anzahl = self.maxZahl;
        for food in self.futter:
            food.entferne()
            x = Tools.randomNumber(30, WIDTH - 30)
            y = Tools.randomNumber(60, HEIGHT - 60)
            food = Plankton(x, y, self.planktonBild)

    def entferne(self, pNr):
        # verstecken
        self.futter[pNr].entferne()
        # wirklich aus der aktiven Liste entfernen
        self.futter.pop(pNr)
        self.anzahl -= 1
    
    def bewege(self, pDistanz):
        for p in self.futter:
            p.bewege(pDistanz)

    def sucheFutter(self, pFisch):
        for i, p in enumerate(self.futter):
            if p.wirdGefressen(pFisch):
                return i
        return -1
  
# -------------------------------------------------
# Aquarium-Hauptklasse
# -------------------------------------------------
class Aquarium:
    def __init__(self):
        # Hintergrund – zwei Bilder für Endlos-Scroll
        self.bg_speed = BG_SPEED
        self.bg1 = sas.Picture(0, 40, WIDTH, HEIGHT-40, BG_IMG)
        self.bg1.flipHorizontal()
        self.bg2 = sas.Picture(WIDTH, 40, WIDTH, HEIGHT-40, BG_IMG)
        self.bg2.flipHorizontal()
        self.spielBeendet = False
        self.punktAnzeige = sas.Text(5,10,"Punkte: 0","blue");

        # Objekte
        self.fisch = Fisch(200, HEIGHT // 2)
        # Hai etwas rechts außerhalb starten, damit er sicher ins Bild schwimmt
        self.hai = Hai(WIDTH - 50, HEIGHT // 2)

        # Plankton von Anfang an
        self.futter = Futter(50)
        self.punkte = 0    

    def bewegeHintergrund(self):
        dx = -self.bg_speed  # nach links

        self.bg1.move(dx, 0)
        self.bg2.move(dx, 0)

    # wenn bg1 komplett links raus ist -> rechts hinter bg2 setzen
        if self.bg1.getShapeX() + self.bg1.getShapeWidth() <= 0:
            self.bg1.moveTo(self.bg2.getShapeX() + self.bg2.getShapeWidth(), 40)

    # wenn bg2 komplett links raus ist -> rechts hinter bg1 setzen
        if self.bg2.getShapeX() + self.bg2.getShapeWidth() <= 0:
            self.bg2.moveTo(self.bg1.getShapeX() + self.bg1.getShapeWidth(), 40)

    def spiele(self):
        self.bewegeHintergrund()
        self.fisch.bewege()
        self.hai.bewege()
        self.futter.bewege(PLANKTON_SPEED)
        if self.hai.frisst(self.fisch) and not self.spielBeendet:
            self.spielBeendet = True
            sas.Tools.message("Du hast das Spielverloren", "Meldung")
        planktonNr = self.futter.sucheFutter(self.fisch.getGrafik())
        if planktonNr > - 1:
            self.futter.entferne(planktonNr)
            self .punkte += 1
            self.punktAnzeige.setText(f"Punkte {self.punkte}")
            if self.punkte == 50:
                self.spielBeendet = True
                sas.Tools.message("Herzlichen Glückwunsch! Du hast das Spiel gewonnen", "Meldung")

# -------------------------------------------------
# Hauptprogramm – EIN while-Loop
# -------------------------------------------------
def main():
    view = sas.createView(WIDTH, HEIGHT,"white","Aquarium")
    spiel = Aquarium()
    while view.running:
        view.step()
        if not spiel.spielBeendet:
            spiel.spiele()
            if view.mouse_clicked():  
                spiel.fisch.dreheNach(view.getMouseX(), view.getMouseY())
    pygame.quit()


main()