using System;
using CustomUI;
using Prism.Mvvm;
using System.Linq;
using Prism.Commands;
using System.Windows;
using System.Globalization;
using SHJX.Service.Model.Dao;
using System.Windows.Controls;
using SHJX.Service.Common.Utils;
using SHJX.Service.Model.Control;
using System.Collections.Generic;
using SHJX.Service.Common.ReadXML;
using System.Collections.ObjectModel;
using SHJX.Service.Common.UserDelegate;
using SHJX.Service.Common.ExtendElement;
using SHJX.Service.Control.ServiceController;
using SHJX.Service.Common.Logging;
using Microsoft.Extensions.Logging;
namespace SHJX.Service.ModelView
{
    public class ManualViewModel : BindableBase
    {

        private static readonly ILogger logger = LogFactory.BuildLogger(typeof(ManualViewModel));
        private readonly ManualController _controller;

        public ManualViewModel(ReadConfigUtil config)
        {
            _controller = new ManualController(config);
            RegisterMessage();
            InitData();
        }

        /// <summary>
        /// 注册消息
        /// </summary>
        private void RegisterMessage()
        {
            Messager.Register("ChangeTemperature", SetTemperature);
        }
        

        #region DataBind

        private int _manualBarProcess;

        public int ManualBarProcess
        {
            get => _manualBarProcess;
            set
            {
                _manualBarProcess = value;
                RaisePropertyChanged(nameof(ManualBarProcess));
            }
        }

        private string _settingTemperatures;
        public string SettingTemperature
        {
            get => _settingTemperatures;
            set
            {
                _settingTemperatures = value;
                RaisePropertyChanged(nameof(SettingTemperature));
            }
        }

        private string _temperatureText;
        public string CurrentTemperature
        {
            get => _temperatureText;
            set
            {
                _temperatureText = value;
                RaisePropertyChanged(nameof(CurrentTemperature));
            }
        }

        public ObservableCollection<EquipmentArea> Areas { get; set; }
        public List<ComboBoxItem> AreaPoint { get; set; }

        public EquipmentArea Area
        {
            get => Areas.FirstOrDefault(item => item.PointName.Equals(AreaCurrentPoint.Content));
            set
            {
                Areas.Where(item => item.PointName.Equals(AreaCurrentPoint.Content)).ToArray()[0] = value;
                RaisePropertyChanged(nameof(Area));
            }
        }

        private ComboBoxItem _areaCurrentPoint;
        public ComboBoxItem AreaCurrentPoint
        {
            get => _areaCurrentPoint;
            set
            {
                _areaCurrentPoint = value;
                RaisePropertyChanged(nameof(AreaCurrentPoint));
            }
        }


        private bool _potassiumDichromateHighOutValue;
        public bool PotassiumDichromateHighOutValue
        {
            get => _potassiumDichromateHighOutValue;
            set
            {
                _potassiumDichromateHighOutValue = value;
                RaisePropertyChanged(nameof(PotassiumDichromateHighOutValue));
            }
        }

        private bool _potassiumDichromateHighInValue;
        public bool PotassiumDichromateHighInValue
        {
            get => _potassiumDichromateHighInValue;
            set
            {
                _potassiumDichromateHighInValue = value;
                RaisePropertyChanged(nameof(PotassiumDichromateHighInValue));
            }
        }

        private bool _potassiumDichromateLowOutValue;
        public bool PotassiumDichromateLowOutValue
        {
            get => _potassiumDichromateLowOutValue;
            set
            {
                _potassiumDichromateLowOutValue = value;
                RaisePropertyChanged(nameof(PotassiumDichromateLowOutValue));
            }
        }

        private bool _potassiumDichromateLowInValue;
        public bool PotassiumDichromateLowInValue
        {
            get => _potassiumDichromateLowInValue;
            set
            {
                _potassiumDichromateLowInValue = value;
                RaisePropertyChanged(nameof(PotassiumDichromateLowInValue));
            }
        }


