/*
 * Copyright (C) 2010 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.replica.replicaisland;

import android.content.Context;
import android.os.Build;
import android.view.KeyEvent;
import android.view.MotionEvent;
import android.view.WindowManager;
import android.widget.Toast;

/**
 * High-level setup object for the AndouKun game engine.
 * This class sets up the core game engine objects and threads.  It also passes events to the
 * game thread from the main UI thread.
 */
public class Game extends AllocationGuard {
    private GameThread mGameThread;
    private Thread mGame;
    private ObjectManager mGameRoot;
    
    private GameRenderer mRenderer;
    private GLSurfaceView mSurfaceView;
    private boolean mRunning;
    private boolean mBootstrapComplete;
    private LevelTree.Level mPendingLevel;
    private LevelTree.Level mCurrentLevel;
    private LevelTree.Level mLastLevel;
    private boolean mGLDataLoaded;
    private ContextParameters mContextParameters;
    private TouchFilter mTouchFilter;
    
    public Game() {
        super();
        mRunning = false;
        mBootstrapComplete = false;
        mGLDataLoaded = false;
        mContextParameters = new ContextParameters();
    }

    /** 
     * Creates core game objects and constructs the game engine object graph.  Note that the
     * game does not actually begin running after this function is called (see start() below).
     * Also note that textures are not loaded from the resource pack by this function, as OpenGl
     * isn't yet available.
     * @param context
     */
    public void bootstrap(Context context, int viewWidth, int viewHeight, int gameWidth, int gameHeight, int difficulty) {
        if (!mBootstrapComplete) {
            mRenderer = new GameRenderer(context, this, gameWidth, gameHeight);
    
            // Create core systems
            BaseObject.sSystemRegistry.openGLSystem = new OpenGLSystem(null);
    
            BaseObject.sSystemRegistry.customToastSystem = new CustomToastSystem(context);
            
            ContextParameters params = mContextParameters;
            params.viewWidth = viewWidth;
            params.viewHeight = viewHeight;
            params.gameWidth = gameWidth;
            params.gameHeight = gameHeight;
            params.viewScaleX = (float)viewWidth / gameWidth;
            params.viewScaleY = (float)viewHeight / gameHeight;
            params.context = context;
            params.difficulty = difficulty;
            BaseObject.sSystemRegistry.contextParameters = params;
            
            final int sdkVersion = Integer.parseInt(Build.VERSION.SDK);
            if (sdkVersion < Build.VERSION_CODES.ECLAIR) {
            	mTouchFilter = new SingleTouchFilter();
            } else {
            	mTouchFilter = new MultiTouchFilter();
            }
    
            // Short-term textures are cleared between levels.
            TextureLibrary shortTermTextureLibrary = new TextureLibrary();
            BaseObject.sSystemRegistry.shortTermTextureLibrary = shortTermTextureLibrary;
            
            // Long-term textures persist between levels.
            TextureLibrary longTermTextureLibrary = new TextureLibrary();
            BaseObject.sSystemRegistry.longTermTextureLibrary = longTermTextureLibrary;
            
            // The buffer library manages hardware VBOs.
            BaseObject.sSystemRegistry.bufferLibrary = new BufferLibrary();
    
            
            
            BaseObject.sSystemRegistry.soundSystem = new SoundSystem();
            
            // The root of the game graph.
            MainLoop gameRoot = new MainLoop();
    
            InputSystem input = new InputSystem();
            BaseObject.sSystemRegistry.inputSystem = input;
            BaseObject.sSystemRegistry.registerForReset(input);
            
            WindowManager windowMgr = (WindowManager)context.getSystemService(Context.WINDOW_SERVICE); 
            int rotationIndex = windowMgr.getDefaultDisplay().getOrientation(); 
            input.setScreenRotation(rotationIndex);

            InputGameInterface inputInterface = new InputGameInterface();
            gameRoot.add(inputInterface);
            BaseObject.sSystemRegistry.inputGameInterface = inputInterface;
            
            LevelSystem level = new LevelSystem();
            BaseObject.sSystemRegistry.levelSystem = level;
            
            CollisionSystem collision = new CollisionSystem();
            BaseObject.sSystemRegistry.collisionSystem = collision;
            BaseObject.sSystemRegistry.hitPointPool = new HitPointPool();

            GameObjectManager gameManager = new GameObjectManager(params.viewWidth * 2);
            BaseObject.sSystemRegistry.gameObjectManager = gameManager;
            
            GameObjectFactory objectFactory = new GameObjectFactory();
            BaseObject.sSystemRegistry.gameObjectFactory = objectFactory;
            
            BaseObject.sSystemRegistry.hotSpotSystem = new HotSpotSystem();
            
            BaseObject.sSystemRegistry.levelBuilder = new LevelBuilder();
            
            BaseObject.sSystemRegistry.channelSystem = new ChannelSystem();
            BaseObject.sSystemRegistry.registerForReset(BaseObject.sSystemRegistry.channelSystem);
            
            CameraSystem camera = new CameraSystem();
            
    
            BaseObject.sSystemRegistry.cameraSystem = camera;
            BaseObject.sSystemRegistry.registerForReset(camera);
    
            collision.loadCollisionTiles(context.getResources().openRawResource(R.raw.collision));
    
            gameRoot.add(gameManager);
    
            // Camera must come after the game manager so that the camera target moves before the camera 
            // centers.
            
            gameRoot.add(camera);

    
            // More basic systems.
            
            GameObjectCollisionSystem dynamicCollision = new GameObjectCollisionSystem();
            gameRoot.add(dynamicCollision);
            BaseObject.sSystemRegistry.gameObjectCollisionSystem = dynamicCollision;
            
            
            RenderSystem renderer = new RenderSystem();
            BaseObject.sSystemRegistry.renderSystem = renderer;
            BaseObject.sSystemRegistry.vectorPool = new VectorPool();
            BaseObject.sSystemRegistry.drawableFactory = new DrawableFactory();
          
            HudSystem hud = new HudSystem();
            hud.setFuelDrawable(
                    new DrawableBitmap(longTermTextureLibrary.allocateTexture(
                            R.drawable.ui_bar), 0, 0),
                    new DrawableBitmap(longTermTextureLibrary.allocateTexture(
                            R.drawable.ui_bar_bg), 0, 0));
            hud.setFadeTexture(longTermTextureLibrary.allocateTexture(R.drawable.black));
            hud.setButtonDrawables(
                    new DrawableBitmap(longTermTextureLibrary.allocateTexture(
                            R.drawable.ui_button_fly_disabled), 0, 0), 
                    new DrawableBitmap(longTermTextureLibrary.allocateTexture(
                            R.drawable.ui_button_fly_off), 0, 0),
                    new DrawableBitmap(longTermTextureLibrary.allocateTexture(
                            R.drawable.ui_button_fly_on), 0, 0),
                    new DrawableBitmap(longTermTextureLibrary.allocateTexture(
                            R.drawable.ui_button_stomp_off), 0, 0),
                    new DrawableBitmap(longTermTextureLibrary.allocateTexture(
                            R.drawable.ui_button_stomp_on), 0, 0),
                    new DrawableBitmap(longTermTextureLibrary.allocateTexture(
                            R.drawable.ui_movement_slider_base), 0, 0),
                    new DrawableBitmap(longTermTextureLibrary.allocateTexture(
                            R.drawable.ui_movement_slider_button_off), 0, 0),
                    new DrawableBitmap(longTermTextureLibrary.allocateTexture(
                            R.drawable.ui_movement_slider_button_on), 0, 0));
            Texture[] digitTextures = {
                    longTermTextureLibrary.allocateTexture(R.drawable.ui_0),
                    longTermTextureLibrary.allocateTexture(R.drawable.ui_1),
                    longTermTextureLibrary.allocateTexture(R.drawable.ui_2),
                    longTermTextureLibrary.allocateTexture(R.drawable.ui_3),
                    longTermTextureLibrary.allocateTexture(R.drawable.ui_4),
                    longTermTextureLibrary.allocateTexture(R.drawable.ui_5),
                    longTermTextureLibrary.allocateTexture(R.drawable.ui_6),
                    longTermTextureLibrary.allocateTexture(R.drawable.ui_7),
                    longTermTextureLibrary.allocateTexture(R.drawable.ui_8),
                    longTermTextureLibrary.allocateTexture(R.drawable.ui_9)
            };
            DrawableBitmap[] digits = {
                    new DrawableBitmap(digitTextures[0], 0, 0),
                    new DrawableBitmap(digitTextures[1], 0, 0),
                    new DrawableBitmap(digitTextures[2], 0, 0),
                    new DrawableBitmap(digitTextures[3], 0, 0),
                    new DrawableBitmap(digitTextures[4], 0, 0),
                    new DrawableBitmap(digitTextures[5], 0, 0),
                    new DrawableBitmap(digitTextures[6], 0, 0),
                    new DrawableBitmap(digitTextures[7], 0, 0),
                    new DrawableBitmap(digitTextures[8], 0, 0),
                    new DrawableBitmap(digitTextures[9], 0, 0)
            };
            DrawableBitmap xDrawable = new DrawableBitmap(
                    longTermTextureLibrary.allocateTexture(R.drawable.ui_x), 0, 0);
            
            hud.setDigitDrawables(digits, xDrawable);
            hud.setCollectableDrawables(
                    new DrawableBitmap(
                            longTermTextureLibrary.allocateTexture(R.drawable.ui_pearl), 0, 0), 
                    new DrawableBitmap(
                            longTermTextureLibrary.allocateTexture(R.drawable.ui_gem), 0, 0));
            
            BaseObject.sSystemRegistry.hudSystem = hud;
            if (AndouKun.VERSION < 0) {
            	hud.setShowFPS(true);
            }
            gameRoot.add(hud);
    
            BaseObject.sSystemRegistry.vibrationSystem = new VibrationSystem();
            
            EventRecorder eventRecorder = new EventRecorder();
            BaseObject.sSystemRegistry.eventRecorder = eventRecorder;
            BaseObject.sSystemRegistry.registerForReset(eventRecorder);
            
            gameRoot.add(collision);
            
            // debug systems
            //BaseObject.sSystemRegistry.debugSystem = new DebugSystem(longTermTextureLibrary);
            //dynamicCollision.setDebugPrefs(false, true);
            
            
            objectFactory.preloadEffects();
    
            mGameRoot = gameRoot;
            
            mGameThread = new GameThread(mRenderer);
            mGameThread.setGameRoot(mGameRoot);
    
            
            mCurrentLevel = null;
            
            mBootstrapComplete = true;
        }
    }
    
    
    protected synchronized void stopLevel() {
        stop();
        GameObjectManager manager = BaseObject.sSystemRegistry.gameObjectManager;
        manager.destroyAll();
        manager.commitUpdates();
        
        //TODO: it's not strictly necessary to clear the static data here, but if I don't do it
        // then two things happen: first, the static data will refer to junk Texture objects, and
        // second, memory that may not be needed for the next level will hang around.  One solution
        // would be to break up the texture library into static and non-static things, and
        // then selectively clear static game components based on their usefulness next level,
        // but this is way simpler.
        GameObjectFactory factory = BaseObject.sSystemRegistry.gameObjectFactory;
        factory.clearStaticData();
        factory.sanityCheckPools();
        
        // Reset the level
        BaseObject.sSystemRegistry.levelSystem.reset();
        
        // Ensure sounds have stopped.
        BaseObject.sSystemRegistry.soundSystem.stopAll();
        
        // Reset systems that need it.
        BaseObject.sSystemRegistry.reset();
        
        // Dump the short-term texture objects only.
        mSurfaceView.flushTextures(BaseObject.sSystemRegistry.shortTermTextureLibrary);
        BaseObject.sSystemRegistry.shortTermTextureLibrary.removeAll(); 
        mSurfaceView.flushBuffers(BaseObject.sSystemRegistry.bufferLibrary);
        BaseObject.sSystemRegistry.bufferLibrary.removeAll();
    }
    
