using MECF.Framework.Common.Beckhoff.AxisProvider;
using MECF.Framework.Common.Beckhoff.Station;
using MECF.Framework.Common.DataCenter;
using MECF.Framework.Common.Layout;
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>
    /// TransporterStationPositionControl.xaml 的交互逻辑
    /// </summary>
    public partial class TransporterStationPositionControl : 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;
        #endregion

        #region 属性
        public static readonly DependencyProperty ModuleNameProperty = DependencyProperty.Register( "ModuleName", typeof(string), typeof(TransporterStationPositionControl),
           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(TransporterStationPositionControl));

        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);
                if (_cellNameCellIdDictionary.ContainsKey(value)&&value.ToLower()!="loader")
                {
                    _moduleSelectedCellItem = _cellNameCellIdDictionary[value];
                }
                else
                {
                    _moduleSelectedCellItem = value;
                }
                _moduleSelectedItem = value;
                InvokePropertyChanged(nameof(ModuleSelectedItem));
            }
        }
        public static readonly DependencyProperty CommandProperty = DependencyProperty.Register("OperationCommand", typeof(ICommand), typeof(TransporterStationPositionControl),
           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(TransporterStationPositionControl),
            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(TransporterStationPositionControl), 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(TransporterStationPositionControl), 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(TransporterStationPositionControl), 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 IsMotorOnProperty = DependencyProperty.Register(
          "IsMotorOn", typeof(bool), typeof(TransporterStationPositionControl),
          new FrameworkPropertyMetadata(true, FrameworkPropertyMetadataOptions.AffectsRender));
        /// <summary>
        /// AtStation
        /// </summary>
        public bool IsMotorOn
        {
            get
            {
                return (bool)this.GetValue(IsMotorOnProperty);
            }
            set
            {
                this.SetValue(IsMotorOnProperty, value);
            }
        }


        public static readonly DependencyProperty DegValueProperty = DependencyProperty.Register(
         "DegValue", typeof(double), typeof(TransporterStationPositionControl), new FrameworkPropertyMetadata(0.00, FrameworkPropertyMetadataOptions.AffectsRender));

        /// <summary>
        /// 当前位置
        /// </summary>
        public double DegValue
        {
            get
            {
                return (double)this.GetValue(DegValueProperty);
            }
            set
            {
                this.SetValue(DegValueProperty, value);
            }
        }
        public static readonly DependencyProperty CurrentStationProperty = DependencyProperty.Register("CurrentStation", typeof(string), typeof(TransporterStationPositionControl));
        /// <summary>
        /// 当前位置
        /// </summary>
        public string CurrentStation
        {
            get
            {
                return (string) this.GetValue(CurrentStationProperty);
            }
            set
            {
                this.SetValue(CurrentStationProperty, value);
            }
        }
        /// <summary>
        /// CellId与CellName字典
        /// </summary>
        private Dictionary<string, string> _cellIdCellNameDictionary = new Dictionary<string, string>();
        /// <summary>
        /// Cell名称与Cell Id字典
        /// </summary>
        private Dictionary<string, string> _cellNameCellIdDictionary = new Dictionary<string, string>();
        /// <summary>
        /// 选择Cell名称
        /// </summary>
        private string _moduleSelectedCellItem;
        /// <summary>
        /// 当前位置
        /// </summary>
        public double IncrementValue
        {
            get { return _incrementValue; }
            set
            {
                _incrementValue = value;
                InvokePropertyChanged(nameof(IncrementValue));
            }
        }
        public event PropertyChangedEventHandler PropertyChanged;
        #endregion
        /// <summary>
        /// 构造函数
        /// </summary>
        public TransporterStationPositionControl()
        {
            InitializeComponent();
        }

        private void GotoSavedPos_Click(object sender, RoutedEventArgs e)
        {
            if (ModuleName.ToLower().Contains("gantry"))
            {
                InvokeClient.Instance.Service.DoOperation($"{ModuleName}.GantryGotoSavedPosition", "TargetPosition", _moduleSelectedCellItem);
            }
            else
            {
                InvokeClient.Instance.Service.DoOperation($"{ModuleName}.GotoSavedPosition", "TargetPosition", _moduleSelectedCellItem);
            }
        }

        private void MotorPos_Click(object sender, RoutedEventArgs e)
        {
            if (ModuleName.ToLower().Contains("gantry"))
            {
                InvokeClient.Instance.Service.DoOperation($"{ModuleName}.SaveWithModifyLayout", $"{_moduleSelectedCellItem}", Math.Round(CurrentPosition, 2));
            }
            else
            {
                InvokeClient.Instance.Service.DoOperation($"{ModuleName}.Save", $"{ModuleName}.{_moduleSelectedCellItem}", 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>
        /// 初始化cellId
        /// </summary>
        /// <param name="items"></param>
        private void InitializeCellIdCellNameDictionary(List<ProcessLayoutCellItem> items)
        {
            if(items==null)
            {
                return;
            }
            foreach (ProcessLayoutCellItem item in items)
            {
                if (!string.IsNullOrEmpty(item.ModuleName))
                {
                    _cellIdCellNameDictionary[$"Cell{item.CellId}"] = item.ModuleName;
                    _cellNameCellIdDictionary[item.ModuleName] = $"Cell{item.CellId}";
                }
            }
        }

        /// <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)
            {
                string[] strAry = item.Name.Split('.');
                string lastName = strAry[strAry.Length - 1];
                if (_cellIdCellNameDictionary!=null&&_cellIdCellNameDictionary.ContainsKey(lastName))
                {
                    string moduleName = _cellIdCellNameDictionary[lastName];
                    if (!string.IsNullOrEmpty(moduleName))
                    {
                        lst.Add(_cellIdCellNameDictionary[lastName]);
                    }
                }
                else
                {
                    if (!lastName.StartsWith("Cell"))
                    {
                        lst.Add(lastName);
                    }
                }
            }
            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.EndsWith(station))
                {
                    double.TryParse(item.Position, out var position);
                    return position;
                }
                else if (_cellNameCellIdDictionary.ContainsKey(station))
                {
                    if (item.Name.EndsWith(_cellNameCellIdDictionary[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))
                {
                    IncrementValue = (double)QueryDataClient.Instance.Service.GetConfig("System.Increment");
                    _rtDataKeys.Add($"Station.{ModuleName}");
                    _rtDataKeys.Add($"{ModuleName}.AxisProvider");
                    _rtDataKeys.Add("System.Layout");
                    _rtDataValues = QueryDataClient.Instance.Service.PollData(_rtDataKeys);
                    _axis = CommonFunction.GetValue<BeckhoffStationAxis>(_rtDataValues, $"Station.{ModuleName}");
                    ProcessLayout processLayout = CommonFunction.GetValue<ProcessLayout>(_rtDataValues, "System.Layout");
                    if (processLayout != null)
                    {
                        InitializeCellIdCellNameDictionary(processLayout.Items);
                    }
                    BeckhoffProviderAxis beckhoffProviderAxis = CommonFunction.GetValue<BeckhoffProviderAxis>(_rtDataValues, $"{ModuleName}.AxisProvider");
                    if (_axis != null)
                    {
                        ToleranceDefault = _axis.ToleranceDefault;
                        ModuleItemSource = GetStationList(_axis);
                        if (ModuleItemSource != null && ModuleItemSource.Count != 0)
                        {
                            ModuleSelectedItem = ModuleItemSource[0];
                        }
                    }

                    if (beckhoffProviderAxis != null)
                    {
                        _scaleFactor = beckhoffProviderAxis.ScaleFactor;
                    }
                }
            }
        }
    }
}