using DeltaEngine.Core;
using DeltaEngine.Datatypes;
using DeltaEngine.Graphics;
using DeltaEngine.Rendering3D;
using DeltaEngine.Rendering3D.Cameras;

namespace FreeCamTest
{
	/// <summary>
	/// A camera that can be moved in local and world directions and rotate around own axes. 
    /// MiKo version 1.0 - 2/2014. Thanks to http://www.madgamedev.com and others
	/// </summary>
	public class myFreeCamera : Camera
	{
        private Quaternion m_rRotation;
        private Vector3D m_vPosition;
        private Matrix m_mCameraMatrix;

        private Vector3D m_vLocalX;  // Right
        private Vector3D m_vLocalY;  // Fwd
        private Vector3D m_vLocalZ;  // Up

        private Vector3D C_vX = Vector3D.UnitX; // Need this for Vector3D.Transform(ref...) below
        private Vector3D C_vY = Vector3D.UnitY;
        private Vector3D C_vZ = Vector3D.UnitZ;

        // Properties
        // ---------------------------------------------------------------------------

        public Quaternion Rotation 
        { 
            get { return m_rRotation; }
            set 
            { 
                m_rRotation = value;
                UpdateCameraAxes(); // Need to call this before Matrix update
                UpdateCameraMatrix();
            } 
        }

        override public Vector3D Position
        {
            get { return m_vPosition; }
            set
            {
                m_vPosition = value;
                UpdateCameraMatrix(); // No need to update axes here
            }
        }

        public Matrix CamMatrix
        {
            get { return m_mCameraMatrix; }
            private set { }
        }
 
        // Methods
        // ---------------------------------------------------------------------------

        static private float ClampAngle(float fAngle)
        {
            if (fAngle > 360.0f) return (fAngle - 360.0f);
            if (fAngle < 0.0f) return (fAngle + 360.0f);
            return (fAngle);
        }
        
        public myFreeCamera(Device device, Window window) : base(device, window)
		{
            m_vPosition = Vector3D.Zero;
            m_rRotation = Quaternion.Identity;

            UpdateCameraAxes(); // Need to call this before Matrix update
            UpdateCameraMatrix();           
		}

        public void RotateLocal(Vector3D vDegrees)
        {
            Vector3D vX = Vector3D.UnitX.Transform(m_rRotation);
            Vector3D vY = Vector3D.UnitY.Transform(m_rRotation);
            Vector3D vZ = Vector3D.UnitZ.Transform(m_rRotation);
            
            Quaternion qX = Quaternion.FromAxisAngle(vX, vDegrees.X);
            Quaternion qY = Quaternion.FromAxisAngle(vY, vDegrees.Y);
            Quaternion qZ = Quaternion.FromAxisAngle(vZ, vDegrees.Z);

            m_rRotation *= qX;
            m_rRotation *= qY;
            m_rRotation *= qZ;

            UpdateCameraAxes(); // Need to call this before Matrix update
            UpdateCameraMatrix();    
        }

        private void UpdateCameraMatrix()
        {
            m_mCameraMatrix = Matrix.CreateLookAt(m_vPosition, m_vPosition + m_vLocalY, m_vLocalZ);
        }

        private void UpdateCameraAxes()
        {
            Vector3D.Transform(ref C_vX, ref m_rRotation, out m_vLocalX);
            Vector3D.Transform(ref C_vY, ref m_rRotation, out m_vLocalY);
            Vector3D.Transform(ref C_vZ, ref m_rRotation, out m_vLocalZ);

            m_vLocalX.Normalize();
            m_vLocalY.Normalize();
            m_vLocalZ.Normalize();
        }

        public void MoveLocalX(float fDistance) // Right-Left
        {
            m_vPosition += m_vLocalX * fDistance;
            UpdateCameraMatrix(); // No need to update axes here
        }

        public void MoveLocalY(float fDistance) // Forward-Back
        {
            m_vPosition += m_vLocalY * fDistance;
            UpdateCameraMatrix(); // No need to update axes here
        }

		public void MoveLocalZ(float fDistance) // Up-down
		{
            m_vPosition += m_vLocalZ * fDistance;
            UpdateCameraMatrix(); // No need to update axes here
		}

        public void MoveWorldX(float fDistance) // Right-Left
        {
            m_vPosition += C_vX * fDistance;
            UpdateCameraMatrix(); // No need to update axes here
        }

        public void MoveWorldY(float fDistance) // Forward-Back
        {
            m_vPosition += C_vY * fDistance;
            UpdateCameraMatrix(); // No need to update axes here
        }

        public void MoveWorldZ(float fDistance) // Up-down
        {
            m_vPosition += C_vZ * fDistance;
            UpdateCameraMatrix(); // No need to update axes here
        }

        // Overrides
        // ---------------------------------------------------------------------------

		public override void ResetDefaults() {}

		protected override Matrix GetCurrentViewMatrix()
		{
            return m_mCameraMatrix;
		}
	}
}