    public synchronized void requestNewLevel() {
    	// tell the Renderer to call us back when the
    	// render thread is ready to manage some texture memory.
    	mRenderer.requestCallback();
    }
    
    public synchronized void restartLevel() {
        DebugLog.d("AndouKun", "Restarting...");
        final LevelTree.Level level = mCurrentLevel;
        stop();
        
        // Destroy all game objects and respawn them.  No need to destroy other systems.
        GameObjectManager manager = BaseObject.sSystemRegistry.gameObjectManager;
        manager.destroyAll();
        manager.commitUpdates();
        
        // Ensure sounds have stopped.
        BaseObject.sSystemRegistry.soundSystem.stopAll();
        
        // Reset systems that need it.
        BaseObject.sSystemRegistry.reset();
        
        LevelSystem levelSystem = BaseObject.sSystemRegistry.levelSystem;
        levelSystem.incrementAttemptsCount();
        levelSystem.spawnObjects();
        
        BaseObject.sSystemRegistry.hudSystem.startFade(true, 0.2f);
        
        mCurrentLevel = level;
        mPendingLevel = null;
        start();
    }
    
    protected synchronized void goToLevel(LevelTree.Level level) {
        
        ContextParameters params = BaseObject.sSystemRegistry.contextParameters;
        BaseObject.sSystemRegistry.levelSystem.loadLevel(level,
                params.context.getResources().openRawResource(level.resource), mGameRoot);
        
        Context context = params.context;
        mRenderer.setContext(context);
        mSurfaceView.loadTextures(BaseObject.sSystemRegistry.longTermTextureLibrary);
        mSurfaceView.loadTextures(BaseObject.sSystemRegistry.shortTermTextureLibrary);
        mSurfaceView.loadBuffers(BaseObject.sSystemRegistry.bufferLibrary);
        
        mGLDataLoaded = true;
        
        mCurrentLevel = level;
        mPendingLevel = null;
        
        TimeSystem time = BaseObject.sSystemRegistry.timeSystem;
        time.reset();
        
        HudSystem hud = BaseObject.sSystemRegistry.hudSystem;
        if (hud != null) {
            hud.startFade(true, 1.0f);
        }
        
        
        CustomToastSystem toast = BaseObject.sSystemRegistry.customToastSystem;
        if (toast != null) {
        	if (level.inThePast) {
        		toast.toast(context.getString(R.string.memory_playback_start), Toast.LENGTH_LONG);
        	} else {
        		if (mLastLevel != null && mLastLevel.inThePast) {
            		toast.toast(context.getString(R.string.memory_playback_complete), Toast.LENGTH_LONG);
        		}
        	}
        }
        
        mLastLevel = level;
        
        start();
    }

