// src/core/Game.ts
import { Application, Container } from 'pixi.js';
import { SceneManager } from './SceneManager';
import { InputManager } from './InputManager';
import { AudioManager } from './AudioManager';

export class Game {
    public app: Application;
    public scenes: SceneManager;
    public input: InputManager;
    public audio: AudioManager;
    public width = 800;
    public height = 600;

    constructor() {
        this.app = new Application();
        this.scenes = new SceneManager(this);
        this.input = new InputManager();
        this.audio = new AudioManager();
    }

    async init() {
        await this.app.init({
            width: this.width,
            height: this.height,
            backgroundColor: 0x0a0a1a,
            antialias: true,
            resolution: Math.min(window.devicePixelRatio, 2),
            autoDensity: true,
        });

        document.getElementById('app')!.appendChild(this.app.canvas);

        this.app.ticker.add((ticker) => {
            this.update(ticker.deltaTime);
        });

        await this.scenes.switchTo('menu');
    }

    private update(delta: number) {
        this.scenes.update(delta);
    }
}

// src/core/SceneManager.ts
import { Container } from 'pixi.js';
import type { Game } from './Game';

export interface Scene {
    container: Container;
    init(): Promise<void>;
    update(delta: number): void;
    destroy(): void;
}

export class SceneManager {
    private current: Scene | null = null;
    private scenes = new Map<string, () => Promise<Scene>>();
    private game: Game;

    constructor(game: Game) {
        this.game = game;
    }

    register(name: string, factory: () => Promise<Scene>) {
        this.scenes.set(name, factory);
    }

    async switchTo(name: string) {
        if (this.current) {
            this.game.app.stage.removeChild(this.current.container);
            this.current.destroy();
        }

        const factory = this.scenes.get(name);
        if (!factory) throw new Error(`Scene "${name}" not found`);

        this.current = await factory();
        await this.current.init();
        this.game.app.stage.addChild(this.current.container);
    }

    update(delta: number) {
        this.current?.update(delta);
    }
}

// src/core/InputManager.ts
export class InputManager {
    private keys = new Set<string>();
    private _mouseX = 0;
    private _mouseY = 0;
    private _mouseDown = false;

    constructor() {
        window.addEventListener('keydown', (e) => this.keys.add(e.code));
        window.addEventListener('keyup', (e) => this.keys.delete(e.code));
        window.addEventListener('mousemove', (e) => {
            this._mouseX = e.clientX;
            this._mouseY = e.clientY;
        });
        window.addEventListener('mousedown', () => this._mouseDown = true);
        window.addEventListener('mouseup', () => this._mouseDown = false);
    }

    isKeyDown(code: string): boolean {
        return this.keys.has(code);
    }

    get mouseX() { return this._mouseX; }
    get mouseY() { return this._mouseY; }
    get mouseDown() { return this._mouseDown; }
}

// src/core/AudioManager.ts
export class AudioManager {
    private sounds = new Map<string, HTMLAudioElement>();
    private musicVolume = 0.5;
    private sfxVolume = 0.7;

    load(name: string, src: string) {
        const audio = new Audio(src);
        audio.preload = 'auto';
        this.sounds.set(name, audio);
    }

    play(name: string, loop = false) {
        const sound = this.sounds.get(name);
        if (!sound) return;
        const clone = sound.cloneNode() as HTMLAudioElement;
        clone.volume = this.sfxVolume;
        clone.loop = loop;
        clone.play();
    }

    playMusic(name: string) {
        const sound = this.sounds.get(name);
        if (!sound) return;
        sound.volume = this.musicVolume;
        sound.loop = true;
        sound.play();
    }

    stopAll() {
        this.sounds.forEach(s => { s.pause(); s.currentTime = 0; });
    }
}

// src/entities/Player.ts
import { Sprite, Texture, Container, Graphics } from 'pixi.js';
import type { InputManager } from '../core/InputManager';

export class Player extends Container {
    public sprite: Sprite;
    public hp = 100;
    public maxHp = 100;
    public lives = 3;
    public speed = 5;
    public fireRate = 150;        // 射击间隔 (ms)
    public fireLevel = 1;         // 火力等级
    public invincible = false;
    public collisionRadius = 16;

    private lastFireTime = 0;
    private invincibleTimer = 0;
    private blinkTimer = 0;

    constructor() {
        super();
        this.sprite = Sprite.from('/image/player.png');
        this.sprite.anchor.set(0.5);
        this.addChild(this.sprite);
    }

