/*
 * 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 com.replica.replicaisland.CollisionParameters.HitType;
import com.replica.replicaisland.GameObject.ActionType;
import com.replica.replicaisland.SoundSystem.Sound;

/**
 * Player Animation game object component.  Responsible for selecting an animation to describe the 
 * player's current state.  Requires the object to contain a SpriteComponent to play animations.
 */
public class AnimationComponent extends GameComponent {
    
    public enum PlayerAnimations {
        IDLE,
        MOVE,
        MOVE_FAST,
        BOOST_UP,
        BOOST_MOVE,
        BOOST_MOVE_FAST,
        STOMP,
        HIT_REACT,
        DEATH,
        FROZEN
    }
    
    private static final float MIN_ROCKET_TIME = 0.0f;
    private static final float FLICKER_INTERVAL = 0.15f;
    private static final float FLICKER_DURATION = 3.0f;
    private static final float LAND_THUMP_DELAY = 0.5f;
    
    private SpriteComponent mSprite;
    private SpriteComponent mJetSprite;
    private SpriteComponent mSparksSprite;
    
    private PlayerComponent mPlayer;
    private float mLastFlickerTime;
    private boolean mFlickerOn;
    private float mFlickerTimeRemaining;
    
    private GameObject.ActionType mPreviousAction;
    
    private float mLastRocketsOnTime;
    private boolean mExplodingDeath;
    
    private ChangeComponentsComponent mDamageSwap;
    private Sound mLandThump;
    private Sound mRocketSound;
    private Sound mExplosionSound;
    private float mLandThumpDelay;
    private int mRocketSoundStream;
    private boolean mRocketSoundPaused;
    
    private int mLastRubyCount;
    private Sound mRubySound1;
    private Sound mRubySound2;
    private Sound mRubySound3;
    private InventoryComponent mInventory;
    

    public AnimationComponent() {
        super();
        reset();
        setPhase(ComponentPhases.ANIMATION.ordinal());
    }
    
    @Override
    public void reset() {
        mPreviousAction = ActionType.INVALID;
        mSprite = null;
        mJetSprite = null;
        mSparksSprite = null;
        mPlayer = null;
        mLastFlickerTime = 0.0f;
        mFlickerOn = false;
        mFlickerTimeRemaining = 0.0f;
        mLastRocketsOnTime = 0.0f;
        mExplodingDeath = false;
        mDamageSwap = null;
        mLandThump = null;
        mLandThumpDelay = 0.0f;
        mRocketSound = null;
        mRocketSoundStream = -1;
        mLastRubyCount = 0;
        mInventory = null;
        mExplosionSound = null;
    }

