// src/map/TileMap.ts
import { Container, Graphics, Text } from 'pixi.js';

export enum TileType {
    Ground = 0,    // 可建造
    Path = 1,      // 敌人路径
    Blocked = 2,   // 不可建造（装饰/障碍）
    Spawn = 3,     // 敌人出生点
    Exit = 4,      // 敌人终点（基地）
}

export class TileMap extends Container {
    public readonly cols: number;
    public readonly rows: number;
    public readonly tileSize: number;
    public grid: TileType[][];

    private graphics: Graphics;

    constructor(data: number[][], tileSize: number = 48) {
        super();
        this.tileSize = tileSize;
        this.rows = data.length;
        this.cols = data[0].length;
        this.grid = data;

        this.graphics = new Graphics();
        this.addChild(this.graphics);
        this.drawMap();
    }

    private drawMap() {
        const g = this.graphics;
        g.clear();

        const colors: Record<TileType, number> = {
            [TileType.Ground]: 0x2d5a27,   // 绿色草地
            [TileType.Path]: 0x8b7355,     // 土路
            [TileType.Blocked]: 0x555555,  // 灰色障碍
            [TileType.Spawn]: 0xcc3333,    // 红色出生点
            [TileType.Exit]: 0x3333cc,     // 蓝色基地
        };

        for (let row = 0; row < this.rows; row++) {
            for (let col = 0; col < this.cols; col++) {
                const type = this.grid[row][col];
                const x = col * this.tileSize;
                const y = row * this.tileSize;

                g.rect(x, y, this.tileSize, this.tileSize)
                    .fill({ color: colors[type] ?? 0x000000 });

                // 网格线
                g.rect(x, y, this.tileSize, this.tileSize)
                    .stroke({ color: 0x000000, alpha: 0.2, width: 1 });
            }
        }
    }

    // 获取世界坐标对应的网格坐标
    worldToGrid(worldX: number, worldY: number): { col: number; row: number } {
        return {
            col: Math.floor(worldX / this.tileSize),
            row: Math.floor(worldY / this.tileSize),
        };
    }

    // 获取网格中心的世界坐标
    gridToWorld(col: number, row: number): { x: number; y: number } {
        return {
            x: col * this.tileSize + this.tileSize / 2,
            y: row * this.tileSize + this.tileSize / 2,
        };
    }

    // 检查某格是否可建塔
    canBuild(col: number, row: number): boolean {
        if (col < 0 || col >= this.cols || row < 0 || row >= this.rows) return false;
        return this.grid[row][col] === TileType.Ground;
    }

    // 设置地块类型（建塔后标记为 Blocked）
    setTile(col: number, row: number, type: TileType) {
        this.grid[row][col] = type;
        this.drawMap();
    }

    // 获取出生点和终点
    getSpawnPoint(): { col: number; row: number } {
        for (let r = 0; r < this.rows; r++) {
            for (let c = 0; c < this.cols; c++) {
                if (this.grid[r][c] === TileType.Spawn) return { col: c, row: r };
            }
        }
        return { col: 0, row: 0 };
    }

    getExitPoint(): { col: number; row: number } {
        for (let r = 0; r < this.rows; r++) {
            for (let c = 0; c < this.cols; c++) {
                if (this.grid[r][c] === TileType.Exit) return { col: c, row: r };
            }
        }
        return { col: this.cols - 1, row: this.rows - 1 };
    }
}

// src/levels/level1.ts
// 0=Ground, 1=Path, 2=Blocked, 3=Spawn, 4=Exit
export const LEVEL_1_MAP = [
    [2, 2, 2, 3, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2],
    [2, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 2],
    [2, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 2],
    [2, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 2],
    [2, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 2],
    [2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 2],
    [2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 2],
    [2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 4, 2],
    [2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2],
];

// src/pathfinding/PathManager.ts
import { TileMap, TileType } from '../map/TileMap';