        private void InitData()
        {
            PotassiumDichromateHighOutValue = false;
            PotassiumDichromateHighInValue = false;
            PotassiumDichromateLowOutValue = false;
            PotassiumDichromateLowInValue = false;

            ManualBarProcess = 0;
            AreaPoint = new List<ComboBoxItem>();
            Areas = new ObservableCollection<EquipmentArea>(_controller.GetAreaInfo());
            (from EquipmentArea item in Areas select item.PointName).ToList().ForEach(item =>
            {
                AreaPoint.Add(
                    new ComboBoxItem()
                    {
                        Foreground = "#99CCCC".ConvertToBrush(),
                        Content = item
                    }
                );
            });
            AreaCurrentPoint = AreaPoint.FirstOrDefault();
        }

        #endregion

        #region Command
        private DelegateCommand<object> _forwardCommand;
        public DelegateCommand<object> ForwardCommand => _forwardCommand ?? new DelegateCommand<object>(Forward);
        private DelegateCommand<object> _motorStopCommand;
        public DelegateCommand<object> MotorStopCommand => _motorStopCommand ?? new DelegateCommand<object>(MotorStopAsync);
        private DelegateCommand<object> _inversionCommand;
        public DelegateCommand<object> InversionCommand => _inversionCommand ?? new DelegateCommand<object>(Inversion);
        private DelegateCommand<object> _singleMoveCommand;
        public DelegateCommand<object> SingleMoveCommand => _singleMoveCommand ?? new DelegateCommand<object>(SingleMove);
        private DelegateCommand<object> _updateAreaCommand;
        public DelegateCommand<object> UpdateAreaCommand => _updateAreaCommand ?? new DelegateCommand<object>(UpdateArea);
        private DelegateCommand<object> _maniOperateCommand;
        public DelegateCommand<object> ManiOperateCommand => _maniOperateCommand ?? new DelegateCommand<object>(ManiOperateAsync);
        private DelegateCommand<object> _motorGoBackCommand;
        public DelegateCommand<object> MotorGoBackCommand => _motorGoBackCommand ?? new DelegateCommand<object>(MotorGoBackAsync);
        private DelegateCommand<object> _pumpInLiquidCommand;
        public DelegateCommand<object> PumpInLiquidCommand => _pumpInLiquidCommand ?? new DelegateCommand<object>(InPumpLiquid);
        private DelegateCommand<object> _pumpOutLiquidCommand;
        public DelegateCommand<object> PumpOutLiquidCommand => _pumpOutLiquidCommand ?? new DelegateCommand<object>(OutPumpLiquid);
        private DelegateCommand<object> _manualStopHeatCommand;
        public DelegateCommand<object> ManualStopHeatCommand => _manualStopHeatCommand ?? new DelegateCommand<object>(ManualStopHeat);
        private DelegateCommand<object> _coolingPipeMoveCommand;
        public DelegateCommand<object> CoolingPipeMoveCommand => _coolingPipeMoveCommand ?? new DelegateCommand<object>(CoolingPipeMoveAsync);
        private DelegateCommand<object> _manualStartHeatCommand;
        public DelegateCommand<object> ManualStartHeatCommand => _manualStartHeatCommand ?? new DelegateCommand<object>(ManualStartHeat);
        private DelegateCommand<object> _areaSelectionChangedCommand;
        public DelegateCommand<object> AreaSelectionChangedCommand => _areaSelectionChangedCommand ?? new DelegateCommand<object>(AreaSelectionChanged);
        private DelegateCommand<object> _dripNozzleOperateCommand;
        public DelegateCommand<object> DripNozzleOperateCommand => _dripNozzleOperateCommand ?? new DelegateCommand<object>(DripNozzleOperate);
        private DelegateCommand<object> _manualStirStartCommand;
        public DelegateCommand<object> ManualStirStartCommand => _manualStirStartCommand ?? new DelegateCommand<object>(ManualStirStart);
        private DelegateCommand<object> _manualStirStopCommand;
        public DelegateCommand<object> ManualStirStopCommand => _manualStirStopCommand ?? new DelegateCommand<object>(ManualStirStop);
        private DelegateCommand<object> _manualFanStartCommand;
        public DelegateCommand<object> ManualFanStartCommand => _manualFanStartCommand ?? new DelegateCommand<object>(ManualFanStart);
        private DelegateCommand<object> _manualFanStopCommand;
        public DelegateCommand<object> ManualFanStopCommand => _manualFanStopCommand ?? new DelegateCommand<object>(ManualFanStop);


