using SA_LTT.Info.WaferInfo;
using System;
using System.Collections.Generic;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Shapes;
using static SA_LTT.Info.WaferInfo.WaferInfo;
using static SA_LTT.Info.WaferInfo.WaferInfoManager;

namespace SA_LTT_UI.Screen
{
    /// <summary>
    /// Interaction logic for AnimationEquipment.xaml
    /// </summary>
    public partial class AnimationEquipment : UserControl
    {
        SolidColorBrush _doorOpenColor;
        SolidColorBrush _doorCloseColor;

        SolidColorBrush _waferExistColor;
        SolidColorBrush _waferEmptyColor;
        SolidColorBrush _waferErrorColor;
        SolidColorBrush _waferProcessCompleteColor;

        public delegate void MouseDownDel(object sender, MouseButtonEventArgs e);

        Dictionary<WaferNumbers, Shape> WaferShapes = new Dictionary<WaferNumbers, Shape>();
        public AnimationEquipment()
        {
            InitializeComponent();
            InitializeColor();
            InitializeUI();
        }

        private void InitializeColor()
        {
            _doorOpenColor = new SolidColorBrush(Colors.Red);
            _doorCloseColor = new SolidColorBrush(Colors.Lime);

            _waferExistColor = new SolidColorBrush(Colors.Lime);
            _waferEmptyColor = new SolidColorBrush(Colors.Transparent);
            _waferErrorColor = new SolidColorBrush(Colors.Red);
            _waferProcessCompleteColor = new SolidColorBrush(Colors.MediumPurple);
        }

        private void InitializeUI()
        {
            foreach(WaferNumbers info in Enum.GetValues(typeof(WaferNumbers)))
            {
                if (WaferNumbers.A1 <= info && info <= WaferNumbers.A25)
                {
                    Rectangle rectangle = new Rectangle();

                    rectangle.Height = 7;
                    rectangle.Width = 113;
                    rectangle.Stroke = new SolidColorBrush(Colors.Black);
                    WaferShapes[info] = rectangle;
                    Port1.Children.Add(rectangle);
                    Canvas.SetBottom(rectangle, 6 * (int)info);
                }
                else if (WaferNumbers.B1 <= info && info <= WaferNumbers.B25)
                {
                    Rectangle rectangle = new Rectangle();

                    rectangle = new Rectangle();
                    rectangle.Height = 7;
                    rectangle.Width = 113;
                    rectangle.Stroke = new SolidColorBrush(Colors.Black);
                    WaferShapes[info] = rectangle;
                    Port2.Children.Add(rectangle);
                    Canvas.SetBottom(rectangle, 6 * (int)(info - 25));
                }
                else if(info == WaferNumbers.Robot)
                {
                    Rectangle rectangle = new Rectangle();

                    rectangle = new Rectangle();
                    rectangle.Height = 7;
                    rectangle.Width = 113;
                    rectangle.Stroke = new SolidColorBrush(Colors.Black);
                    WaferShapes[info] = rectangle;
                }
                else if (info == WaferNumbers.PreAligner)
                {
                    Rectangle rectangle = new Rectangle();

                    rectangle = new Rectangle();
                    rectangle.Height = 7;
                    rectangle.Width = 113;
                    rectangle.Stroke = new SolidColorBrush(Colors.Black);
                    WaferShapes[info] = rectangle;
                }
                else if (info == WaferNumbers.Chamber)
                {
                    Rectangle rectangle = new Rectangle();

                    rectangle = new Rectangle();
                    rectangle.Height = 7;
                    rectangle.Width = 113;
                    rectangle.Stroke = new SolidColorBrush(Colors.Black);
                    WaferShapes[info] = rectangle;
                }
            }
        }

        //X : -2 ~ 384
        public void SetDoor1Status(bool open)
        {
            Door1.Fill = open ? _doorOpenColor : _doorCloseColor;
        }

        public void SetDoor2Status(bool open)
        {
            Door2.Fill = open ? _doorOpenColor : _doorCloseColor;
        }