interface Node {
    col: number;
    row: number;
    g: number;  // 从起点到当前的实际距离
    h: number;  // 启发式估价（到终点的估计距离）
    f: number;  // g + h
    parent: Node | null;
}

export class PathManager {
    private tileMap: TileMap;
    private pathCache = new Map<string, { col: number; row: number }[]>();

    constructor(tileMap: TileMap) {
        this.tileMap = tileMap;
    }

    findPath(startCol: number, startRow: number, endCol: number, endRow: number): { col: number; row: number }[] {
        const key = `${startCol},${startRow}-${endCol},${endRow}`;
        if (this.pathCache.has(key)) {
            return this.pathCache.get(key)!;
        }

        const path = this.aStar(startCol, startRow, endCol, endRow);
        this.pathCache.set(key, path);
        return path;
    }

    clearCache() {
        this.pathCache.clear();
    }

    private aStar(startCol: number, startRow: number, endCol: number, endRow: number): { col: number; row: number }[] {
        const openList: Node[] = [];
        const closedSet = new Set<string>();

        const startNode: Node = {
            col: startCol, row: startRow,
            g: 0, h: 0, f: 0, parent: null,
        };
        startNode.h = this.heuristic(startCol, startRow, endCol, endRow);
        startNode.f = startNode.g + startNode.h;
        openList.push(startNode);

        const dirs = [
            { dc: 0, dr: -1 }, // 上
            { dc: 0, dr: 1 },  // 下
            { dc: -1, dr: 0 }, // 左
            { dc: 1, dr: 0 },  // 右
        ];

        while (openList.length > 0) {
            // 找 f 值最小的节点
            openList.sort((a, b) => a.f - b.f);
            const current = openList.shift()!;

            // 到达终点
            if (current.col === endCol && current.row === endRow) {
                return this.buildPath(current);
            }

            const currentKey = `${current.col},${current.row}`;
            if (closedSet.has(currentKey)) continue;
            closedSet.add(currentKey);

            // 检查相邻节点
            for (const dir of dirs) {
                const nc = current.col + dir.dc;
                const nr = current.row + dir.dr;

                // 边界检查
                if (nc < 0 || nc >= this.tileMap.cols || nr < 0 || nr >= this.tileMap.rows) continue;

                // 可通行检查（Path / Spawn / Exit 可以走）
                const tile = this.tileMap.grid[nr][nc];
                if (tile === TileType.Blocked || tile === TileType.Ground) continue;

                const neighborKey = `${nc},${nr}`;
                if (closedSet.has(neighborKey)) continue;

                const g = current.g + 1;
                const h = this.heuristic(nc, nr, endCol, endRow);

                const node: Node = {
                    col: nc, row: nr,
                    g, h, f: g + h,
                    parent: current,
                };

                // 检查 openList 中是否有更优路径
                const existing = openList.find(n => n.col === nc && n.row === nr);
                if (existing && existing.g <= g) continue;

                openList.push(node);
            }
        }

        // 未找到路径
        return [];
    }

    private heuristic(col1: number, row1: number, col2: number, row2: number): number {
        return Math.abs(col1 - col2) + Math.abs(row1 - row2); // 曼哈顿距离
    }

    private buildPath(node: Node): { col: number; row: number }[] {
        const path: { col: number; row: number }[] = [];
        let current: Node | null = node;
        while (current) {
            path.unshift({ col: current.col, row: current.row });
            current = current.parent;
        }
        return path;
    }
}

// src/towers/TowerConfig.ts
export type TowerType = 'single' | 'area' | 'slow' | 'laser';

export interface TowerConfig {
    name: string;
    texture: string;
    cost: number;
    damage: number;
    range: number;        // 像素
    fireRate: number;     // 毫秒
    splash: number;       // 溅射半径，0 = 单体
    slowFactor?: number;  // 减速倍率
    slowDuration?: number;// 减速持续时间 (ms)
    description: string;
}

