using CommunityToolkit.Mvvm.ComponentModel;
using CommunityToolkit.Mvvm.Input;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Threading;
using SlnMesnac.Business.@base;
using static Microsoft.WindowsAPICodePack.Shell.PropertySystem.SystemProperties.System;
using SlnMesnac.Repository.service;
using SlnMesnac.Repository;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.DependencyInjection;
using Task = System.Threading.Tasks.Task;
using SlnMesnac.WPF.Page.IndexPage;
using System.Windows.Documents;
using SlnMesnac.TouchSocket;
using HslCommunication.Enthernet;
using SlnMesnac.Config;
using System.Threading;
using SlnMesnac.Model.AirportApiEntity;
using SlnMesnac.Model.ViewEntity;
using SlnMesnac.Model.domain;

#region << 版 本 注 释 >>
/*--------------------------------------------------------------------
* 版权所有 (c) 2024 WenJY 保留所有权利。
* CLR版本：4.0.30319.42000
* 机器名称：T14-GEN3-7895
* 命名空间：SlnMesnac.WPF.ViewModel.IndexPage
* 唯一标识：ffdc8ddd-928f-4910-b6ac-d6d6426c39d0
*
* 创建者：WenJY
* 电子邮箱：
* 创建时间：2024-09-05 15:05:57
* 版本：V1.0.0
* 描述：
*
*--------------------------------------------------------------------
* 修改人：
* 时间：
* 修改说明：
*
* 版本：V1.0.0
*--------------------------------------------------------------------*/
#endregion << 版 本 注 释 >>
namespace SlnMesnac.WPF.ViewModel.IndexPage
{
    public partial class IndexContentViewModel : ObservableObject
    {
        private ILogger<IndexContentViewModel> _logger;
        private ILogger<BaseTaskInfoBusiness> _taskBusinessLogger;
        private ILogger<BaseStateRefreshBusiness> _stateBusinessLogger;
        private ILogger<BaseAGVBusiness> _AGVBusinessLogger;
        private ILogger<VisionBusiness> _visionBusinessLogger;
        private IAirportTaskService _taskservice;
        private IAGVStateService _agvstateService;
        private IAGVSettingService _aGVSettingService;
        private IAGVMapPointService _agvmapPointService;
        private IAGVJobService _agvJobService;
        private IVisionSettingService _visionSettingService;
        private BaseTaskInfoBusiness _taskInfoBusiness;
        private BaseStateRefreshBusiness _StateRefreshBusiness;
        private BaseAGVBusiness _baseAGVBusiness;
        private VisionBusiness _visionBusiness;
        private DispatcherTimer _timer;
        private TcpServer _tcpServer;
        private AppConfig _appConfig;
        private AirPorthttpClient _airPorthttpClient;

        public IndexContentViewModel()
        {
            LogMessages = new ObservableCollection<string>();
            _taskBusinessLogger = App.ServiceProvider.GetService<ILogger<BaseTaskInfoBusiness>>();
            _stateBusinessLogger = App.ServiceProvider.GetService<ILogger<BaseStateRefreshBusiness>>();
            _AGVBusinessLogger = App.ServiceProvider.GetService<ILogger<BaseAGVBusiness>>();
            _visionBusinessLogger = App.ServiceProvider.GetService<ILogger<VisionBusiness>>();
            _logger = App.ServiceProvider.GetService<ILogger<IndexContentViewModel>>();
            _taskservice = App.ServiceProvider.GetService<IAirportTaskService>();
            _agvmapPointService = App.ServiceProvider.GetService<IAGVMapPointService>();
            _agvstateService = App.ServiceProvider.GetService<IAGVStateService>();
            _agvJobService = App.ServiceProvider.GetService<IAGVJobService>();
            _aGVSettingService = App.ServiceProvider.GetService<IAGVSettingService>();
            _visionSettingService = App.ServiceProvider.GetService<IVisionSettingService>();
            _tcpServer = App.ServiceProvider.GetService<TcpServer>();
            _appConfig = App.ServiceProvider.GetService<AppConfig>();
            _airPorthttpClient = App.ServiceProvider.GetService<AirPorthttpClient>();

            _visionBusiness = VisionBusiness.GetInstance(_visionBusinessLogger, _tcpServer, _taskservice, _visionSettingService, _agvstateService, _agvJobService);
            _baseAGVBusiness = BaseAGVBusiness.GetInstance(_AGVBusinessLogger, _airPorthttpClient, _agvstateService, _agvmapPointService, _appConfig, _agvJobService, _aGVSettingService);
            _taskInfoBusiness = BaseTaskInfoBusiness.GetInstance(_taskBusinessLogger, 
                _taskservice, _agvstateService, _agvmapPointService, _agvJobService, _visionSettingService, 
                _tcpServer, _airPorthttpClient, _baseAGVBusiness, _visionBusiness);
            _taskInfoBusiness._RefreshLogMessageAction += RefreshLogMessage;
            _taskInfoBusiness._Taskaction += task =>
            {
                if (task != null)
                {
                    var x = TaskItems.ToList().Find(x => x.conveyorno == task.conveyorno);
                    if (x != null)
                    {
                        x.id = task.id;
                        x.taskno = task.taskno;
                        x.flightno = task.flightno;
                        x.amragvno = task.amragvno;
                        x.deliveragvno = task.deliveragvno;
                        x.taskstate = task.taskstate;
                        TaskItems = new ObservableCollection<AirportTask>(TaskItems);

                    }
                }
            };
            this.Init();
        }