        public void SetDoor3Status(bool open)
        {
            Door3.Fill = open ? _doorOpenColor : _doorCloseColor;
        }

        public void SetDoor4Status(bool open)
        {
            Door4.Fill = open ? _doorOpenColor : _doorCloseColor;
        }

        public void SetDoorCPStatus(bool open)
        {
            DoorCP.Fill = open ? _doorOpenColor : _doorCloseColor;
        }

        public void SetChamberGate(bool open)
        {
            ChamberGate.Fill = open ? _doorOpenColor : _doorCloseColor;
        }

        public void SetWaferExist(WaferNumbers waferNumber, WaferInfo waferInfo)
        {
            if(waferNumber == WaferNumbers.PreAligner)
            {
                if (waferInfo.IsStatus == WaferStatus.Empty)
                {
                    PreAlignerWafer.Opacity = 0;
                }
                else if (waferInfo.IsStatus == WaferStatus.Exist)
                {
                    PreAlignerWafer.Opacity = 100;

                    if (waferInfo.IsProcessComplete)
                    {
                        PreAlignerWaferStatus.Fill = _waferProcessCompleteColor;
                    }
                    else
                    {
                        PreAlignerWaferStatus.Fill = new SolidColorBrush(Colors.Silver);
                    }
                }
            }
            else if(waferNumber == WaferNumbers.Chamber)
            {
                if (waferInfo.IsStatus == WaferStatus.Empty)
                {
                    ChamberWafer.Opacity = 0;
                }
                else if (waferInfo.IsStatus == WaferStatus.Exist)
                {
                    ChamberWafer.Opacity = 100;

                    if (waferInfo.IsProcessComplete)
                    {
                        ChamberWaferStatus.Fill = _waferProcessCompleteColor;
                    }
                    else
                    {
                        ChamberWaferStatus.Fill = new SolidColorBrush(Colors.Silver);
                    }
                }
            }
            else if (waferNumber == WaferNumbers.Robot)
            {
                if (waferInfo.IsStatus == WaferStatus.Empty)
                {
                    RobotWafer.Opacity = 0;
                }
                else if (waferInfo.IsStatus == WaferStatus.Exist)
                {
                    RobotWafer.Opacity = 100;

                    if (waferInfo.IsProcessComplete)
                    {
                        RobotWaferStatus.Fill = _waferProcessCompleteColor;
                    }
                    else
                    {
                        RobotWaferStatus.Fill = new SolidColorBrush(Colors.Silver);
                    }
                }
            }
            else
            {
                if (waferInfo.IsStatus == WaferStatus.Empty)
                {
                    WaferShapes[waferNumber].Fill = _waferEmptyColor;
                }
                else if (waferInfo.IsStatus == WaferStatus.Exist)
                {
                    if(waferInfo.IsProcessComplete)
                    {
                        WaferShapes[waferNumber].Fill = _waferProcessCompleteColor;
                    }
                    else
                    {
                        WaferShapes[waferNumber].Fill = _waferExistColor;
                    }
                }
                else if (waferInfo.IsStatus == WaferStatus.Leaning)
                {
                    WaferShapes[waferNumber].Fill = _waferErrorColor;
                }
                else if (waferInfo.IsStatus == WaferStatus.Overlap)
                {
                    WaferShapes[waferNumber].Fill = _waferErrorColor;
                }
            }
        }
        
        public void SetRobotPositionArm(double position)
        {
            position = position + 5.3;
            //RobotArm1
            RotateTransform rt = new RotateTransform();
            rt.Angle = (position * 1.1);
            TransformGroup tg1 = new TransformGroup();
            tg1.Children.Add(rt);
            RobotArm1.RenderTransform = tg1;

            //RobotArm2
            rt = new RotateTransform();
            rt.Angle = -(position * 2.4);
            tg1 = new TransformGroup();
            tg1.Children.Add(rt);
            RobotArm2.RenderTransform = tg1;

            //Robot Hand
            Thickness margin = RobotHand.Margin;
            margin.Top = position * 3;
            RobotHand.Margin = margin;
        }

