using Prism.Commands;
using Prism.Mvvm;
using Prism.Services.Dialogs;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Windows;
using System.Windows.Media.Media3D;
using Team.FFFeederService;
using Team.FFFeederService.Interfaces;
using Team.FFFeederService.Models;
using TeamAAS_VP.Core;
using TeamAAS_VP.Enums;
using TeamAAS_VP.Models;
using TeamAAS_VP.Resources.Languages;

namespace TeamAAS_VP.ViewModels.Setting
{
    public class AddFeederViewModel : BindableBase, IDialogAware
    {
        private FeederIPManage feederIPManage;
        #region 属性
        private System.Collections.ObjectModel.ObservableCollection<FeederNetworkInterfaceInfo> feeders;

        /// <summary>
        /// 识别出来的Feeder集合
        /// </summary>
        public System.Collections.ObjectModel.ObservableCollection<FeederNetworkInterfaceInfo> Feeders
        {
            get { return feeders; }
            set { feeders = value; RaisePropertyChanged(); }
        }

        private FeederInfo _Feeder;
        /// <summary>
        /// 选中的Feeder
        /// </summary>
        public FeederInfo Feeder
        {
            get { return _Feeder; }
            set { SetProperty(ref _Feeder, value); }
        }

        public string Title { get; set; }= Lang.添加Feeder;

        private int _SelectedIndex;
        public int SelectedIndex
        {
            get { return _SelectedIndex; }
            set { SetProperty(ref _SelectedIndex, value); }
        }

        private bool _IsInit=false;
        public bool IsInit
        {
            get { return _IsInit; }
            set { SetProperty(ref _IsInit, value);
                if (value)
                {
                    IsShowProgressBar = Visibility.Hidden;
                }
                else
                {
                    IsShowProgressBar = Visibility.Visible;
                }
            }
        }

        private Visibility _IsShowProgressBar= Visibility.Visible;
        public Visibility IsShowProgressBar
        {
            get { return _IsShowProgressBar; }
            set { SetProperty(ref _IsShowProgressBar, value); }
        }
        #endregion

        #region 命令

        private DelegateCommand<object> _SetFeedetIPCommand;
        public DelegateCommand<object> SetFeedetIPCommand =>
            _SetFeedetIPCommand ?? (_SetFeedetIPCommand = new DelegateCommand<object>(ExecuteSetFeedetIPCommand));

        private DelegateCommand<object> _SelectFeedetCommand;
        public DelegateCommand<object> SelectFeedetCommand =>
            _SelectFeedetCommand ?? (_SelectFeedetCommand = new DelegateCommand<object>(ExecuteSelectFeedetCommand));

        private DelegateCommand _ManualAddFeederCommand;
        public DelegateCommand ManualAddFeederCommand =>
            _ManualAddFeederCommand ?? (_ManualAddFeederCommand = new DelegateCommand(ExecuteManualAddFeederCommand));

        private DelegateCommand _ConfirmCommand;
        public DelegateCommand ConfirmCommand =>
            _ConfirmCommand ?? (_ConfirmCommand = new DelegateCommand(ExecuteConfirmCommand, CanExecuteConfirmCommand).ObservesProperty(()=> Feeder.FeederName));

        private DelegateCommand _CancelCommand;
        public DelegateCommand CancelCommand =>
            _CancelCommand ?? (_CancelCommand = new DelegateCommand(ExecuteCancelCommand));
        #endregion

        #region 事件
        public event Action<IDialogResult> RequestClose;
        #endregion

        public AddFeederViewModel()
        {
            feederIPManage = new FeederIPManage();
        }

        #region 方法

        /// <summary>
        /// 确定
        /// </summary>
        void ExecuteConfirmCommand()
        {
            if (string.IsNullOrEmpty(Feeder.FeederName))
            {
                return;
            }

            if (!FileHelper.CheckFileName(Feeder.FeederName))
            {
                MessageBox.Show(Lang.AddCameraVM_message1, "AAS", MessageBoxButton.OK, MessageBoxImage.Error);
                return;
            }

            IDialogParameters parameters = new DialogParameters();
            parameters.Add("Feeder", Feeder);
            RequestClose?.Invoke(new DialogResult(ButtonResult.OK, parameters));
        }

        bool CanExecuteConfirmCommand()
        {
            return Feeder != null && Feeder.FeederName != null && !string.IsNullOrEmpty(Feeder.FeederName);
        }

        /// <summary>
        /// 取消
        /// </summary>
        void ExecuteCancelCommand()
        {
            IDialogParameters parameters = new DialogParameters();
            parameters.Add("Feeder", Feeder);
            RequestClose?.Invoke(new DialogResult(ButtonResult.Cancel, parameters));
        }

        public bool CanCloseDialog()
        {
            return true;
        }

        public void OnDialogClosed()
        {
            feederIPManage.Disposed();
        }

        public async void OnDialogOpened(IDialogParameters parameters)
        {
            Title = Lang.增加Feeder;
            IsInit = false;
            Feeders = new System.Collections.ObjectModel.ObservableCollection<FeederNetworkInterfaceInfo>();
            Feeders.Clear();
            var feeds = await feederIPManage.Scan();
            foreach (var item in feeds)
            {
                Feeders.Add(item);
            }
            Feeder = new FeederInfo() { Id = Guid.NewGuid() };
            IsInit = true;
        }

        /// <summary>
        /// 修改IP地址
        /// </summary>
        /// <param name="feederinfo"></param>
        async void ExecuteSetFeedetIPCommand(object feederinfo)
        {
            try
            {
                IsInit = false;
                var feeder = feederinfo as FeederNetworkInterfaceInfo;
                bool res=await feederIPManage.SetFeederIP(feeder.MAC, feeder.IP, feeder.Port, feeder.Subnet, feeder.Network);
                
                if (feederIPManage.AreFirstThreeOctetsEqual(IPAddress.Parse(feeder.IP), feeder.Network.IPv4Address))
                {
                    feeder.IsAccessible = true;
                }
                else
                {
                    feeder.IsAccessible = false;
                }

                if (!res)
                {
                    MessageBox.Show($"{Lang.成功}!", $"AAS", MessageBoxButton.OK, MessageBoxImage.Error);
                }
                else
                {
                    MessageBox.Show($"{Lang.失败}!", $"AAS", MessageBoxButton.OK, MessageBoxImage.Information);
                }
            }
            catch (Exception)
            {

            }
            finally
            {
                IsInit = true;
            }
        }

        /// <summary>
        /// 选中Feeder
        /// </summary>
        /// <param name="feederinfo"></param>
        void ExecuteSelectFeedetCommand(object feederinfo)
        {
            var feeder = feederinfo as FeederNetworkInterfaceInfo;
            SelectedIndex = 1;
            Feeder.ConnectType = TCPConnectType.Client;
            Feeder.FeederBrand = FeederBrand.TEAM;
            Feeder.IP = feeder.IP;
            Feeder.Port = feeder.Port;
        }

        /// <summary>
        /// 手动添加Feeder
        /// </summary>
        void ExecuteManualAddFeederCommand()
        {
            SelectedIndex = 1;
        }
        #endregion
    }
}