using RoboforkApp.DataModel;
  using System;

  using System.Collections.Generic;
  using System.Linq;
  using System.Text;
  using System.Threading.Tasks;
  using System.Windows;
  using System.Windows.Controls;
  using System.Windows.Media;

  using System.Windows.Media.Animation;

  using System.Windows.Shapes;
  
  namespace RoboforkApp
  {
      public class ScheduleCanvas : Canvas
      {

          const double COOR_Y = 65;
          const double RADIUS_NODE = 25;

          public simulationRobo simulation;
          private VehicleModelList vehicleModelList;

          private Point _startPoint;
          private Point _endPoint;

          private bool _isGoal = false;

          private double _speed;

          private int _index;

          private List<ucNode> _lstNode;
  
          /// <summary>
          /// Create simulation
          /// </summary>

          /// <param name="lstNode">List node on schedule</param>
          /// <param name="vehicleModel">Vehicle model on map</param>
          /// <param name="vehicleIndex">Current index of vehicle</param>
          public void CreateSimulation(List<ucNode> lstNode, VehicleModel vehicleModel, int vehicleIndex)

          {

              //If node is less than 2 so return
              if (this.Children.Count < 2)
              {
                  return;
              }

              this.Children.Remove(simulation);

              //Init data
              this._lstNode = lstNode;

              this.vehicleModelList = vehicleModel.VehicleModelList[vehicleIndex];

              this._startPoint = new Point(Canvas.GetLeft(_lstNode[_index]) + RADIUS_NODE, COOR_Y);
              this._endPoint = new Point(Canvas.GetLeft(_lstNode[_index + 1]) + RADIUS_NODE, COOR_Y);
  
              //Get speed
              double scheDis = GetDistance(_startPoint, _endPoint);
              double mapDis = GetDistance(new Point(vehicleModelList.pointMapList[_index].pointMap_X, vehicleModelList.pointMapList[_index].pointMap_Y),
                                          new Point(vehicleModelList.pointMapList[_index + 1].pointMap_X, vehicleModelList.pointMapList[_index + 1].pointMap_Y + 1));
              this._speed = GetSpeed(mapDis, scheDis, vehicleModelList.pointMapList[_index].speed_Map);
  
              //Check next node is goal
              this._index += 1;
              if (_index == _lstNode.Count - 1)

              {
                  _isGoal = true;
              }
  
              // Start simulation
              RoboSimulation();
          }
  
          /// <summary>
          /// Create robo simulation on line
          /// </summary>
          private void RoboSimulation()
          {

              simulation = new simulationRobo();

              simulation.storyBoard = CreatPathAnimation(_startPoint, _endPoint, _speed);

              this.Children.Add(simulation);

          }
  
          /// <summary>
          /// Get storyboard
          /// </summary>
          /// <param name="startPoint">Point start line</param>
          /// <param name="endPoit">Point end line</param>
          /// <param name="speed">speed on line</param>
          /// <returns>Storyboard</returns>
          private Storyboard CreatPathAnimation(Point startPoint, Point endPoit, double speed)
          {

              PathGeometry animationPath = new PathGeometry();
              PathFigure pFigure = new PathFigure();

              pFigure.StartPoint = startPoint; //new Point(50, 65);

              LineSegment lineSegment = new LineSegment();

              lineSegment.Point = endPoit; // new Point(800, 65);

              pFigure.Segments.Add(lineSegment);
              animationPath.Figures.Add(pFigure);
  
              // Freeze the PathGeometry for performance benefits.
              animationPath.Freeze();
  
              // Create a MatrixAnimationUsingPath to move the

              // simulation along the path by animating

              // its MatrixTransform.
              MatrixAnimationUsingPath matrixAnimation = new MatrixAnimationUsingPath();
              matrixAnimation.PathGeometry = animationPath;

              matrixAnimation.SpeedRatio = speed;

              matrixAnimation.AutoReverse = false;
              matrixAnimation.DoesRotateWithTangent = true;

              matrixAnimation.Completed += delegate { AnimationCompleted(this._isGoal); };

  
              // Set the animation to target the Matrix property
              // of the MatrixTransform named "ButtonMatrixTransform".
              Storyboard.SetTargetName(matrixAnimation, "fl");
              Storyboard.SetTargetProperty(matrixAnimation, new PropertyPath(MatrixTransform.MatrixProperty));
  
              // Create a Storyboard to contain and apply the animation.
              Storyboard pathAnimationStoryboard = new Storyboard();
              pathAnimationStoryboard.Children.Add(matrixAnimation);

              return pathAnimationStoryboard;
          }
  
          /// <summary>
          /// Process when simulation is end line
          /// </summary>
          /// <param name="isGoal">check is node end</param>
          private void AnimationCompleted(bool isGoal)
          {
              // If not end node
              if (!isGoal)
              {

                  this.Children.Remove(simulation);

                  this._startPoint = _endPoint;
                  this._endPoint = new Point(Canvas.GetLeft(_lstNode[_index + 1]) + RADIUS_NODE, COOR_Y);
  
                  //Get speed
                  double scheDis = GetDistance(_startPoint, _endPoint);
                  double mapDis = GetDistance(new Point(vehicleModelList.pointMapList[_index].pointMap_X, vehicleModelList.pointMapList[_index].pointMap_Y),
                                              new Point(vehicleModelList.pointMapList[_index + 1].pointMap_X, vehicleModelList.pointMapList[_index + 1].pointMap_Y + 1));
                  this._speed = GetSpeed(mapDis, scheDis, vehicleModelList.pointMapList[_index].speed_Map);
  
                  //Check next node is goal
                  this._index += 1;
                  if (this._index == this._lstNode.Count - 1)

                  {
                      this._isGoal = true;
                  }

                  RoboSimulation();
                  return;
              }
  
              // Reset data when finish

              this._index = 0;

              this._speed = 0;

              this._isGoal = false;

          }

  
          /// <summary>
          /// Get speed on schedule
          /// </summary>
          /// <param name="mapDis">Distance the line on Map</param>
          /// <param name="scheDis">Distance the line on Schedule</param>
          /// <param name="mapSpeed">Speed the fork on Map</param>
          /// <returns>Speed the fork on schedule</returns>
          private double GetSpeed(double mapDis, double scheDis, double mapSpeed)
          {
              if (mapDis == 0)
                  return 0.0;
  
              return mapSpeed * (scheDis / mapDis);
          }
  
          /// <summary>
          /// Get distance between two point
          /// </summary>
          /// <param name="point1">Point 1</param>
          /// <param name="point2">Point 2</param>
          /// <returns>Distance between two point</returns>
          private double GetDistance(Point point1, Point point2)
          {
              //pythagorean theorem c^2 = a^2 + b^2
              //thus c = square root(a^2 + b^2)
              double a = (double)(point2.X - point1.X);
              double b = (double)(point2.Y - point1.Y);
  
              return Math.Sqrt(a * a + b * b);
          }

      }
  }