using Aitex.Core.Common.DeviceData;
using Caliburn.Micro.Core;
using Caliburn.Micro;
using FurnaceUI.Models;
using FurnaceUI.Views.Parameter;
using MECF.Framework.UI.Client.CenterViews.Configs.SystemConfig;
using SciChart.Core.Extensions;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Xml.Linq;
using MECF.Framework.Common.DataCenter;
using MECF.Framework.Common.OperationCenter;
using Microsoft.DwayneNeed.Win32.User32;
using Aitex.Core.Util;
using MECF.Framework.UI.Client.ClientBase;
using OpenSEMI.ClientBase;
using System.Windows;

namespace FurnaceUI.Views.Maintenances
{
    public class WaferRobotParameterViewModel : FurnaceUIViewModelBase
    {
        public bool IsManagerPermission { get => this.Permission == 3; }
        private const string WaferRobotParameter_PATH = "PM1.RecipeEditParameter.WaferRobotParameter.";

        private string _checkTypeParameter = "Speed";
        private string _checkAxis = "ZAxis";
        public Dictionary<string, string> SetValues { get; set; } = new Dictionary<string, string>();
        public Dictionary<string, string> ConfigDict { get; set; } = new Dictionary<string, string>();


        [Subscription("WaferRobot.ReadRobotParameterResultDict")]
        public Dictionary<string, string> ReadRobotParameterResultDict { get; set; }
        [Subscription("WaferRobot.Status")]
        public string WaferRobotStaus { get; set; }


        public bool IsClickButton { get; set; }
        private ConfigNode _waferRobotParameterNode { get; set; }

        private List<ConfigNode> _tableDataSource = new List<ConfigNode>();
        public List<ConfigNode> TableDataSource
        {
            get { return _tableDataSource; }
            set { _tableDataSource = value; this.NotifyOfPropertyChange(nameof(TableDataSource)); }
        }

