//------------------------------------------------------------------
//
//  The following article discusses the mechanics behind this
//  trackball implementation: http://viewport3d.com/trackball.htm
//
//  Reading the article is not required to use this sample code,
//  but skimming it might be useful.
//
//  For licensing information and to get the latest version go to:
//  http://workspaces.gotdotnet.com/3dtools
//
//------------------------------------------------------------------

//------------------------------------------------------------------
//
// using http://www.codeplex.com/3DTools
//
//-------------------------------------------------------------------


using System;
using System.Windows;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Media3D;
using System.Windows.Controls;
using Petzold.Media3D;
using _3DTools;


namespace Xenki.DefaultRenderer
{
    public class CameraControl
    {
        private FrameworkElement _eventSource;
        private Point _previousPosition2D;
        private Vector3D _previousPosition3D = new Vector3D(0, 0, 1);

        private Transform3DGroup _transform;
        private ScaleTransform3D _scale = new ScaleTransform3D();
        private AxisAngleRotation3D _rotation = new AxisAngleRotation3D();
        private TranslateTransform3D _translate = new TranslateTransform3D();

        private Vector3D _cameraLookDirection = new Vector3D(128, 128, 10);

        private PerspectiveCamera _camera;
        private Point3D _cameraLookPoint;
        private RotateTransform3D _rotationTransform = new RotateTransform3D();
        //ModelVisual3D clickedVisual;
        ModelVisual3D visul3d;

        //rotate and pan object clicked
        private TranslateTransform3D _clickedTranslate ;//= new TranslateTransform3D();
        private TranslateTransform3D _clickedTranslateOriginal;// = new TranslateTransform3D();
        private RotateTransform3D _clickedRotate ;//= new RotateTransform3D();
        private AxisAngleRotation3D _clickedAxisAngleRotate = new AxisAngleRotation3D();
        Point3D _clickedCenterPosition;
     

        bool isTracking = false;

        public CameraControl(PerspectiveCamera camera)
        {
            _camera = camera;

            _rotationTransform.Rotation = _rotation;
          
            _transform = new Transform3DGroup();
            //_transform.Children.Add(_translate);
            _transform.Children.Add(_rotationTransform);
            // _transform.Children.Add(_scale); 

           // _clickedRotate.Rotation = _clickedAxisAngleRotate;
        }

        /// <summary>
        ///     A transform to move the camera or scene to the trackball's
        ///     current orientation and scale.
        /// </summary>
        public Transform3DGroup Transform
        {
            get { return _transform; }
        }

        #region Event Handling

        /// <summary>
        ///     The FrameworkElement we listen to for mouse events.
        /// </summary>
        public FrameworkElement EventSource
        {
            get { return _eventSource; }

            set
            {
                if (_eventSource != null)
                {
                    _eventSource.MouseWheel -= _eventSource_MouseWheel;
                    _eventSource.MouseUp -= this.OnMouseUp;
                    _eventSource.MouseMove -= this.OnMouseMove;
                    _eventSource.MouseLeftButtonDown -= _eventSource_MouseLeftButtonDown;
                }
                _eventSource = value;
                _eventSource.MouseWheel += _eventSource_MouseWheel;
                _eventSource.MouseLeftButtonDown += new MouseButtonEventHandler(_eventSource_MouseLeftButtonDown);
                _eventSource.MouseUp += this.OnMouseUp;
                _eventSource.MouseMove += this.OnMouseMove;

            }
        }

        void _eventSource_MouseWheel(object sender, MouseWheelEventArgs e)
        {
            double scale = e.Delta / 1200.00;
            double distance = Point3D.Subtract(_cameraLookPoint, _camera.Position).Length;

            if (distance > 1024 || distance <= 10)
            {
                if (touch == false)
                {
                    touch = true;
                }
            }
            else
            {
                touch = false;
            }

            if (touch == true)
                scale = -scale;
            _camera.Position = new Point3D(_camera.Position.X + scale * _cameraLookDirection.X,
                _camera.Position.Y + scale * _cameraLookDirection.Y, 
                _camera.Position.Z + scale * _cameraLookDirection.Z);
            _camera.LookDirection = Point3D.Subtract(_cameraLookPoint, _camera.Position);
        }