    /** Starts the game running. */
    public void start() {
        if (!mRunning) {
            assert mGame == null;
            // Now's a good time to run the GC.
            Runtime r = Runtime.getRuntime();
            r.gc();
            DebugLog.d("AndouKun", "Start!");
            mGame = new Thread(mGameThread);
            mGame.setName("Game");
            mGame.start();
            mRunning = true;
            AllocationGuard.sGuardActive = false;
        } else {
            mGameThread.resumeGame();
        }
    }
    
    public void stop() {
        if (mRunning) {
            DebugLog.d("AndouKun", "Stop!");
            if (mGameThread.getPaused()) {
                mGameThread.resumeGame();
            }
            mGameThread.stopGame();
            try {
                mGame.join();
            } catch (InterruptedException e) {
                mGame.interrupt();
            }
            mGame = null;
            mRunning = false;
            mCurrentLevel = null;
            AllocationGuard.sGuardActive = false;
        }
    }

    public boolean onTrackballEvent(MotionEvent event) {
        if (mRunning) {
        	if (event.getAction() == MotionEvent.ACTION_MOVE) {
        		BaseObject.sSystemRegistry.inputSystem.roll(event.getRawX(), event.getRawY());
        	} else if (event.getAction() == MotionEvent.ACTION_DOWN) {
        		onKeyDownEvent(KeyEvent.KEYCODE_DPAD_CENTER);
        	} else if (event.getAction() == MotionEvent.ACTION_UP) {
        		onKeyUpEvent(KeyEvent.KEYCODE_DPAD_CENTER);
        	}
        }
        return true;
    }
    
