using Aitex.Core.Common;
using Aitex.Core.UI.MVVM;
using Aitex.Sorter.UI.Controls.Common;
using MECF.Framework.Common.Equipment;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Threading;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Animation;

namespace Aitex.Sorter.UI.Controls
{
    /// <summary>
    /// AtmRobot3.xaml 的交互逻辑
    /// </summary>
    public partial class AtmRobot3 : UserControl, INotifyPropertyChanged
    {
        protected readonly int MoveTime = 300;
        private const int AnimationTimeout = 3000; // seconds

        public int RotateAngle
        {
            get { return (int)GetValue(RotateAngleProperty); }
            set { SetValue(RotateAngleProperty, value); }
        }

        // Using a DependencyProperty as the backing store for RotateAngel.  This enables animation, styling, binding, etc...
        public static readonly DependencyProperty RotateAngleProperty =
            DependencyProperty.Register("RotateAngel", typeof(int), typeof(AtmRobot3), new PropertyMetadata(0));

        public ModuleName Station
        {
            get { return (ModuleName)GetValue(StationProperty); }
            set { SetValue(StationProperty, value); }
        }

        // Using a DependencyProperty as the backing store for Station.  This enables animation, styling, binding, etc...
        public static readonly DependencyProperty StationProperty =
            DependencyProperty.Register("Station", typeof(ModuleName), typeof(AtmRobot3), new PropertyMetadata(ModuleName.Robot));

        public ICommand Command
        {
            get { return (ICommand)GetValue(CommandProperty); }
            set { SetValue(CommandProperty, value); }
        }

        // Using a DependencyProperty as the backing store for Command.  This enables animation, styling, binding, etc...
        public static readonly DependencyProperty CommandProperty =
            DependencyProperty.Register("Command", typeof(ICommand), typeof(AtmRobot3), new PropertyMetadata(null));

        public string RobotBladeTarget
        {
            get { return (string)GetValue(RobotBladeTargetProperty); }
            set { SetValue(RobotBladeTargetProperty, value); }
        }

        public static readonly DependencyProperty RobotBladeTargetProperty =
            DependencyProperty.Register("RobotBladeTarget", typeof(string), typeof(AtmRobot3), new FrameworkPropertyMetadata(null, FrameworkPropertyMetadataOptions.AffectsRender));


        public string RobotBlade2Target
        {
            get { return (string)GetValue(RobotBlade2TargetProperty); }
            set { SetValue(RobotBlade2TargetProperty, value); }
        }

        public static readonly DependencyProperty RobotBlade2TargetProperty =
            DependencyProperty.Register("RobotBlade2Target", typeof(string), typeof(AtmRobot3), new FrameworkPropertyMetadata(null, FrameworkPropertyMetadataOptions.AffectsRender));


        public Dictionary<string, StationPosition> StationPosition
        {
            get { return (Dictionary<string, StationPosition>)GetValue(StationPositionProperty); }
            set { SetValue(StationPositionProperty, value); }
        }

        // Using a DependencyProperty as the backing store for StationPosition2.  This enables animation, styling, binding, etc...
        public static readonly DependencyProperty StationPositionProperty =
            DependencyProperty.Register("StationPosition", typeof(Dictionary<string, StationPosition>), typeof(AtmRobot3), new PropertyMetadata(null, StationPositionChangedCallback));

        public bool ShowDock
        {
            get { return (bool)GetValue(ShowDockProperty); }
            set { SetValue(ShowDockProperty, value); }
        }

        // Using a DependencyProperty as the backing store for ShowDock.  This enables animation, styling, binding, etc...
        public static readonly DependencyProperty ShowDockProperty =
            DependencyProperty.Register("ShowDock", typeof(bool), typeof(AtmRobot3), new PropertyMetadata(false));

        public WaferInfo Wafer1
        {
            get { return (WaferInfo)GetValue(Wafer1Property); }
            set { SetValue(Wafer1Property, value); }
        }