        public void SetRobotPositionAngle(double position)
        {
            RotateTransform rt = new RotateTransform();
            rt.Angle = 28 - position;

            TransformGroup tg1 = new TransformGroup();
            tg1.Children.Add(rt);
            Robot.RenderTransform = tg1;

            RotateTransform rt1 = new RotateTransform();
            rt1.Angle = position - 28;

            TransformGroup tg2 = new TransformGroup();
            tg2.Children.Add(rt1);

            RobotWafer.RenderTransform = tg2;
        }

        public void SetRobotPositionZ(double position)
        {
            double value = position;
            if (value < 5)
            {
                value = 5;
            }
            else if (value > 244)
            {
                value = 244;
            }

            RobotZ.Value = value;
        }

        public void SetMotorPositionX(double position)
        {
            // 0 ~ 500
            Thickness margin = Chamber.Margin;
            margin.Top = - (position * 1.298);
            Chamber.Margin = margin;
        }

        public void SetMotorPositionY(double position)
        {
            // 0 ~ 895
            Thickness margin = Motor_Y.Margin;
            margin.Left = - (position * 2.2375);
            Motor_Y.Margin = margin;
        }

        public void SetMotorPositionT(double position)
        {
            RotateTransform rt = new RotateTransform();
            rt.Angle = -(position * 10);

            TransformGroup tg1 = new TransformGroup();
            tg1.Children.Add(rt);
            Chamber.RenderTransform = tg1;
            
            RotateTransform rt1 = new RotateTransform();
            rt1.Angle = (position * 10);

            TransformGroup tg2 = new TransformGroup();
            tg2.Children.Add(rt1);

            ChamberWafer.RenderTransform = tg2;
        }

        public void SetRobotWaferNum(WaferNumbers waferNumber)
        {
            RobotWaferSourceName.Text = waferNumber.ToString();
        }

        public void SetPreAlignerWaferNum(WaferNumbers waferNumber)
        {
            PreAlignerWaferSourceName.Text = waferNumber.ToString();
        }

        public void SetChamberWaferNum(WaferNumbers waferNumber)
        {
            ChamberWaferSourceName.Text = waferNumber.ToString();
        }

        public void SetChamberLiftPin(bool up)
        {
            if(up)
            {
                LiftPin.Value = 1;
            }
            else
            {
                LiftPin.Value = 0;
            }
        }

        public void SetIsAlignRun(bool run)
        {
            IsAlignRun.Fill = run ? _doorCloseColor : _doorOpenColor;
        }
        
        public void AddPortMouseDownEvent(MouseButtonEventHandler mouseButtonEventHandler)
        {
            Port1.MouseDown += mouseButtonEventHandler;
            Port2.MouseDown += mouseButtonEventHandler;
        }

        public void AddChamberMouseDownEvent(MouseButtonEventHandler mouseButtonEventHandler)
        {
            Chamber.MouseDown += mouseButtonEventHandler;
        }

        public void AddPreAlignerMouseDownEvent(MouseButtonEventHandler mouseButtonEventHandler)
        {
            PreAlignerBody.MouseDown += mouseButtonEventHandler;
        }

        public void AddRobotMouseDownEvent(MouseButtonEventHandler mouseButtonEventHandler)
        {
            RobotBody.MouseDown += mouseButtonEventHandler;
        }

        public void AddUvLaserMouseDownEvent(MouseButtonEventHandler mouseButtonEventHandler)
        {
            UVLaser.MouseDown += mouseButtonEventHandler;
        }

        public void AddScannerMouseDownEvent(MouseButtonEventHandler mouseButtonEventHandler)
        {
            Scanner.MouseDown += mouseButtonEventHandler;
        }


        public void AddAttenuatorMouseDownEvent(MouseButtonEventHandler mouseButtonEventHandler)
        {
            Attenuator.MouseDown += mouseButtonEventHandler;
        }
    }
}