package sg;

import java.util.logging.Level;
import java.util.logging.Logger;

import sg.env.Environment;
import sg.util.SGUtil;

import com.jme.bounding.BoundingBox;
import com.jme.scene.Node;
import com.jme.scene.shape.Sphere;
import com.jme.scene.state.TextureState;
import com.jme.system.DisplaySystem;
import com.jme.image.Texture;
import com.jme.input.ChaseCamera;
import com.jme.input.InputHandler;
import com.jme.input.KeyInput;
import com.jme.input.action.InputAction;
import com.jme.input.action.InputActionEvent;
import com.jme.math.Quaternion;
import com.jme.math.Vector3f;
import com.jme.util.TextureManager;
import com.jmex.physics.DynamicPhysicsNode;
import com.jmex.physics.PhysicsSpace;
import com.jmex.physics.PhysicsUpdateCallback;
import com.jmex.physics.StaticPhysicsNode;
import com.jmex.physics.util.SimplePhysicsGame;

public class SpaceGame extends SimplePhysicsGame {
	private StaticPhysicsNode staticNode;
	private DynamicPhysicsNode dynamicNode;
	private Environment environment;
	private InputHandler physicsStepInputHandler;

	public static void main(String[] args) {
		//Logger.getLogger("").setLevel( Level.WARNING );
		SpaceGame game = new SpaceGame();
		game.setConfigShowMode(ConfigShowMode.AlwaysShow);
		game.start(); 
	}

	protected void simpleInitGame() {
		display.setTitle("SpaceGame");

		//physics
		getPhysicsSpace().setDirectionalGravity(new Vector3f(0f, 0f, 0f));
		staticNode = getPhysicsSpace().createStaticNode();
		rootNode.attachChild(staticNode);
		dynamicNode = getPhysicsSpace().createDynamicNode();
		rootNode.attachChild(dynamicNode);

		//environment
		environment = new Environment();
		rootNode.attachChild(environment);

		//light
		//TODO

		//controll
		physicsStepInputHandler = new InputHandler();
		getPhysicsSpace().addToUpdateCallbacks( new PhysicsUpdateCallback() {
			public void beforeStep( PhysicsSpace space, float time ) {
				physicsStepInputHandler.update( time );
			}
			public void afterStep( PhysicsSpace space, float time ) {

			}
		} );
		physicsStepInputHandler.addAction( new MyInputAction(700, MyInputAction.FORWARD),
				InputHandler.DEVICE_KEYBOARD, KeyInput.KEY_HOME, InputHandler.AXIS_NONE, true );
		physicsStepInputHandler.addAction( new MyInputAction(700, MyInputAction.BACK),
				InputHandler.DEVICE_KEYBOARD, KeyInput.KEY_END, InputHandler.AXIS_NONE, true );
		physicsStepInputHandler.addAction( new MyInputAction(700, MyInputAction.LEFT),
				InputHandler.DEVICE_KEYBOARD, KeyInput.KEY_PGUP, InputHandler.AXIS_NONE, true );
		physicsStepInputHandler.addAction( new MyInputAction(700, MyInputAction.RIGHT),
				InputHandler.DEVICE_KEYBOARD, KeyInput.KEY_PGDN, InputHandler.AXIS_NONE, true );

		//sphere
		/*
		Sphere s = new Sphere("Sphere", 10, 10, 25);
		s.setLocalTranslation(new Vector3f(0,0,-40));
		s.setModelBound(new BoundingBox());
		s.updateModelBound();
		Texture texture = TextureManager.loadTexture(
				SpaceGame.class.getClassLoader().getResource(
						"jmetest/data/images/Monkey.jpg"),
		                Texture.MinificationFilter.BilinearNearestMipMap,
		                Texture.MagnificationFilter.Bilinear);
		TextureState ts = display.getRenderer().createTextureState();
		ts.setEnabled(true);
		ts.setTexture(texture);
		s.setRenderState(ts);
		dynamicNode.attachChild(s);
		 */

		Node ship = SGUtil.loadModel("sg/data/models/ships/G6.3ds");
		ship.setLocalTranslation(new Vector3f(0,0,-40));
		dynamicNode.attachChild(ship);

		//ChaseCamera ccam = new ChaseCamera( cam, ship);
		//input = ccam;
	}

	public void simpleUpdate(){
		environment.update();
	}

	private class MyInputAction extends InputAction {
		public static final int FORWARD = 1;
		public static final int BACK = 2;
		public static final int LEFT = 3;
		public static final int RIGHT = 4;
		private final float force;
		private final Vector3f appliedForce = new Vector3f();
		private Vector3f rotation;
		private final int direction;

		public MyInputAction(float force, int direction) {
			this.force = force;
			this.direction = direction;
		}

		public void performAction( InputActionEvent evt ) {
			rotation = dynamicNode.getLocalRotation().getRotationColumn(2);
			switch(direction){
			case 1:
			case 2:
				appliedForce.set(rotation.mult(force)).multLocal( evt.getTime() );
				dynamicNode.addForce(appliedForce);
				break;
			case 3:
				break;
			case 4:
				break;
			}
		}
	}
}