using MECF.Framework.Common.Beckhoff.AxisProvider;
using MECF.Framework.Common.Beckhoff.Station;
using MECF.Framework.Common.DataCenter;
using MECF.Framework.Common.OperationCenter;
using MECF.Framework.Common.Utilities;
using CyberX8_Core;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;

namespace CyberX8_Themes.UserControls
{
    /// <summary>
    /// LoaderStationPositionControl.xaml 的交互逻辑
    /// </summary>
    public partial class LoaderStationPositionControl : UserControl, INotifyPropertyChanged
    {
        #region 内部变量
        /// <summary>
        /// 步进
        /// </summary>
        private double _incrementValue;
        /// <summary>
        /// 查询后台数据集合
        /// </summary>
        private List<string> _rtDataKeys = new List<string>();
        /// <summary>
        /// 查询后台的数据
        /// </summary>
        private Dictionary<string, object> _rtDataValues;
        /// <summary>
        /// axis
        /// </summary>
        BeckhoffStationAxis _axis;
        /// <summary>
        /// Stations
        /// </summary>
        private List<string> _moduleStations;
        /// <summary>
        /// 选择项
        /// </summary>
        private string _moduleSelectedItem;
        /// <summary>
        /// 已经保存的位置
        /// </summary>
        private double _savePosition;
        /// <summary>
        /// scaleFactor
        /// </summary>
        private double _scaleFactor;
        /// <summary>
        /// Combox index buffer
        /// </summary>
        private int _indexBuffer = 0;
        #endregion

        #region 属性
        public static readonly DependencyProperty ModuleNameProperty = DependencyProperty.Register(
           "ModuleName", typeof(string), typeof(LoaderStationPositionControl),
           new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.AffectsRender));
        /// <summary>
        /// 模块名称
        /// </summary>
        public string ModuleName
        {
            get
            {
                return (string)this.GetValue(ModuleNameProperty);
            }
            set
            {
                this.SetValue(ModuleNameProperty, value);
            }
        }

        public List<string> ModuleItemSource
        {
            get { return _moduleStations; }
            set
            {
                _moduleStations = value;
                InvokePropertyChanged(nameof(ModuleItemSource));
            }

        }
        public static readonly DependencyProperty IsAtStationProperty = DependencyProperty.Register(
          "IsAtStation", typeof(bool), typeof(LoaderStationPositionControl));

        public bool IsAtStation
        {
            get 
            {
                return (bool)this.GetValue(IsAtStationProperty); 
            }
            set
            {
                SetValue(IsAtStationProperty, value);
                InvokePropertyChanged(nameof(IsAtStation));
            }
        }

