package entities;

import entities.npcs.Drone;
import entities.npcs.Smarty;
import entities.weapons.Grenade;
import entities.weapons.Item;
import entities.weapons.Bullet;
import flixel.addons.nape.FlxNapeSpace;
import flixel.addons.nape.FlxNapeSprite;
import flixel.system.FlxAssets.FlxGraphicAsset;
import flixel.tweens.FlxEase;
import flixel.tweens.FlxTween;
import flixel.group.FlxGroup;
import flixel.addons.display.FlxExtendedSprite;
import flixel.math.FlxRandom;
import flixel.ui.FlxButton;
import flixel.FlxG;
import flixel.group.FlxGroup;
import flixel.FlxObject;
import flixel.math.FlxPoint;
import flixel.util.FlxSave;
import flixel.FlxState;
import flixel.FlxSprite;
import flixel.text.FlxText;
import flixel.util.FlxColor;
import flixel.util.FlxTimer;
import flixel.math.FlxRandom;
import flash.display.BlendMode;
import flash.display.BitmapData;
import flash.display.Sprite;
import flash.geom.Matrix;
import flixel.addons.nape.FlxNapeSprite;
import flixel.addons.nape.FlxNapeSpace;
import flixel.FlxG;
import flixel.FlxSprite;
import flixel.group.FlxGroup;
import flixel.text.FlxText;
import flixel.tweens.FlxEase;
import flixel.tweens.FlxTween;
import flixel.math.FlxAngle;
import flixel.math.FlxPoint;
import nape.callbacks.CbEvent;
import nape.callbacks.CbType;
import nape.callbacks.InteractionCallback;
import nape.callbacks.InteractionListener;
import nape.callbacks.InteractionType;
import nape.geom.GeomPoly;
import nape.geom.GeomPolyList;
import nape.geom.Ray;
import nape.geom.RayResultList;
import nape.geom.Vec2;
import nape.phys.Body;
import nape.phys.BodyType;
import nape.phys.Material;
import nape.shape.Polygon;
import particles.ParticlesGroup;
import particles.BaseParticle;
import states.StateGameplay;
import states.StateInventory.SubStateWeapons;
//import flixel.effects.FlxSpriteFilter;
//import flash.filters.BlurFilter;

/**
 * ...
 * @author ...
 */
class Explodable extends FlxNapeSprite
{

    public function new(X:Float, Y:Float, ?SimpleGraphic:FlxGraphicAsset )
    {
        super(X, Y, SimpleGraphic,false);//don't create default body, we gonna tweak it

        antialiasing = true;

        createRectangularBody(width*0.95, height*0.95);//use less of the sprite so collision is smaller

        body.userData.flxSprite = this;

        setBodyMaterial(0.3, 1, 0.5);

        health = 5;

        //wait a bit, StateGameplay.instance.napeLevel might be null
        new FlxTimer().start(0.5, function(timer:FlxTimer):Void
        {
            if (StateGameplay.instance.napeLevel != null)
            {
                var groupTest:CbType = new CbType();
                var groupMap:CbType = new CbType();
                body.cbTypes.add(groupTest);

                StateGameplay.instance.napeLevel.body.cbTypes.add(groupMap);

                FlxNapeSpace.space.listeners.add(new InteractionListener(CbEvent.BEGIN, InteractionType.COLLISION, groupMap, groupTest, onColides));
            }
        } );


    }

    function onColides(callback:InteractionCallback)
    {
        if (body != null)
        {
        //  trace("onColides - velocity: " + ZMath.vectorVelocity(body.velocity.x, body.velocity.y));

            var impact_force:Float = ZMath.vectorVelocity(body.velocity.x, body.velocity.y);
            var impact_volume:Float = impact_force / 100;

            if (impact_force >= 200)
            {
                FlxG.sound.play("assets/sounds/physics/barrel_impact_hard"+FlxG.random.int(1,2)+".ogg",impact_volume).proximity(getMidpoint().x,getMidpoint().y,FlxG.camera.target, FlxG.width);
            }
            else
            {
                FlxG.sound.play("assets/sounds/physics/barrel_impact_soft"+FlxG.random.int(1,3)+".ogg",impact_volume).proximity(getMidpoint().x,getMidpoint().y,FlxG.camera.target, FlxG.width);
            }
        }
        else//body is null, most likely the little pieces created
        {
        //  trace(callback.int2.userData.flxSprite);

            //lets grab the body involved in the interaction
            var orgPhySpr:FlxNapeSprite = callback.int2.userData.flxSprite;

            if (orgPhySpr != null)
            {
                var impact_force:Float = ZMath.vectorVelocity(orgPhySpr.body.velocity.x, orgPhySpr.body.velocity.y);
                var impact_volume:Float = impact_force / 100;

                //      trace("orgPhySpr::onColides- velocity: " + ZMath.vectorVelocity(orgPhySpr.body.velocity.x, orgPhySpr.body.velocity.y));

                FlxG.sound.play("assets/sounds/physics/barrel_impact_soft"+FlxG.random.int(1,3)+".ogg",impact_volume).proximity(getMidpoint().x,getMidpoint().y,FlxG.camera.target, FlxG.width);
            }
        }
    }

