import pygame
import sys
import random

# Initialize Pygame
pygame.init()

# Constants
WIDTH, HEIGHT = 800, 600
FPS = 20
PLAYER_SPEED = 10
JUMP_FORCE = -35
GRAVITY = 4
GROUND_Y = 450
LEVEL_DURATION = 15 * FPS  # 15 seconds per level

# Setup display
screen = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption("Monkey Dodge Game")
clock = pygame.time.Clock()

# Load images
background_png = pygame.image.load("background.png").convert()
background_png = pygame.transform.scale(background_png, (WIDTH, HEIGHT))

idle_img = pygame.image.load("idle.png").convert_alpha()
walk_imgs = [
    pygame.image.load("jump.png").convert_alpha(),
    pygame.image.load("walk1.png").convert_alpha()
]
jump_img = walk_imgs[0]
duck_img = pygame.transform.scale(pygame.image.load("idle.png").convert_alpha(), (60, 60))

obstacle_img = pygame.image.load("log.png").convert_alpha()
obstacle_img = pygame.transform.scale(obstacle_img, (80, 60))

flying_obstacle_img = pygame.image.load("flying_obstacle.png").convert_alpha()
flying_obstacle_img = pygame.transform.scale(flying_obstacle_img, (40, 40))

# Fonts
font = pygame.font.SysFont(None, 60)
small_font = pygame.font.SysFont(None, 30)