        #region 参数定义

        /// <summary>
        /// AGV状态
        /// </summary>
        private ObservableCollection<AGVStateViewEntity> _agvState = new ObservableCollection<AGVStateViewEntity>();

        public ObservableCollection<AGVStateViewEntity> AgvStates
        {
            get => _agvState;
            set => SetProperty(ref _agvState, value);
        }

        /// <summary>
        /// 任务列表
        /// </summary>
        private ObservableCollection<AirportTask> _taskItems = new ObservableCollection<AirportTask>();

        public ObservableCollection<AirportTask> TaskItems
        {
            get => _taskItems;
            set => SetProperty(ref _taskItems, value);
        }

        /// <summary>
        /// 日志信息
        /// </summary>
        private ObservableCollection<string> _logMessages = new ObservableCollection<string>();

        public ObservableCollection<string> LogMessages
        {
            get => _logMessages;
            set => SetProperty(ref _logMessages, value);
        }

        /// <summary>
        /// 日期时间
        /// </summary>
        private DateTime _currentDateTime;

        public DateTime CurrentDateTime
        {
            get => _currentDateTime;
            set
            {
                if (_currentDateTime != value)
                {
                    SetProperty(ref _currentDateTime, value);
                }
            }
        }

        #endregion
        
        /// <summary>
        /// 加载AGV状态信息
        /// </summary>
        private void LoadAGVStateInfo()
        {
            try
            {
                List<AGVState> aGVStates = _agvstateService.GetAllAGVState();
                List<AGVSetting> aGVSettings = _aGVSettingService.GetAllAgvSetting();
                List<AGVStateViewEntity> viewList = new List<AGVStateViewEntity>();
                foreach (AGVState state in aGVStates)
                {
                    var nameE = aGVSettings.FirstOrDefault(x => x.AGVNo == state.agvno);
                    if (nameE == null)
                    {
                        return;
                    }
                    viewList.Add(new AGVStateViewEntity()
                    {
                        AgvName = nameE.AGVName,
                        AgvAlarmState = state.agvalarmstate,
                        AgvWorkState = state.agvworkstate,
                        AgvCount = state.stackcount.ToString(),
                        AgvType = state.agvtype,
                        AgvTaskState = state.taskstate,
                    });
                }
                AgvStates = new ObservableCollection<AGVStateViewEntity>(viewList);
            }
            catch (Exception ex)
            {
                RefreshLogMessage("AGV状态刷新异常");
            }
        }
        
        /// <summary>
        /// 加载任务信息
        /// </summary>
        private void LoadTaskInfo()
        {
            try
            {
                List<AirportTask> AirportTaskItem = _taskservice.GetTaskInfos();
                TaskItems = new ObservableCollection<AirportTask>(AirportTaskItem);
            }
            catch (Exception ex)
            {
                RefreshLogMessage("任务状态刷新异常");
            }
        }

        private void Init()
        {

            //Timer
            _currentDateTime = DateTime.Now;
            _timer = new DispatcherTimer
            {
                Interval = TimeSpan.FromSeconds(1) // 每秒更新一次
            };
            _timer.Tick += (s, e) =>
            {
                LoadAGVStateInfo();
                LoadTaskInfo();
                CurrentDateTime = DateTime.Now;
            };
            _timer.Start();
        }
        