        #region method
        private void ManualFanStop(object obj)
        {
            try
            {
                if (obj is not SegmentItem element) return;
                var res = _controller.ManualFanStop(element.Content);
                UMessageBox.InfoTip($"手动关闭{element.Content}位风扇{(res ? "成功" : "失败")}");
            }
            catch (Exception ex)
            {
                logger.LogError(ex.Message);
            }
        }

        private void ManualFanStart(object obj)
        {
            try
            {
                if (obj is not SegmentItem element) return;
                var res = _controller.ManualFanStrat(element.Content);
                UMessageBox.InfoTip($"手动打开{element.Content}位风扇{(res ? "成功" : "失败")}");
            }
            catch (Exception ex)
            {
                logger.LogError(ex.Message);
            }
        }

        private void ManualStirStop(object obj)
        {
            try
            {
                if (obj is not SegmentItem element) return;
                var res = _controller.ManualStirStop(element.Content);
                UMessageBox.InfoTip($"{element.Content}位搅拌结束{(res ? "成功" : "失败")}");
            }
            catch (Exception ex)
            {
                logger.LogError(ex.Message);
            }
        }

        private void ManualStirStart(object obj)
        {
            try
            {
                if (obj is not SegmentItem element) return;
                var res = _controller.ManualStirStrat(element.Content);
                UMessageBox.InfoTip($"{element.Content}位搅拌开始{(res ? "成功" : "失败")}");
            }
            catch (Exception ex)
            {
                logger.LogError(ex.Message);
            }
        }

        private void DripNozzleOperate(object obj)
        {
            try
            {
                var way = obj.ToString() switch
                {
                    "滴正" => "Arrive",
                    "滴返" => "GoBack",
                    "滴2正" => "Arrive2",
                    "滴2返" => "GoBack2",
                    _ => throw new ArgumentNullException(obj.ToString())
                };
                var res = _controller.DripNozzleManual(way);
            }
            catch (Exception ex)
            {
                logger.LogError(ex.ToString());
            }
        }

        /// <summary>
        /// 设置温度
        /// </summary>
        /// <param name="obj"></param>
        private void SetTemperature(object obj)
        {
            try
            {
                if (obj is null) return;
                Application.Current.Dispatcher.BeginInvoke(new Action(() =>
                {
                    var temp = obj as Dictionary<string, double>;
                    if (temp is null or { Count: 0 }) return;
                    if (temp.TryGetValue("sv", out var svValue))
                    {
                        SettingTemperature = svValue.ToString(CultureInfo.InvariantCulture);
                    }
                    if (temp.TryGetValue("pv", out var pvValue))
                    {
                        CurrentTemperature = pvValue.ToString(CultureInfo.InvariantCulture);
                    }
                }));
            }
            catch (Exception ex)
            {
                logger.LogError(ex.ToString());
            }
        }

        /// <summary>
        /// 吸液
        /// </summary>
        /// <param name="obj"></param>
        private async void InPumpLiquid(object obj)
        {
            if (obj is not object[] objs) return;
            var name = (objs[0].ToString()) switch
            {
                "重铬酸钾(低)" => "PotassiumDichromate_Low",
                "重铬酸钾(高)" => "PotassiumDichromate_High",
                "硫酸银(1)" or "硫酸银(13)" => "SilverSulfate",
                _ => throw new ArgumentNullException(objs[0].ToString()),
            };
            if (name.Equals("PotassiumDichromate_Low"))
                PotassiumDichromateLowInValue = true;
            else if (name.Equals("PotassiumDichromate_High"))
                PotassiumDichromateHighInValue = true;
            _ = await _controller.ManualPumpInLiquidAsync(name, Convert.ToInt32(string.IsNullOrWhiteSpace(objs[1].ToString()) ? 0 : objs[1]));
            if (name.Equals("PotassiumDichromate_Low"))
                PotassiumDichromateLowInValue = false;
            else if (name.Equals("PotassiumDichromate_High"))
                PotassiumDichromateHighInValue = false;
        }