        void _eventSource_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
        {
            Mouse.Capture(EventSource, CaptureMode.Element);

            Point pclick = e.GetPosition(EventSource);
            HitTestResult hitresult = VisualTreeHelper.HitTest(EventSource, pclick);
            RayMeshGeometry3DHitTestResult result3d = hitresult as RayMeshGeometry3DHitTestResult;
            if (result3d == null)
                return;

            visul3d = result3d.VisualHit as ModelVisual3D;
            if (visul3d == null)
                return;

            Transform3DGroup group = visul3d.Transform as Transform3DGroup;
            if (group != null)
            {
                foreach (Transform3D tran in group.Children)
                {
                    if (tran is RotateTransform3D)
                    {
                        _clickedRotate = new RotateTransform3D();
                        _clickedRotate =  group.Children[0] as RotateTransform3D;
                        if (_clickedRotate != null)
                        {
                            _clickedAxisAngleRotate = new AxisAngleRotation3D();
                            _clickedRotate.Rotation = _clickedAxisAngleRotate;
                        }
                    }
                    else if (tran is TranslateTransform3D)
                        _clickedTranslate = group.Children[1] as TranslateTransform3D;
                }
            }
            else
                return;


            //for pan the object
            //clickedVisual = visul3d;
            //visul3d.Transform = group;
            _clickedTranslateOriginal = _clickedTranslate.Clone();


            //for ALT + MOUSE + ROTATE
            Petzold.Media3D.LineRange line;
            Petzold.Media3D.ViewportInfo.Point2DtoPoint3D(_eventSource as Viewport3D, pclick, out line);
            _cameraLookPoint = line.PointFromY(visul3d.Content.Bounds.Y);

            _rotationTransform.CenterX = _cameraLookPoint.X;
            _rotationTransform.CenterY = _cameraLookPoint.Y;
            _rotationTransform.CenterZ = _cameraLookPoint.Z;

            //for rotate the object mouse clicked

            _clickedRotate.CenterX = _clickedCenterPosition.X = visul3d.Content.Bounds.Location.X + visul3d.Content.Bounds.SizeX / 2; 
            _clickedRotate.CenterY = _clickedCenterPosition.Y = visul3d.Content.Bounds.Location.Y + visul3d.Content.Bounds.SizeY / 2;
            _clickedRotate.CenterZ = _clickedCenterPosition.Z = visul3d.Content.Bounds.Location.Z + visul3d.Content.Bounds.SizeZ / 2;

            _cameraLookDirection = Point3D.Subtract(_cameraLookPoint, _camera.Position);
            _camera.LookDirection = _cameraLookDirection;

            //TRACK BALL
            _previousPosition3D = ProjectToTrackball(
               EventSource.ActualWidth,
               EventSource.ActualHeight,
               _previousPosition2D);

            isTracking = true;
            _eventSource.CaptureMouse();
            _eventSource.Focus();
            e.Handled = true;
        }

        private void OnMouseUp(object sender, MouseEventArgs e)
        {
            Mouse.Capture(EventSource, CaptureMode.None);
            isTracking = false;

            //Transform3DGroup clickedtransformGroup = new Transform3DGroup();
            //clickedtransformGroup.Children.Add(_clickedRotate);
            //clickedtransformGroup.Children.Add(_clickedTranslate);

            //visul3d.Transform =  clickedtransformGroup;

            _clickedTranslate = null;

            _eventSource.ReleaseMouseCapture();
            _eventSource.Cursor = Cursors.Arrow;
        }

        private void OnMouseMove(object sender, MouseEventArgs e)
        {
            Point currentPosition = e.GetPosition(EventSource);

            if (e.RightButton == MouseButtonState.Pressed && (Keyboard.IsKeyDown(Key.LeftShift) || Keyboard.IsKeyDown(Key.RightShift)))
            {
                LookUpDown(currentPosition);
            }
            else if (e.LeftButton == MouseButtonState.Pressed && (Keyboard.IsKeyDown(Key.LeftAlt) || Keyboard.IsKeyDown(Key.RightAlt)))
            {
                if (isTracking)
                {
                    _eventSource.Cursor = Cursors.None;
                    Focus(currentPosition);
                }
            }
            else if (e.RightButton == MouseButtonState.Pressed && Keyboard.IsKeyDown(Key.Q))
            {
                CameraPanUP(currentPosition);
            }
            else if (e.RightButton == MouseButtonState.Pressed && Keyboard.IsKeyDown(Key.A))
            {
                //TODO:
                CameraPanLeft(currentPosition);
            }
            else if (e.LeftButton == MouseButtonState.Pressed && (Keyboard.IsKeyDown(Key.LeftCtrl) || Keyboard.IsKeyDown(Key.RightCtrl))
                && (Keyboard.IsKeyDown(Key.LeftShift) || Keyboard.IsKeyDown(Key.RightShift)))
            {
                if (isTracking)
                {
                    _eventSource.Cursor = Cursors.None;
                    RotateObject(currentPosition);
                }
            }
            else if (e.LeftButton == MouseButtonState.Pressed && (Keyboard.IsKeyDown(Key.LeftCtrl) || Keyboard.IsKeyDown(Key.RightCtrl)))
            {
                if (isTracking)
                {
                    _eventSource.Cursor = Cursors.None;
                    PanObject(currentPosition);
                }
            }
            
            _previousPosition2D = currentPosition;
        }

