import pygame
import math
import random
import asyncio
import platform

# Initialize Pygame
pygame.init()
WIDTH, HEIGHT = 800, 600
screen = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption("Space Shooter")
clock = pygame.time.Clock()
FPS = 60

# Colors
WHITE = (255, 255, 255)
BLACK = (0, 0, 0)
RED = (255, 0, 0)
BLUE = (0, 0, 255)
YELLOW = (255, 255, 0)
GREEN = (0, 255, 0)

# Player
class Player:
    def __init__(self):
        self.width = 40
        self.height = 40
        self.x = WIDTH // 2
        self.y = HEIGHT - 60
        self.speed = 5
        self.bullets = []
        self.bullet_speed = -10
        self.shoot_delay = 10
        self.shoot_timer = 0
        self.power_level = 1
        self.lives = 3
        self.score = 0

    def move(self, keys):
        if keys[pygame.K_LEFT] and self.x > 0:
            self.x -= self.speed
        if keys[pygame.K_RIGHT] and self.x < WIDTH - self.width:
            self.x += self.speed
        if keys[pygame.K_UP] and self.y > 0:
            self.y -= self.speed
        if keys[pygame.K_DOWN] and self.y < HEIGHT - self.height:
            self.y += self.speed

    def shoot(self):
        if self.shoot_timer <= 0:
            if self.power_level == 1:
                bullet = Bullet(self.x + self.width // 2, self.y, self.bullet_speed)
                self.bullets.append(bullet)
            elif self.power_level == 2:
                bullet1 = Bullet(self.x + self.width // 4, self.y, self.bullet_speed)
                bullet2 = Bullet(self.x + 3 * self.width // 4, self.y, self.bullet_speed)
                self.bullets.extend([bullet1, bullet2])
            elif self.power_level >= 3:
                bullet1 = Bullet(self.x + self.width // 4, self.y, self.bullet_speed)
                bullet2 = Bullet(self.x + 3 * self.width // 4, self.y, self.bullet_speed)
                bullet3 = Bullet(self.x + self.width // 2, self.y, self.bullet_speed - 2)
                self.bullets.extend([bullet1, bullet2, bullet3])
            self.shoot_timer = self.shoot_delay
        self.shoot_timer -= 1

    def draw(self):
        # Draw spaceship (triangle with thrusters)
        points = [
            (self.x + self.width // 2, self.y),
            (self.x, self.y + self.height),
            (self.x + self.width, self.y + self.height)
        ]
        pygame.draw.polygon(screen, BLUE, points)
        # Thruster effect
        pygame.draw.rect(screen, RED, (self.x + self.width // 4, self.y + self.height, self.width // 2, 10))

# Bullet
class Bullet:
    def __init__(self, x, y, speed):
        self.x = x
        self.y = y
        self.speed = speed
        self.width = 5
        self.height = 10

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

    def draw(self):
        pygame.draw.rect(screen, YELLOW, (self.x, self.y, self.width, self.height))

# Enemy
class Enemy:
    def __init__(self, x, y):
        self.x = x
        self.y = y
        self.width = 30
        self.height = 30
        self.speed = 2
        self.health = 2

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

    def draw(self):
        # Draw enemy (octagon-like shape)
        points = [
            (self.x + self.width // 2, self.y),
            (self.x + self.width, self.y + self.height // 4),
            (self.x + self.width, self.y + 3 * self.height // 4),
            (self.x + self.width // 2, self.y + self.height),
            (self.x, self.y + 3 * self.height // 4),
            (self.x, self.y + self.height // 4)
        ]
        pygame.draw.polygon(screen, RED, points)

# PowerUp
class PowerUp:
    def __init__(self, x, y):
        self.x = x
        self.y = y
        self.width = 20
        self.height = 20
        self.speed = 3
        self.type = random.choice(["power", "life"])

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

    def draw(self):
        color = GREEN if self.type == "power" else WHITE
        pygame.draw.circle(screen, color, (self.x + self.width // 2, self.y + self.height // 2), self.width // 2)

# Particle for explosions
class Particle:
    def __init__(self, x, y):
        self.x = x
        self.y = y
        self.vx = random.uniform(-2, 2)
        self.vy = random.uniform(-2, 2)
        self.lifetime = 30
        self.color = YELLOW

    def update(self):
        self.x += self.vx
        self.y += self.vy
        self.lifetime -= 1

    def draw(self):
        pygame.draw.circle(screen, self.color, (int(self.x), int(self.y)), 2)

# Game state
player = Player()
enemies = []
power_ups = []
particles = []
enemy_spawn_timer = 0
wave = 1
game_over = False

def setup():
    global player, enemies, power_ups, particles, enemy_spawn_timer, wave, game_over
    player = Player()
    enemies = []
    power_ups = []
    particles = []
    enemy_spawn_timer = 0
    wave = 1
    game_over = False

def spawn_enemy_wave():
    global wave
    for _ in range(wave * 2):
        x = random.randint(0, WIDTH - 30)
        enemies.append(Enemy(x, -30))

def update_loop():
    global enemy_spawn_timer, wave, game_over

    if game_over:
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                pygame.quit()
                return
            if event.type == pygame.KEYDOWN and event.key == pygame.K_r:
                setup()
        return

    # Handle events
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            pygame.quit()
            return

    keys = pygame.key.get_pressed()
    if keys[pygame.K_SPACE]:
        player.shoot()

    # Update player
    player.move(keys)

    # Spawn enemies
    enemy_spawn_timer += 1
    if enemy_spawn_timer > 60:
        spawn_enemy_wave()
        enemy_spawn_timer = 0
        wave += 1

    # Update bullets
    for bullet in player.bullets[:]:
        bullet.move()
        if bullet.y < 0:
            player.bullets.remove(bullet)

    # Update enemies
    for enemy in enemies[:]:
        enemy.move()
        if enemy.y > HEIGHT:
            enemies.remove(enemy)
            player.lives -= 1
            if player.lives <= 0:
                game_over = True

        # Bullet-enemy collision
        for bullet in player.bullets[:]:
            if (bullet.x < enemy.x + enemy.width and
                bullet.x + bullet.width > enemy.x and
                bullet.y < enemy.y + enemy.height and
                bullet.y + bullet.height > enemy.y):
                enemy.health -= 1
                player.bullets.remove(bullet)
                if enemy.health <= 0:
                    enemies.remove(enemy)
                    player.score += 10
                    # Spawn particles
                    for _ in range(10):
                        particles.append(Particle(enemy.x + enemy.width // 2, enemy.y + enemy.height // 2))
                    # Spawn power-up (10% chance)
                    if random.random() < 0.1:
                        power_ups.append(PowerUp(enemy.x, enemy.y))

    # Update power-ups
    for power_up in power_ups[:]:
        power_up.move()
        if power_up.y > HEIGHT:
            power_ups.remove(power_up)
        # Player-power-up collision
        if (player.x < power_up.x + power_up.width and
            player.x + player.width > power_up.x and
            player.y < power_up.y + power_up.height and
            player.y + player.height > power_up.y):
            if power_up.type == "power":
                player.power_level = min(player.power_level + 1, 3)
            elif power_up.type == "life":
                player.lives += 1
            power_ups.remove(power_up)

    # Update particles
    for particle in particles[:]:
        particle.update()
        if particle.lifetime <= 0:
            particles.remove(particle)

    # Draw
    screen.fill(BLACK)
    player.draw()
    for bullet in player.bullets:
        bullet.draw()
    for enemy in enemies:
        enemy.draw()
    for power_up in power_ups:
        power_up.draw()
    for particle in particles:
        particle.draw()

    # Draw HUD
    font = pygame.font.SysFont("arial", 20)
    score_text = font.render(f"Score: {player.score}", True, WHITE)
    lives_text = font.render(f"Lives: {player.lives}", True, WHITE)
    wave_text = font.render(f"Wave: {wave}", True, WHITE)
    screen.blit(score_text, (10, 10))
    screen.blit(lives_text, (10, 30))
    screen.blit(wave_text, (10, 50))

    if game_over:
        game_over_text = font.render("Game Over! Press R to Restart", True, WHITE)
        screen.blit(game_over_text, (WIDTH // 2 - 100, HEIGHT // 2))

    pygame.display.flip()

async def main():
    setup()
    while True:
        update_loop()
        await asyncio.sleep(1.0 / FPS)

if platform.system() == "Emscripten":
    asyncio.ensure_future(main())
else:
    if __name__ == "__main__":
        asyncio.run(main())