//Class PlayScreen
package me.nroffler.Screens;

import com.badlogic.gdx.Gdx;
import com.badlogic.gdx.Input;
import com.badlogic.gdx.Screen;
import com.badlogic.gdx.graphics.Color;
import com.badlogic.gdx.graphics.GL20;
import com.badlogic.gdx.graphics.OrthographicCamera;
import com.badlogic.gdx.graphics.g2d.ParticleEffect;
import com.badlogic.gdx.maps.MapObject;
import com.badlogic.gdx.maps.objects.RectangleMapObject;
import com.badlogic.gdx.maps.tiled.TiledMap;
import com.badlogic.gdx.maps.tiled.TmxMapLoader;
import com.badlogic.gdx.maps.tiled.renderers.OrthogonalTiledMapRenderer;
import com.badlogic.gdx.math.Rectangle;
import com.badlogic.gdx.math.Vector2;
import com.badlogic.gdx.physics.box2d.Body;
import com.badlogic.gdx.physics.box2d.BodyDef;
import com.badlogic.gdx.physics.box2d.Box2DDebugRenderer;
import com.badlogic.gdx.physics.box2d.FixtureDef;
import com.badlogic.gdx.physics.box2d.PolygonShape;
import com.badlogic.gdx.physics.box2d.World;
import com.badlogic.gdx.utils.viewport.FitViewport;
import com.badlogic.gdx.utils.viewport.Viewport;

import box2dLight.PointLight;
import box2dLight.RayHandler;
import me.nroffler.main.DarkWorld;
import me.nroffler.sprites.Player;

public class PlayScreen implements Screen {

    private boolean running = true;
    private DarkWorld game;

    private TmxMapLoader maploader;
    private TiledMap map;
    private OrthogonalTiledMapRenderer renderer;

    private OrthographicCamera gamecam;
    private Viewport gameport;

    private World world;
    private Box2DDebugRenderer b2dr;

    private Player player;

    private RayHandler handler;
    private PointLight light;

    private ParticleEffect particleEffect;
    private float sclfkt = 0.001f;

    public PlayScreen(DarkWorld game, int level){
        this.game = game;

        gamecam = new OrthographicCamera();
        gameport = new FitViewport(DarkWorld.V_WIDTH / DarkWorld.PPM, DarkWorld.V_HEIGHT / DarkWorld.PPM, gamecam);

        maploader = new TmxMapLoader();
        map = maploader.load("level/map1-1.tmx");
        renderer = new OrthogonalTiledMapRenderer(map, 1 / DarkWorld.PPM);

        gamecam.position.set(gameport.getWorldWidth() / 2, gameport.getWorldHeight() / 2, 0);

        world = new World(new Vector2(0,-0.8f), true);

        b2dr = new Box2DDebugRenderer();

        player = new Player(this);


        for (MapObject object : map.getLayers().get(1).getObjects().getByType(RectangleMapObject.class)){
            Body pbody;
            BodyDef bdef = new BodyDef();

            Rectangle rect = ((RectangleMapObject) object).getRectangle();

            bdef.type = BodyDef.BodyType.StaticBody;
            bdef.position.set(new Vector2((rect.getX() + rect.getWidth() /2 )/ DarkWorld.PPM, (rect.getY() + rect.getHeight() / 2 )/ DarkWorld.PPM));
            bdef.fixedRotation = true;

            pbody = world.createBody(bdef);

            PolygonShape shape = new PolygonShape();
            shape.setAsBox(rect.getWidth() / 2 / DarkWorld.PPM, rect.getHeight() / 2 / DarkWorld.PPM);
            pbody.createFixture(shape, 1.0f);
            System.out.println("created");
        }

        createBox(32/ DarkWorld.PPM,1f,100f / DarkWorld.PPM, 10f / DarkWorld.PPM, true);
        //Shadows working

        handler = new RayHandler(world);
        handler.setAmbientLight(0.0f);
        light = new PointLight(handler, 200, Color.WHITE, 1.9f / DarkWorld.PPM, 0,0);
        light.setSoftnessLength(0);

        particleEffect = new ParticleEffect();
        particleEffect.load(Gdx.files.internal("particles/fine.pe"),Gdx.files.internal("particles/"));
        particleEffect.getEmitters().first().setPosition(38.3f,1.6f);
        particleEffect.scaleEffect(sclfkt);
        particleEffect.start();
        particleEffect.setDuration(30000000);




    }

    @Override
    public void show() {

    }

    public void update(float dt){

        handleInput(dt);

        player.update(dt);

        if (running) {
            gamecam.position.x = player.b2body.getPosition().x;
        }
        gamecam.update();
        renderer.setView(gamecam);

        world.step(1 / 60f,6,2);

        updatelighthandler();
        //handler.update();
    }

    private void updatelighthandler() {
        light.setPosition(player.b2body.getPosition().x/DarkWorld.PPM,player.b2body.getPosition().y/DarkWorld.PPM);
    }

    private void handleInput(float dt) {
        if (Gdx.input.isTouched()){
            move(dt);
        }
        if (Gdx.input.isKeyPressed(Input.Keys.SPACE)){
            move(dt);
        }
    }

    private void move(float dt) {
        if (running) {
            if (player.b2body.getLinearVelocity().x < 0.7f) {
                player.b2body.applyLinearImpulse(new Vector2(200 * dt / DarkWorld.PPM, 0), player.b2body.getWorldCenter(), true);
            }
            player.b2body.applyLinearImpulse(new Vector2(0, 500 * dt / DarkWorld.PPM), player.b2body.getWorldCenter(), true);
        }
    }


