package com.game.matematika.dasar;

import java.io.IOException;
import java.io.InputStream;

import org.andengine.engine.camera.Camera;
import org.andengine.engine.handler.IUpdateHandler;
import org.andengine.engine.options.EngineOptions;
import org.andengine.engine.options.ScreenOrientation;
import org.andengine.engine.options.resolutionpolicy.RatioResolutionPolicy;
import org.andengine.entity.scene.IOnSceneTouchListener;
import org.andengine.entity.scene.Scene;
import org.andengine.entity.sprite.AnimatedSprite;
import org.andengine.entity.sprite.Sprite;
import org.andengine.input.touch.TouchEvent;
import org.andengine.opengl.texture.ITexture;
import org.andengine.opengl.texture.bitmap.BitmapTexture;
import org.andengine.opengl.texture.region.TextureRegion;
import org.andengine.opengl.texture.region.TextureRegionFactory;
import org.andengine.opengl.texture.region.TiledTextureRegion;
import org.andengine.ui.activity.SimpleBaseGameActivity;
import org.andengine.util.adt.io.in.IInputStreamOpener;

import android.hardware.Sensor;
import android.hardware.SensorEvent;
import android.hardware.SensorEventListener;
import android.hardware.SensorManager;

public class MatematikaDasarActivity extends SimpleBaseGameActivity implements
        IOnSceneTouchListener, SensorEventListener {
    private static final float lebar = 240;
    private static final float tinggi = 320;
    private Camera cam;
    private TextureRegion trBG, trLakon;
    private ITexture itBG, itLakon;
    private Scene scene;
    private boolean touch = false;
    private float posX, posY;
    private Sprite sBG, sLakon;
    private SensorManager smGoyang;
    private TiledTextureRegion ttrLakon;
    private AnimatedSprite asLakon;

    @Override
    public EngineOptions onCreateEngineOptions() {
        this.cam = new Camera(0, 0, lebar, tinggi);
        return new EngineOptions(true, ScreenOrientation.PORTRAIT_FIXED,
                new RatioResolutionPolicy(lebar, tinggi), this.cam);
    }

    @Override
    protected void onCreateResources() {
        try {
            itBG = new BitmapTexture(getTextureManager(),
                    new IInputStreamOpener() {

                        @Override
                        public InputStream open() throws IOException {
                            return getAssets().open("gfx/bg.jpg");
                        }
                    });
            itLakon = new BitmapTexture(getTextureManager(),
                    new IInputStreamOpener() {

                        @Override
                        public InputStream open() throws IOException {
                            return getAssets().open("gfx/lakon.png");
                        }
                    });
            itBG.load();
            itLakon.load();

        } catch (IOException ioe) {
            ioe.printStackTrace();
        }
        this.trBG = TextureRegionFactory.extractFromTexture(itBG);
        this.trLakon = TextureRegionFactory.extractFromTexture(itLakon);

        this.ttrLakon = TextureRegionFactory.extractTiledFromTexture(itLakon,
                3, 2);
    }

    @Override
    protected Scene onCreateScene() {
        this.mEngine.registerUpdateHandler(new IUpdateHandler() {

            @Override
            public void reset() {

            }

            @Override
            public void onUpdate(float f) {
                if (touch) {
                    sLakon.setPosition(posX, posY);
                }
            }
        });

        this.smGoyang = (SensorManager) this.getSystemService(SENSOR_SERVICE);
        this.smGoyang.registerListener(this,
                smGoyang.getDefaultSensor(Sensor.TYPE_ACCELEROMETER),
                SensorManager.SENSOR_DELAY_GAME);

        scene = new Scene();
        sBG = new Sprite(0, 0, this.trBG, this.getVertexBufferObjectManager());
        sLakon = new Sprite(0, 0, this.trLakon,
                this.getVertexBufferObjectManager());

        this.asLakon = new AnimatedSprite(0, 0, 96, 50, this.ttrLakon,
                this.getVertexBufferObjectManager());
        this.asLakon.animate(new long[] { 100, 100 }, 0, 3, true);

        sBG.setPosition(posX, posY);
        scene.attachChild(sBG);
        scene.attachChild(sLakon);

        scene.attachChild(asLakon);

        scene.setOnSceneTouchListener(this);
        scene.setTouchAreaBindingOnActionMoveEnabled(true);
        return scene;
    }

    @Override
    public boolean onSceneTouchEvent(Scene s, TouchEvent te) {
        if (te.getAction() == TouchEvent.ACTION_MOVE) {
            posX = (sLakon.getX() + sLakon.getWidth()) / 2;
            posY = (sLakon.getY() + sLakon.getHeight()) / 2;
            touch = true;
        } else {
            posX = 0;
            posY = 0;
        }
        return touch;
    }

    @Override
    public void onAccuracyChanged(Sensor sensor, int accuracy) {
    }

    @Override
    public void onSensorChanged(SensorEvent event) {
        synchronized (this) {
            switch (event.sensor.getType()) {
            case Sensor.TYPE_ACCELEROMETER:
                if (event.values[0] > 0 && sLakon.getX() < 240) {
                    posX = sLakon.getX() + event.values[0];
                    posY = sLakon.getY() + event.values[1];
                } else if (event.values[0]  240) {
                    posX = -(sLakon.getX() + event.values[0]);
                    posY = sLakon.getY() + event.values[1];
                }
                break;
            default:
                break;
            }
        }
    }
}