    public boolean onOrientationEvent(float x, float y, float z) {
        if (mRunning) {
        	BaseObject.sSystemRegistry.inputSystem.setOrientation(x, y, z);
        }
        return true;
    }
    
    public boolean onTouchEvent(MotionEvent event) {
        if (mRunning) {
        	mTouchFilter.updateTouch(event);
        }
        return true;
    }
    
    
    
    public boolean onKeyDownEvent(int keyCode) {
        boolean result = false;
        if (mRunning) {
            BaseObject.sSystemRegistry.inputSystem.keyDown(keyCode);
        }
        return result;
    }
    
    public boolean onKeyUpEvent(int keyCode) {
        boolean result = false;
        if (mRunning) {
        	BaseObject.sSystemRegistry.inputSystem.keyUp(keyCode);
        }
        return result;
    }

    public GameRenderer getRenderer() {
        return mRenderer;
    }  
    
    public void onPause() {
    	if (mRunning) {
    		mGameThread.pauseGame(); 
    	}
    }
    
    public void onResume(Context context, boolean force) {
    	if (force && mRunning) {
    		mGameThread.resumeGame();
    	} else {
	        mRenderer.setContext(context);
	        // Don't explicitly resume the game here.  We'll do that in
	        // the SurfaceReady() callback, which will prevent the game
	        // starting before the render thread is ready to go.
	        BaseObject.sSystemRegistry.contextParameters.context = context;
    	}
    }
    
