package classes
{
    import net.flashpunk.*;
    import net.flashpunk.masks.*;
    import net.flashpunk.graphics.Image;

    import net.flashpunk.graphics.Spritemap;
    import net.flashpunk.utils.Input
    import net.flashpunk.utils.Key

    import it.svelto.graphic.importers.SpriteBuddy;
    import it.svelto.graphic.flashpunk.FlexiSpriteMap;


    public class Blackbox extends Entity
    {
        public var lifes:int;
        public var energy:int;
        public var velocity:Number;
        public var status:String;
        private var hFriction:Number;
        private var vFriction:Number;
        private var xSpeed:Number=0;
        private var ySpeed:Number = 0;
        private var gravity:Number = 0.4;
        private var jumpPower:Number = 12;
        private var onTheGround:Boolean = false;
        private var pressed:Boolean = false;
        private var jumped:Boolean = false;

        //(0 = no, 1 = left, 2 = right)
        public var walljumping:int = 0;

        //(false = no, true = yes)
        public var doublejump:Boolean = false;

        private var activePixelMask:Boolean = false;

        [Embed(source = '../assets/charsets/blackbox.gif')] private const PLAYER_IMG:Class;
        public var blackboxSpriteMap:Spritemap;
        private var pixemask:Pixelmask;

        public function Blackbox(xpos:Number,ypos:Number)
        {

            type = "Player";
            lifes = 3;
            energy = 100;
            velocity = 0.05;
            status = "normal";


            blackboxSpriteMap = new Spritemap(PLAYER_IMG,64,64);

            pixemask = new Pixelmask(blackboxSpriteMap.getBuffer());
            blackboxSpriteMap.add("fermo", [0], 0, false);
            blackboxSpriteMap.add("jump", [3], 0, false);
            blackboxSpriteMap.add("falling", [3], 0, false);
            blackboxSpriteMap.add("slideWall", [5], 0, false);
            blackboxSpriteMap.add("walk", [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12], 20, true);
            graphic = blackboxSpriteMap;
            blackboxSpriteMap.play("fermo");
            hFriction=0.95;
            vFriction = 0.99;
            blackboxSpriteMap.originX = 20;
            blackboxSpriteMap.originY = 17;
            setHitbox(27, 47, 0, 0);


            x = xpos;
            y = ypos;
        }

        override public function update():void //aggiorna
        {

            if (Input.check(Key.LEFT)) { moveLeft(); pressed = true; }
            if (Input.check(Key.RIGHT)) { moveRight();pressed = true;  }
            if (Input.released(Key.LEFT) || Input.released(Key.RIGHT) ) { stopMove() }
            if ((Input.check(Key.LEFT)) && (Input.check(Key.RIGHT))) { fixMove(); }

            xSpeed*=hFriction;
            ySpeed*=vFriction;

            enemyCollision();

            updateMaskCollision();
            updateAnimation();
            checkGravity();


        }



        //funzioni

        public function fixMove():void {
            if(onTheGround){
            xSpeed = 0;
            x = x;
            }
        }
        public function togglePixelMask():void
        {
        /**
         * Attiva la maschera di collisione per pixel o la hitbox.
         */
            if (activePixelMask) {
                activePixelMask = false;
                blackboxSpriteMap.originX = 20;
                blackboxSpriteMap.originY = 17;
                setHitbox(27, 47, 0, 0);
            }
            else {
                activePixelMask = true;
                updateMaskCollision();
            }
        }
        public function updateMaskCollision():void {
        /**
         * Aggiorna la maschera di Hitbox.
         */
            if(activePixelMask){
                pixemask = new Pixelmask(blackboxSpriteMap.getBuffer());
                mask = pixemask;
            }
        }

        public function updateAnimation():void {
        /**
         * Aggiorna l'animazione.
         */
            if ((onTheGround) && (xSpeed == 0)) blackboxSpriteMap.play("fermo", false);
            if ((onTheGround) && (xSpeed != 0)) blackboxSpriteMap.play("walk", false);
            if ((onTheGround) && (xSpeed != 0) && (ySpeed != 0)) blackboxSpriteMap.play("falling", false);
            if ((!onTheGround) && (ySpeed != 0)) blackboxSpriteMap.play("jump");
            if (collide("wall", x - 1, y) && (!onTheGround))blackboxSpriteMap.play("slideWall",false);

        }

        public function checkGravity():void
        {
        /**
         * Aggiorna la y e controlla l'intenzione del Jump.
         */
            if (collide("wall", x, y + 1)) {
                walljumping = 0;
                onTheGround = true;
                ySpeed=0;
                if (Input.check(Key.X)) { jump() }

            } else {
                ySpeed+=gravity;
            }
            if (Math.abs(xSpeed)<1&&! pressed) {
                xSpeed=0;
            }
            adjustXPosition();
            adjustYPosition();


        }

        public function enemyCollision():Boolean {
        /**
         * Controlla se sta hittando un nemico.
         *
         * @return  True se sta hittando.
         */
            if (collide("Enemy", x, y))
            {

                FP.console.log("Tocco")
                return true;
            }
            else
            {
                FP.console.log("Non tocco");
                return false;
            }
        }


        public function wallJump():void
        {
            if (collide("wall", x - 1, y)&& jumped && !onTheGround)
                {
                    ySpeed -= jumpPower;            //jump up
                    xSpeed += xSpeed * 2;   //move right fast
                    walljumping = 2;            //and set wall jump direction


                }
                //same as above
            if (collide("wall", x + 1, y)&& jumped && !onTheGround)
            {
                    ySpeed -= jumpPower;
                    xSpeed -= xSpeed * 4;
                    walljumping = 1;


            }


        }

        public function jump():void
        {
        /**
         * salta.
         */
            jumped = false;


            if (onTheGround)
            {
                ySpeed -= jumpPower;
                jumped = true;
            }
            onTheGround = false;


        }

        public function moveLeft():void
        {
        /**
         * Muove a sinistra.
         */

            if(onTheGround && !(Input.check(Key.RIGHT))){
                blackboxSpriteMap.flipped = true;
                xSpeed-=velocity;
                adjustXPosition();
            }
            if (!onTheGround) {
                blackboxSpriteMap.flipped = true;
                xSpeed-=velocity;
                adjustXPosition();
            }

        }

        public function moveRight():void
        {
        /**
         * Muove a destra.
         */if(onTheGround && !(Input.check(Key.LEFT))){
                blackboxSpriteMap.flipped = false;
                xSpeed+=velocity;
                adjustXPosition();
            }
            if (!onTheGround) {
                blackboxSpriteMap.flipped = false;
                xSpeed+=velocity;
                adjustXPosition();
            }

        }

        public function stopMove():void
        {
        /**
         * Ferma il movimento.
         */
            xSpeed=0;
            adjustXPosition();
        }

        private function adjustXPosition():void {
        /**
         * Aggiorna la posizione X.
         */
            for (var i:int=0; i<Math.abs(xSpeed); i++) {
                if (! collide("wall",x+FP.sign(xSpeed),y)) {
                //x += FP.sign(xSpeed);
                    moveBy(FP.sign(xSpeed), 0);
                } else {
                    xSpeed=0;
                    break;
                }
            }

            if (Math.abs(xSpeed)<1&&! pressed) {
                xSpeed=0;
            }
        }
        private function adjustYPosition():void {

        /**
         * Aggiorna la posizione Y.
         */
            for (var i:int=0; i<Math.abs(ySpeed); i++) {
                if (! collide("wall",x,y+FP.sign(ySpeed))) {
                    //y+=FP.sign(ySpeed);
                    moveBy(0,FP.sign(ySpeed));
                } else {
                    ySpeed=0;
                    break;
                }
            }
        }

    }

}