        private Visibility _parameterTableVisibility = Visibility.Visible;
        public Visibility ParameterTableVisibility
        {
            get { return _parameterTableVisibility; }
            set { _parameterTableVisibility = value; this.NotifyOfPropertyChange(nameof(ParameterTableVisibility)); }
        }
        private Visibility _positionAxisTableVisibility = Visibility.Collapsed;
        public Visibility PositionAxisTableVisibility
        {
            get { return _positionAxisTableVisibility; }
            set { _positionAxisTableVisibility = value; this.NotifyOfPropertyChange(nameof(PositionAxisTableVisibility)); }
        }
        private Visibility _positionConfigTableVisibility = Visibility.Collapsed;
        public Visibility PositionConfigTableVisibility
        {
            get { return _positionConfigTableVisibility; }
            set { _positionConfigTableVisibility = value; this.NotifyOfPropertyChange(nameof(PositionConfigTableVisibility)); }
        }
        private Visibility _downloadUploadVisibility = Visibility.Collapsed;
        public Visibility DownloadUploadVisibility
        {
            get { return _downloadUploadVisibility; }
            set { _downloadUploadVisibility = value; this.NotifyOfPropertyChange(nameof(DownloadUploadVisibility)); }
        }
        private Visibility _axisBtnVisibility = Visibility.Collapsed;
        public Visibility AxisBtnVisibility
        {
            get { return _axisBtnVisibility; }
            set { _axisBtnVisibility = value; this.NotifyOfPropertyChange(nameof(AxisBtnVisibility)); }
        }
        public void SwitchListView(object obj)
        {
            _checkTypeParameter = obj.ToString();
            TableDataSource.Clear();

            switch (_checkTypeParameter)
            {
                case "PositionConfig":
                    PositionConfigTableVisibility = Visibility.Visible;
                    PositionAxisTableVisibility = Visibility.Collapsed;
                    ParameterTableVisibility = Visibility.Collapsed;
                    DownloadUploadVisibility = Visibility.Visible;
                    AxisBtnVisibility = Visibility.Collapsed;
                    break;
                case "PositionAxis":
                    PositionAxisTableVisibility = Visibility.Visible;
                    PositionConfigTableVisibility = Visibility.Collapsed;
                    ParameterTableVisibility = Visibility.Collapsed;
                    DownloadUploadVisibility = Visibility.Visible;
                    AxisBtnVisibility = Visibility.Collapsed;
                    break;
                case "Speed":
                case "Time":
                    ParameterTableVisibility = Visibility.Visible;
                    PositionAxisTableVisibility = Visibility.Collapsed;
                    PositionConfigTableVisibility = Visibility.Collapsed;
                    DownloadUploadVisibility = Visibility.Visible;
                    AxisBtnVisibility = Visibility.Visible;
                    break;
                case "Other":
                    ParameterTableVisibility = Visibility.Visible;
                    PositionAxisTableVisibility = Visibility.Collapsed;
                    PositionConfigTableVisibility = Visibility.Collapsed;
                    DownloadUploadVisibility = Visibility.Visible;
                    AxisBtnVisibility = Visibility.Visible;
                    break;
                case "Slot":
                    ParameterTableVisibility = Visibility.Visible;
                    PositionAxisTableVisibility = Visibility.Collapsed;
                    PositionConfigTableVisibility = Visibility.Collapsed;
                    DownloadUploadVisibility = Visibility.Visible;
                    AxisBtnVisibility = Visibility.Collapsed;
                    break;
            }

            SwitchAxis(_checkAxis);
        }
        public void SwitchAxis(object obj)
        {
            _checkAxis = obj.ToString();
            TableDataSource.Clear();
            var data = new List<ConfigNode>();
            foreach (var itemType in _waferRobotParameterNode.SubNodes)
            {
                foreach (var item in itemType.SubNodes)
                {
                    var ptype = item.Items.Where(a => a.Name.Equals("Type")).FirstOrDefault().DefaultValue;
                    if (_checkTypeParameter.Equals(ptype))
                    {
                        var axisItem = item.Items.Where(a => a.Name.Equals("Axis")).FirstOrDefault();

                        if (axisItem != null && _checkAxis.Contains(axisItem.DefaultValue))
                        {
                            data.Add(item);
                        }
                        if (axisItem == null)
                        {
                            data.Add(item);
                        }
                    }
                }

            }
            TableDataSource = data;
            GetDataOfConfigItems();


        }
        private void GetDataOfConfigItems()
        {
            if (TableDataSource == null)
            {
                return;
            }
            new Task(() =>
            {
                Dictionary<string, ConfigItem> keyValuePairs = new Dictionary<string, ConfigItem>();
                List<string> getConfigs = new List<string>();
                foreach (var item in TableDataSource)
                {

                    foreach (var tableItem in item.Items)
                    {
                        var key = $"{tableItem.Path}.{tableItem.Name}";
                        getConfigs.Add(key);
                        keyValuePairs.Add(key, tableItem);
                    }
                }
                var configs = QueryDataClient.Instance.Service.PollConfig(getConfigs);
                foreach (var key in configs.Keys)
                {
                    keyValuePairs[key].CurrentValue = configs[key].ToString();
                }
            }).Start();
        }

