/**
 * GRAVE SYSTEM
 * Zombi workers lahko počivajo v grobovih za regeneracijo
 */
class GraveSystem {
    constructor(scene) {
        this.scene = scene;
        this.graves = []; // Seznam vseh postavljenih grobov
    }

    /**
     * Place grave on terrain
     */
    placeGrave(gridX, gridY) {
        const terrain = this.scene.terrainSystem;
        if (!terrain) return false;

        const tile = terrain.getTile(gridX, gridY);
        if (!tile) return false;

        // Check if already has grave
        const key = `${gridX},${gridY}`;
        if (this.graves.find(g => g.key === key)) {
            console.log('⚠️ Grave already exists here!');
            return false;
        }

        // Create grave object
        const grave = {
            gridX,
            gridY,
            key,
            occupiedBy: null, // Zombie currently resting
            sprite: null
        };

        // Create visual sprite
        const screenPos = this.scene.iso.toScreen(gridX, gridY);
        grave.sprite = this.scene.add.sprite(
            screenPos.x + this.scene.terrainOffsetX,
            screenPos.y + this.scene.terrainOffsetY,
            'gravestone'
        );
        grave.sprite.setOrigin(0.5, 1);
        grave.sprite.setScale(0.3);
        grave.sprite.setDepth(this.scene.iso.getDepth(gridX, gridY, this.scene.iso.LAYER_OBJECTS));

        this.graves.push(grave);
        console.log(`🪦 Grave placed at ${gridX},${gridY}`);
        return true;
    }

    /**
     * Remove grave
     */
    removeGrave(gridX, gridY) {
        const key = `${gridX},${gridY}`;
        const index = this.graves.findIndex(g => g.key === key);

        if (index === -1) return false;

        const grave = this.graves[index];

        // Kick out occupant
        if (grave.occupiedBy) {
            grave.occupiedBy.workerData.isResting = false;
            grave.occupiedBy = null;
        }

        if (grave.sprite) grave.sprite.destroy();
        this.graves.splice(index, 1);

        console.log(`🪦 Grave removed at ${gridX},${gridY}`);
        return true;
    }

    /**
     * Assign zombie to rest in grave
     */
    assignZombieToGrave(zombie) {
        if (!zombie.workerData) return false;

        // Find empty grave
        const emptyGrave = this.graves.find(g => g.occupiedBy === null);

        if (!emptyGrave) {
            console.log('🚫 No empty graves available!');
            return false;
        }

        // Mark zombie as resting
        zombie.workerData.isResting = true;
        zombie.workerData.restingGrave = emptyGrave;
        emptyGrave.occupiedBy = zombie;

        // Move zombie to grave
        zombie.gridX = emptyGrave.gridX;
        zombie.gridY = emptyGrave.gridY;
        zombie.updatePosition();

        // Visual: Make zombie semi-transparent
        if (zombie.sprite) {
            zombie.sprite.setAlpha(0.5);
        }

        console.log(`🪦 Zombie resting in grave at ${emptyGrave.gridX},${emptyGrave.gridY}`);
        return true;
    }

    /**
     * Wake zombie from grave
     */
    wakeZombie(zombie) {
        if (!zombie.workerData || !zombie.workerData.isResting) return false;

        const grave = zombie.workerData.restingGrave;
        if (grave) {
            grave.occupiedBy = null;
        }

        zombie.workerData.isResting = false;
        zombie.workerData.restingGrave = null;

        // Restore visual
        if (zombie.sprite) {
            zombie.sprite.setAlpha(1.0);
        }

        console.log(`🪦 Zombie woke up from grave`);
        return true;
    }

    /**
     * Update - regenerate resting zombies
     */
    update(delta) {
        for (const grave of this.graves) {
            if (grave.occupiedBy && grave.occupiedBy.workerData) {
                const zombie = grave.occupiedBy;
                const wd = zombie.workerData;

                // Regenerate energy (slower than normal decay)
                wd.energy += (0.2 * delta) / 1000; // +0.2 energy/sec
                wd.energy = Math.min(100, wd.energy);

                // Regenerate HP if energy > 50
                if (wd.energy > 50) {
                    zombie.hp += (0.1 * delta) / 1000; // +0.1 HP/sec
                    zombie.hp = Math.min(zombie.maxHp, zombie.hp);
                }

                // Visual feedback - green tint when regenerating
                if (zombie.sprite) {
                    zombie.sprite.setTint(0x00FF00);
                }
            }
        }
    }

    /**
     * Find nearest empty grave
     */
    findNearestEmptyGrave(x, y) {
        let nearest = null;
        let minDist = 999;

        for (const grave of this.graves) {
            if (grave.occupiedBy === null) {
                const dist = Phaser.Math.Distance.Between(x, y, grave.gridX, grave.gridY);
                if (dist < minDist) {
                    minDist = dist;
                    nearest = grave;
                }
            }
        }

        return nearest;
    }

    /**
     * Auto-rest: Send low-energy zombies to graves
     */
    autoRest() {
        if (!this.scene.zombieWorkerSystem) return;

        for (const worker of this.scene.zombieWorkerSystem.workers) {
            if (!worker.workerData) continue;

            // If energy < 20 and not resting, send to grave
            if (worker.workerData.energy < 20 && !worker.workerData.isResting) {
                const grave = this.findNearestEmptyGrave(worker.gridX, worker.gridY);
                if (grave) {
                    this.assignZombieToGrave(worker);
                    console.log(`🪦 Auto-rest: Zombie sent to grave (Low energy)`);
                }
            }

            // If energy > 80 and resting, wake up
            if (worker.workerData.energy > 80 && worker.workerData.isResting) {
                this.wakeZombie(worker);
                console.log(`🪦 Auto-wake: Zombie restored and ready to work`);
            }
        }
    }
}