    update(delta: number, input: InputManager, now: number, bounds: { w: number; h: number }) {
        this.handleMovement(delta, input, bounds);
        this.handleInvincibility(delta);

        // 返回是否应该发射子弹
        return input.isKeyDown('Space') && now - this.lastFireTime > this.fireRate;
    }

    fire(now: number) {
        this.lastFireTime = now;
    }

    private handleMovement(delta: number, input: InputManager, bounds: { w: number; h: number }) {
        const spd = this.speed * delta;

        if (input.isKeyDown('ArrowUp') || input.isKeyDown('KeyW')) this.y -= spd;
        if (input.isKeyDown('ArrowDown') || input.isKeyDown('KeyS')) this.y += spd;
        if (input.isKeyDown('ArrowLeft') || input.isKeyDown('KeyA')) this.x -= spd;
        if (input.isKeyDown('ArrowRight') || input.isKeyDown('KeyD')) this.x += spd;

        // 限制在屏幕内
        this.x = Math.max(20, Math.min(bounds.w - 20, this.x));
        this.y = Math.max(20, Math.min(bounds.h - 20, this.y));
    }

    takeDamage(amount: number) {
        if (this.invincible) return;
        this.hp -= amount;
        if (this.hp <= 0) {
            this.lives--;
            if (this.lives > 0) {
                this.respawn();
            }
        }
    }

    respawn() {
        this.hp = this.maxHp;
        this.invincible = true;
        this.invincibleTimer = 120; // 2 秒无敌 (60fps)
    }

    private handleInvincibility(delta: number) {
        if (!this.invincible) return;

        this.invincibleTimer -= delta;
        this.blinkTimer += delta;

        // 闪烁效果
        this.sprite.alpha = Math.floor(this.blinkTimer / 4) % 2 === 0 ? 0.3 : 1;

        if (this.invincibleTimer <= 0) {
            this.invincible = false;
            this.sprite.alpha = 1;
        }
    }

    canFire(now: number): boolean {
        return now - this.lastFireTime > this.fireRate;
    }
}

// src/systems/WaveManager.ts
interface WaveConfig {
    enemies: { type: string; count: number; interval: number }[];
    delay: number; // 波次之间的延迟
}

const WAVE_DATA: WaveConfig[] = [
    {
        delay: 0,
        enemies: [{ type: 'grunt', count: 5, interval: 1000 }],
    },
    {
        delay: 3000,
        enemies: [
            { type: 'grunt', count: 8, interval: 800 },
            { type: 'fast', count: 3, interval: 1500 },
        ],
    },
    {
        delay: 3000,
        enemies: [
            { type: 'grunt', count: 10, interval: 600 },
            { type: 'tank', count: 2, interval: 2000 },
        ],
    },
    {
        delay: 5000,
        enemies: [{ type: 'boss', count: 1, interval: 0 }],
    },
];

export class WaveManager {
    private currentWave = 0;
    private spawnTimers = new Map<string, number>();
    private waveDelay = 0;
    private active = true;

    update(
        delta: number,
        now: number,
        spawnEnemy: (type: string) => void,
    ) {
        if (!this.active || this.currentWave >= WAVE_DATA.length) return;

        const wave = WAVE_DATA[this.currentWave];

        // 波次延迟
        if (this.waveDelay < wave.delay) {
            this.waveDelay += delta * 16.67;
            return;
        }

        // 生成敌人
        let allSpawned = true;
        for (const group of wave.enemies) {
            const key = `${this.currentWave}_${group.type}`;
            if (!this.spawnTimers.has(key)) {
                this.spawnTimers.set(key, 0);
            }

            const timer = this.spawnTimers.get(key)!;
            if (timer < group.count) {
                allSpawned = false;
                const elapsed = this.spawnTimers.get(key + '_time') ?? 0;
                if (elapsed >= group.interval) {
                    spawnEnemy(group.type);
                    this.spawnTimers.set(key, timer + 1);
                    this.spawnTimers.set(key + '_time', 0);
                } else {
                    this.spawnTimers.set(key + '_time', elapsed + delta * 16.67);
                }
            }
        }

        if (allSpawned) {
            this.currentWave++;
            this.waveDelay = 0;
        }
    }

    get isComplete(): boolean {
        return this.currentWave >= WAVE_DATA.length;
    }

    get waveNumber(): number {
        return this.currentWave + 1;
    }
}

// src/entities/Enemy.ts
import { Sprite, Container, Texture } from 'pixi.js';

export interface EnemyConfig {
    texture: string;
    hp: number;
    speed: number;
    score: number;
    collisionRadius: number;
    behavior: 'straight' | 'zigzag' | 'track';
}