        /// <summary>
        /// 出液
        /// </summary>
        /// <param name="obj"></param>
        private void OutPumpLiquid(object obj)
        {
            if (obj is not object[] objs) return;
            var name = (objs[0].ToString()) switch
            {
                "水(1)" => "Water_1",
                "水(13)" => "Water_13",
                "试亚铁灵" => "Indicator",
                "试亚铁灵(高)" => "Indicator2",
                "硫酸汞" => "Mercury",
                "重铬酸钾(低)" => "PotassiumDichromate_Low",
                "重铬酸钾(高)" => "PotassiumDichromate_High",
                "硫酸亚铁铵(低)" => "FAS_Low",
                "硫酸亚铁铵(高)" => "FAS_High",
                "硫酸银(1)" => "SilverSulfate_1",
                "硫酸银(13)" => "SilverSulfate_13",
                _ => throw new ArgumentNullException(objs[0].ToString()),
            };

            switch (name)
            {
                case "Water_1" or "Water_13":
                    WaterLiquid(name, Convert.ToInt32(objs[1]));
                    break;
                case "Indicator" or "Mercury" or "Indicator2":
                    SecondLiquid(name, Convert.ToInt32(objs[1]));
                    break;
                case "PotassiumDichromate_Low" or "PotassiumDichromate_High" or "SilverSulfate_1" or "SilverSulfate_13" or "FAS_Low" or "FAS_High":
                    OutLiquid(name, Convert.ToInt32(objs[1]));
                    break;
            }
        }

        public async void WaterLiquid(string name, int second)
        {
            string nameStr = name switch
            {
                "Water_1" => "R1",
                "Water_13" => "R13",
                _ => throw new ArgumentNullException("NULL"),
            };
            _ = await _controller.ManualStorageOutLiquidAsync("Water", second, nameStr);
        }

        public async void SecondLiquid(string name, int second)
        {
            _ = await _controller.ManualStorageOutLiquidAsync(name, second);
        }

        public async void OutLiquid(string name, int amount)
        {
            if (name.Equals("PotassiumDichromate_Low"))
                PotassiumDichromateLowOutValue = true;
            else if (name.Equals("PotassiumDichromate_High"))
                PotassiumDichromateHighOutValue = true;

            _ = await _controller.ManualPumpOutLiquidAsync(name, amount);

            if (name.Equals("PotassiumDichromate_Low"))
                PotassiumDichromateLowOutValue = false;
            else if (name.Equals("PotassiumDichromate_High"))
                PotassiumDichromateHighOutValue = false;
        }

        /// <summary>
        /// 停止加热
        /// </summary>
        /// <param name="obj"></param>
        private void ManualStopHeat(object obj)
        {
            var res = _controller.SetHeating(-100);
            UMessageBox.InfoTip(res ? "停止加热设置成功!" : "停止加热设置失败!");
        }

        /// <summary>
        /// 开始加热
        /// </summary>
        /// <param name="obj"></param>
        private void ManualStartHeat(object obj)
        {
            var value = Convert.ToInt32(obj);
            var res = _controller.SetHeating(value);
            UMessageBox.InfoTip(res ? "加热设置成功!" : "加热设置失败!");
        }

        /// <summary>
        /// 电机停止
        /// </summary>
        /// <param name="obj"></param>
        private async void MotorStopAsync(object obj)
        {
            try
            {
                var motorName = obj.ToString() switch
                {
                    "X轴" => "MotorX",
                    "Y轴" => "MotorY",
                    "Z轴" => "MotorZ",
                    "H轴" => "MotorT",
                    "消解" => "Dissolve",
                    _ => throw new ArgumentNullException(obj.ToString())
                };
                var res = await _controller.MotorStop(motorName);
            }
            catch (Exception ex)
            {
                logger.LogError(ex.ToString());
            }
        }

        /// <summary>
        /// 机械手操作
        /// </summary>
        /// <param name="obj"></param>
        private async void ManiOperateAsync(object obj)
        {
            try
            {
                var way = obj.ToString() switch
                {
                    "杯松" => WriteWay.Normotopia,
                    "杯抓" => WriteWay.Antiposition,
                    _ => throw new ArgumentNullException(obj.ToString())
                };
                var res = await _controller.ManiManual(way);
            }
            catch (Exception ex)
            {
                logger.LogError(ex.ToString());
            }
        }

        /// <summary>
        /// 冷凝管单独操作
        /// </summary>
        /// <param name="obj"></param>
        public async void CoolingPipeMoveAsync(object obj)
        {
            try
            {
                var way = obj.ToString() switch
                {
                    "上升" => WriteWay.Normotopia,
                    "下降" => WriteWay.Antiposition,
                    _ => throw new ArgumentNullException(obj.ToString())
                };
                var res = await _controller.CageManualOperate(way);
                if (res)
                {
                    UMessageBox.SuccessTip("冷凝管" + obj.ToString() + "成功！");
                }
            }
            catch (Exception ex)
            {
                logger.LogError(ex.ToString());
            }
        }

