/*
 * 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.GameObject.ActionType;
import com.replica.replicaisland.HotSpotSystem.HotSpotType;

/**
 * This component implements the "patrolling" behavior for AI characters.  Patrolling characters
 * will walk forward on the map until they hit a direction hot spot or a wall, in which case they
 * may change direction.  Patrollers can also be configured via this component to attack the player
 * if appropriate conditions are met.
 */
public class PatrolComponent extends GameComponent {
    private float mMaxSpeed;
    private float mAcceleration;
    private boolean mAttack;
    private float mAttackAtDistance;
    private boolean mAttackStopsMovement;
    private float mAttackDuration;
    private float mAttackDelay;
    private boolean mTurnToFacePlayer;
    private boolean mFlying;
    
    private float mLastAttackTime;
    Vector2 mWorkingVector;
    Vector2 mWorkingVector2;

    
    public PatrolComponent() {
        super();
        mWorkingVector = new Vector2();
        mWorkingVector2 = new Vector2();

        reset();
        setPhase(GameComponent.ComponentPhases.THINK.ordinal());
    }
    
    @Override
    public void reset() {
        mTurnToFacePlayer = false;
        mMaxSpeed = 0.0f;
        mAcceleration = 0.0f;
        mAttack = false;
        mAttackAtDistance = 0.0f;
        mAttackStopsMovement = false;
        mAttackDuration = 0.0f;
        mAttackDelay = 0.0f;
        mWorkingVector.zero();
        mWorkingVector2.zero();
        mFlying = false;
    }
    
    @Override
    public void update(float timeDelta, BaseObject parent) {   
        GameObject parentObject = (GameObject) parent;
        
        if (parentObject.getCurrentAction() == ActionType.INVALID
        	|| parentObject.getCurrentAction() == ActionType.HIT_REACT) {
            parentObject.setCurrentAction(GameObject.ActionType.MOVE);
        }
        
        if ((mFlying || parentObject.touchingGround()) && parentObject.life > 0) {
            GameObjectManager manager = sSystemRegistry.gameObjectManager;
            GameObject player = null;
            if (manager != null) {
                player = manager.getPlayer();
            }
            
            if (mAttack) {
                updateAttack(player, parentObject);
            }
            
            
            if (parentObject.getCurrentAction() == GameObject.ActionType.MOVE
                    && mMaxSpeed > 0.0f) {
                int hotSpot = HotSpotSystem.HotSpotType.NONE;
                HotSpotSystem hotSpotSystem = sSystemRegistry.hotSpotSystem;
                if (hotSpotSystem != null) {
                    // TODO: ack, magic number
                    hotSpot = hotSpotSystem.getHotSpot(parentObject.getCenteredPositionX(), 
                            parentObject.getPosition().y + 10.0f);
                }
                final float targetVelocityX = parentObject.getTargetVelocity().x;
                final float targetVelocityY = parentObject.getTargetVelocity().y;

                boolean goLeft = (parentObject.touchingRightWall() 
                        || hotSpot == HotSpotType.GO_LEFT) && targetVelocityX >= 0.0f;
                    
                boolean goRight = (parentObject.touchingLeftWall() 
                        || hotSpot == HotSpotType.GO_RIGHT) && targetVelocityX <= 0.0f;
                    
                boolean pause = (mMaxSpeed == 0.0f) || hotSpot == HotSpotType.GO_DOWN;
                
                if (mTurnToFacePlayer && player != null && player.life > 0) {
                    final float horizontalDelta = player.getCenteredPositionX() 
                        - parentObject.getCenteredPositionX();
                    final int targetFacingDirection = Utils.sign(horizontalDelta);
                    final float closestDistance = player.width / 2.0f;
                    
                    if (targetFacingDirection < 0.0f) { // we want to turn to the left
                        if (goRight) {
                            goRight = false;
                            pause = true;
                        } else if (targetFacingDirection 
                                != Utils.sign(parentObject.facingDirection.x)) {
                            goLeft = true;
                        }
                    } else if (targetFacingDirection > 0.0f) { // we want to turn to the right
                        if (goLeft) {
                            goLeft = false;
                            pause = true;
                        } else if (targetFacingDirection 
                                != Utils.sign(parentObject.facingDirection.x)) {
                            goRight = true;
                        }
                    }
                    
                    if (Math.abs(horizontalDelta) < closestDistance) {
                        goRight = false;
                        goLeft = false;
                        pause = true;
                    }
                }
                
                if (!mFlying) {
                    if (!pause && !goLeft && !goRight && targetVelocityX == 0.0f) {
                        if (parentObject.facingDirection.x < 0.0f) {
                            goLeft = true;
                        } else {
                            goRight = true;
                        }
                    }
                    
                    
                    if (goRight) {
                        parentObject.getTargetVelocity().x = mMaxSpeed;
                        parentObject.getAcceleration().x = mAcceleration;
                    } else if (goLeft) {
                        parentObject.getTargetVelocity().x = -mMaxSpeed;
                        parentObject.getAcceleration().x = mAcceleration;
                    } else if (pause) {
                        parentObject.getTargetVelocity().x = 0;
                        parentObject.getAcceleration().x = mAcceleration;
                    }
                } else {
                    final boolean goUp = (parentObject.touchingGround() && targetVelocityY < 0.0f) 
                    	|| hotSpot == HotSpotType.GO_UP;
                        
                    final boolean goDown = (parentObject.touchingCeiling() && targetVelocityY > 0.0f)
                            || hotSpot == HotSpotType.GO_DOWN;
                            
                    if (goUp) {
                        parentObject.getTargetVelocity().x = 0.0f;
                        parentObject.getTargetVelocity().y = mMaxSpeed;
                        parentObject.getAcceleration().y = mAcceleration;
                        parentObject.getAcceleration().x = mAcceleration;

                    } else if (goDown) {
                        parentObject.getTargetVelocity().x = 0.0f;
                        parentObject.getTargetVelocity().y = -mMaxSpeed;
                        parentObject.getAcceleration().y = mAcceleration;
                        parentObject.getAcceleration().x = mAcceleration;

                    } else if (goRight) {
                        parentObject.getTargetVelocity().x = mMaxSpeed;
                        parentObject.getAcceleration().x = mAcceleration;
                        parentObject.getAcceleration().y = mAcceleration;
                        parentObject.getTargetVelocity().y = 0.0f;
                    } else if (goLeft) {
                        parentObject.getTargetVelocity().x = -mMaxSpeed;
                        parentObject.getAcceleration().x = mAcceleration;
                        parentObject.getAcceleration().y = mAcceleration;
                        parentObject.getTargetVelocity().y = 0.0f;
                    } 
                }
            }
        } else if (!mFlying && !parentObject.touchingGround() && parentObject.life > 0) {
        	// A non-flying unit is in the air.  In this case, just watch for bounces off walls.
        	if (Utils.sign(parentObject.getTargetVelocity().x) != Utils.sign(parentObject.getVelocity().x)) {
        		// Todo: maybe the physics code should adjust target velocity instead in this case?
        		parentObject.getTargetVelocity().x *= -1.0f;
        	}
        }
    }
    