export const ENEMY_CONFIGS: Record<string, EnemyConfig> = {
    grunt: {
        texture: '/image/enemy_grunt.png',
        hp: 20,
        speed: 2,
        score: 100,
        collisionRadius: 14,
        behavior: 'straight',
    },
    fast: {
        texture: '/image/enemy_fast.png',
        hp: 10,
        speed: 5,
        score: 150,
        collisionRadius: 10,
        behavior: 'zigzag',
    },
    tank: {
        texture: '/image/enemy_tank.png',
        hp: 80,
        speed: 1,
        score: 300,
        collisionRadius: 20,
        behavior: 'straight',
    },
    boss: {
        texture: '/image/enemy_boss.png',
        hp: 500,
        speed: 0.5,
        score: 5000,
        collisionRadius: 40,
        behavior: 'track',
    },
};

export class Enemy extends Container {
    public sprite: Sprite;
    public hp: number;
    public maxHp: number;
    public speed: number;
    public score: number;
    public collisionRadius: number;
    public behavior: string;
    public active = true;
    private time = 0;
    private startX = 0;

    constructor(config: EnemyConfig) {
        super();
        this.sprite = Sprite.from(config.texture);
        this.sprite.anchor.set(0.5);
        this.addChild(this.sprite);

        this.hp = config.hp;
        this.maxHp = config.hp;
        this.speed = config.speed;
        this.score = config.score;
        this.collisionRadius = config.collisionRadius;
        this.behavior = config.behavior;
    }

    update(delta: number, playerX: number, playerY: number) {
        this.time += delta;
        this.x -= this.speed * delta;

        switch (this.behavior) {
            case 'zigzag':
                this.y += Math.sin(this.time * 0.1) * 2;
                break;
            case 'track':
                const dy = playerY - this.y;
                this.y += Math.sign(dy) * Math.min(Math.abs(dy * 0.02), 2) * delta;
                break;
        }
    }

    takeDamage(amount: number): boolean {
        this.hp -= amount;
        return this.hp <= 0;
    }
}

// src/entities/BulletPool.ts
import { Sprite, Texture, Container } from 'pixi.js';

export class Bullet extends Sprite {
    public vx = 0;
    public vy = 0;
    public active = false;
    public damage = 10;
    public collisionRadius = 4;

    constructor() {
        super(Texture.from('/image/bullet.png'));
        this.anchor.set(0.5);
    }

    fire(x: number, y: number, vx: number, vy: number, damage: number) {
        this.x = x;
        this.y = y;
        this.vx = vx;
        this.vy = vy;
        this.damage = damage;
        this.active = true;
        this.visible = true;
    }

    deactivate() {
        this.active = false;
        this.visible = false;
    }
}

export class BulletPool {
    private pool: Bullet[] = [];
    private active: Bullet[] = [];
    private container: Container;

    constructor(container: Container, preallocate = 50) {
        this.container = container;
        for (let i = 0; i < preallocate; i++) {
            const bullet = new Bullet();
            bullet.deactivate();
            this.pool.push(bullet);
            container.addChild(bullet);
        }
    }

    spawn(x: number, y: number, vx: number, vy: number, damage: number): Bullet {
        let bullet = this.pool.pop();
        if (!bullet) {
            bullet = new Bullet();
            this.container.addChild(bullet);
        }
        bullet.fire(x, y, vx, vy, damage);
        this.active.push(bullet);
        return bullet;
    }

    update(delta: number, bounds: { w: number; h: number }) {
        for (let i = this.active.length - 1; i >= 0; i--) {
            const bullet = this.active[i];
            bullet.x += bullet.vx * delta;
            bullet.y += bullet.vy * delta;

            // 超出边界回收
            if (bullet.x < -20 || bullet.x > bounds.w + 20 ||
                bullet.y < -20 || bullet.y > bounds.h + 20) {
                bullet.deactivate();
                this.active.splice(i, 1);
                this.pool.push(bullet);
            }
        }
    }

    getActiveBullets(): Bullet[] {
        return this.active;
    }

    recycle(bullet: Bullet) {
        const idx = this.active.indexOf(bullet);
        if (idx !== -1) {
            this.active.splice(idx, 1);
            bullet.deactivate();
            this.pool.push(bullet);
        }
    }
}

// src/entities/Item.ts
import { Sprite, Container, Texture } from 'pixi.js';

export type ItemType = 'powerup' | 'shield' | 'life' | 'bomb';

export interface ItemConfig {
    texture: string;
    duration?: number;
    value: number;
}

