import Phaser from 'phaser';

/**
 * Entité Dog - Petit chien en cage
 * Fait des va-et-vient dans la cage avec alternance idle/marche
 */
export class Dog extends Phaser.GameObjects.Sprite {
    public scene: Phaser.Scene;
    private direction: number = 1; // 1 = droite, -1 = gauche
    private moveTimer?: Phaser.Time.TimerEvent;
    private idleTimer?: Phaser.Time.TimerEvent;
    private cageLeft: number;
    private cageRight: number;
    private isMoving: boolean = false;
    private isFree: boolean = false;

    constructor(
        scene: Phaser.Scene,
        x: number,
        y: number,
        cageWidth: number = 150
    ) {
        super(scene, x, y, 'dog-idle', 0);
        this.scene = scene;

        // Définir les limites de la cage
        this.cageLeft = x - cageWidth / 2 + 20;
        this.cageRight = x + cageWidth / 2 - 20;

        // Ajouter au scene
        scene.add.existing(this);

        // Échelle du chien
        this.setScale(0.8);
        this.setOrigin(0.5, 1); // Origine aux pieds

        // Depth
        this.setDepth(50);

        // Démarrer le comportement
        this.startBehavior();
    }

    /**
     * Démarre le comportement de va-et-vient
     */
    private startBehavior(): void {
        // Commencer par idle
        this.playIdleAnimation();

        // Après un temps aléatoire (2-4 sec), commencer à marcher
        const idleDuration = Phaser.Math.Between(2000, 4000);
        this.idleTimer = this.scene.time.delayedCall(idleDuration, () => {
            this.startWalking();
        });
    }

    /**
     * Joue l'animation idle
     */
    private playIdleAnimation(): void {
        this.isMoving = false;
        this.play('dog-idle', true);
    }

    /**
     * Commence à marcher
     */
    private startWalking(): void {
        this.isMoving = true;

        // Choisir aléatoirement la direction (sauf si on est contre un mur)
        if (this.x <= this.cageLeft) {
            this.direction = 1; // Forcer vers la droite
        } else if (this.x >= this.cageRight) {
            this.direction = -1; // Forcer vers la gauche
        } else {
            this.direction = Phaser.Math.Between(0, 1) === 0 ? -1 : 1;
        }

        // Si on change de direction, jouer l'animation de tour
        if (this.direction === 1 && this.flipX) {
            this.playTurnAnimation(() => {
                this.flipX = false;
                this.walk();
            });
        } else if (this.direction === -1 && !this.flipX) {
            this.playTurnAnimation(() => {
                this.flipX = true;
                this.walk();
            });
        } else {
            this.walk();
        }
    }

    /**
     * Marche dans la direction actuelle
     */
    private walk(): void {
        // Jouer l'animation de marche (walkback = marche vers la gauche en visuel)
        this.play('dog-walkback', true);

        // Marcher pendant 1-2 secondes
        const walkDuration = Phaser.Math.Between(1000, 2000);
        this.moveTimer = this.scene.time.delayedCall(walkDuration, () => {
            this.stopWalking();
        });
    }

    /**
     * Arrête de marcher et retourne en idle
     */
    private stopWalking(): void {
        this.playIdleAnimation();

        // Après un temps d'idle, recommencer à marcher
        const idleDuration = Phaser.Math.Between(2000, 4000);
        this.idleTimer = this.scene.time.delayedCall(idleDuration, () => {
            if (!this.isFree) {
                this.startWalking();
            }
        });
    }

    /**
     * Joue l'animation de tour (demi-tour)
     */
    private playTurnAnimation(onComplete: () => void): void {
        this.play('dog-turn');
        this.once('animationcomplete', () => {
            onComplete();
        });
    }

    /**
     * Libère le chien (sort de la cage)
     */
    public free(): void {
        this.isFree = true;
        this.isMoving = false;

        // Annuler les timers
        this.moveTimer?.destroy();
        this.idleTimer?.destroy();

        // Jouer une animation de joie (idle pour l'instant)
        this.playIdleAnimation();

        // Animation de sortie de cage (optionnel - peut courir vers la droite)
        this.scene.tweens.add({
            targets: this,
            x: this.x + 200,
            duration: 2000,
            ease: 'Power2',
            onStart: () => {
                this.flipX = false;
                this.play('dog-walkback', true);
            },
            onComplete: () => {
                this.playIdleAnimation();
            }
        });
    }

    /**
     * Méthode update pour le mouvement
     */
    public update(): void {
        if (!this.isMoving || this.isFree) return;

        // Déplacer le chien
        const speed = 20;
        this.x += this.direction * speed * (1 / 60); // 60 FPS

        // Vérifier les limites de la cage
        if (this.x <= this.cageLeft) {
            this.x = this.cageLeft;
            this.stopWalking();
        } else if (this.x >= this.cageRight) {
            this.x = this.cageRight;
            this.stopWalking();
        }
    }

    /**
     * Nettoyage
     */
    public destroy(fromScene?: boolean): void {
        this.moveTimer?.destroy();
        this.idleTimer?.destroy();
        super.destroy(fromScene);
    }
}