export const TOWER_CONFIGS: Record<TowerType, TowerConfig> = {
    single: {
        name: '箭塔',
        texture: '/image/tower_arrow.png',
        cost: 100,
        damage: 25,
        range: 150,
        fireRate: 800,
        splash: 0,
        description: '单体高伤，攻速中等',
    },
    area: {
        name: '炮塔',
        texture: '/image/tower_cannon.png',
        cost: 200,
        damage: 40,
        range: 120,
        fireRate: 1500,
        splash: 60,
        description: '范围伤害，攻速慢',
    },
    slow: {
        name: '冰塔',
        texture: '/image/tower_ice.png',
        cost: 150,
        damage: 10,
        range: 130,
        fireRate: 1000,
        splash: 0,
        slowFactor: 0.5,
        slowDuration: 2000,
        description: '减速敌人 50%',
    },
    laser: {
        name: '激光塔',
        texture: '/image/tower_laser.png',
        cost: 300,
        damage: 8,        // 每帧伤害
        range: 180,
        fireRate: 0,       // 持续发射
        splash: 0,
        description: '持续激光，高 DPS',
    },
};

// src/towers/Tower.ts
import { Sprite, Container, Graphics, Texture } from 'pixi.js';
import { TowerType, TowerConfig, TOWER_CONFIGS } from './TowerConfig';
import { Enemy } from '../enemies/Enemy';

export class Tower extends Container {
    public type: TowerType;
    public config: TowerConfig;
    public gridCol: number;
    public gridRow: number;
    public level = 1;
    public totalDamage = 0;

    private sprite: Sprite;
    private rangeCircle: Graphics;
    private lastFireTime = 0;
    private target: Enemy | null = null;
    private angle = 0;

    constructor(type: TowerType, col: number, row: number, worldX: number, worldY: number) {
        super();
        this.type = type;
        this.config = { ...TOWER_CONFIGS[type] };
        this.gridCol = col;
        this.gridRow = row;
        this.x = worldX;
        this.y = worldY;

        // 塔精灵
        this.sprite = Sprite.from(this.config.texture);
        this.sprite.anchor.set(0.5);
        this.addChild(this.sprite);

        // 范围指示器（默认隐藏）
        this.rangeCircle = new Graphics();
        this.rangeCircle.visible = false;
        this.addChild(this.rangeCircle);
        this.drawRange();
    }

    private drawRange() {
        this.rangeCircle.clear();
        this.rangeCircle.circle(0, 0, this.config.range);
        this.rangeCircle.stroke({ color: 0xffffff, alpha: 0.3, width: 1 });
    }

    showRange(visible: boolean) {
        this.rangeCircle.visible = visible;
    }

    // 升级
    upgrade(): number {
        const cost = Math.floor(this.config.cost * 0.7 * this.level);
        this.level++;
        this.config.damage = Math.floor(this.config.damage * 1.3);
        this.config.range += 10;
        this.drawRange();
        return cost;
    }

    // 出售价格
    getSellPrice(): number {
        return Math.floor(this.config.cost * 0.6 * this.level);
    }

    // 找到范围内最近的敌人
    findTarget(enemies: Enemy[]): Enemy | null {
        let closest: Enemy | null = null;
        let closestDist = Infinity;

        for (const enemy of enemies) {
            if (!enemy.active || enemy.isDead) continue;
            const dx = enemy.x - this.x;
            const dy = enemy.y - this.y;
            const dist = Math.sqrt(dx * dx + dy * dy);

            if (dist <= this.config.range && dist < closestDist) {
                closest = enemy;
                closestDist = dist;
            }
        }

        return closest;
    }

    // 更新攻击逻辑，返回是否发射了子弹
    update(delta: number, enemies: Enemy[], now: number): { fired: boolean; target: Enemy | null } {
        this.target = this.findTarget(enemies);

        if (!this.target) {
            return { fired: false, target: null };
        }

        // 旋转朝向目标
        this.angle = Math.atan2(this.target.y - this.y, this.target.x - this.x);
        this.sprite.rotation = this.angle;

        // 激光塔持续输出
        if (this.type === 'laser') {
            return { fired: true, target: this.target };
        }

        // 普通塔射击间隔检查
        if (now - this.lastFireTime >= this.config.fireRate) {
            this.lastFireTime = now;
            return { fired: true, target: this.target };
        }

        return { fired: false, target: null };
    }
}