# Buttons
button_color = (0, 200, 0)
hover_color = (0, 255, 0)
button_rect = pygame.Rect(WIDTH // 2 - 100, HEIGHT // 2 - 40, 200, 80)
start_text = font.render("Start Game", True, (255, 255, 255))
level_start_button_rect = pygame.Rect(WIDTH // 2 - 100, HEIGHT // 2 - 40, 200, 80)
level_start_text = font.render("Start Level", True, (255, 255, 255))

# Game state
player_name = "gery back gorilla"
player_x, player_y = WIDTH // 2, GROUND_Y
frame = 0
direction = pygame.Vector2(0, 0)
velocity_y = 0
is_jumping = False
on_ground = True
is_ducking = False
player_health = 100
max_health = 100

obstacles = []
flying_obstacles = []
flying_obstacle_states = []
obstacle_timer = 0
base_obstacle_interval = 90
obstacle_speed = 30

level = 1
level_timer = LEVEL_DURATION
max_level = 10

def show_start_menu():
    while True:
        screen.fill((50, 50, 50))
        mouse_pos = pygame.mouse.get_pos()
        click = pygame.mouse.get_pressed()

        color = hover_color if button_rect.collidepoint(mouse_pos) else button_color
        pygame.draw.rect(screen, color, button_rect)
        screen.blit(start_text, (button_rect.x + 25, button_rect.y + 20))

        controls_text = [
            "Controls:",
            "W or SPACE = Jump",
            "A = Left",
            "D = Right",
            "S = Duck"
        ]
        for i, line in enumerate(controls_text):
            control_surface = small_font.render(line, True, (255, 255, 255))
            screen.blit(control_surface, (20, 20 + i * 30))

        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                pygame.quit()
                sys.exit()

        if button_rect.collidepoint(mouse_pos) and click[0]:
            break

        pygame.display.flip()
        clock.tick(60)

def show_level_start_menu(level):
    global player_health, flying_obstacles, obstacles, obstacle_timer, flying_obstacle_states
    while True:
        screen.fill((50, 50, 50))
        mouse_pos = pygame.mouse.get_pos()
        click = pygame.mouse.get_pressed()

        level_text = font.render(f"Level {level}", True, (255, 255, 0))
        screen.blit(level_text, (WIDTH // 2 - level_text.get_width() // 2, HEIGHT // 2 - 100))

        color = hover_color if level_start_button_rect.collidepoint(mouse_pos) else button_color
        pygame.draw.rect(screen, color, level_start_button_rect)
        screen.blit(level_start_text, (level_start_button_rect.x + 25, level_start_button_rect.y + 20))

        if level > 1:
            congratulations_text = font.render(f"Congratulations! You completed Level {level - 1}", True, (0, 255, 0))
            screen.blit(congratulations_text, (WIDTH // 2 - congratulations_text.get_width() // 2, HEIGHT // 2 - 160))

        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                pygame.quit()
                sys.exit()

        if level_start_button_rect.collidepoint(mouse_pos) and click[0]:
            player_health = max_health
            flying_obstacles.clear()
            obstacles.clear()
            flying_obstacle_states.clear()
            obstacle_timer = base_obstacle_interval
            break

        pygame.display.flip()
        clock.tick(60)

def draw_health_and_name(surface, x, y, name, health, max_health):
    name_text = small_font.render(name, True, (255, 255, 255))
    name_rect = name_text.get_rect(center=(x + 40, y - 40))
    surface.blit(name_text, name_rect)

    bar_width = 80
    bar_height = 10
    health_ratio = health / max_health
    bg_rect = pygame.Rect(x, y - 20, bar_width, bar_height)
    fg_rect = pygame.Rect(x, y - 20, bar_width * health_ratio, bar_height)

    pygame.draw.rect(surface, (255, 0, 0), bg_rect)
    pygame.draw.rect(surface, (0, 255, 0), fg_rect)
    pygame.draw.rect(surface, (255, 255, 255), bg_rect, 2)

def draw_level(surface, level):
    level_text = small_font.render(f"Level {level}", True, (255, 255, 0))
    surface.blit(level_text, (10, 10))

def draw_controls(surface):
    controls = [
        ("W or SPACE", "Jump"),
        ("A", "Left"),
        ("D", "Right"),
        ("S", "Duck")
    ]
    for i, (key, action) in enumerate(controls):
        key_surface = small_font.render(f"[{key}]", True, (255, 255, 255))
        action_surface = small_font.render(f"= {action}", True, (255, 255, 0))
        surface.blit(key_surface, (10, HEIGHT - 120 + i * 25))
        surface.blit(action_surface, (110, HEIGHT - 120 + i * 25))

def game_over_screen():
    screen.fill((0, 0, 0))
    over_text = font.render("Game Over!", True, (255, 0, 0))
    screen.blit(over_text, (WIDTH // 2 - over_text.get_width() // 2, HEIGHT // 2 - 30))
    screen.blit(start_text, (WIDTH // 2 - start_text.get_width() // 2, HEIGHT // 2 + 40))
    pygame.display.flip()
    pygame.time.wait(3000)

def reset_game():
    global player_x, player_y, velocity_y, is_jumping, on_ground, direction, player_health, level, level_timer, obstacles, flying_obstacles, flying_obstacle_states
    player_x, player_y = WIDTH // 2, GROUND_Y
    velocity_y = 0
    is_jumping = False
    on_ground = True
    direction = pygame.Vector2(0, 0)
    player_health = max_health
    level = 1
    level_timer = LEVEL_DURATION
    obstacles.clear()
    flying_obstacles.clear()
    flying_obstacle_states.clear()

show_start_menu()
running = True
while running:
    clock.tick(FPS)
    screen.blit(background_png, (0, 0))

    if player_health <= 0:
        game_over_screen()
        reset_game()
        show_start_menu()

    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False

    keys = pygame.key.get_pressed()
    direction.x = keys[pygame.K_d] - keys[pygame.K_a]
    is_ducking = keys[pygame.K_s]

    if (keys[pygame.K_SPACE] or keys[pygame.K_w]) and on_ground:
        velocity_y = JUMP_FORCE
        is_jumping = True
        on_ground = False

    velocity_y += GRAVITY
    player_y += velocity_y

    if player_y >= GROUND_Y:
        player_y = GROUND_Y
        velocity_y = 0
        is_jumping = False
        on_ground = True

    if direction.length_squared() > 0:
        direction = direction.normalize()
        player_x += direction.x * PLAYER_SPEED

    obstacle_timer += 1
    spawn_interval = max(20, base_obstacle_interval - level * 5)
    if obstacle_timer >= spawn_interval:
        obstacle_timer = 0
        if random.random() < 0.5:
            new_obstacle = pygame.Rect(WIDTH, GROUND_Y + 20, 80, 60)
            obstacles.append(new_obstacle)
        else:
            flying_y = GROUND_Y - 60
            flying_obstacle = pygame.Rect(WIDTH, flying_y, 40, 40)
            flying_obstacles.append(flying_obstacle)
            flying_obstacle_states.append({'rect': flying_obstacle, 'jump_over_started': False, 'jump_over_passed': False})

    for obs in obstacles:
        obs.x -= obstacle_speed + (level * 2)
    obstacles = [obs for obs in obstacles if obs.x > -50]

    for obs in flying_obstacles:
        obs.x -= obstacle_speed + (level * 2)
    flying_obstacles = [obs for obs in flying_obstacles if obs.x > -50]
    flying_obstacle_states = [state for state in flying_obstacle_states if state['rect'].x > -50]

    player_rect = pygame.Rect(player_x, player_y, 80, 80 if not is_ducking else 60)

    for obs in obstacles:
        if player_rect.colliderect(obs):
            player_health = max(0, player_health - 10)

    for state in flying_obstacle_states:
        rect = state['rect']
        if player_rect.colliderect(rect):
            if is_ducking:
                state['jump_over_started'] = False
                state['jump_over_passed'] = False
            else:
                player_health = max(0, player_health - 20)
                state['jump_over_started'] = False
                state['jump_over_passed'] = False
        else:
            player_bottom = player_y + (60 if is_ducking else 80)
            bird_top = rect.y
            if is_jumping and player_bottom < bird_top:
                if not state['jump_over_started'] and player_x + 80 > rect.x + rect.width:
                    state['jump_over_started'] = True
                    state['jump_over_passed'] = True
            else:
                if not is_jumping or player_bottom >= bird_top:
                    if state['jump_over_started'] and state['jump_over_passed']:
                        player_health = 0
                    state['jump_over_started'] = False
                    state['jump_over_passed'] = False

    draw_health_and_name(screen, player_x, player_y, player_name, player_health, max_health)
    draw_level(screen, level)

    seconds_left = level_timer // FPS
    timer_text = font.render(f"Time: {seconds_left}s", True, (255, 255, 0))
    timer_rect = timer_text.get_rect(center=(WIDTH // 2, 30))
    screen.blit(timer_text, timer_rect)

    player_img = duck_img if is_ducking else (jump_img if is_jumping else idle_img)
    screen.blit(player_img, (player_x, player_y))
    for obs in obstacles:
        screen.blit(obstacle_img, obs)
    for obs in flying_obstacles:
        screen.blit(flying_obstacle_img, obs)

    draw_controls(screen)

    level_timer -= 1
    if level_timer <= 0:
        level += 1
        if level > max_level:
            game_over_screen()
            reset_game()
            show_start_menu()
        else:
            level_timer = LEVEL_DURATION
            show_level_start_menu(level)
            obstacle_timer = base_obstacle_interval

    pygame.display.flip()

pygame.quit()
sys.exit()