    @Override
    public void render(float delta) {
        update(delta);

        Gdx.gl.glClearColor(0.1f, 0.1f, 0.2f, 1);
        Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT);

        //Render tiled Map
        renderer.render();
        b2dr.render(world, gamecam.combined);

        //Render Light
        handler.setCombinedMatrix(gamecam.combined.cpy().scl(DarkWorld.PPM));
        handler.updateAndRender();

        game.batch.setProjectionMatrix(gamecam.combined);
        game.batch.begin();
        player.draw(game.batch);
        if((light.getDistance() < 0.5f)) {
            particleEffect.update(delta);
            particleEffect.draw(game.batch);
        }
        game.batch.end();

        if (!running){
            if (light.getDistance() < 0.3f) {
                world.setGravity(new Vector2(0,0));
                player.b2body.setLinearVelocity(0,0);
                light.setDistance(light.getDistance() + 0.001f);
                particleEffect.scaleEffect(sclfkt);
                sclfkt -= 0.0001f;
            } else {
                game.setScreen(new MainMenu(game));
            }
        }

    }

    @Override
    public void resize(int width, int height) {
        gameport.update(width, height);
    }

    @Override
    public void pause() {

    }

    @Override
    public void resume() {

    }

    @Override
    public void hide() {

    }

    @Override
    public void dispose() {
        handler.dispose();
        world.dispose();
        map.dispose();
        renderer.dispose();
        player.dispose();
        particleEffect.dispose();
        light.dispose();
    }

    public World getWorld() {
        return world;
    }

    public void setRunning(boolean running){
        this.running = running;
    }

    public boolean isRunning(){
        return running;
    }

    public Body createBox(float x, float y, float width, float height, boolean isStatic){
        Body pBody;
        BodyDef def = new BodyDef();

        if (isStatic){
            def.type = BodyDef.BodyType.StaticBody;
        } else {
            def.type = BodyDef.BodyType.DynamicBody;
        }
        def.position.set(x / DarkWorld.PPM,y / DarkWorld.PPM);
        def.fixedRotation = true;
        pBody = world.createBody(def);

        PolygonShape shape = new PolygonShape();
        shape.setAsBox(width/2 / DarkWorld.PPM, height/2 / DarkWorld.PPM);

        pBody.createFixture(shape, 1.0f);
        shape.dispose();

        return pBody;
    }
}
//Class Player
package me.nroffler.sprites;

import com.badlogic.gdx.graphics.Texture;
import com.badlogic.gdx.graphics.g2d.Sprite;
import com.badlogic.gdx.graphics.g2d.TextureRegion;
import com.badlogic.gdx.physics.box2d.Body;
import com.badlogic.gdx.physics.box2d.BodyDef;
import com.badlogic.gdx.physics.box2d.CircleShape;
import com.badlogic.gdx.physics.box2d.FixtureDef;
import com.badlogic.gdx.physics.box2d.World;
import com.badlogic.gdx.utils.Disposable;

import me.nroffler.Screens.PlayScreen;
import me.nroffler.main.DarkWorld;

public class Player extends Sprite implements Disposable {

    private World world;
    public Body b2body;
    public TextureRegion region;
    private PlayScreen screen;

    public Player(PlayScreen screen){
        super(new TextureRegion(new Texture("Sprites/player01.png"), 16,16));
        world = screen.getWorld();

        setBounds(0, 0, 16 / DarkWorld.PPM, 16 / DarkWorld.PPM);

        definePlayer();

        setTexture(new Texture("Sprites/player01.png"));
        region = new TextureRegion(getTexture(), 16,16);
        setRegion(region);

        this.screen = screen;
    }

    private void definePlayer() {
        BodyDef bdef = new BodyDef();
        bdef.position.set(0 / DarkWorld.PPM, 64 / DarkWorld.PPM);
        bdef.type = BodyDef.BodyType.DynamicBody;

        b2body = world.createBody(bdef);

        FixtureDef fdef = new FixtureDef();
        CircleShape shape = new CircleShape();
        shape.setRadius(6 / DarkWorld.PPM);

        fdef.shape = shape;
        b2body.createFixture(fdef);
    }

    public void update(float dt){
        setPosition(b2body.getPosition().x - getWidth() / 2, b2body.getPosition().y - getHeight() / 2);
        if (b2body.getPosition().x > 38.3f && screen.isRunning()){  //38
            screen.setRunning(false);

            //start Particle
        }
    }

    @Override
    public void dispose() {
        getTexture().dispose();
    }
}
//Class Darkworld
package me.nroffler.main;

import com.badlogic.gdx.ApplicationAdapter;
import com.badlogic.gdx.Game;
import com.badlogic.gdx.Gdx;
import com.badlogic.gdx.graphics.GL20;
import com.badlogic.gdx.graphics.Texture;
import com.badlogic.gdx.graphics.g2d.SpriteBatch;

import me.nroffler.Screens.MainMenu;
import me.nroffler.Screens.PlayScreen;

public class DarkWorld extends Game {

    public SpriteBatch batch;
    public static final int V_WIDTH = 400;
    public static final int V_HEIGHT = 208;
    public static final float PPM = 100;

    @Override
    public void create () {
        batch = new SpriteBatch();
        setScreen(new MainMenu(this));
    }

    @Override
    public void render () {
        super.render();
    }

    @Override
    public void dispose () {
        batch.dispose();
    }
}