        private void RotateObject(Point currentPosition)
        {
            Vector3D currentPosition3D = ProjectToTrackball(EventSource.ActualWidth, EventSource.ActualHeight, currentPosition);

            Vector3D axis = Vector3D.CrossProduct(_previousPosition3D, currentPosition3D);
            double angle = Vector3D.AngleBetween(_previousPosition3D, currentPosition3D);
            Quaternion delta = new Quaternion(axis, -angle);

            // Get the current orientantion from the RotateTransform3D
            Quaternion q = new Quaternion(_clickedAxisAngleRotate.Axis, _clickedAxisAngleRotate.Angle);

            // Compose the delta with the previous orientation
            q *= delta;

            // Write the new orientation back to the Rotation3D
                
            if (_clickedAxisAngleRotate.Angle >= 360||_clickedAxisAngleRotate.Angle<=-360)
                _clickedAxisAngleRotate.Angle = 0;

            _clickedAxisAngleRotate.Axis = q.Axis;
            _clickedAxisAngleRotate.Angle -= q.Angle;
      

            _previousPosition3D = currentPosition3D;
        }

        private Vector3D ProjectToTrackball(double width, double height, Point point)
        {
            double x = point.X / (width / 2);    // Scale so bounds map to [0,0] - [2,2]
            double y = point.Y / (height / 2);

            x = x - 1;                           // Translate 0,0 to the center
            y = 1 - y;                           // Flip so +Y is up instead of down

            double z2 = 1 - x * x - y * y;       // z^2 = 1 - x^2 - y^2
            double z = z2 > 0 ? Math.Sqrt(z2) : 0;

            return new Vector3D(x, y, z);
        }

        #endregion Event Handling


        private void CameraPanLeft(Point currentPosition)
        {
            LineRange range;
            ViewportInfo.Point2DtoPoint3D(_eventSource as Viewport3D, currentPosition, out range);
            Point3D pointNew = range.PointFromY(_clickedCenterPosition.Y);

            //_camera.Position.
        }

        private void PanObject(Point currentPosition)
        {
            double scaley = currentPosition.Y - _previousPosition2D.Y;
            scaley = scaley / 100.00;


            double scalex = currentPosition.X - _previousPosition2D.X;
            scalex = scalex / 100.00;

            Vector3D vector3D = GetTranslationVector3D(visul3d, _previousPosition2D, currentPosition);
           // Matrix3D matrix3D = visul3d.Transform.Value;// modelHit.Transform.Value;
           // vector3D += new Vector3D(matrix3D.OffsetX, matrix3D.OffsetY, matrix3D.OffsetZ);

            _clickedTranslate.OffsetX += vector3D.X*1.5;// _clickedTranslateOriginal.OffsetX + vector3D.X;
            _clickedTranslate.OffsetY += vector3D.Y*1.5;// _clickedTranslateOriginal.OffsetY + vector3D.Y;
            _clickedTranslate.OffsetZ += vector3D.Z*1.5;// _clickedTranslateOriginal.OffsetZ + vector3D.Z;// vectMouse.Z;


            //double scalez = Math.Sqrt(scalex * scalex + scaley * scaley);
            /*
            LineRange range;
            ViewportInfo.Point2DtoPoint3D(_eventSource as Viewport3D, currentPosition, out range);
            Point3D pointNew = range.PointFromY(_clickedCenterPosition.Y+scaley*_clickedCenterPosition.Y);

            Vector3D vectMouse = pointNew - _cameraLookPoint;
            //vectMouse = Vector3D.Multiply(_cameraLookDirection, visul3d.Transform.Value);
            _clickedTranslate.OffsetX = _clickedTranslateOriginal.OffsetX + vectMouse.X;
            _clickedTranslate.OffsetY = _clickedTranslateOriginal.OffsetY + vectMouse.Y;
            _clickedTranslate.OffsetZ = _clickedTranslateOriginal.OffsetZ + vectMouse.Z;// vectMouse.Z;

           // //vectMouse = Vector3D.Multiply(_cameraLookDirection, visul3d.Transform.Value);
           //_clickedTranslate.OffsetX += scalex * vectMouse.X;// _clickedTranslateOriginal.OffsetX + vectMouse.X;
           // _clickedTranslate.OffsetY += scaley * vectMouse.Y;// _clickedTranslateOriginal.OffsetY + vectMouse.Y;
           // //_clickedTranslate.OffsetZ += scaley * vectMouse.Z;// _clickedTranslateOriginal.OffsetZ + vectMouse.Z;// vectMouse.Z;
            */

            // matrix3D.OffsetX = vector3D.X;
           // matrix3D.OffsetY = vector3D.Y;
           // matrix3D.OffsetZ = vector3D.Z;
           //visul3d.Transform = new MatrixTransform3D(matrix3D);
         
            //mm += vectMouse.Y.ToString() + "/n";
      
        }

