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;
          private simulationRobo simulation;
          private Point startPoint;
          private Point endPoint;
          private bool _isGoal = false;
          private double _speed = 0.2; //Now _speed is fixed, but when update node
          private int index;

          private List<ucNode> _lstNode;
  
          /// <summary>
          /// Create simulation
          /// </summary>
          /// <param name="lstNode"></param>
          public void CreateSimulation(List<ucNode> lstNode)

          {

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

              //Init data
              this._lstNode = lstNode;
              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);
              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); //pathAnimationStoryboard;
              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.index += 1;
                  this.Children.Remove(simulation);
                  this.startPoint = endPoint;
                  this.endPoint = new Point(Canvas.GetLeft(_lstNode[index]) + RADIUS_NODE, COOR_Y);
                  
                  if (this.index == this._lstNode.Count - 1)
                  {
                      this._isGoal = true;
                  }
                  this._speed += 0.2;
                  RoboSimulation();
                  return;
              }
  
              // Reset data when finish
              this.index = 0;
              this._speed = 0.2;
              this._isGoal = false;

          }
      }
  }