import pygame
import sys
import os
import random

# Initialize Pygame
pygame.init()
pygame.mixer.init()

# Constants
WIDTH, HEIGHT = 800, 600
PADDLE_WIDTH, PADDLE_HEIGHT = 100, 10
PADDLE_SPEED = 10
BRICK_WIDTH, BRICK_HEIGHT = 80, 20
BRICK_ROWS = 4
BRICK_COLS = 10
LINE_HEIGHT = 5
CUPCAKE_WIDTH, CUPCAKE_HEIGHT = 30, 30

# Colors
WHITE = (255, 255, 255)
BLACK = (0, 0, 0)
RED = (255, 0, 0)
PURPLE = (128, 0, 128)

# Load additional sound files
if os.path.exists("wearethechampions.mp3"):
    win_sound = pygame.mixer.Sound("wearethechampions.mp3")
if os.path.exists("waltzn2.mp3"):
    bg_music = pygame.mixer.Sound("waltzn2.mp3")
if os.path.exists("dishesfall.mp3"):
    fall_sound = pygame.mixer.Sound("dishesfall.mp3")
if os.path.exists("boing.wav"):
    boing_sound = pygame.mixer.Sound("boing.wav")
if os.path.exists("glassbreaking.mp3"):
    block_sound = pygame.mixer.Sound("glassbreaking.mp3")
if os.path.exists("lookatthisdude.mp3"):
    death_sound = pygame.mixer.Sound("lookatthisdude.mp3")
if os.path.exists("chew.wav"):
    chew_sound = pygame.mixer.Sound("chew.wav")

# Create the game window
screen = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption("Arkanoid")

# Load beach background image
background_image = pygame.image.load("beach.jpg").convert()
background_image = pygame.transform.scale(background_image, (WIDTH, HEIGHT))

# Load cat image
cat_original_image = pygame.image.load("cat.png").convert_alpha()
CAT_WIDTH, CAT_HEIGHT = 50, 50
cat_image = pygame.transform.scale(cat_original_image, (CAT_WIDTH, CAT_HEIGHT))

# Load cupcake image
cupcake_original_image = pygame.image.load("cupcake.png").convert_alpha()
cupcake_image = pygame.transform.scale(cupcake_original_image, (CUPCAKE_WIDTH, CUPCAKE_HEIGHT))