        private Vector3D GetTranslationVector3D(DependencyObject modelHit, Point startPosition, Point endPosition)
        {
            Vector3D translationVector3D = new Vector3D();

            Viewport3DVisual viewport = null;
            bool success = false;

            Matrix3D matrix3D = MathUtils.TryTransformTo2DAncestor(modelHit, out viewport, out success);
            if (success && matrix3D.HasInverse)
            {
                matrix3D.Invert();
                Point3D startPoint3D = new Point3D(startPosition.X, startPosition.Y, 0);
                Point3D endPoint3D = new Point3D(endPosition.X, endPosition.Y, 0);
                Vector3D vector3D = endPoint3D - startPoint3D;
                translationVector3D = matrix3D.Transform(vector3D);
            }

            return translationVector3D;
        }



        private void LookUpDown(Point currentPosition)
        { 
            double scale  = currentPosition.Y- _previousPosition2D.Y;
            scale = scale/5;
            _camera.LookDirection = new Vector3D(_camera.LookDirection.X, _camera.LookDirection.Y, _camera.LookDirection.Z + scale);
        }

        string mm = "";
        bool touch = false;
        private void Focus(Point currentPosition)
        {
            double yDelta = currentPosition.Y - _previousPosition2D.Y;
            double scale = yDelta / 100.0;
            //Maybe this part need replaced by collision detection method
            double distance = Point3D.Subtract(_cameraLookPoint, _camera.Position).Length;
            if (distance > 1024 || distance <= 1)
            {
                if (touch == false)
                    touch = true;
            }
            else
            {
                touch = false;
            }
             if (touch == true)
                scale = -scale;

            _camera.Position = new Point3D(_camera.Position.X - scale * _cameraLookDirection.X, _camera.Position.Y - scale * _cameraLookDirection.Y, _camera.Position.Z - scale * _cameraLookDirection.Z);

            //_translate.OffsetX -= scale * _cameraLookDirection.X;// _camera.LookDirection.X;
            //_translate.OffsetY -= scale * _cameraLookDirection.Y;//_camera.LookDirection.Y;
            //_translate.OffsetZ -= scale * _cameraLookDirection.Z;//_camera.LookDirection.Z;

            _camera.LookDirection = Point3D.Subtract(_cameraLookPoint, _camera.Position);

            double axisAngle = currentPosition.X - _previousPosition2D.X;
            double angletimes = axisAngle;

            if ( _rotation.Angle- angletimes <= -360)
                _rotation.Angle = 0;
            _rotation.Axis = new Vector3D(0, 0, 1);
            _rotation.Angle -= axisAngle;
        }

        public HitTestResultBehavior HitTestCallback(HitTestResult result)
        {
            if (result.VisualHit != null)
            {
                return HitTestResultBehavior.Stop;
            }
            return HitTestResultBehavior.Continue;
        }

        private void CameraPanUP(Point currentPosition)
        {
            double yDelta = currentPosition.Y - _previousPosition2D.Y;
            double xDelta = currentPosition.X - _previousPosition2D.X;
            double scale = yDelta / 5.00;

            _camera.Position = new Point3D(_camera.Position.X, _camera.Position.Y, _camera.Position.Z + scale);
        }


    }


}