        /// <summary>
        /// 电机返回原点
        /// </summary>
        /// <param name="obj"></param>
        public async void MotorGoBackAsync(object obj)
        {
            try
            {
                var checkName = obj.ToString();
                var name = checkName switch
                {
                    "X轴" => "MotorX",
                    "Y轴" => "MotorY",
                    "Z轴" => "MotorZ",
                    "H轴" => "MotorT",
                    "消解" => "Dissolve",
                    "全部" => "AllGoBack",
                    _ => throw new ArgumentNullException(checkName)
                };
                bool res = false;
                if (name == "AllGoBack")
                {
                    res = await _controller.MotorGoBackAsync("MotorZ");
                    res &= await _controller.MotorGoBackAsync("MotorX");
                    res &= await _controller.MotorGoBackAsync("MotorY");
                    res &= await _controller.MotorGoBackAsync("MotorT");
                    res &= await _controller.CageManualOperate(WriteWay.Normotopia);
                    res &= await _controller.MotorGoBackAsync("Dissolve");
                }
                else
                    res = await _controller.MotorGoBackAsync(name);
                UMessageBox.InfoTip($"{checkName}返回原点{(res ? "成功" : "失败")}");
            }
            catch (Exception ex)
            {
                logger.LogError(ex.ToString());
            }
        }

        /// <summary>
        /// 正转
        /// </summary>
        /// <param name="obj"></param>
        private void Forward(object obj)
        {
            try
            {
                if (obj is not object[] objs) return;
                var name = objs[0].ToString();
                var value = Math.Abs(Convert.ToDouble(objs[1]));
                ManualMoveAsync(name, -value);
            }
            catch (Exception ex)
            {
                logger.LogError(ex.ToString());
            }
        }

        /// <summary>
        /// 反转
        /// </summary>
        /// <param name="obj"></param>
        public void Inversion(object obj)
        {
            try
            {
                if (obj is not object[] objs) return;
                var name = objs[0].ToString();
                var value = Math.Abs(Convert.ToDouble(objs[1]));
                ManualMoveAsync(name, value);
            }
            catch (Exception ex)
            {
                logger.LogError(ex.ToString());
            }
        }

        /// <summary>
        /// 手动移动
        /// </summary>
        /// <param name="name"></param>
        /// <param name="value"></param>
        public async void ManualMoveAsync(string name, double value)
        {
            try
            {
                var sendName = name switch
                {
                    "X轴" => "MotorX",
                    "Y轴" => "MotorY",
                    "Z轴" => "MotorZ",
                    "H轴" => "MotorT",
                    "消解" => "Dissolve",
                    _ => throw new ArgumentNullException(name)
                };
                await _controller.ManualMove(sendName, value);
            }
            catch (Exception ex)
            {
                logger.LogError(ex.Message);
                UMessageBox.Error(ex.Message);
            }
        }

        /// <summary>
        /// 下拉框改变事件
        /// </summary>
        /// <param name="obj"></param>
        public void AreaSelectionChanged(object obj)
        {
            Area = Areas.FirstOrDefault(item => item.PointName.Equals(AreaCurrentPoint.Content));
        }

        /// <summary>
        /// 单点移动
        /// </summary>
        /// <param name="obj"></param>
        public void SingleMove(object obj)
        {
            try
            {
                var point = Areas.FirstOrDefault(item => item.PointName.Equals(AreaCurrentPoint.Content));
                _controller.SinglePointMove(point);
            }
            catch (Exception ex)
            {
                logger.LogError(ex.ToString());
            }
        }

        /// <summary>
        /// 更新区域
        /// </summary>
        /// <param name="obj"></param>
        public void UpdateArea(object obj)
        {
            try
            {
                var area = Areas.FirstOrDefault(item => item.PointName.Equals(AreaCurrentPoint.Content));
                _controller.UpdateAreaInfo(area);
                Messager.Send("UpdateElementStatus", area);
            }
            catch (Exception ex)
            {
                logger.LogError(ex.ToString());
            }
        }

        #endregion

        #endregion
    }
}