        public void Upload(object obj)
        {

            var selection = DialogBox.ShowDialog(DialogButton.Yes | DialogButton.No, DialogType.CONFIRM,
              $"Are you sure you want to Upload?");
            if (selection == DialogButton.No)
                return;

            if (!IsClickButton)
            {
                return;
            }
            if (obj.ToString().Equals("PositionConfig"))
            {
                SetPositionConfigUpload();
            }
            else if (obj.ToString().Equals("PositionAxis"))
            {
                SetPositionAxisUpload();
            }
            else if (obj.ToString().Equals("Parameter"))
            {
                SetParameterUpload();
            }


            GetDataOfConfigItems();

            void SetPositionAxisUpload()
            {
                var allNames = TableDataSource.Select(a => a.Name).ToList();
                string parameter = string.Join(";", TableDataSource.Select(a => a.Name).ToArray());
                if (!string.IsNullOrEmpty(parameter))
                {
                    InvokeClient.Instance.Service.DoOperation("WaferRobot.ReadRobotParameters", "CurrentRobotPositionAxis", parameter);
                }
                if (ReadRobotParameterResultDict != null && ReadRobotParameterResultDict.Count > 0)
                {
                    foreach (var item in ReadRobotParameterResultDict)
                    {
                        if (!allNames.Contains(item.Key))
                        {
                            continue;
                        }

                        var itemValues = item.Value.Split(',').ToList();
                        InvokeClient.Instance.Service.DoOperation("System.SetConfig", $"PM1.RecipeEditParameter.WaferRobotParameter.{item.Key}.ToDownAxis", GetAxisValue(itemValues[0]));
                        InvokeClient.Instance.Service.DoOperation("System.SetConfig", $"PM1.RecipeEditParameter.WaferRobotParameter.{item.Key}.RotateAxis", GetAxisValue(itemValues[1]));
                        InvokeClient.Instance.Service.DoOperation("System.SetConfig", $"PM1.RecipeEditParameter.WaferRobotParameter.{item.Key}.TelescopingAxis1", GetAxisValue(itemValues[2]));
                        InvokeClient.Instance.Service.DoOperation("System.SetConfig", $"PM1.RecipeEditParameter.WaferRobotParameter.{item.Key}.TelescopingAxis2", GetAxisValue(itemValues[3]));
                        InvokeClient.Instance.Service.DoOperation("System.SetConfig", $"PM1.RecipeEditParameter.WaferRobotParameter.{item.Key}.VariableSpacingAxis", GetAxisValue(itemValues[4]));
                    }
                }
            }

            void SetPositionConfigUpload()
            {

                var allNames = TableDataSource.Select(a => a.Name).ToList();
                List<string> parameterItem = new List<string>();
                foreach (var item in TableDataSource)
                {
                    parameterItem.Add($"{item.Name},{item.Items.Where(a => a.Name.Equals("StParam")).FirstOrDefault().CurrentValue}");
                }

                string parameter = string.Join(";", parameterItem);
                if (!string.IsNullOrEmpty(parameter))
                {
                    InvokeClient.Instance.Service.DoOperation("WaferRobot.ReadRobotParameters", "CurrentRobotPositionConfig", parameter);
                }
                if (ReadRobotParameterResultDict != null && ReadRobotParameterResultDict.Count > 0)
                {
                    foreach (var item in ReadRobotParameterResultDict)
                    {
                        if (!allNames.Contains(item.Key))
                        {
                            continue;
                        }
                        InvokeClient.Instance.Service.DoOperation("System.SetConfig", $"PM1.RecipeEditParameter.WaferRobotParameter.{item.Key}.StParam", item.Value.Split(',').FirstOrDefault());

                        InvokeClient.Instance.Service.DoOperation("System.SetConfig", $"PM1.RecipeEditParameter.WaferRobotParameter.{item.Key}.SetValue", item.Value.Split(',').LastOrDefault().TrimStart('0'));
                    }
                }
            }

            void SetParameterUpload()
            {

                var allNames = TableDataSource.Select(a => a.Name.Replace("P", "")).ToList();
                string parameter = string.Join(";", allNames);

                if (!string.IsNullOrEmpty(parameter))
                {
                    InvokeClient.Instance.Service.DoOperation("WaferRobot.ReadRobotParameters", "CurrentRobotParameters", parameter);
                }
                if (ReadRobotParameterResultDict != null && ReadRobotParameterResultDict.Count > 0)
                {
                    foreach (var item in ReadRobotParameterResultDict)
                    {
                        if (!allNames.Contains(item.Key))
                        {
                            continue;
                        }
                        InvokeClient.Instance.Service.DoOperation("System.SetConfig", $"PM1.RecipeEditParameter.WaferRobotParameter.P{item.Key}.SetValue", item.Value.TrimStart('0'));
                    }
                }
            }

        }
        private string GetAxisValue(string value)
        {
            return (double.Parse(value.TrimStart('0')) / 1000).ToString("f3");

        }
        public void Download(object obj)
        {
            var selection = DialogBox.ShowDialog(DialogButton.Yes | DialogButton.No, DialogType.CONFIRM,
             $"Are you sure you want to Download?");
            if (selection == DialogButton.No)
                return;

            string parameter = "";
            string setParameter = "";
            if (obj.ToString().Equals("PositionConfig"))
            {
                SetPositionConfigDownload();
            }
            else if (obj.ToString().Equals("PositionAxis"))
            {
                SetPositionAxisDownload();
            }
            else if (obj.ToString().Equals("Parameter"))
            {
                SetParameterDownload();
            }
            if (!string.IsNullOrEmpty(parameter))
            {
                InvokeClient.Instance.Service.DoOperation("WaferRobot.SetRobotParameters", setParameter, parameter);
                SetValues.Clear();
            }

            void SetParameterDownload()
            {
                foreach (var item in SetValues)
                {

                    parameter = parameter + $"{item.Key.Replace("P", "")},{item.Value};";
                    setParameter = "SetParameter";
                }

            };
            void SetPositionAxisDownload()
            {
                foreach (var item in SetValues)
                {
                    parameter = parameter + $"{item.Key},{item.Value};";
                    setParameter = "SetPositionAxis";
                }

            };
            void SetPositionConfigDownload()
            {
                foreach (var item in SetValues)
                {
                    parameter = parameter + $"{item.Key},{item.Value};";
                    setParameter = "SetPositionConfig";
                }
            };
        }
        public void SelectionChangedHandle(object obj)
        {
            ConfigNode node = (ConfigNode)obj;
            if (node == null)
            {
                return;
            }
            var windowManager = IoC.Get<IWindowManager>();
            var colData = TableDataSource.Where(a => a.Name.Equals(node.Name)).FirstOrDefault();
            if (_checkTypeParameter == "PositionConfig")
            {
                WaferRobotPositionEditViewModel editViewModel = new WaferRobotPositionEditViewModel();
                editViewModel.TableNodeItems = colData.Items;
                var rtn = (windowManager as WindowManager)?.ShowDialogWithTitle(editViewModel, null, "Edit WaferRobotPosition");
                if ((bool)rtn)
                {
                    if (string.IsNullOrEmpty(editViewModel.setValue))
                    {
                        return;
                    }
                    if (SetValues.ContainsKey(colData.Name))
                    {
                        SetValues[editViewModel._pName] = editViewModel.setValue;
                    }
                    else
                    {
                        SetValues.Add(editViewModel._pName, editViewModel.setValue);

                    }
                }
            }
            else if (_checkTypeParameter == "PositionAxis")
            {
                WaferRobotPositionAxisEditViewModel editViewModel = new WaferRobotPositionAxisEditViewModel();
                editViewModel.TableNodeItems = colData.Items;
                var rtn = (windowManager as WindowManager)?.ShowDialogWithTitle(editViewModel, null, "Edit WaferRobotPositionAxis");
                if ((bool)rtn)
                {
                    if (string.IsNullOrEmpty(editViewModel.setValue))
                    {
                        return;
                    }
                    if (SetValues.ContainsKey(colData.Name))
                    {
                        SetValues[editViewModel._pName] = editViewModel.setValue;
                    }
                    else
                    {
                        SetValues.Add(editViewModel._pName, editViewModel.setValue);

                    }
                }
            }
            else
            {
                WaferRobotParameterEditViewModel editViewModel = new WaferRobotParameterEditViewModel();
                editViewModel.TableNodeItems = colData.Items;
                var rtn = (windowManager as WindowManager)?.ShowDialogWithTitle(editViewModel, null, "Edit WaferRobotParameter");
                if ((bool)rtn)
                {
                    if (string.IsNullOrEmpty(editViewModel.setValue))
                    {
                        return;
                    }
                    if (SetValues.ContainsKey(colData.Name))
                    {
                        SetValues[editViewModel._pName] = editViewModel.setValue;
                    }
                    else
                    {
                        SetValues.Add(editViewModel._pName, editViewModel.setValue);

                    }

                }
            }
            GetDataOfConfigItems();
        }
        protected override void OnInitialize()
        {
            base.OnInitialize();

            InitData();

        }
        private void InitData()
        {

            ConfigNode rootNode = SystemConfigProvider.Instance.GetConfig(true);
            _waferRobotParameterNode = FindNodeByName(rootNode, WaferRobotParameter_PATH);
            SwitchListView(_checkTypeParameter);
        }
        protected override void InvokeAfterUpdateProperty(Dictionary<string, object> data)
        {
            base.InvokeAfterUpdateProperty(data);
            if (WaferRobotStaus != null)
            {
                IsClickButton = WaferRobotStaus == "Idle";
            }
        }
        private ConfigNode FindNodeByName(ConfigNode parentNode, string strName)
        {
            string strCates = strName.Split('.')[0];
            ConfigNode node = parentNode.SubNodes.Find((x) => x.Name == strCates);
            if (node == null)
                return parentNode;
            else
                return FindNodeByName(node, strName.Replace(strCates + ".", ""));
        }

    }
}