package sg.states;

import java.util.concurrent.Callable;
import java.util.logging.Logger;

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

import com.jme.input.FirstPersonHandler;
import com.jme.input.InputHandler;
import com.jme.light.PointLight;
import com.jme.math.Vector3f;
import com.jme.renderer.ColorRGBA;
import com.jme.renderer.Renderer;
import com.jme.scene.Node;
import com.jme.scene.state.LightState;
import com.jme.system.DisplaySystem;
import com.jme.util.GameTaskQueueManager;
import com.jmex.game.state.CameraGameState;
import com.jmex.game.state.GameStateManager;
import com.jmex.game.state.load.LoadingGameState;
import com.jmex.physics.DynamicPhysicsNode;
import com.jmex.physics.PhysicsDebugger;
import com.jmex.physics.PhysicsSpace;
import com.jmex.physics.StaticPhysicsNode;

public class InGameState extends CameraGameState {
	/** The Keyboard/ mouse input handler */
	protected InputHandler input;
	/** The environment of the game */
	protected Environment environment;
	/** The physics space */
	private PhysicsSpace physicsSpace;
	/** The Speed of the physics */
	private float physicsSpeed = 1;
	/** Render pass manager */
	//protected BasicPassManager passManager;

	public InGameState(String name) {
		super(name);
	}
	
	public void setActive(boolean b){
		if(b){ // initiate the game
			if(environment == null){
				GameTaskQueueManager.getManager().update(new LoadingTask(this));
				this.active = false;
			}
			else { // the game is already initaiated
				this.active = true;
				onActivate();
				GameStateManager.getInstance().activateChildNamed("hud");
			}
		}
		else{
			this.active = false;
			onDeactivate();
			GameStateManager.getInstance().deactivateChildNamed("hud");
		}
	}

	public void stateUpdate(float tpf) {		
		input.update(tpf);

		environment.update();

		if ( tpf > 0.2 || Float.isNaN( tpf ) ) {
			Logger.getLogger( PhysicsSpace.LOGGER_NAME ).warning( "Maximum physics update interval is 0.2 seconds - capped." );
			physicsSpace.update( 0.2f * physicsSpeed );
		}
		else physicsSpace.update( tpf * physicsSpeed );

		//passManager.updatePasses(tpf);
	}

	public void stateRender(float tpf){
		Renderer r = DisplaySystem.getDisplaySystem().getRenderer();

		// debug
		PhysicsDebugger.drawPhysics( physicsSpace, r );

		/** Have the PassManager render. */
		//passManager.renderPasses(r);
	}
	
	//****************************************************************************
	//**************************   Loader    *************************************	
	
	private class LoadingTask implements Callable<Void>{
		private static final int STEP_COUNT = 7;
		private LoadingGameState loader;
		private InGameState parentState;
		private int progress;

		public LoadingTask(InGameState parentState){
			this.parentState = parentState;

			loader = new LoadingGameState(STEP_COUNT+1);
			GameStateManager.getInstance().attachChild(loader);
			loader.setActive(true);

			progress = 0;
			loader.increment("Loading Passes...");
		}

		public Void call() throws Exception {		
			// ***************** Load the Game **********************************
			switch(progress){
			case 0:
				// Pass (render thingies)
				//passManager = new BasicPassManager();
				
				loader.increment("Loading Physics...");
				break;
			case 1:
				//physics				
				physicsSpace = PhysicsSpace.create();

				physicsSpace.setDirectionalGravity(new Vector3f(0f, 0f, 0f));
				StaticPhysicsNode staticNode = physicsSpace.createStaticNode();
				DynamicPhysicsNode dynamicNode = physicsSpace.createDynamicNode();
				rootNode.attachChild(dynamicNode);
				rootNode.attachChild(staticNode);
				
				loader.increment("Loading Environment...");
				break;
			case 2:
				// environment				
				environment = new Environment(rootNode);
				rootNode.attachChild(environment);
				
				loader.increment("Loading Ships...");
				break;
			case 3:
				// ship			
				Node ship = SGUtil.loadModel("sg/data/models/ships/G6.3ds");
				ship.setLocalTranslation(new Vector3f( 0, 0, 40));
				rootNode.attachChild(ship);
				
				loader.increment("Loading Inputs...");
				break;
			case 4:
				// inputs
				FirstPersonHandler first = new FirstPersonHandler( cam, 50, 1 );
				input = new InputHandler();
				input.addToAttachedHandlers( first );
				
				loader.increment("Loading Lights...");
				break;
			case 5:
				// lights
				/** Set up a basic, default light. */
				PointLight light = new PointLight();
				light.setDiffuse( new ColorRGBA( 0.75f, 0.75f, 0.75f, 0.75f ) );
				light.setAmbient( new ColorRGBA( 0.5f, 0.5f, 0.5f, 1.0f ) );
				light.setLocation( new Vector3f( 100, 100, 100 ) );
				light.setEnabled( true );

				/** Attach the light to a lightState and the lightState to rootNode. */
				LightState lightState = DisplaySystem.getDisplaySystem().getRenderer().createLightState();
				lightState.setEnabled( true );
				lightState.attach( light );
				rootNode.setRenderState( lightState );
				rootNode.updateRenderState();
				
				loader.increment("Loading Hud...");
				break;
			case 6:
				HudState hud = new HudState("hud");
				GameStateManager.getInstance().attachChild(hud);
				
				loader.increment("Loading Starting...");
				break;
			case 7:
				cam.setFrustumFar(5000);

				// ***************** Done loading **********************************
				loader.setActive(false);
				GameStateManager.getInstance().detachChild(loader);

				parentState.setActive(true);
				break;
			}

			if (progress < STEP_COUNT) {				
				GameTaskQueueManager.getManager().update(this);
			}
			progress++;
			
			return null;
		}
	}
}