    private void updateAttack(GameObject player, GameObject parentObject) {
        TimeSystem time = sSystemRegistry.timeSystem;
        final float gameTime = time.getGameTime();
        
        boolean visible = true;
        CameraSystem camera = sSystemRegistry.cameraSystem;
        ContextParameters context = sSystemRegistry.contextParameters;
        final float dx = 
            Math.abs(parentObject.getCenteredPositionX() - camera.getFocusPositionX());
        final float dy = 
            Math.abs(parentObject.getCenteredPositionY() - camera.getFocusPositionY());
        if (dx > context.gameWidth / 2.0f || dy > context.gameHeight / 2.0f) {
            visible = false;
        }
        if (visible && parentObject.getCurrentAction() == GameObject.ActionType.MOVE) {
            boolean closeEnough = false;
            boolean timeToAttack = (gameTime - mLastAttackTime) > mAttackDelay;
            if (mAttackAtDistance > 0 && player != null && player.life > 0 
                    && timeToAttack) {
                // only attack if we are facing the player
                if (Utils.sign(player.getPosition().x - parentObject.getPosition().x)
                        == Utils.sign(parentObject.facingDirection.x)) {
                    mWorkingVector.set(parentObject.getPosition());
                    mWorkingVector.x = parentObject.getCenteredPositionX();
                    mWorkingVector2.set(player.getPosition());
                    mWorkingVector2.x = player.getCenteredPositionX();
                    if (mWorkingVector2.distance2(mWorkingVector) < 
                        mAttackAtDistance * mAttackAtDistance) {
                        closeEnough = true;
                    }
                } 
            } else {
                closeEnough = true;  // If no distance has been set, don't worry about
                                     // the player's position.
            }
            
            if (timeToAttack && closeEnough) {
                // Time to attack.
                parentObject.setCurrentAction(GameObject.ActionType.ATTACK);
                mLastAttackTime = gameTime;
                if (mAttackStopsMovement) {
                    parentObject.getVelocity().zero();
                    parentObject.getTargetVelocity().zero();
                }
            }
        } else if (parentObject.getCurrentAction() == GameObject.ActionType.ATTACK) {
            if (gameTime - mLastAttackTime > mAttackDuration) {
                parentObject.setCurrentAction(GameObject.ActionType.MOVE);
                if (mAttackStopsMovement) {
                    parentObject.getTargetVelocity().x = 
                        mMaxSpeed * Utils.sign(parentObject.facingDirection.x);
                    parentObject.getAcceleration().x = mAcceleration;
                }
            }
        }
    }
    
    public void setMovementSpeed(float speed, float acceleration) {
        mMaxSpeed = speed;
        mAcceleration = acceleration;
    }
    
    public void setupAttack(float distance, float duration, float delay, boolean stopMovement) {
        mAttack = true;
        mAttackAtDistance = distance;
        mAttackStopsMovement = stopMovement;
        mAttackDuration = duration;
        mAttackDelay = delay;
    }
    
    public void setTurnToFacePlayer(boolean turn) {
        mTurnToFacePlayer = turn;
    }
    
    public void setFlying(boolean flying) {
        mFlying = flying;
    }
}