    public function explode():Void
    {
    //  trace("explode");
            for (i in 0...15)
            {
            //  trace("cut?");
                var source:FlxPoint = FlxPoint.get(getMidpoint().x+FlxG.random.float(-50,50),getMidpoint().y+FlxG.random.float(-50,50));
                var mouse:FlxPoint = getMidpoint();

                var deg:Float = source.angleBetween(mouse) - 90;
                var groundPoint = FlxPoint.get(source.x + (FlxG.height-source.y) / Math.tan(deg * FlxAngle.TO_RAD), FlxG.height);

                var sP = Vec2.get(source.x, source.y);
                var eP = Vec2.get(groundPoint.x, groundPoint.y+1);  // +1 make sure no tiny gap in between groundPoint and groundY
                var ray = Ray.fromSegment(sP, eP);

                if (ray.maxDistance > 0)
                {
                    var rayResultList:RayResultList = FlxNapeSpace.space.rayMultiCast(ray);
                    for (rayResult in rayResultList)
                    {
                        var orgBody:Body = rayResult.shape.body;
                        if (orgBody.isStatic())
                            continue;
                        var orgPoly:Polygon = rayResult.shape.castPolygon;
                        // If the shape's not polygon eg. a circle, it can't get cut
                        // You can use a regular polygon to simulate a circle instead
                        if (orgPoly == null)
                            continue;
                        var orgPhySpr:FlxNapeSprite = orgBody.userData.flxSprite;
                        if (orgPhySpr != null)
                            applyCut(orgPhySpr, sP, eP);
                    }
                }

                sP.dispose();
                eP.dispose();
            }

    }

    override public function update(elapsed:Float):Void
    {
        super.update(elapsed);

        if (!alive)
        return;



        FlxG.collide(this, StateGameplay.instance.bullets, collided);
        FlxG.overlap(this, StateGameplay.instance.players, overlapped);



    }

    private function collided(Sprite1:FlxObject, Sprite2:FlxObject):Void
    {
        if (Std.is(Sprite1, Explodable) && Std.is(Sprite2, Bullet))
        {
            var thisBarrel:Explodable = cast(Sprite1, Explodable);
            var bullet:Bullet = cast(Sprite2, Bullet);


            thisBarrel.attacker = bullet.owner;
            thisBarrel.hurt(bullet.owner.activeGun.damage);

            if (thisBarrel.body != null)
            {
                thisBarrel.body.applyImpulse(new Vec2(bullet.velocity.x, bullet.velocity.y  ));

                ParticlesGroup.emit(bullet.getMidpoint(), BaseParticle.SPARKS, FlxG.random.int(4, 8));
                FlxG.sound.play("assets/sounds/guns/Riccochet" + FlxG.random.int(1, 5) + ".ogg", FlxG.random.float(0.5, 1.0));
                FlxG.sound.play("assets/sounds/physics/barrel_impact_hard" + FlxG.random.int(1, 2) + ".ogg" );
                            FlxG.sound.play("assets/sounds/guns/metal"+FlxG.random.int(1,3)+".ogg",FlxG.random.float(0.5,1.0));


            }
        }
    }

    private function overlapped(Sprite1:FlxObject, Sprite2:FlxObject):Void
    {
        if (Std.is(Sprite1, Explodable) && Std.is(Sprite2, Player))
        {
            var thisBarrel:Explodable = cast(Sprite1, Explodable);
            var player:Player = cast(Sprite2, Player);

            if (thisBarrel.body != null)
            thisBarrel.body.applyImpulse(new Vec2(player.velocity.x*.5, player.velocity.y*.5  ));
        }
    }