    public void onSurfaceReady() {
        DebugLog.d("AndouKun", "Surface Ready");

        if (mPendingLevel != null && mPendingLevel != mCurrentLevel) {
            if (mRunning) {
                stopLevel();
            }
            goToLevel(mPendingLevel);
        } else if (mGameThread.getPaused() && mRunning) {
            mGameThread.resumeGame();
        } 
    }
    
    public void setSurfaceView(GLSurfaceView view) {
        mSurfaceView = view;
    }
    
    public void onSurfaceLost() {
        DebugLog.d("AndouKun", "Surface Lost");
        
        BaseObject.sSystemRegistry.shortTermTextureLibrary.invalidateAll();
        BaseObject.sSystemRegistry.longTermTextureLibrary.invalidateAll();
        BaseObject.sSystemRegistry.bufferLibrary.invalidateHardwareBuffers();

        mGLDataLoaded = false;
    }
    
    public void onSurfaceCreated() {
        DebugLog.d("AndouKun", "Surface Created");
        
        // TODO: this is dumb.  SurfaceView doesn't need to control everything here.
        // GL should just be passed to this function and then set up directly.
        
        if (!mGLDataLoaded && mGameThread.getPaused() && mRunning && mPendingLevel == null) {
        	
            mSurfaceView.loadTextures(BaseObject.sSystemRegistry.longTermTextureLibrary);
            mSurfaceView.loadTextures(BaseObject.sSystemRegistry.shortTermTextureLibrary);
            mSurfaceView.loadBuffers(BaseObject.sSystemRegistry.bufferLibrary);
            mGLDataLoaded = true;
        }  
    }
    
    public void setPendingLevel(LevelTree.Level level) {
        mPendingLevel = level;
    }

	public void setSoundEnabled(boolean soundEnabled) {
		BaseObject.sSystemRegistry.soundSystem.setSoundEnabled(soundEnabled);
	}
	
	public void setControlOptions(boolean clickAttack, 
			boolean tiltControls, int tiltSensitivity, int movementSensitivity, boolean onScreenControls) {
		BaseObject.sSystemRegistry.inputGameInterface.setUseClickForAttack(clickAttack);
		BaseObject.sSystemRegistry.inputGameInterface.setUseOrientationForMovement(tiltControls);
		BaseObject.sSystemRegistry.inputGameInterface.setOrientationMovementSensitivity((tiltSensitivity / 100.0f));
		BaseObject.sSystemRegistry.inputGameInterface.setMovementSensitivity((movementSensitivity / 100.0f));
		BaseObject.sSystemRegistry.inputGameInterface.setUseOnScreenControls(onScreenControls);
		BaseObject.sSystemRegistry.hudSystem.setMovementSliderMode(onScreenControls);
	}
	
	public void setSafeMode(boolean safe) {
		mSurfaceView.setSafeMode(safe);
	}
	
	public float getGameTime() {
		return BaseObject.sSystemRegistry.timeSystem.getGameTime();
	}
	
	public Vector2 getLastDeathPosition() {
		return BaseObject.sSystemRegistry.eventRecorder.getLastDeathPosition();
	}
	
	public void setLastEnding(int ending) {
		BaseObject.sSystemRegistry.eventRecorder.setLastEnding(ending);
	}
	
	public int getLastEnding() {
		return BaseObject.sSystemRegistry.eventRecorder.getLastEnding();
	}

	public boolean isPaused() {
		return (mRunning && mGameThread != null && mGameThread.getPaused());
	}

	public void setKeyConfig(int leftKey, int rightKey, int jumpKey,
			int attackKey) {
		BaseObject.sSystemRegistry.inputGameInterface.setKeys(leftKey, rightKey, jumpKey, attackKey);
	}

	public int getRobotsDestroyed() {
		return BaseObject.sSystemRegistry.eventRecorder.getRobotsDestroyed();
	}
	
	public int getPearlsCollected() {
		return BaseObject.sSystemRegistry.eventRecorder.getPearlsCollected();
	}

	public int getPearlsTotal() {
		return BaseObject.sSystemRegistry.eventRecorder.getPearlsTotal();
	}
}