export const ITEM_CONFIGS: Record<ItemType, ItemConfig> = {
    powerup: { texture: '/image/item_power.png', value: 1 },
    shield: { texture: '/image/item_shield.png', duration: 5000, value: 1 },
    life: { texture: '/image/item_life.png', value: 1 },
    bomb: { texture: '/image/item_bomb.png', value: 1 },
};

export class Item extends Container {
    public type: ItemType;
    public collisionRadius = 12;
    public active = true;
    private speed = 2;
    private time = 0;

    constructor(type: ItemType) {
        super();
        this.type = type;

        const config = ITEM_CONFIGS[type];
        const sprite = Sprite.from(config.texture);
        sprite.anchor.set(0.5);
        this.addChild(sprite);
    }

    update(delta: number) {
        this.time += delta;
        this.x -= this.speed * delta;
        this.y += Math.sin(this.time * 0.05) * 0.5; // 轻微浮动
    }

    apply(player: any) {
        const config = ITEM_CONFIGS[this.type];
        switch (this.type) {
            case 'powerup':
                player.fireLevel = Math.min(player.fireLevel + config.value, 5);
                break;
            case 'shield':
                player.invincible = true;
                player.invincibleTimer = (config.duration ?? 5000) / 16.67;
                break;
            case 'life':
                player.lives = Math.min(player.lives + config.value, 5);
                break;
            case 'bomb':
                // 清屏炸弹效果由 GameScene 处理
                break;
        }
        this.active = false;
    }
}

// 道具掉落管理
export class ItemSpawner {
    private dropRates: Record<string, number> = {
        grunt: 0.05,
        fast: 0.08,
        tank: 0.15,
        boss: 1.0,
    };

    rollDrop(enemyType: string): ItemType | null {
        const rate = this.dropRates[enemyType] ?? 0;
        if (Math.random() > rate) return null;

        const roll = Math.random();
        if (roll < 0.4) return 'powerup';
        if (roll < 0.6) return 'shield';
        if (roll < 0.8) return 'life';
        return 'bomb';
    }
}

// src/systems/ParallaxBackground.ts
import { TilingSprite, Texture, Container } from 'pixi.js';

export class ParallaxBackground extends Container {
    private layers: { sprite: TilingSprite; speed: number }[] = [];

    constructor(width: number, height: number) {
        super();

        // 星空远景（移动最慢）
        this.addLayer('/image/bg_stars.png', 0.2, width, height);
        // 星云中景
        this.addLayer('/image/bg_nebula.png', 0.5, width, height);
        // 小行星近景（移动最快）
        this.addLayer('/image/bg_asteroids.png', 1.0, width, height);
    }

    private addLayer(texturePath: string, speed: number, w: number, h: number) {
        const texture = Texture.from(texturePath);
        const sprite = new TilingSprite({
            texture,
            width: w,
            height: h,
        });
        this.addChild(sprite);
        this.layers.push({ sprite, speed });
    }

    update(delta: number) {
        for (const layer of this.layers) {
            // 向左滚动（tilePosition.x 递减）
            layer.sprite.tilePosition.x -= layer.speed * delta;
        }
    }
}

// src/entities/Boss.ts
import { Enemy, EnemyConfig } from './Enemy';
import { Graphics, Container } from 'pixi.js';

export class Boss extends Enemy {
    private phase = 1;
    private attackTimer = 0;
    private attackPatterns: (() => void)[] = [];
    private onAttack: (pattern: number) => void;

    constructor(onAttack: (pattern: number) => void) {
        const config: EnemyConfig = {
            texture: '/image/enemy_boss.png',
            hp: 500,
            speed: 0.5,
            score: 5000,
            collisionRadius: 40,
            behavior: 'track',
        };
        super(config);
        this.onAttack = onAttack;
    }

    update(delta: number, playerX: number, playerY: number) {
        super.update(delta, playerX, playerY);
        this.attackTimer += delta;

        // 根据血量切换阶段
        const hpPercent = this.hp / this.maxHp;
        if (hpPercent < 0.3) this.phase = 3;
        else if (hpPercent < 0.6) this.phase = 2;

        // 攻击模式
        this.handleAttack(delta);
    }

    private handleAttack(delta: number) {
        const attackInterval = this.phase === 3 ? 40 : this.phase === 2 ? 60 : 90;

        if (this.attackTimer >= attackInterval) {
            this.attackTimer = 0;

            switch (this.phase) {
                case 1:
                    this.onAttack(0); // 散射
                    break;
                case 2:
                    this.onAttack(1); // 瞄准射击
                    break;
                case 3:
                    this.onAttack(2); // 弹幕
                    break;
            }
        }
    }
}