/*
      Copyright (C) 2010 Bepu Entertainment LLC.

      This software source code is provided 'as-is', without 
      any express or implied warranty.  In no event will the authors be held 
      liable for any damages arising from the use of this software.

      Permission is granted to anyone to use this software for any purpose,
      including commercial applications, and to alter it and redistribute it
      freely, subject to the following restrictions:

      1. The origin of this software must not be misrepresented; you must not
         claim that you wrote the original software. If you use this software
         in a product, an acknowledgment in the product documentation would be
         appreciated but is not required.
      2. Altered source versions must be plainly marked as such, and must not be
         misrepresented as being the original software.
      3. This notice may not be removed or altered from any source distribution.

    Contact us at:
    contact@bepu-games.com
 */


using System.Collections.Generic;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Input;
using BEPUphysics;
using BEPUphysics.Entities;
using Microsoft.Xna.Framework.Input.Touch;
using BEPUphysicsPhoneDemo.UIManagement;
using System;

namespace BEPUphysicsPhoneDemo
{

    /// <summary>
    /// Simple camera class for moving around the demos area.
    /// </summary>
    public class Camera
    {
        /// <summary>
        /// Gets or sets the position of the camera.
        /// </summary>
        public Vector3 position { get; set; }
        float myYaw;
        float myPitch;
        /// <summary>
        /// Gets or sets the yaw rotation of the camera.
        /// </summary>
        public float yaw
        {
            get
            {
                return myYaw;
            }
            set
            {
                myYaw = MathHelper.WrapAngle(value);
            }
        }
        /// <summary>
        /// Gets or sets the pitch rotation of the camera.
        /// </summary>
        public float pitch
        {
            get
            {
                return myPitch;
            }
            set
            {
                myPitch = value;
                if (myPitch > MathHelper.PiOver2)
                    myPitch = MathHelper.PiOver2;
                else if (myPitch < -MathHelper.PiOver2)
                    myPitch = -MathHelper.PiOver2;
            }
        }

        /// <summary>
        /// Gets or sets the speed at which the camera moves.
        /// </summary>
        public float speed { get; set; }

        Matrix myViewMatrix;
        /// <summary>
        /// Gets the view matrix of the camera.
        /// </summary>
        public Matrix viewMatrix
        {
            get
            {
                return myViewMatrix;
            }
        }
        /// <summary>
        /// Gets or sets the projection matrix of the camera.
        /// </summary>
        public Matrix projectionMatrix { get; set; }

        Matrix myWorldMatrix;
        /// <summary>
        /// Gets the world transformation of the camera.
        /// </summary>
        public Matrix worldMatrix
        {
            get
            {
                return myWorldMatrix;
            }
        }


        /// <summary>
        /// Gets the game used by the camera.
        /// </summary>
        public PhoneGame game { get; private set; }


        /// <summary>
        /// Creates a camera.
        /// </summary>
        /// <param name="game">Game used by the camera.</param>
        /// <param name="manager">Touch manager to control the input of the camera.</param>
        /// <param name="pos">Initial position of the camera.</param>
        /// <param name="s">Speed of the camera per second.</param>
        /// <param name="p">Initial pitch angle of the camera.</param>
        /// <param name="y">Initial yaw value of the camera.</param>
        /// <param name="projMatrix">Projection matrix used.</param>
        public Camera(PhoneGame game, TouchManager manager, Vector3 pos, float s, float p, float y, Matrix projMatrix)
        {
            this.game = game;
            position = pos;
            speed = s;
            yaw = y;
            pitch = p;
            projectionMatrix = projMatrix;

            touchedMethod = new Func<TouchLocation, bool>(touched);
            touchUpdatedMethod = new Func<TouchLocation, bool>(touchUpdated);
            touchReleasedMethod = new Func<TouchLocation, bool>(released);
        }

        /// <summary>
        /// Moves the camera forward.
        /// </summary>
        /// <param name="distance">Distance to move.</param>
        public void moveForward(float distance)
        {
            position += myWorldMatrix.Forward * distance;
        }

        /// <summary>
        /// Moves the camera to the right.
        /// </summary>
        /// <param name="distance">Distance to move.</param>
        public void moveRight(float distance)
        {
            position += myWorldMatrix.Right * distance;
        }

        /// <summary>
        /// Moves the camera up.
        /// </summary>
        /// <param name="distance">Distanec to move.</param>
        public void moveUp(float distance)
        {
            position += new Vector3(0, distance, 0);
        }


        TouchLocation originalTouchLocation;
        TouchLocation currentTouchLocation;


        bool touched(TouchLocation location)
        {
            if (originalTouchLocation.State == TouchLocationState.Invalid)
            {
                originalTouchLocation = location;
                currentTouchLocation = originalTouchLocation;
                return true;
            }
            return false;
        }

        bool released(TouchLocation location)
        {
            if (originalTouchLocation.Id == location.Id)
            {
                originalTouchLocation = default(TouchLocation);
                return true;
            }
            return false;
        }

        bool touchUpdated(TouchLocation location)
        {
            if (location.Id == originalTouchLocation.Id)
            {
                currentTouchLocation = location;
                return true;
            }
            return false;
        }

        /// <summary>
        /// Updates the state of the camera.
        /// </summary>
        /// <param name="dt">Time since the last frame in seconds.</param>
        public void update(float dt)
        {

            myWorldMatrix = Matrix.CreateFromAxisAngle(Vector3.Right, pitch) * Matrix.CreateFromAxisAngle(Vector3.Up, yaw);

            float distance = speed * dt;
            if (originalTouchLocation.State != TouchLocationState.Invalid)
            {
                bool moving = false;
                if (originalTouchLocation.Position.X < game.graphics.PreferredBackBufferWidth * .1f)
                {
                    moveRight(-distance);
                    moving = true;
                }
                if (originalTouchLocation.Position.X > game.graphics.PreferredBackBufferWidth * .9f)
                {
                    moveRight(distance);
                    moving = true;
                }
                if (originalTouchLocation.Position.Y < game.graphics.PreferredBackBufferHeight * .1f)
                {
                    moveForward(distance);
                    moving = true;
                }
                if (originalTouchLocation.Position.Y > game.graphics.PreferredBackBufferHeight * .9f)
                {
                    moveForward(-distance);
                    moving = true;
                }
                if (!moving)
                {
                    Vector2 offset;
                    TouchLocation oldLocation;
                    if (currentTouchLocation.TryGetPreviousLocation(out oldLocation))
                    {
                        offset = currentTouchLocation.Position - oldLocation.Position;
                        yaw += offset.X * .05f * dt;
                        pitch += offset.Y * .05f * dt;
                    }
                }

            }

            myWorldMatrix = myWorldMatrix * Matrix.CreateTranslation(position);
            myViewMatrix = Matrix.Invert(myWorldMatrix);

        }


        Func<TouchLocation, bool> touchedMethod, touchUpdatedMethod, touchReleasedMethod;

        /// <summary>
        /// Clears out any input handling events that the camera is using.
        /// </summary>
        public void removeInputEvents()
        {
            originalTouchLocation = default(TouchLocation);
            game.touchManager.touched -= touchedMethod;
            game.touchManager.touchUpdated -= touchUpdatedMethod;
            game.touchManager.released -= touchReleasedMethod;
        }

        /// <summary>
        /// Adds input handling events to the camera.
        /// </summary>
        public void addInputEvents()
        {
            game.touchManager.touched += touchedMethod;
            game.touchManager.touchUpdated += touchUpdatedMethod;
            game.touchManager.released += touchReleasedMethod;
        }
    }
}