import pygame
class PhysicsEntity:

    def __init__(self, game, e_type, pos:tuple, size):
        self.game = game
        self.e_type = e_type
        self.pos = list(pos)
        self.size = size
        self.velocity = [0,0]
        self.collisions = {"top":False, "bottom":False, "left":False, "right":False}
        self.speed = 3

        # Animationen
        self.action = ""
        self.flip = False
        self.animation_offset = (-3, -3)
        self.set_action('idle')

    def update(self, tilemap, movement:tuple=(0,0)):
        self.collisions = {"top":False, "bottom":False, "left":False, "right":False}
        frame_movement = ((movement[0] + self.velocity[0])*self.speed, movement[1] + self.velocity[1])
        self.pos[0] += frame_movement[0]

        entity_rect = self.rect()
        for recto in tilemap.physics_rects_around(self.pos):
            if entity_rect.colliderect(recto):
                if frame_movement[0] > 0:
                    entity_rect.right = recto.left
                    self.collisions["right"] = True
                    self.game.isJumping = False


                if frame_movement[0] < 0:
                    entity_rect.left = recto.right
                    self.collisions["left"] = True
                    self.game.isJumping = False


                self.pos[0] = entity_rect.x
        
        self.pos[1] += frame_movement[1]
        entity_rect = self.rect()

        for rectolino in tilemap.physics_rects_around(self.pos):
            if entity_rect.colliderect(rectolino):

                if frame_movement[1] > 0:
                    entity_rect.bottom = rectolino.top
                    self.collisions["bottom"] = True
                    self.game.isJumping = False

                if frame_movement[1] < 0:
                    entity_rect.top = rectolino.bottom
                    self.collisions["top"] = True

                self.pos[1] = entity_rect.y
        
        if movement[0] > 0:
            self.flip = False
        if movement[0] < 0:
            self.flip = True
        
        if self.collisions['bottom'] or self.collisions['top']:
            self.velocity[1] = 0


        self.velocity[1] = min(5, self.velocity[1] + 0.1)

        self.animation.update()
    def render(self, surface:pygame.Surface, offset:tuple=(0,0)):
        surface.blit(pygame.transform.flip(self.animation.img(), self.flip, False), (self.pos[0] - offset[0] + self.animation_offset[0],self.pos[1] - offset[1] + self.animation_offset[1]))

        
    def rect(self):
        return pygame.Rect(self.pos[0], self.pos[1], self.size[0], self.size[1])
    
    def set_action(self, action):
        if action != self.action:
            self.action = action
            image = self.e_type + "/" + self.action
            self.animation = self.game.assets[image].copy()


class Player(PhysicsEntity):
    def __init__(self, game, pos, size):
        super().__init__(game, "player", pos, size)
        self.air_time = 0  # Neu! Zählt, wie lange wir fallen/springe

    def update(self, tilemap, movement = (0, 0)):
        super().update(tilemap, movement)

        self.air_time += 1

        if self.collisions["bottom"]:
            self.air_time = 0
        # Wenn wir länger als 4 Frames in der Luft sind -> Springen!
        if self.air_time > 4:
            self.set_action('jump')
        
        # Wenn wir nicht in der Luft sind, aber uns bewegen -> Rennen!
        elif movement[0] != 0:
            self.set_action('run')
        
        # Sonst -> Rumstehen!
        else:
            self.set_action('idle')