        /// <summary>
        /// 选项索引
        /// </summary>
        public string ModuleSelectedItem
        {
            get
            {
                return _moduleSelectedItem;
            }
            set
            {
                SavedPosition = GetStationPosition(_axis, value);
                _moduleSelectedItem = value;
                InvokePropertyChanged(nameof(ModuleSelectedItem));
            }
        }
        public static readonly DependencyProperty CommandProperty = DependencyProperty.Register(
           "OperationCommand", typeof(ICommand), typeof(LoaderStationPositionControl),
           new FrameworkPropertyMetadata(null, FrameworkPropertyMetadataOptions.AffectsRender));
        public ICommand OperationCommand
        {
            get
            {
                return (ICommand)this.GetValue(CommandProperty);
            }
            set
            {
                this.SetValue(CommandProperty, value);
            }
        }
        public static readonly DependencyProperty ModuleTitleProperty = DependencyProperty.Register(
            "ModuleTitle", typeof(string), typeof(LoaderStationPositionControl),
            new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.AffectsRender));
        /// <summary>
        /// 标题
        /// </summary>
        public string ModuleTitle
        {
            get
            {
                return (string)this.GetValue(ModuleTitleProperty);
            }
            set
            {
                this.SetValue(ModuleTitleProperty, value);
            }
        }
        public static readonly DependencyProperty SavedPositionProperty = DependencyProperty.Register(
           "SavedPosition", typeof(double), typeof(LoaderStationPositionControl), new FrameworkPropertyMetadata(0.00, new PropertyChangedCallback(OnCurrentPositionChanged)));
        /// <summary>
        /// 保存位置
        /// </summary>
        public double SavedPosition
        {
            get
            {
                return _savePosition;
            }
            set
            {
                _savePosition = value;
                SetValue(SavedPositionProperty, value);
                IsAtStation = JudgeAtStation(value,CurrentPosition,ToleranceDefault);
                InvokePropertyChanged(nameof(SavedPosition));
            }
        }

        public static readonly DependencyProperty ToleranceDefaultProperty = DependencyProperty.Register(
           "ToleranceDefault", typeof(double), typeof(LoaderStationPositionControl), new FrameworkPropertyMetadata(0.00, new PropertyChangedCallback(OnCurrentPositionChanged)));
        /// <summary>
        /// 保存位置
        /// </summary>
        public double ToleranceDefault
        {
            get
            {
                if(_axis!=null)
                {
                    return _axis.ToleranceDefault;
                }
                else
                {
                    return 0;
                }
            }
            set
            {
                SetValue(ToleranceDefaultProperty, _axis != null ? _axis.ToleranceDefault : 0);
            }
        }
        public static readonly DependencyProperty CurrentPositionProperty = DependencyProperty.Register(
           "CurrentPosition", typeof(double), typeof(LoaderStationPositionControl), new FrameworkPropertyMetadata(0.00, new PropertyChangedCallback(OnCurrentPositionChanged)));
        /// <summary>
        /// 当前位置
        /// </summary>
        public double CurrentPosition
        {
            get
            {
                return (double)this.GetValue(CurrentPositionProperty);
            }
            set
            {
                SetValue(CurrentPositionProperty, value);
            }
        }
        private static void OnCurrentPositionChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            if (e.NewValue != null)
            {
                double tmpSavedPosition = (double)d.GetValue(SavedPositionProperty);
                double toleranceDefault = (double)d.GetValue(ToleranceDefaultProperty);
                bool result = JudgeAtStation(tmpSavedPosition, (double)e.NewValue, toleranceDefault);
                d.SetValue(IsAtStationProperty, result);
            }
        }

        public static readonly DependencyProperty DegValueProperty = DependencyProperty.Register(
         "DegValue", typeof(double), typeof(LoaderStationPositionControl), new FrameworkPropertyMetadata(0.00, FrameworkPropertyMetadataOptions.AffectsRender));
        /// <summary>
        /// jog value
        /// </summary>
        public double DegValue
        {
            get
            {
                return (double)this.GetValue(DegValueProperty);
            }
            set
            {
                this.SetValue(DegValueProperty, value);
            }
        }
        public static readonly DependencyProperty TorqueProperty = DependencyProperty.Register(
       "Torque", typeof(double), typeof(LoaderStationPositionControl), new FrameworkPropertyMetadata(0.00, FrameworkPropertyMetadataOptions.AffectsRender));

        /// <summary>
        /// Torque
        /// </summary>
        public double Torque
        {
            get
            {
                return (double)this.GetValue(TorqueProperty);
            }
            set
            {
                this.SetValue(TorqueProperty, value);
            }
        }
        public static readonly DependencyProperty CurrentStationProperty = DependencyProperty.Register("CurrentStation", typeof(string), typeof(LoaderStationPositionControl));
        /// <summary>
        /// 当前位置
        /// </summary>
        public string CurrentStation
        {
            get
            {
                return (string)this.GetValue(CurrentStationProperty);
            }
            set
            {
                this.SetValue(CurrentStationProperty, value);
            }
        }
        /// <summary>
        /// 当前位置
        /// </summary>
        public double IncrementValue
        {
            get { return _incrementValue; }
            set
            {
                _incrementValue = value;
                InvokePropertyChanged(nameof(IncrementValue));
            }
        }
        public event PropertyChangedEventHandler PropertyChanged;
        #endregion

        /// <summary>
        /// 构造函数
        /// </summary>
        public LoaderStationPositionControl()
        {
            InitializeComponent();
        }

        private void SavedPos_Click(object sender, RoutedEventArgs e)
        {
            InvokeClient.Instance.Service.DoOperation($"{ModuleName}.GotoSavedPosition", "TargetPosition", ModuleSelectedItem);
            
        }

        private void MotorPos_Click(object sender, RoutedEventArgs e)
        {
            InvokeClient.Instance.Service.DoOperation($"{ModuleName}.Save", $"{ModuleSelectedItem}", Math.Round(CurrentPosition, 2));
            SavedPosition = CurrentPosition;
            foreach (Station item in _axis.Stations)
            {
                if (item.Name == ModuleSelectedItem)
                {
                    item.Position = CurrentPosition.ToString();
                    break;
                }
            }
        }

        private void LeftCommand_Click(object sender, RoutedEventArgs e)
        {
            InvokeClient.Instance.Service.DoOperation($"{ModuleName}.JogDown", "TargetPosition", DegValue,CurrentPosition);
        }

        private void RightCommand_Click(object sender, RoutedEventArgs e)
        {
            InvokeClient.Instance.Service.DoOperation($"{ModuleName}.JogUp", "TargetPosition", DegValue,CurrentPosition);
        }

        /// <summary>
        /// 获取工位集合
        /// </summary>
        /// <param name="stationAxis"></param>
        /// <returns></returns>
        private List<string> GetStationList(BeckhoffStationAxis stationAxis)
        {
            List<string> lst = new List<string>();
            if (stationAxis == null)
            {
                return lst;
            }
            foreach (var item in stationAxis.Stations)
            {
                lst.Add(item.Name);
            }
            return lst;
        }
        /// <summary>
        /// 获取工位位置
        /// </summary>
        /// <param name="stationAxis"></param>
        /// <param name="station"></param>
        /// <returns></returns>
        private double GetStationPosition(BeckhoffStationAxis stationAxis, string station)
        {
            if (stationAxis == null)
            {
                return 0;
            }
            foreach (var item in stationAxis.Stations)
            {
                if (item.Name == station)
                {
                    double.TryParse(item.Position, out var position);
                    return position;
                }
            }
            return 0;
        }
        /// <summary>
        /// 转换数值
        /// </summary>
        /// <param name="value"></param>
        /// <returns></returns>
        private int ConvertValue(double value)
        {
            if(_scaleFactor!=0)
            {
                return (int)Math.Round(value * _scaleFactor,0);
            }
            else
            {
                return (int)Math.Round(value,0);
            }
        }
        private void InvokePropertyChanged(string propertyName)
        {
            if (PropertyChanged != null)
            {
                PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
            }
        }
        /// <summary>
        /// 判定AtStation
        /// </summary>
        private static bool JudgeAtStation(double saved,double current,double tolerance)
        {
            return Math.Abs(saved - current) <= tolerance;
        }

        private void IsControlVisibleChanged(object sender, DependencyPropertyChangedEventArgs e)
        {
            if (e.NewValue != null && ((bool)e.NewValue) == true)
            {
                if (!string.IsNullOrEmpty(ModuleName))
                {
                    _rtDataKeys.Clear();
                    IncrementValue = (double)QueryDataClient.Instance.Service.GetConfig("System.Increment");
                    _rtDataKeys.Add($"Station.{ModuleName}");
                    _rtDataKeys.Add($"{ModuleName}.AxisProvider");
                    _rtDataValues = QueryDataClient.Instance.Service.PollData(_rtDataKeys);
                    if (_rtDataValues != null)
                    {
                        _axis = CommonFunction.GetValue<BeckhoffStationAxis>(_rtDataValues, $"Station.{ModuleName}");
                        BeckhoffProviderAxis beckhoffProviderAxis = CommonFunction.GetValue<BeckhoffProviderAxis>(_rtDataValues, $"{ModuleName}.AxisProvider");
                        if (beckhoffProviderAxis != null)
                        {
                            _scaleFactor = beckhoffProviderAxis.ScaleFactor;
                        }
                    }
                    if (_axis != null)
                    {
                        ToleranceDefault = _axis.ToleranceDefault;
                        ModuleItemSource = GetStationList(_axis);
                        if (ModuleItemSource != null && ModuleItemSource.Count != 0)
                        {
                            if(_indexBuffer <= ModuleItemSource.Count - 1)
                            {
                                ModuleSelectedItem = ModuleItemSource[_indexBuffer];
                            }
                            else
                            {
                                ModuleSelectedItem = ModuleItemSource[0];
                            }
                            
                        }
                    }

                   
                }
            }
        }

        private void Station_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            ComboBox comboBox = sender as ComboBox; 
            string itemBuffer = comboBox.SelectedItem.ToString();
            _indexBuffer = ModuleItemSource.IndexOf(itemBuffer);
        }
    }
}