        /// <summary>
        /// 未知刷新类
        /// </summary>
        /// <param name="airportTask"></param>
        //public async void RefreshTaskItems(AirportTask airportTask)
        //{
        //    try
        //    {
        //        await Task.Run(async () =>
        //        {
        //            foreach (var VARIABLE in TaskItems)
        //            {
        //                if (VARIABLE.deliveragvno == airportTask.conveyorno)
        //                {
        //                    VARIABLE.taskstate = airportTask.taskstate;
        //                    VARIABLE.deliveragvno = airportTask.deliveragvno;
        //                    VARIABLE.totalcount = airportTask.totalcount;
        //                    VARIABLE.loadcount = airportTask.loadcount;
        //                }
        //            }
        //        });
        //    }
        //    catch (Exception ex)
        //    {

        //    }
        //}
        
        /// <summary>
        /// 刷新日志
        /// </summary>
        /// <param name="msg"></param>
        public void RefreshLogMessage(string msg)
        {
            try
            {
                App.Current.Dispatcher.BeginInvoke(() =>
                {
                    LogMessages.Add($"{DateTime.Now}: {msg}");
                    while (LogMessages.Count > 120)
                    {
                        LogMessages.RemoveAt(0);
                    }
                    var orderedList = LogMessages.OrderByDescending(x => x);  // 排序后转为 List
                    LogMessages = new ObservableCollection<string>(orderedList);
                });
            }
            catch (Exception ex)
            {

            }

        }

        /// <summary>
        /// 系统运行日志输出
        /// </summary>
        /// <param name="message"></param>
        private async void PrintMessageToListBox(string message)
        {
            await Task.Run(() =>
            {
                try
                {
                    string formattedMessage = $"{DateTime.Now.ToString("HH:mm:ss.ss")} ==> {message}";

                    lock (LogMessages)
                    {
                        LogMessages.Add(formattedMessage);

                        while (LogMessages.Count > 120)
                        {
                            LogMessages.RemoveAt(0);
                        }

                        var orderedList = LogMessages.OrderByDescending(x => x).ToList();  // 排序后转为 List

                    }
                }
                catch (Exception ex)
                {
                    _logger.LogError($"日志数据绑定异常:{ex.Message}");
                }
            });
        }

        /// <summary>
        /// 添加任务
        /// </summary>
        [RelayCommand]
        private void AddTask()
        {
            //生成任务号
            //输入航班号
            //任务状态默认等待
            AddTaskContent AddTaskContent = new AddTaskContent();
            AddTaskContent._Taskaction = task =>
            {
                if (task != null)
                {
                    var x = TaskItems.ToList().Find(x => x.conveyorno == task.conveyorno);
                    if (x != null)
                    {
                        x.id = task.id;
                        x.taskno = task.taskno;
                        x.flightno = task.flightno;
                        x.amragvno = task.amragvno;
                        x.deliveragvno = task.deliveragvno;
                        x.taskstate = task.taskstate;
                        TaskItems = new ObservableCollection<AirportTask>(TaskItems);
                    }
                    else
                    {
                        TaskItems.Add(task);
                    }
                }
            };
            AddTaskContent.ShowDialog();
            if ((bool)AddTaskContent.DialogResult)
            {
                RefreshLogMessage("任务添加成功!");
            }


        }

        /// <summary>
        /// 处理任务
        /// </summary>
        /// <param name="taskCode"></param>
        [RelayCommand]
        private void HandleTask(AirportTask taskCode)
        {
            var info = taskCode;
            if (info != null)
            {

                DetailTaskContent DetailTaskContent = new DetailTaskContent();
                DetailTaskContent.AirportTask = taskCode;
                DetailTaskContent.ShowDialog();
            }
        }

        /// <summary>
        /// 删除任务
        /// </summary>
        /// <param name="taskCode"></param>
        [RelayCommand]
        private void DeleteTask(AirportTask task)
        {
            if (task.taskstate != "等待")
            {
                MessageBox.Show("任务已下发,不允许删除!");
            }
            else
            {
                if (MessageBox.Show("请确认是否删除该任务?", "Confirm Message", MessageBoxButton.OKCancel) == MessageBoxResult.OK)
                {
                    //根据任务号删除任务
                    TaskItems.Remove(task);
                    //清表
                    _taskservice.DeleteTaskAsync(task);
                    //TaskItems = new ObservableCollection<AirportTask>(TaskItems);
                    LoadTaskInfo();
                }

            }
        }

        /// <summary>
        /// 手动终止
        /// </summary>
        [RelayCommand]
        private void ManualTerminate()
        {
            MessageBox.Show("入库");
        }

        /// <summary>
        /// 复位
        /// </summary>
        [RelayCommand]
        private void Reset()
        {
            MessageBox.Show("终止成功");
            
        }
    }

}