        // Using a DependencyProperty as the backing store for Wafer1.  This enables animation, styling, binding, etc...
        public static readonly DependencyProperty Wafer1Property =
            DependencyProperty.Register("Wafer1", typeof(WaferInfo), typeof(AtmRobot3), new PropertyMetadata(null));

        public WaferInfo Wafer2
        {
            get { return (WaferInfo)GetValue(Wafer2Property); }
            set { SetValue(Wafer2Property, value); }
        }

        // Using a DependencyProperty as the backing store for Wafer2.  This enables animation, styling, binding, etc...
        public static readonly DependencyProperty Wafer2Property =
            DependencyProperty.Register("Wafer2", typeof(WaferInfo), typeof(AtmRobot3), new PropertyMetadata(null));

        private string CurrentPosition
        {
            get; set;
        }

        private List<MenuItem> menu;
        public List<MenuItem> Menu
        {
            get
            {
                return menu;
            }
            set
            {
                menu = value;
                PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("Menu"));
            }
        }

        public ICommand MoveCommand
        {
            get
            {
                return new DelegateCommand<string>(MoveTo);
            }
        }

        private AnimationQueue queue;

        public event PropertyChangedEventHandler PropertyChanged;

        static void StationPositionChangedCallback(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            var self = (AtmRobot3)d;
            var positions = (Dictionary<string, StationPosition>)e.NewValue;
            self.Menu = positions.Select(x => new MenuItem() { Header = x.Key, Command = self.MoveCommand, CommandParameter = x.Key }).ToList();
        }

        public AtmRobot3()
        {
#if DEBUG
            System.Diagnostics.PresentationTraceSources.DataBindingSource.Switch.Level = System.Diagnostics.SourceLevels.Critical;
#endif
            InitializeComponent();
            root.DataContext = this;

            queue = new AnimationQueue("Robot Animation");
            queue.StatusUpdated += Queue_StatusUpdated;

            canvas1.Rotate(90);
            canvas2.Rotate(180);
            canvas3.Rotate(180);
            canvas21.Rotate(90);
            canvas22.Rotate(180);
            canvas23.Rotate(180);

            CurrentPosition = "ArmA." + ModuleName.System.ToString();
        }

        protected override void OnRender(DrawingContext drawingContext)
        {
            base.OnRender(drawingContext);

            if (DesignerProperties.GetIsInDesignMode(this))
            {
                return;
            }

            if (RobotBladeTarget != null)
            {
                queue.EnqueueStatus(new AnimationParameter() { Target = RobotBladeTarget });
            }
            if (RobotBlade2Target != null)
            {
                queue.EnqueueStatus(new AnimationParameter() { Target = RobotBlade2Target });
            }
        }

        private void Queue_StatusUpdated(object sender, StatusUpdateArgs e)
        {
            string TargetPosition = CurrentPosition.Split('.')[0] + "." + e.Parameter.Target;

            LogMsg(string.Format("Target: {0} - {1}", CurrentPosition, TargetPosition));

            var nextEvent = new AutoResetEvent(false);

            var next = new Action(() =>
            {
                nextEvent.Set();
            });

            var wait = new Action(() =>
            {
                if (!nextEvent.WaitOne(AnimationTimeout))
                {
                    LogMsg("Aniamtion time out!");
                }
            });

            var done = new Action(() =>
            {
                CurrentPosition = TargetPosition;
                e.Event.Set();
            });

            var needMove = CurrentPosition != TargetPosition;

            if (needMove)
            {
                Invoke(() => MoveRobot(TargetPosition, next));
                wait();
            }

            done();
        }

        private void MoveRobot(string target, Action onComplete = null)
        {
            MoveToStart(CurrentPosition, () => TranslateTo(target, () =>
                 RetractArm(() =>
                 MoveToStart(target, () => MoveToEnd(target, onComplete)))));
        }