// src/enemies/Enemy.ts
import { Sprite, Container, Graphics, Text } from 'pixi.js';
import { TileMap } from '../map/TileMap';

export interface EnemyConfig {
    name: string;
    texture: string;
    hp: number;
    speed: number;
    reward: number;
    armor: number;
}

export const ENEMY_CONFIGS: Record<string, EnemyConfig> = {
    slime: { name: '史莱姆', texture: '/image/enemy_slime.png', hp: 50, speed: 1.2, reward: 10, armor: 0 },
    goblin: { name: '哥布林', texture: '/image/enemy_goblin.png', hp: 80, speed: 1.8, reward: 15, armor: 2 },
    orc: { name: '兽人', texture: '/image/enemy_orc.png', hp: 200, speed: 0.8, reward: 30, armor: 5 },
    dragon: { name: '龙', texture: '/image/enemy_dragon.png', hp: 500, speed: 0.6, reward: 100, armor: 10 },
};

export class Enemy extends Container {
    public config: EnemyConfig;
    public hp: number;
    public maxHp: number;
    public speed: number;
    public currentSpeed: number;
    public armor: number;
    public reward: number;
    public active = true;
    public isDead = false;

    private sprite: Sprite;
    private hpBar: Graphics;
    private path: { col: number; row: number }[] = [];
    private pathIndex = 0;
    private slowTimer = 0;
    private tileMap: TileMap;

    constructor(configName: string, tileMap: TileMap) {
        super();
        this.config = { ...ENEMY_CONFIGS[configName] };
        this.tileMap = tileMap;
        this.hp = this.config.hp;
        this.maxHp = this.config.hp;
        this.speed = this.config.speed;
        this.currentSpeed = this.speed;
        this.armor = this.config.armor;
        this.reward = this.config.reward;

        // 精灵
        this.sprite = Sprite.from(this.config.texture);
        this.sprite.anchor.set(0.5);
        this.addChild(this.sprite);

        // 血条
        this.hpBar = new Graphics();
        this.hpBar.y = -24;
        this.addChild(this.hpBar);
    }

    setPath(path: { col: number; row: number }[]) {
        this.path = path;
        this.pathIndex = 0;

        // 起始位置
        if (path.length > 0) {
            const pos = tileMap.gridToWorld(path[0].col, path[0].row);
            this.x = pos.x;
            this.y = pos.y;
        }
    }

    update(delta: number) {
        if (this.isDead || this.path.length === 0) return;

        // 减速计时
        if (this.slowTimer > 0) {
            this.slowTimer -= delta * 16.67;
            if (this.slowTimer <= 0) {
                this.currentSpeed = this.speed;
            }
        }

        // 沿路径移动
        const target = this.path[this.pathIndex];
        const targetPos = this.tileMap.gridToWorld(target.col, target.row);
        const dx = targetPos.x - this.x;
        const dy = targetPos.y - this.y;
        const dist = Math.sqrt(dx * dx + dy * dy);

        if (dist < this.currentSpeed * delta) {
            // 到达当前路径点
            this.pathIndex++;
            if (this.pathIndex >= this.path.length) {
                this.active = false; // 到达终点
                return;
            }
        } else {
            // 朝目标移动
            this.x += (dx / dist) * this.currentSpeed * delta;
            this.y += (dy / dist) * this.currentSpeed * delta;
        }

        this.updateHpBar();
    }

    takeDamage(damage: number): boolean {
        const effectiveDamage = Math.max(1, damage - this.armor);
        this.hp -= effectiveDamage;

        if (this.hp <= 0) {
            this.hp = 0;
            this.isDead = true;
            this.active = false;
            return true; // 已死亡
        }
        return false;
    }

