package dk.sdu.mmmi.cbse.project6.asteroids;

import com.decouplink.DisposableList;
import static com.decouplink.Utilities.context;
import dk.sdu.mmmi.cbse.project6.common.data.BehaviourEnum;
import dk.sdu.mmmi.cbse.project6.common.data.Entity;
import dk.sdu.mmmi.cbse.project6.common.data.EntityType;
import static dk.sdu.mmmi.cbse.project6.common.data.EntityType.PLAYER;
import dk.sdu.mmmi.cbse.project6.common.data.GameTime;
import dk.sdu.mmmi.cbse.project6.common.data.Position;
import dk.sdu.mmmi.cbse.project6.common.data.Rotation;
import dk.sdu.mmmi.cbse.project6.common.data.Scale;
import dk.sdu.mmmi.cbse.project6.common.data.View;
import dk.sdu.mmmi.cbse.project6.common.services.IEntityProcessingService;
import dk.sdu.mmmi.cbse.project6.common.services.IGamePluginService;
import java.util.ArrayList;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.apache.tuscany.sca.Node;
import org.oasisopen.sca.NoSuchServiceException;
import playn.core.Game;
import playn.core.GroupLayer;
import playn.core.Image;
import playn.core.ImageLayer;
import playn.core.Keyboard;
import playn.core.PlayN;
import static playn.core.PlayN.assets;
import static playn.core.PlayN.graphics;
import playn.core.util.Clock;

public class AsteroidsGame extends Game.Default {

    private final Clock.Source clock = new Clock.Source(33);
    private GroupLayer layer;
    private final Object world = new Object();
    private Node node;
    private Entity player;
    private ArrayList<IEntityProcessingService> EntityProcessingServices = new ArrayList<>();

    public AsteroidsGame(Node node) {
        super(33); // call update every 33ms (30 times per second)
        this.node = node;
    }

    @Override
    public void init() {

        // Add clock to world context
        context(world).add(GameTime.class, new GameTime());

	// Lookup all Game Plugins using ServiceLoader
        getPluginService().start(world);

        PlayN.keyboard().setListener(keyboardListener);

        // create a group layer to hold everything
        layer = graphics().rootLayer();

        // create and add background image layer
        layer.add(graphics().createImmediateLayer(
                new StarRenderer(clock, world)));

        // Create views for each entity
        createViews();
        for (Entity entity : context(world).all(Entity.class)) {
            if (context(entity).one(EntityType.class) == PLAYER) {
                this.player = entity;
                System.out.println("Link created");
            }
        }

        EntityProcessingServices = getEntityProcessingService();

        onInit();
    }

    @Override
    public void update(int delta) {

        clock.update(delta);
        context(world).one(GameTime.class).delta = delta;

		// Process each entity using provided processing services (i.e.,
        // ServiceLoader services)

        for (IEntityProcessingService p: EntityProcessingServices)
        {
//        IEntityProcessingService entityProcessorService = getEntityProcessingService();
//        for (Entity e : context(world).all(Entity.class)) {
//            entityProcessorService.process(world, e);
//        }
//        IEntityProcessingService entityProcessorService2 = getEntityProcessingService2();
            for (Entity e : context(world).all(Entity.class)) {
                p.process(world, e);
            }
        }


    }

    @Override
    public void paint(float alpha) {
		// the background automatically paints itself, so no need to do anything
        // here!
        clock.paint(alpha);

        for (Entity e : context(world).all(Entity.class)) {
            ImageLayer view = context(e).one(ImageLayer.class);
            Position p = context(e).one(Position.class);
            Rotation r = context(e).one(Rotation.class);
            Scale s = context(e).one(Scale.class);

            view.setTranslation(p.x, p.y);
            view.setRotation(r.angle);
            view.setAlpha(1.0f);
            view.setScale(s.x, s.y);
        }
    }

    private void createViews() {
        for (Entity entity : context(world).all(Entity.class)) {

            View sprite = context(entity).one(View.class);

            String imagePath = sprite.getImageFilePath();

            Image image = assets().getImageSync(imagePath);

            ImageLayer viewLayer = graphics().createImageLayer(image);
            viewLayer.setOrigin(image.width() / 2f, image.height() / 2f);

            context(entity).add(ImageLayer.class, viewLayer);
            layer.add(viewLayer);
        }
    }

    private IGamePluginService getPluginService() {

        IGamePluginService gp = null;

        try {
            gp = node.getService(IGamePluginService.class, "EntityComponent");
        } catch (NoSuchServiceException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        return gp;
    }

    private final Keyboard.Listener keyboardListener = new Keyboard.Listener() {

        private final DisposableList disposables = new DisposableList();


        @Override
        public void onKeyDown(Keyboard.Event event) {
            switch (event.key()) {
                case W:
                    disposables.add(context(player).add(BehaviourEnum.class, BehaviourEnum.MOVE_UP));
                    break;

                case S:
                    disposables.add(context(player).add(BehaviourEnum.class, BehaviourEnum.MOVE_DOWN));
                    break;

                case A:
                    disposables.add(context(player).add(BehaviourEnum.class, BehaviourEnum.MOVE_LEFT));
                    break;

                case D:
                    disposables.add(context(player).add(BehaviourEnum.class, BehaviourEnum.MOVE_RIGHT));
                    break;

//                case SPACE:
//                    context(player).add(BehaviourEnum.class, BehaviourEnum.SHOOT);
//                    break;

                default:
                    break;
            }
        }

        @Override
        public void onKeyTyped(Keyboard.TypedEvent te) {
        }

        @Override
        public void onKeyUp(Keyboard.Event event) {
            disposables.dispose();
        }
    };

    private ArrayList<IEntityProcessingService> getEntityProcessingService() {
        ArrayList<IEntityProcessingService> IEntityProcessingService = new ArrayList<>();


        try {
            System.out.println("got added 1");
            IEntityProcessingService.add(node.getService(IEntityProcessingService.class, "EntityProcessingComponent"));
        } catch (NoSuchServiceException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        try {
            System.out.println("got added 2");
            IEntityProcessingService.add(node.getService(IEntityProcessingService.class,
                    "PlayerSystem"));
        } catch (NoSuchServiceException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        try {
            System.out.println("got added 3");
            IEntityProcessingService.add(node.getService(IEntityProcessingService.class,
                    "MoveSystem"));
        } catch (NoSuchServiceException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        return IEntityProcessingService;
    }

    private void onInit() {
        for (Entity entity : context(world).all(Entity.class)) {
            if (context(entity).one(EntityType.class) == PLAYER) {
                this.player = entity;
            }
        }
    }
}