        private void RetractArm(Action onComplete = null)
        {
            canvas2.Rotate(180, true, 50, 0, 0, onComplete);
            canvas3.Rotate(180, true);
            canvas2.Rotate(180, true);
            canvas3.Rotate(180, true);
        }

        private void MoveToStart(string station, Action onComplete = null)
        {
            //var position = StationPosition[station];
            StationPosition positionA = station.Contains("ArmA") ? StationPosition[station] : StationPosition[station.Replace("ArmB", "ArmA")];
            StationPosition positionB = station.Contains("ArmB") ? StationPosition[station] : StationPosition[station.Replace("ArmA", "ArmB")];
            canvas1.Rotate(positionA.StartPosition.Root, true, MoveTime, 0, 0, onComplete);
            canvas2.Rotate(positionA.StartPosition.Arm, true, MoveTime);
            canvas3.Rotate(positionA.StartPosition.Hand, true, MoveTime);

            canvas21.Rotate(positionB.StartPosition.Root, true, MoveTime);
            canvas22.Rotate(positionB.StartPosition.Arm, true, MoveTime);
            canvas23.Rotate(positionB.StartPosition.Hand, true, MoveTime);
            CurrentPosition = station;
        }

        private void MoveToEnd(string station, Action onComplete = null)
        {
            var position = StationPosition[station];
            if (station.Contains("ArmA"))
            {
                canvas1.Rotate(position.EndPosition.Root, true, MoveTime, 0, 0, onComplete);
                canvas2.Rotate(position.EndPosition.Arm, true, MoveTime);
                canvas3.Rotate(position.EndPosition.Hand, true, MoveTime);
            }
            if (station.Contains("ArmB"))
            {
                canvas21.Rotate(position.EndPosition.Root, true, MoveTime, 0, 0, onComplete);
                canvas22.Rotate(position.EndPosition.Arm, true, MoveTime);
                canvas23.Rotate(position.EndPosition.Hand, true, MoveTime);
            }
            CurrentPosition = station;
        }

        private void TranslateTo(string station, Action onComplete = null)
        {
            var position = StationPosition[station];
            if (position.StartPosition.X.HasValue)
            {
                Translate(position.StartPosition.X.Value, onComplete);
            }
            else
            {
                onComplete?.Invoke();
            }
        }

        private void Translate(int x, Action onComplete = null)
        {
            var storyBoard = new Storyboard();
            var oldX = translate.X;
            var animation = new DoubleAnimation(oldX, x, TimeSpan.FromMilliseconds(MoveTime));
            storyBoard.Children.Add(animation);
            Storyboard.SetTarget(animation, root);
            var propertyChain = new DependencyProperty[]
                    {
                        Canvas.RenderTransformProperty,
                        TransformGroup.ChildrenProperty,
                        TranslateTransform.XProperty
                    };
            string thePath = "(0).(1)[1].(2)";
            PropertyPath myPropertyPath = new PropertyPath(thePath, propertyChain);
            Storyboard.SetTargetProperty(animation, myPropertyPath);
            storyBoard.Completed += (s, e) =>
            {
                //InvalidateVisual();
                if (onComplete != null)
                {
                    onComplete();
                }
            };
            storyBoard.Begin();
        }

        private void MoveTo(string target)
        {
            MoveRobot(target);
        }

        private void Invoke(Action action)
        {
            Dispatcher.Invoke(action);
        }

        private void LogMsg(string msg)
        {
            var source = "Robot";
            Console.WriteLine("{0} {1}", source, msg);
        }
    }

    //public enum BladeStatusLP
    //{
    //	Extend,
    //	Retract
    //}

    //public class Robot2Position
    //{
    //	public int? X;
    //	public int Root;
    //	public int Arm;
    //	public int Hand;
    //}

    //public class StationPosition2
    //{
    //	public Robot2Position StartPosition;
    //	public Robot2Position EndPosition;
    //}
}