    private function applyCut(orgPhySpr:FlxNapeSprite, sP:Vec2, eP:Vec2):Void
    {
        var orgBody = orgPhySpr.body;
        var geomPoly = new GeomPoly(orgBody.shapes.at(0).castPolygon.worldVerts);
        var geomPolyList:GeomPolyList = geomPoly.cut(sP, eP, true, true);

        // Make current FlxNapeSprite graphic (may rotated) a reference BitmapData
        var bmp = new BitmapData(Math.ceil(orgBody.bounds.width), Math.ceil(orgBody.bounds.height), true, 0x0);
        var mat = new Matrix();
        mat.translate( -orgPhySpr.origin.x, -orgPhySpr.origin.y);
        mat.rotate(orgPhySpr.angle * FlxAngle.TO_RAD % 360);
        mat.translate(orgBody.position.x - orgBody.bounds.x, orgBody.position.y - orgBody.bounds.y);
        bmp.draw(orgPhySpr.pixels, mat);

        if (geomPolyList.length > 1)
        {
            for (cutGeomPoly in geomPolyList)
            {
                // Make a new body in world space
                var cutPoly = new Polygon(cutGeomPoly);
                var cutBody = new Body(BodyType.DYNAMIC);
                cutBody.setShapeMaterials(Material.steel());
                cutBody.shapes.add(cutPoly);
                cutBody.align();
                // too small piece cause problem when creating BitmapData
                if (cutBody.bounds.width < 2 && cutBody.bounds.height < 2)
                    continue;
                cutBody.space = FlxNapeSpace.space;

                // Sprite has ability to do polygon fill to fit new body's vertices
                var sprite = new Sprite();
                sprite.graphics.beginBitmapFill(bmp,
                    new Matrix(1, 0, 0, 1,
                        orgBody.bounds.x - cutBody.position.x,
                        orgBody.bounds.y - cutBody.position.y));
                for (i in 0...cutPoly.localVerts.length)
                {
                    var vert:Vec2 = cutPoly.localVerts.at(i);
                    if (i == 0)
                        sprite.graphics.moveTo(vert.x, vert.y);
                    else
                        sprite.graphics.lineTo(vert.x, vert.y);
                }
                sprite.graphics.endFill();

                // don't create the unnecessary default body on construction, it will become a ghost!
                var cutPhySpr = new FlxNapeSprite(0, 0, null, false);

                cutPhySpr.body = cutBody;
                // force the bitmap to be unique, or same-sized bmp will share one instance
                cutPhySpr.makeGraphic(Math.ceil(cutBody.bounds.width), Math.ceil(cutBody.bounds.height), 0x00ff0000, true);
                cutPhySpr.pixels.draw(sprite, new Matrix(1, 0, 0, 1, cutBody.worldCOM.x - cutBody.bounds.x, cutBody.worldCOM.y - cutBody.bounds.y));
                cutPhySpr.dirty = true;
                cutPhySpr.origin.set(cutBody.worldCOM.x - cutBody.bounds.x, cutBody.worldCOM.y - cutBody.bounds.y);
                cutPhySpr.reset(cutBody.worldCOM.x, cutBody.worldCOM.y);
                cutPhySpr.angle = cutBody.rotation * FlxAngle.TO_DEG;
                StateGameplay.instance.buttons_bases.add(cutPhySpr);

                // apply small random impulse
                var pulseAgl:Float = FlxG.random.float() * Math.PI * 2;
                var power:Float = FlxG.random.float(800, 2000);//100, 250
                cutPhySpr.body.applyImpulse(Vec2.weak(
                    power * Math.cos(pulseAgl), power * Math.sin(pulseAgl)
                ));
                cutBody.userData.flxSprite = cutPhySpr;

                //give the created sprite a new fancy impact sound
                if (StateGameplay.instance.napeLevel != null)
                {
                    var groupTest:CbType = new CbType();
                    var groupMap:CbType = new CbType();
                    cutPhySpr.body.cbTypes.add(groupTest);

                    StateGameplay.instance.napeLevel.body.cbTypes.add(groupMap);

                    FlxNapeSpace.space.listeners.add(new InteractionListener(CbEvent.BEGIN, InteractionType.COLLISION, groupMap, groupTest, onColides));
                }
            }
            orgPhySpr.kill();
            orgPhySpr.destroyPhysObjects();
        }
    }

    override public function kill():Void
    {
        if (!alive)
        return;

        //explode();

        super.kill();

    //  trace("kill");

        var daBomb:Grenade = new Grenade(0,0);

        daBomb.owner = StateGameplay.instance.player;

        daBomb.x = x + width / 2 - daBomb.width / 2;
        daBomb.y = y + height / 2 - daBomb.height / 2;

        daBomb.kill();

        StateGameplay.instance.foreGroundStuff.add(daBomb);









    //  exists = true;
    //  solid = false;


    }

    override public function hurt(Damage:Float):Void
    {

        if (!alive)
        return;

    //  trace("hurt");

        if (health <= 1)
        {
            explode();
        }

                    //FlxG.sound.play("impact", 0.2);
//
                    //FlxG.sound.play("bullet_hit1", 1);


        super.hurt(Damage);


    }

}