# Create the paddle
paddle = pygame.Rect((WIDTH - PADDLE_WIDTH) // 2, HEIGHT - PADDLE_HEIGHT - 20, PADDLE_WIDTH, PADDLE_HEIGHT)

# Create the ball (cat)
cat_rect = cat_image.get_rect(center=(WIDTH // 2, HEIGHT // 2))
cat_speed = [5, 5]  # Cat movement speed

# Create death line
line = pygame.Rect(0, HEIGHT - LINE_HEIGHT, WIDTH, LINE_HEIGHT)

# Create bricks
bricks = []
for row in range(BRICK_ROWS):
    for col in range(BRICK_COLS):
        brick = pygame.Rect(col * (BRICK_WIDTH + 5), row * (BRICK_HEIGHT + 5), BRICK_WIDTH, BRICK_HEIGHT)
        bricks.append(brick)

# Falling Cupcakes
class Cupcake:
    def __init__(self):
        self.width = CUPCAKE_WIDTH
        self.height = CUPCAKE_HEIGHT
        self.x = random.randint(0, WIDTH - self.width)
        self.y = 0
        self.speed = random.randint(1, 3)

    def update(self):
        self.y += self.speed

    def draw(self, surface):
        surface.blit(cupcake_image, (self.x, self.y))

# Create a list to hold falling cupcakes
falling_cupcakes = []

# Function to spawn falling cupcakes
def spawn_cupcakes():
    if len(falling_cupcakes) < 2:  # Maximum 2 cupcakes on screen
        falling_cupcakes.append(Cupcake())

# Scoring
score = 0
font = pygame.font.Font(None, 36)

# Lives
lives = 9  # Start with 9 lives

# Game Over flag and text
game_over = False
game_started = False
game_over_text = font.render("Game Over", True, WHITE)
game_over_rect = game_over_text.get_rect(center=(WIDTH // 2, HEIGHT // 2))

# Winning flag and text
winning = False
winning_text = font.render("YOU WON!", True, WHITE)
winning_rect = winning_text.get_rect(center=(WIDTH // 2, HEIGHT // 2))

# Flags for paddle movement
move_left = False
move_right = False

# Function to draw heart
def draw_heart(surface, color, pos):
    # Draw filled heart
    pygame.draw.polygon(surface, color, [(pos[0] + 5, pos[1] + 10), (pos[0] + 10, pos[1] + 5), (pos[0] + 15, pos[1] + 10), 
                                          (pos[0] + 20, pos[1] + 5), (pos[0] + 25, pos[1] + 10), (pos[0] + 15, pos[1] + 25),
                                          (pos[0], pos[1] + 10)])

# Main game loop
while not game_over:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            pygame.quit()
            sys.exit()
        # Key pressed
        elif event.type == pygame.KEYDOWN:
            if event.key == pygame.K_LEFT:
                move_left = True
            elif event.key == pygame.K_RIGHT:
                move_right = True
        # Key released
        elif event.type == pygame.KEYUP:
            if event.key == pygame.K_LEFT:
                move_left = False
            elif event.key == pygame.K_RIGHT:
                move_right = False

    # Move the paddle based on flags
    if move_left and paddle.left > 0:
        paddle.x -= PADDLE_SPEED
    if move_right and paddle.right < WIDTH:
        paddle.x += PADDLE_SPEED

    # Move the cat
    cat_rect.x += cat_speed[0]
    cat_rect.y += cat_speed[1]

    # Check for collision with walls
    if cat_rect.left <= 0 or cat_rect.right >= WIDTH:
        cat_speed[0] = -cat_speed[0]
        if boing_sound:
            boing_sound.play()
    if cat_rect.top <= 0 or cat_rect.colliderect(paddle):
        cat_speed[1] = -cat_speed[1]
        if boing_sound:
            boing_sound.play()

    # Check for collision with bricks
    for brick in bricks[:]:
        if cat_rect.colliderect(brick):
            bricks.remove(brick)
            if block_sound:
                block_sound.play()
            score += 1

    # Check for collision with cupcakes
    for cupcake in falling_cupcakes[:]:
        if cat_rect.colliderect(cupcake.x, cupcake.y, cupcake.width, cupcake.height):
            falling_cupcakes.remove(cupcake)
            if chew_sound:
                chew_sound.play()
            lives += 1  # Restore one life
            # Increase the size of the cat
            cat_image = pygame.transform.scale(cat_original_image, (CAT_WIDTH + 10, CAT_HEIGHT + 10))
            cat_rect = cat_image.get_rect(center=cat_rect.center)

    # Check for loss of life
    if cat_rect.bottom >= HEIGHT:
        lives -= 1
        if fall_sound:
            fall_sound.play()
        cat_rect.center = (WIDTH // 2, HEIGHT // 2)  # Reset cat position to the center
        if lives <= 0:
            game_over = True

    # Check for winning condition
    if len(bricks) == 0:
        winning = True

    # Clear the screen
    screen.fill(BLACK)

    # Draw background image
    screen.blit(background_image, (0, 0))

    # Draw paddle
    pygame.draw.rect(screen, WHITE, paddle)

    # Draw bricks
    for brick in bricks:
        pygame.draw.rect(screen, WHITE, brick)

    # Draw cat
    screen.blit(cat_image, cat_rect)

    # Draw falling cupcakes
    for cupcake in falling_cupcakes:
        cupcake.update()
        cupcake.draw(screen)

    # Draw heart bar representing lives
    for i in range(lives):
        draw_heart(screen, RED, (10 + i * 30, 10))  # Adjust the heart position and color as needed

    # Draw score
    score_text = font.render(f"Score: {score}", True, PURPLE)
    screen.blit(score_text, (10, 50))

    # Spawn falling cupcakes
    spawn_cupcakes()

    # Update the display
    pygame.display.flip()

    # Cap the frame rate
    pygame.time.Clock().tick(60)

# Play appropriate sound and display text
if game_over:
    if death_sound:
        death_sound.play()
    screen.blit(game_over_text, game_over_rect)
elif winning:
    if win_sound:
        win_sound.play()
    screen.blit(winning_text, winning_rect)
pygame.display.flip()

# Stop background music when game is over
if bg_music:
    bg_music.stop()

# Wait for a few seconds before quitting
pygame.time.delay(1500)

pygame.quit()
sys.exit()