    applySlow(factor: number, duration: number) {
        this.currentSpeed = this.speed * factor;
        this.slowTimer = duration;
        // 减速视觉效果
        this.sprite.tint = 0x88ccff;
    }

    private updateHpBar() {
        this.hpBar.clear();
        const w = 30;
        const h = 4;

        // 背景
        this.hpBar.rect(-w / 2, 0, w, h).fill({ color: 0x333333 });

        // 血量
        const hpPercent = this.hp / this.maxHp;
        const color = hpPercent > 0.5 ? 0x00ff00 : hpPercent > 0.25 ? 0xffaa00 : 0xff0000;
        this.hpBar.rect(-w / 2, 0, w * hpPercent, h).fill({ color });
    }
}

// src/systems/WaveManager.ts
export interface WaveEntry {
    type: string;
    count: number;
    interval: number;   // 每个敌人间隔 (ms)
    startDelay: number; // 本组开始延迟 (ms)
}

export interface WaveConfig {
    entries: WaveEntry[];
    reward: number; // 通关奖励
}

const WAVE_DATA: WaveConfig[] = [
    {
        reward: 50,
        entries: [
            { type: 'slime', count: 5, interval: 1500, startDelay: 0 },
        ],
    },
    {
        reward: 80,
        entries: [
            { type: 'slime', count: 8, interval: 1200, startDelay: 0 },
            { type: 'goblin', count: 3, interval: 2000, startDelay: 5000 },
        ],
    },
    {
        reward: 120,
        entries: [
            { type: 'goblin', count: 10, interval: 1000, startDelay: 0 },
            { type: 'slime', count: 5, interval: 800, startDelay: 3000 },
        ],
    },
    {
        reward: 200,
        entries: [
            { type: 'orc', count: 3, interval: 3000, startDelay: 0 },
            { type: 'goblin', count: 8, interval: 1000, startDelay: 2000 },
            { type: 'slime', count: 10, interval: 600, startDelay: 8000 },
        ],
    },
    {
        reward: 500,
        entries: [
            { type: 'dragon', count: 1, interval: 0, startDelay: 0 },
            { type: 'orc', count: 5, interval: 2000, startDelay: 5000 },
        ],
    },
];

export class WaveManager {
    private currentWave = 0;
    private waveStarted = false;
    private waveClear = false;
    private spawnTimers: { entry: WaveEntry; spawned: number; timer: number }[] = [];
    private countdown = 10000; // 首波倒计时 10 秒

    get waveNumber() { return this.currentWave + 1; }
    get totalWaves() { return WAVE_DATA.length; }
    get isComplete() { return this.currentWave >= WAVE_DATA.length; }
    get isWaveClear() { return this.waveClear; }

    startWave() {
        if (this.currentWave >= WAVE_DATA.length) return;

        const wave = WAVE_DATA[this.currentWave];
        this.spawnTimers = wave.entries.map(entry => ({
            entry,
            spawned: 0,
            timer: entry.startDelay,
        }));

        this.waveStarted = true;
        this.waveClear = false;
    }

    update(delta: number, onSpawn: (type: string) => void) {
        if (!this.waveStarted) {
            this.countdown -= delta * 16.67;
            if (this.countdown <= 0) {
                this.startWave();
            }
            return;
        }

        // 检查是否所有敌人都已生成
        let allDone = true;
        for (const st of this.spawnTimers) {
            if (st.spawned < st.entry.count) {
                allDone = false;
                st.timer -= delta * 16.67;
                if (st.timer <= 0) {
                    onSpawn(st.entry.type);
                    st.spawned++;
                    st.timer = st.entry.interval;
                }
            }
        }

        if (allDone) {
            this.waveClear = true;
        }
    }

    nextWave() {
        this.currentWave++;
        this.waveStarted = false;
        this.waveClear = false;
        this.countdown = 8000;
    }

    get reward(): number {
        return WAVE_DATA[this.currentWave]?.reward ?? 0;
    }

    get countdownSeconds(): number {
        return Math.ceil(this.countdown / 1000);
    }
}