    @Override
    public void update(float timeDelta, BaseObject parent) {
        if (mSprite != null) {

            GameObject parentObject = (GameObject) parent;
            
            final float velocityX = parentObject.getVelocity().x;
            final float velocityY = parentObject.getVelocity().y;
            

            GameObject.ActionType currentAction = parentObject.getCurrentAction();
            
            if (mJetSprite != null) {
                mJetSprite.setVisible(false);
            }
            
            if (mSparksSprite != null) {
                mSparksSprite.setVisible(false);
            }
            
            
            final TimeSystem time = sSystemRegistry.timeSystem;
            final float gameTime = time.getGameTime();
            
            if (currentAction != ActionType.HIT_REACT && mPreviousAction == ActionType.HIT_REACT) {
                mFlickerTimeRemaining = FLICKER_DURATION;
            }
            
            
            final boolean touchingGround = parentObject.touchingGround();
           
            boolean boosting = mPlayer != null ? mPlayer.getRocketsOn() : false;
            
            boolean visible = true;
            
            SoundSystem sound = sSystemRegistry.soundSystem;
            
            // It's usually not necessary to test to see if sound is enabled or not (when it's disabled,
            // play() is just a nop), but in this case I have a stream that is maintained for the rocket
            // sounds.  So it's simpler to just avoid that code if sound is off.
            if (sound.getSoundEnabled()) {
	            if (boosting) {
	                mLastRocketsOnTime = gameTime;
	            } else {
	                if (gameTime - mLastRocketsOnTime < MIN_ROCKET_TIME 
	                        && velocityY >= 0.0f) {
	                    boosting = true;
	                }
	            }
	            
	            if (mRocketSound != null) {
		            if (boosting) {
		            	if (mRocketSoundStream == -1) {
		            		mRocketSoundStream = sound.play(mRocketSound, true, SoundSystem.PRIORITY_HIGH);
		            		mRocketSoundPaused = false;
		            	} else if (mRocketSoundPaused) {
		            		sound.resume(mRocketSoundStream);
		            		mRocketSoundPaused = false;
		            	}
		            } else {
		            	sound.pause(mRocketSoundStream);
		            	mRocketSoundPaused = true;
		            }
	            }
            }
            
            // Normally, for collectables like the coin, we could just tell the object to play
            // a sound when it is collected.  The gems are a special case, though, as we
            // want to pick a different sound depending on how many have been collected.
            if (mInventory != null && mRubySound1 != null && mRubySound2 != null && mRubySound3 != null) {
            	InventoryComponent.UpdateRecord inventory = mInventory.getRecord();
            	final int rubyCount = inventory.rubyCount;
            	if (rubyCount != mLastRubyCount) {
            		mLastRubyCount = rubyCount;
            		switch (rubyCount) {
            		case 1:
            			sound.play(mRubySound1, false, SoundSystem.PRIORITY_NORMAL);
            			break;
            		case 2:
            			sound.play(mRubySound2, false, SoundSystem.PRIORITY_NORMAL);
            			break;
            		case 3:
            			sound.play(mRubySound3, false, SoundSystem.PRIORITY_NORMAL);
            			break;
            		}
            		
            	}
            }
            
            // Turn on visual effects (smoke, etc) when the player's life reaches 1.
            if (mDamageSwap != null) {
                if (parentObject.life == 1 && !mDamageSwap.getCurrentlySwapped()) {
                    mDamageSwap.activate(parentObject);
                } else if (parentObject.life != 1 && mDamageSwap.getCurrentlySwapped()) {
                    mDamageSwap.activate(parentObject);
                }
            }
            
            float opacity = 1.0f;
            
            if (currentAction == ActionType.MOVE) {
                InputGameInterface input = sSystemRegistry.inputGameInterface;
                final InputXY dpad = input.getDirectionalPad();
                if (dpad.getX() < 0.0f) {
                    parentObject.facingDirection.x = -1.0f; 
                } else if (dpad.getX() > 0.0f) {
                    parentObject.facingDirection.x = 1.0f;
                }
                
                // TODO: get rid of these magic numbers!
                if (touchingGround) {
                    
                    if (Utils.close(velocityX, 0.0f, 30.0f)) {
                        mSprite.playAnimation(PlayerAnimations.IDLE.ordinal());
                    } else if (Math.abs(velocityX) > 300.0f) {
                        mSprite.playAnimation(PlayerAnimations.MOVE_FAST.ordinal());
                    } else {
                        mSprite.playAnimation(PlayerAnimations.MOVE.ordinal());
                    }  
                    
                    final InputButton attackButton = input.getAttackButton();
                    
                    if (attackButton.getPressed()) {
                        // charge
                        final float pressedTime = gameTime - attackButton.getLastPressedTime();
                        final float wave = (float)Math.cos(pressedTime * (float)Math.PI * 2.0f);
                        opacity = (wave * 0.25f) + 0.75f;
                    }
                    
                } else {
                    if (boosting) {
                        if (mJetSprite != null) {
                            mJetSprite.setVisible(true);
                        }
                        
                        if (Math.abs(velocityX) < 100.0f && velocityY > 10.0f) {
                            mSprite.playAnimation(PlayerAnimations.BOOST_UP.ordinal());
                        } else if (Math.abs(velocityX) > 300.0f) {
                            mSprite.playAnimation(PlayerAnimations.BOOST_MOVE_FAST.ordinal());
                        } else {
                            mSprite.playAnimation(PlayerAnimations.BOOST_MOVE.ordinal());
                        }
                    } else {
                        
                        if (Utils.close(velocityX, 0.0f, 1.0f)) {
                            mSprite.playAnimation(PlayerAnimations.IDLE.ordinal());
                        } else if (Math.abs(velocityX) > 300.0f) {
                            mSprite.playAnimation(PlayerAnimations.MOVE_FAST.ordinal());
                        } else {
                            mSprite.playAnimation(PlayerAnimations.MOVE.ordinal());
                        } 
                    }
                    
                }
            } else if (currentAction == ActionType.ATTACK) {
                mSprite.playAnimation(PlayerAnimations.STOMP.ordinal()); 
                if (touchingGround && gameTime > mLandThumpDelay) {
                    if (mLandThump != null && sound != null) {
                        // modulate the sound slightly to avoid sounding too similar
                        sound.play(mLandThump, false, SoundSystem.PRIORITY_HIGH, 1.0f, 
                                (float)(Math.random() * 0.5f) + 0.75f); 
                        mLandThumpDelay = gameTime + LAND_THUMP_DELAY;
                    }
                }
            } else if (currentAction == ActionType.HIT_REACT) {
                mSprite.playAnimation(PlayerAnimations.HIT_REACT.ordinal());
              
                if (velocityX > 0.0f) {
                    parentObject.facingDirection.x = -1.0f;  
                } else if (velocityX < 0.0f) {
                    parentObject.facingDirection.x = 1.0f;
                }
                
                if (mSparksSprite != null) {
                    mSparksSprite.setVisible(true);
                }
            } else if (currentAction == ActionType.DEATH) {
                if (mPreviousAction != currentAction) {
                	if (mExplosionSound != null) {
                		sound.play(mExplosionSound, false, SoundSystem.PRIORITY_NORMAL);
                	}
                	// by default, explode when hit with the DEATH hit type.
                    boolean explodingDeath = parentObject.lastReceivedHitType == HitType.DEATH;
                    // or if touching a death tile.
                    HotSpotSystem hotSpot = sSystemRegistry.hotSpotSystem;
                    if (hotSpot != null) {
                        // TODO: HACK!  Unify all this code.
                        if (hotSpot.getHotSpot(parentObject.getCenteredPositionX(), 
                                parentObject.getPosition().y + 10.0f) == HotSpotSystem.HotSpotType.DIE) {
                            explodingDeath = true;
                        }
                    }
                    if (explodingDeath) {
                        mExplodingDeath = true;
                        GameObjectFactory factory = sSystemRegistry.gameObjectFactory;
                        GameObjectManager manager = sSystemRegistry.gameObjectManager;
                        if (factory != null && manager != null) {
                            GameObject explosion = factory.spawnEffectExplosionGiant(parentObject.getPosition().x, parentObject.getPosition().y);
                            if (explosion != null) {
                                manager.add(explosion);
                            }
                        }
                    } else {
                        mSprite.playAnimation(PlayerAnimations.DEATH.ordinal()); 
                        mExplodingDeath = false;
                    }
                    
                    mFlickerTimeRemaining = 0.0f;
                    if (mSparksSprite != null) {
                        if (!mSprite.animationFinished()) {
                            mSparksSprite.setVisible(true);
                        }
                    }
                }
                if (mExplodingDeath) {
                    visible = false;
                }
            } else if (currentAction == ActionType.FROZEN) {
                mSprite.playAnimation(PlayerAnimations.FROZEN.ordinal());
            }
            
            if (mFlickerTimeRemaining > 0.0f) {
                mFlickerTimeRemaining -= timeDelta;
                if (gameTime > mLastFlickerTime + FLICKER_INTERVAL) {
                    mLastFlickerTime = gameTime;
                    mFlickerOn = !mFlickerOn;
                }
                mSprite.setVisible(mFlickerOn);
                if (mJetSprite != null && mJetSprite.getVisible()) {
                    mJetSprite.setVisible(mFlickerOn);
                }
            } else {
                mSprite.setVisible(visible);
                mSprite.setOpacity(opacity);
            }
            
            mPreviousAction = currentAction;
        }
    }

    public void setSprite(SpriteComponent sprite) {
        mSprite = sprite;
    }
    
    public void setJetSprite(SpriteComponent sprite) {
        mJetSprite = sprite;
    }
    
    public void setSparksSprite(SpriteComponent sprite) {
        mSparksSprite = sprite;
    }
    
    public void setPlayer(PlayerComponent player) {
        mPlayer = player;
    }

    public final void setDamageSwap(ChangeComponentsComponent damageSwap) {
        mDamageSwap = damageSwap;
    }

    public void setLandThump(Sound land) {
        mLandThump = land;
    }

	public void setRocketSound(Sound sound) {
		mRocketSound = sound;
	}
	
	public void setRubySounds(Sound one, Sound two, Sound three) {
		mRubySound1 = one;
		mRubySound2 = two;
		mRubySound3 = three;
	}
	
	public void setInventory(InventoryComponent inventory) {
		mInventory = inventory;
	}

	public void setExplosionSound(Sound sound) {
		mExplosionSound = sound;
	}
}